diff --git a/common/android_util.cpp b/common/android_util.cpp
index c2c4616..772df06 100644
--- a/common/android_util.cpp
+++ b/common/android_util.cpp
@@ -27,8 +27,7 @@
 
 // Convert Intents to arg list, returning argc and argv
 // Note that this C routine mallocs memory that the caller must free
-char** get_args(struct android_app* app, const char* intent_extra_data_key, const char* appTag, int* count)
-{
+char **get_args(struct android_app *app, const char *intent_extra_data_key, const char *appTag, int *count) {
     std::vector<std::string> args;
     JavaVM &vm = *app->activity->vm;
     JNIEnv *p_env;
@@ -37,15 +36,13 @@
 
     JNIEnv &env = *p_env;
     jobject activity = app->activity->clazz;
-    jmethodID get_intent_method = env.GetMethodID(env.GetObjectClass(activity),
-            "getIntent", "()Landroid/content/Intent;");
+    jmethodID get_intent_method = env.GetMethodID(env.GetObjectClass(activity), "getIntent", "()Landroid/content/Intent;");
     jobject intent = env.CallObjectMethod(activity, get_intent_method);
-    jmethodID get_string_extra_method = env.GetMethodID(env.GetObjectClass(intent),
-            "getStringExtra", "(Ljava/lang/String;)Ljava/lang/String;");
+    jmethodID get_string_extra_method =
+        env.GetMethodID(env.GetObjectClass(intent), "getStringExtra", "(Ljava/lang/String;)Ljava/lang/String;");
     jvalue get_string_extra_args;
     get_string_extra_args.l = env.NewStringUTF(intent_extra_data_key);
-    jstring extra_str = static_cast<jstring>(env.CallObjectMethodA(intent,
-            get_string_extra_method, &get_string_extra_args));
+    jstring extra_str = static_cast<jstring>(env.CallObjectMethodA(intent, get_string_extra_method, &get_string_extra_args));
 
     std::string args_str;
     if (extra_str) {
@@ -70,14 +67,14 @@
     // Convert our STL results to C friendly constructs
     assert(count != nullptr);
     *count = args.size() + 1;
-    char** vector = (char**) malloc(*count * sizeof(char*));
-    const char* appName = appTag ? appTag : (const char*) "appTag";
+    char **vector = (char **)malloc(*count * sizeof(char *));
+    const char *appName = appTag ? appTag : (const char *)"appTag";
 
-   vector[0] = (char*) malloc(strlen(appName) * sizeof(char));
-   strcpy(vector[0], appName);
+    vector[0] = (char *)malloc(strlen(appName) * sizeof(char));
+    strcpy(vector[0], appName);
 
     for (uint32_t i = 0; i < args.size(); i++) {
-        vector[i + 1] = (char*) malloc(strlen(args[i].c_str()) * sizeof(char));
+        vector[i + 1] = (char *)malloc(strlen(args[i].c_str()) * sizeof(char));
         strcpy(vector[i + 1], args[i].c_str());
     }
 
diff --git a/common/android_util.h b/common/android_util.h
index 666afff..e896645 100644
--- a/common/android_util.h
+++ b/common/android_util.h
@@ -20,13 +20,13 @@
 #define ANDROID_UTIL_H
 
 #ifdef __cplusplus
-    extern "C" {
+extern "C" {
 #endif
 
-char** get_args(struct android_app* app, const char* intent_extra_data_key, const char* appTag, int* count);
+char **get_args(struct android_app *app, const char *intent_extra_data_key, const char *appTag, int *count);
 
 #ifdef __cplusplus
-    }
+}
 #endif
 
 #endif
diff --git a/common/vulkan_wrapper.cpp b/common/vulkan_wrapper.cpp
index 1d31f54..a3d517e 100644
--- a/common/vulkan_wrapper.cpp
+++ b/common/vulkan_wrapper.cpp
@@ -22,7 +22,7 @@
 #include <dlfcn.h>
 
 int InitVulkan(void) {
-    void* libvulkan = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
+    void *libvulkan = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
     if (!libvulkan)
         return 0;
 
@@ -30,20 +30,30 @@
     vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(dlsym(libvulkan, "vkCreateInstance"));
     vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(dlsym(libvulkan, "vkDestroyInstance"));
     vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(dlsym(libvulkan, "vkEnumeratePhysicalDevices"));
-    vkGetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(dlsym(libvulkan, "vkGetPhysicalDeviceFeatures"));
-    vkGetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceFormatProperties"));
-    vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceImageFormatProperties"));
-    vkGetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceProperties"));
-    vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceQueueFamilyProperties"));
-    vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceMemoryProperties"));
+    vkGetPhysicalDeviceFeatures =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(dlsym(libvulkan, "vkGetPhysicalDeviceFeatures"));
+    vkGetPhysicalDeviceFormatProperties =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceFormatProperties"));
+    vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceImageFormatProperties"));
+    vkGetPhysicalDeviceProperties =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceProperties"));
+    vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceQueueFamilyProperties"));
+    vkGetPhysicalDeviceMemoryProperties =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceMemoryProperties"));
     vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(dlsym(libvulkan, "vkGetInstanceProcAddr"));
     vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(dlsym(libvulkan, "vkGetDeviceProcAddr"));
     vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(dlsym(libvulkan, "vkCreateDevice"));
     vkDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(dlsym(libvulkan, "vkDestroyDevice"));
-    vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(dlsym(libvulkan, "vkEnumerateInstanceExtensionProperties"));
-    vkEnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(dlsym(libvulkan, "vkEnumerateDeviceExtensionProperties"));
-    vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(dlsym(libvulkan, "vkEnumerateInstanceLayerProperties"));
-    vkEnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(dlsym(libvulkan, "vkEnumerateDeviceLayerProperties"));
+    vkEnumerateInstanceExtensionProperties =
+        reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(dlsym(libvulkan, "vkEnumerateInstanceExtensionProperties"));
+    vkEnumerateDeviceExtensionProperties =
+        reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(dlsym(libvulkan, "vkEnumerateDeviceExtensionProperties"));
+    vkEnumerateInstanceLayerProperties =
+        reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(dlsym(libvulkan, "vkEnumerateInstanceLayerProperties"));
+    vkEnumerateDeviceLayerProperties =
+        reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(dlsym(libvulkan, "vkEnumerateDeviceLayerProperties"));
     vkGetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(dlsym(libvulkan, "vkGetDeviceQueue"));
     vkQueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(dlsym(libvulkan, "vkQueueSubmit"));
     vkQueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(dlsym(libvulkan, "vkQueueWaitIdle"));
@@ -53,14 +63,20 @@
     vkMapMemory = reinterpret_cast<PFN_vkMapMemory>(dlsym(libvulkan, "vkMapMemory"));
     vkUnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(dlsym(libvulkan, "vkUnmapMemory"));
     vkFlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(dlsym(libvulkan, "vkFlushMappedMemoryRanges"));
-    vkInvalidateMappedMemoryRanges = reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(dlsym(libvulkan, "vkInvalidateMappedMemoryRanges"));
-    vkGetDeviceMemoryCommitment = reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(dlsym(libvulkan, "vkGetDeviceMemoryCommitment"));
+    vkInvalidateMappedMemoryRanges =
+        reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(dlsym(libvulkan, "vkInvalidateMappedMemoryRanges"));
+    vkGetDeviceMemoryCommitment =
+        reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(dlsym(libvulkan, "vkGetDeviceMemoryCommitment"));
     vkBindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(dlsym(libvulkan, "vkBindBufferMemory"));
     vkBindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(dlsym(libvulkan, "vkBindImageMemory"));
-    vkGetBufferMemoryRequirements = reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(dlsym(libvulkan, "vkGetBufferMemoryRequirements"));
-    vkGetImageMemoryRequirements = reinterpret_cast<PFN_vkGetImageMemoryRequirements>(dlsym(libvulkan, "vkGetImageMemoryRequirements"));
-    vkGetImageSparseMemoryRequirements = reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(dlsym(libvulkan, "vkGetImageSparseMemoryRequirements"));
-    vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceSparseImageFormatProperties"));
+    vkGetBufferMemoryRequirements =
+        reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(dlsym(libvulkan, "vkGetBufferMemoryRequirements"));
+    vkGetImageMemoryRequirements =
+        reinterpret_cast<PFN_vkGetImageMemoryRequirements>(dlsym(libvulkan, "vkGetImageMemoryRequirements"));
+    vkGetImageSparseMemoryRequirements =
+        reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(dlsym(libvulkan, "vkGetImageSparseMemoryRequirements"));
+    vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceSparseImageFormatProperties"));
     vkQueueBindSparse = reinterpret_cast<PFN_vkQueueBindSparse>(dlsym(libvulkan, "vkQueueBindSparse"));
     vkCreateFence = reinterpret_cast<PFN_vkCreateFence>(dlsym(libvulkan, "vkCreateFence"));
     vkDestroyFence = reinterpret_cast<PFN_vkDestroyFence>(dlsym(libvulkan, "vkDestroyFence"));
@@ -83,7 +99,8 @@
     vkDestroyBufferView = reinterpret_cast<PFN_vkDestroyBufferView>(dlsym(libvulkan, "vkDestroyBufferView"));
     vkCreateImage = reinterpret_cast<PFN_vkCreateImage>(dlsym(libvulkan, "vkCreateImage"));
     vkDestroyImage = reinterpret_cast<PFN_vkDestroyImage>(dlsym(libvulkan, "vkDestroyImage"));
-    vkGetImageSubresourceLayout = reinterpret_cast<PFN_vkGetImageSubresourceLayout>(dlsym(libvulkan, "vkGetImageSubresourceLayout"));
+    vkGetImageSubresourceLayout =
+        reinterpret_cast<PFN_vkGetImageSubresourceLayout>(dlsym(libvulkan, "vkGetImageSubresourceLayout"));
     vkCreateImageView = reinterpret_cast<PFN_vkCreateImageView>(dlsym(libvulkan, "vkCreateImageView"));
     vkDestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(dlsym(libvulkan, "vkDestroyImageView"));
     vkCreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(dlsym(libvulkan, "vkCreateShaderModule"));
@@ -99,8 +116,10 @@
     vkDestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(dlsym(libvulkan, "vkDestroyPipelineLayout"));
     vkCreateSampler = reinterpret_cast<PFN_vkCreateSampler>(dlsym(libvulkan, "vkCreateSampler"));
     vkDestroySampler = reinterpret_cast<PFN_vkDestroySampler>(dlsym(libvulkan, "vkDestroySampler"));
-    vkCreateDescriptorSetLayout = reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(dlsym(libvulkan, "vkCreateDescriptorSetLayout"));
-    vkDestroyDescriptorSetLayout = reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(dlsym(libvulkan, "vkDestroyDescriptorSetLayout"));
+    vkCreateDescriptorSetLayout =
+        reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(dlsym(libvulkan, "vkCreateDescriptorSetLayout"));
+    vkDestroyDescriptorSetLayout =
+        reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(dlsym(libvulkan, "vkDestroyDescriptorSetLayout"));
     vkCreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(dlsym(libvulkan, "vkCreateDescriptorPool"));
     vkDestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(dlsym(libvulkan, "vkDestroyDescriptorPool"));
     vkResetDescriptorPool = reinterpret_cast<PFN_vkResetDescriptorPool>(dlsym(libvulkan, "vkResetDescriptorPool"));
@@ -147,7 +166,8 @@
     vkCmdUpdateBuffer = reinterpret_cast<PFN_vkCmdUpdateBuffer>(dlsym(libvulkan, "vkCmdUpdateBuffer"));
     vkCmdFillBuffer = reinterpret_cast<PFN_vkCmdFillBuffer>(dlsym(libvulkan, "vkCmdFillBuffer"));
     vkCmdClearColorImage = reinterpret_cast<PFN_vkCmdClearColorImage>(dlsym(libvulkan, "vkCmdClearColorImage"));
-    vkCmdClearDepthStencilImage = reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(dlsym(libvulkan, "vkCmdClearDepthStencilImage"));
+    vkCmdClearDepthStencilImage =
+        reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(dlsym(libvulkan, "vkCmdClearDepthStencilImage"));
     vkCmdClearAttachments = reinterpret_cast<PFN_vkCmdClearAttachments>(dlsym(libvulkan, "vkCmdClearAttachments"));
     vkCmdResolveImage = reinterpret_cast<PFN_vkCmdResolveImage>(dlsym(libvulkan, "vkCmdResolveImage"));
     vkCmdSetEvent = reinterpret_cast<PFN_vkCmdSetEvent>(dlsym(libvulkan, "vkCmdSetEvent"));
@@ -165,42 +185,57 @@
     vkCmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(dlsym(libvulkan, "vkCmdEndRenderPass"));
     vkCmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(dlsym(libvulkan, "vkCmdExecuteCommands"));
     vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(dlsym(libvulkan, "vkDestroySurfaceKHR"));
-    vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceSupportKHR"));
-    vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
-    vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
-    vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
+    vkGetPhysicalDeviceSurfaceSupportKHR =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceSupportKHR"));
+    vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
+    vkGetPhysicalDeviceSurfaceFormatsKHR =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
+    vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
     vkCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(dlsym(libvulkan, "vkCreateSwapchainKHR"));
     vkDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(dlsym(libvulkan, "vkDestroySwapchainKHR"));
     vkGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(dlsym(libvulkan, "vkGetSwapchainImagesKHR"));
     vkAcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(dlsym(libvulkan, "vkAcquireNextImageKHR"));
     vkQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(dlsym(libvulkan, "vkQueuePresentKHR"));
-    vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPropertiesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceDisplayPropertiesKHR"));
-    vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
-    vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast<PFN_vkGetDisplayPlaneSupportedDisplaysKHR>(dlsym(libvulkan, "vkGetDisplayPlaneSupportedDisplaysKHR"));
-    vkGetDisplayModePropertiesKHR = reinterpret_cast<PFN_vkGetDisplayModePropertiesKHR>(dlsym(libvulkan, "vkGetDisplayModePropertiesKHR"));
+    vkGetPhysicalDeviceDisplayPropertiesKHR =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPropertiesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceDisplayPropertiesKHR"));
+    vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
+    vkGetDisplayPlaneSupportedDisplaysKHR =
+        reinterpret_cast<PFN_vkGetDisplayPlaneSupportedDisplaysKHR>(dlsym(libvulkan, "vkGetDisplayPlaneSupportedDisplaysKHR"));
+    vkGetDisplayModePropertiesKHR =
+        reinterpret_cast<PFN_vkGetDisplayModePropertiesKHR>(dlsym(libvulkan, "vkGetDisplayModePropertiesKHR"));
     vkCreateDisplayModeKHR = reinterpret_cast<PFN_vkCreateDisplayModeKHR>(dlsym(libvulkan, "vkCreateDisplayModeKHR"));
-    vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast<PFN_vkGetDisplayPlaneCapabilitiesKHR>(dlsym(libvulkan, "vkGetDisplayPlaneCapabilitiesKHR"));
-    vkCreateDisplayPlaneSurfaceKHR = reinterpret_cast<PFN_vkCreateDisplayPlaneSurfaceKHR>(dlsym(libvulkan, "vkCreateDisplayPlaneSurfaceKHR"));
-    vkCreateSharedSwapchainsKHR = reinterpret_cast<PFN_vkCreateSharedSwapchainsKHR>(dlsym(libvulkan, "vkCreateSharedSwapchainsKHR"));
+    vkGetDisplayPlaneCapabilitiesKHR =
+        reinterpret_cast<PFN_vkGetDisplayPlaneCapabilitiesKHR>(dlsym(libvulkan, "vkGetDisplayPlaneCapabilitiesKHR"));
+    vkCreateDisplayPlaneSurfaceKHR =
+        reinterpret_cast<PFN_vkCreateDisplayPlaneSurfaceKHR>(dlsym(libvulkan, "vkCreateDisplayPlaneSurfaceKHR"));
+    vkCreateSharedSwapchainsKHR =
+        reinterpret_cast<PFN_vkCreateSharedSwapchainsKHR>(dlsym(libvulkan, "vkCreateSharedSwapchainsKHR"));
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
     vkCreateXlibSurfaceKHR = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(dlsym(libvulkan, "vkCreateXlibSurfaceKHR"));
-    vkGetPhysicalDeviceXlibPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
+    vkGetPhysicalDeviceXlibPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
 #endif
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
     vkCreateXcbSurfaceKHR = reinterpret_cast<PFN_vkCreateXcbSurfaceKHR>(dlsym(libvulkan, "vkCreateXcbSurfaceKHR"));
-    vkGetPhysicalDeviceXcbPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceXcbPresentationSupportKHR"));
+    vkGetPhysicalDeviceXcbPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceXcbPresentationSupportKHR"));
 #endif
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
     vkCreateWaylandSurfaceKHR = reinterpret_cast<PFN_vkCreateWaylandSurfaceKHR>(dlsym(libvulkan, "vkCreateWaylandSurfaceKHR"));
-    vkGetPhysicalDeviceWaylandPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"));
+    vkGetPhysicalDeviceWaylandPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"));
 #endif
 
 #ifdef VK_USE_PLATFORM_MIR_KHR
     vkCreateMirSurfaceKHR = reinterpret_cast<PFN_vkCreateMirSurfaceKHR>(dlsym(libvulkan, "vkCreateMirSurfaceKHR"));
-    vkGetPhysicalDeviceMirPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceMirPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceMirPresentationSupportKHR"));
+    vkGetPhysicalDeviceMirPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceMirPresentationSupportKHR>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceMirPresentationSupportKHR"));
 #endif
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
@@ -209,7 +244,8 @@
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     vkCreateWin32SurfaceKHR = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(dlsym(libvulkan, "vkCreateWin32SurfaceKHR"));
-    vkGetPhysicalDeviceWin32PresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
+    vkGetPhysicalDeviceWin32PresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>(
+        dlsym(libvulkan, "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
 #endif
     return 1;
 }
diff --git a/common/vulkan_wrapper.h b/common/vulkan_wrapper.h
index d1ae858..bf08766 100644
--- a/common/vulkan_wrapper.h
+++ b/common/vulkan_wrapper.h
@@ -231,7 +231,6 @@
 
 // VK_KHR_sampler_mirror_clamp_to_edge
 
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp
index 03f9c5e..e682aed 100644
--- a/layers/core_validation.cpp
+++ b/layers/core_validation.cpp
@@ -139,7 +139,7 @@
     VkLayerDispatchTable dispatch_table;
 
     devExts device_extensions = {};
-    unordered_set<VkQueue> queues;  // All queues under given device
+    unordered_set<VkQueue> queues; // All queues under given device
     // Global set of all cmdBuffers that are inFlight on this device
     unordered_set<VkCommandBuffer> globalInFlightCmdBuffers;
     // Layer specific data
@@ -171,7 +171,7 @@
     VkDevice device = VK_NULL_HANDLE;
     VkPhysicalDevice physical_device = VK_NULL_HANDLE;
 
-    instance_layer_data *instance_data = nullptr;  // from device to enclosing instance
+    instance_layer_data *instance_data = nullptr; // from device to enclosing instance
 
     VkPhysicalDeviceFeatures enabled_features = {};
     // Device specific data
@@ -198,8 +198,7 @@
         }
         // This has to be logged to console as we don't have a callback at this point.
         if (!foundLayer && !strcmp(createInfo.ppEnabledLayerNames[0], "VK_LAYER_GOOGLE_unique_objects")) {
-            LOGCONSOLE("Cannot activate layer VK_LAYER_GOOGLE_unique_objects prior to activating %s.",
-                       global_layer.layerName);
+            LOGCONSOLE("Cannot activate layer VK_LAYER_GOOGLE_unique_objects prior to activating %s.", global_layer.layerName);
         }
     }
 }
@@ -721,7 +720,7 @@
         if (!mem_binding->sparse) {
             skip = ClearMemoryObjectBinding(dev_data, handle, type, mem_binding->binding.mem);
         } else { // Sparse, clear all bindings
-            for (auto& sparse_mem_binding : mem_binding->sparse_bindings) {
+            for (auto &sparse_mem_binding : mem_binding->sparse_bindings) {
                 skip |= ClearMemoryObjectBinding(dev_data, handle, type, sparse_mem_binding.mem);
             }
         }
@@ -1076,7 +1075,6 @@
     return value.word(3);
 }
 
-
 static void describe_type_inner(std::ostringstream &ss, shader_module const *src, unsigned type) {
     auto insn = src->get_def(type);
     assert(insn != src->end());
@@ -1135,23 +1133,20 @@
     }
 }
 
-
 static std::string describe_type(shader_module const *src, unsigned type) {
     std::ostringstream ss;
     describe_type_inner(ss, src, type);
     return ss.str();
 }
 
-
-static bool is_narrow_numeric_type(spirv_inst_iter type)
-{
+static bool is_narrow_numeric_type(spirv_inst_iter type) {
     if (type.opcode() != spv::OpTypeInt && type.opcode() != spv::OpTypeFloat)
         return false;
     return type.word(2) < 64;
 }
 
-
-static bool types_match(shader_module const *a, shader_module const *b, unsigned a_type, unsigned b_type, bool a_arrayed, bool b_arrayed, bool relaxed) {
+static bool types_match(shader_module const *a, shader_module const *b, unsigned a_type, unsigned b_type, bool a_arrayed,
+                        bool b_arrayed, bool relaxed) {
     // Walk two type trees together, and complain about differences
     auto a_insn = a->get_def(a_type);
     auto b_insn = b->get_def(b_type);
@@ -1200,8 +1195,7 @@
             return false;
         if (relaxed && is_narrow_numeric_type(a->get_def(a_insn.word(2)))) {
             return a_insn.word(3) >= b_insn.word(3);
-        }
-        else {
+        } else {
             return a_insn.word(3) == b_insn.word(3);
         }
     case spv::OpTypeMatrix:
@@ -1261,8 +1255,8 @@
         return insn.word(3) * get_locations_consumed_by_type(src, insn.word(2), false);
     case spv::OpTypeVector: {
         auto scalar_type = src->get_def(insn.word(2));
-        auto bit_width = (scalar_type.opcode() == spv::OpTypeInt || scalar_type.opcode() == spv::OpTypeFloat) ?
-            scalar_type.word(2) : 32;
+        auto bit_width =
+            (scalar_type.opcode() == spv::OpTypeInt || scalar_type.opcode() == spv::OpTypeFloat) ? scalar_type.word(2) : 32;
 
         // Locations are 128-bit wide; 3- and 4-component vectors of 64 bit types require two.
         return (bit_width * insn.word(3) + 127) / 128;
@@ -1309,11 +1303,8 @@
 };
 
 static shader_stage_attributes shader_stage_attribs[] = {
-    {"vertex shader", false, false},
-    {"tessellation control shader", true, true},
-    {"tessellation evaluation shader", true, false},
-    {"geometry shader", true, false},
-    {"fragment shader", false, false},
+    {"vertex shader", false, false},  {"tessellation control shader", true, true}, {"tessellation evaluation shader", true, false},
+    {"geometry shader", true, false}, {"fragment shader", false, false},
 };
 
 static spirv_inst_iter get_struct_type(shader_module const *src, spirv_inst_iter def, bool is_array_of_verts) {
@@ -1332,8 +1323,7 @@
     }
 }
 
-static void collect_interface_block_members(shader_module const *src,
-                                            std::map<location_t, interface_var> *out,
+static void collect_interface_block_members(shader_module const *src, std::map<location_t, interface_var> *out,
                                             std::unordered_map<unsigned, unsigned> const &blocks, bool is_array_of_verts,
                                             uint32_t id, uint32_t type_id, bool is_patch) {
     // Walk down the type_id presented, trying to determine whether it's actually an interface block.
@@ -1391,9 +1381,8 @@
     }
 }
 
-static std::map<location_t, interface_var> collect_interface_by_location(
-        shader_module const *src, spirv_inst_iter entrypoint,
-        spv::StorageClass sinterface, bool is_array_of_verts) {
+static std::map<location_t, interface_var> collect_interface_by_location(shader_module const *src, spirv_inst_iter entrypoint,
+                                                                         spv::StorageClass sinterface, bool is_array_of_verts) {
 
     std::unordered_map<unsigned, unsigned> var_locations;
     std::unordered_map<unsigned, unsigned> var_builtins;
@@ -1491,9 +1480,9 @@
     return out;
 }
 
-static std::vector<std::pair<uint32_t, interface_var>> collect_interface_by_input_attachment_index(
-        debug_report_data *report_data, shader_module const *src,
-        std::unordered_set<uint32_t> const &accessible_ids) {
+static std::vector<std::pair<uint32_t, interface_var>>
+collect_interface_by_input_attachment_index(debug_report_data *report_data, shader_module const *src,
+                                            std::unordered_set<uint32_t> const &accessible_ids) {
 
     std::vector<std::pair<uint32_t, interface_var>> out;
 
@@ -1525,9 +1514,9 @@
     return out;
 }
 
-static std::vector<std::pair<descriptor_slot_t, interface_var>> collect_interface_by_descriptor_slot(
-        debug_report_data *report_data, shader_module const *src,
-        std::unordered_set<uint32_t> const &accessible_ids) {
+static std::vector<std::pair<descriptor_slot_t, interface_var>>
+collect_interface_by_descriptor_slot(debug_report_data *report_data, shader_module const *src,
+                                     std::unordered_set<uint32_t> const &accessible_ids) {
 
     std::unordered_map<unsigned, unsigned> var_sets;
     std::unordered_map<unsigned, unsigned> var_bindings;
@@ -1573,8 +1562,10 @@
                                               shader_stage_attributes const *consumer_stage) {
     bool pass = true;
 
-    auto outputs = collect_interface_by_location(producer, producer_entrypoint, spv::StorageClassOutput, producer_stage->arrayed_output);
-    auto inputs = collect_interface_by_location(consumer, consumer_entrypoint, spv::StorageClassInput, consumer_stage->arrayed_input);
+    auto outputs =
+        collect_interface_by_location(producer, producer_entrypoint, spv::StorageClassOutput, producer_stage->arrayed_output);
+    auto inputs =
+        collect_interface_by_location(consumer, consumer_entrypoint, spv::StorageClassInput, consumer_stage->arrayed_input);
 
     auto a_it = outputs.begin();
     auto b_it = inputs.begin();
@@ -1587,18 +1578,16 @@
         auto b_first = b_at_end ? std::make_pair(0u, 0u) : b_it->first;
 
         if (b_at_end || ((!a_at_end) && (a_first < b_first))) {
-            if (log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                        __LINE__, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC",
-                        "%s writes to output location %u.%u which is not consumed by %s", producer_stage->name, a_first.first,
-                        a_first.second, consumer_stage->name)) {
+            if (log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                        SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC", "%s writes to output location %u.%u which is not consumed by %s",
+                        producer_stage->name, a_first.first, a_first.second, consumer_stage->name)) {
                 pass = false;
             }
             a_it++;
         } else if (a_at_end || a_first > b_first) {
-            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                        __LINE__, SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC",
-                        "%s consumes input location %u.%u which is not written by %s", consumer_stage->name, b_first.first, b_first.second,
-                        producer_stage->name)) {
+            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                        SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", "%s consumes input location %u.%u which is not written by %s",
+                        consumer_stage->name, b_first.first, b_first.second, producer_stage->name)) {
                 pass = false;
             }
             b_it++;
@@ -1609,33 +1598,29 @@
             //   expressed in the member type -- it's expressed in the block type.
             if (!types_match(producer, consumer, a_it->second.type_id, b_it->second.type_id,
                              producer_stage->arrayed_output && !a_it->second.is_patch && !a_it->second.is_block_member,
-                             consumer_stage->arrayed_input && !b_it->second.is_patch && !b_it->second.is_block_member,
-                             true)) {
-                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                            __LINE__, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC", "Type mismatch on location %u.%u: '%s' vs '%s'",
-                            a_first.first, a_first.second,
-                            describe_type(producer, a_it->second.type_id).c_str(),
+                             consumer_stage->arrayed_input && !b_it->second.is_patch && !b_it->second.is_block_member, true)) {
+                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                            SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC", "Type mismatch on location %u.%u: '%s' vs '%s'",
+                            a_first.first, a_first.second, describe_type(producer, a_it->second.type_id).c_str(),
                             describe_type(consumer, b_it->second.type_id).c_str())) {
                     pass = false;
                 }
             }
             if (a_it->second.is_patch != b_it->second.is_patch) {
-                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0,
-                            __LINE__, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC",
+                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, __LINE__,
+                            SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC",
                             "Decoration mismatch on location %u.%u: is per-%s in %s stage but "
-                            "per-%s in %s stage", a_first.first, a_first.second,
-                            a_it->second.is_patch ? "patch" : "vertex", producer_stage->name,
+                            "per-%s in %s stage",
+                            a_first.first, a_first.second, a_it->second.is_patch ? "patch" : "vertex", producer_stage->name,
                             b_it->second.is_patch ? "patch" : "vertex", consumer_stage->name)) {
                     pass = false;
                 }
             }
             if (a_it->second.is_relaxed_precision != b_it->second.is_relaxed_precision) {
-                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0,
-                            __LINE__, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC",
-                            "Decoration mismatch on location %u.%u: %s and %s stages differ in precision",
-                            a_first.first, a_first.second,
-                            producer_stage->name,
-                            consumer_stage->name)) {
+                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, __LINE__,
+                            SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC",
+                            "Decoration mismatch on location %u.%u: %s and %s stages differ in precision", a_first.first,
+                            a_first.second, producer_stage->name, consumer_stage->name)) {
                     pass = false;
                 }
             }
@@ -1749,9 +1734,9 @@
         auto &binding = bindings[desc->binding];
         if (binding) {
             // TODO: VALIDATION_ERROR_02105 perhaps?
-            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                        __LINE__, SHADER_CHECKER_INCONSISTENT_VI, "SC",
-                        "Duplicate vertex input binding descriptions for binding %d", desc->binding)) {
+            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                        SHADER_CHECKER_INCONSISTENT_VI, "SC", "Duplicate vertex input binding descriptions for binding %d",
+                        desc->binding)) {
                 pass = false;
             }
         } else {
@@ -1790,15 +1775,15 @@
         auto b_first = b_at_end ? 0 : it_b->first.first;
         if (!a_at_end && (b_at_end || a_first < b_first)) {
             if (!used && log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                        __LINE__, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC",
-                        "Vertex attribute at location %d not consumed by vertex shader", a_first)) {
+                                 __LINE__, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC",
+                                 "Vertex attribute at location %d not consumed by vertex shader", a_first)) {
                 pass = false;
             }
             used = false;
             it_a++;
         } else if (!b_at_end && (a_at_end || b_first < a_first)) {
-            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0,
-                        __LINE__, SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", "Vertex shader consumes input at location %d but not provided",
+            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, __LINE__,
+                        SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", "Vertex shader consumes input at location %d but not provided",
                         b_first)) {
                 pass = false;
             }
@@ -1809,11 +1794,10 @@
 
             // Type checking
             if (attrib_type != FORMAT_TYPE_UNDEFINED && input_type != FORMAT_TYPE_UNDEFINED && attrib_type != input_type) {
-                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                            __LINE__, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC",
+                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                            SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC",
                             "Attribute type of `%s` at location %d does not match vertex shader input type of `%s`",
-                            string_VkFormat(it_a->second->format), a_first,
-                            describe_type(vs, it_b->second.type_id).c_str())) {
+                            string_VkFormat(it_a->second->format), a_first, describe_type(vs, it_b->second.type_id).c_str())) {
                     pass = false;
                 }
             }
@@ -1857,16 +1841,15 @@
         bool b_at_end = color_attachments.size() == 0 || it_b == color_attachments.end();
 
         if (!a_at_end && (b_at_end || it_a->first.first < it_b->first)) {
-            if (log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                        __LINE__, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC",
+            if (log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                        SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC",
                         "fragment shader writes to output location %d with no matching attachment", it_a->first.first)) {
                 pass = false;
             }
             it_a++;
         } else if (!b_at_end && (a_at_end || it_a->first.first > it_b->first)) {
-            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                        __LINE__, SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", "Attachment %d not written by fragment shader",
-                        it_b->first)) {
+            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                        SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", "Attachment %d not written by fragment shader", it_b->first)) {
                 pass = false;
             }
             it_b++;
@@ -1876,11 +1859,10 @@
 
             // Type checking
             if (att_type != FORMAT_TYPE_UNDEFINED && output_type != FORMAT_TYPE_UNDEFINED && att_type != output_type) {
-                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                            __LINE__, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC",
+                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                            SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC",
                             "Attachment %d of type `%s` does not match fragment shader output type of `%s`", it_b->first,
-                            string_VkFormat(it_b->second),
-                            describe_type(fs, it_a->second.type_id).c_str())) {
+                            string_VkFormat(it_b->second), describe_type(fs, it_a->second.type_id).c_str())) {
                     pass = false;
                 }
             }
@@ -2037,8 +2019,8 @@
                         found_range = true;
 
                         if ((range.stageFlags & stage) == 0) {
-                            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                                        __LINE__, SHADER_CHECKER_PUSH_CONSTANT_NOT_ACCESSIBLE_FROM_STAGE, "SC",
+                            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                                        SHADER_CHECKER_PUSH_CONSTANT_NOT_ACCESSIBLE_FROM_STAGE, "SC",
                                         "Push constant range covering variable starting at "
                                         "offset %u not accessible from stage %s",
                                         offset, string_VkShaderStageFlagBits(stage))) {
@@ -2051,8 +2033,8 @@
                 }
 
                 if (!found_range) {
-                    if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                                __LINE__, SHADER_CHECKER_PUSH_CONSTANT_OUT_OF_RANGE, "SC",
+                    if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                                SHADER_CHECKER_PUSH_CONSTANT_OUT_OF_RANGE, "SC",
                                 "Push constant range covering variable starting at "
                                 "offset %u not declared in layout",
                                 offset)) {
@@ -2084,7 +2066,8 @@
 
 // For given pipelineLayout verify that the set_layout_node at slot.first
 //  has the requested binding at slot.second and return ptr to that binding
-static VkDescriptorSetLayoutBinding const * get_descriptor_binding(PIPELINE_LAYOUT_NODE const *pipelineLayout, descriptor_slot_t slot) {
+static VkDescriptorSetLayoutBinding const *get_descriptor_binding(PIPELINE_LAYOUT_NODE const *pipelineLayout,
+                                                                  descriptor_slot_t slot) {
 
     if (!pipelineLayout)
         return nullptr;
@@ -2290,9 +2273,8 @@
             }
         }
 
-        if (!attachment_references_compatible(0, primaryRPCI->pSubpasses[spIndex].pDepthStencilAttachment,
-                                              1, primaryRPCI->pAttachments,
-                                              secondaryRPCI->pSubpasses[spIndex].pDepthStencilAttachment,
+        if (!attachment_references_compatible(0, primaryRPCI->pSubpasses[spIndex].pDepthStencilAttachment, 1,
+                                              primaryRPCI->pAttachments, secondaryRPCI->pSubpasses[spIndex].pDepthStencilAttachment,
                                               1, secondaryRPCI->pAttachments)) {
             stringstream errorStr;
             errorStr << "depth/stencil attachments of subpass index " << spIndex << " are not compatible.";
@@ -2363,8 +2345,8 @@
     return pass;
 }
 
-static bool descriptor_type_match(shader_module const *module, uint32_t type_id,
-                                  VkDescriptorType descriptor_type, unsigned &descriptor_count) {
+static bool descriptor_type_match(shader_module const *module, uint32_t type_id, VkDescriptorType descriptor_type,
+                                  unsigned &descriptor_count) {
     auto type = module->get_def(type_id);
 
     descriptor_count = 1;
@@ -2374,8 +2356,7 @@
         if (type.opcode() == spv::OpTypeArray) {
             descriptor_count *= get_constant_value(module, type.word(3));
             type = module->get_def(type.word(2));
-        }
-        else {
+        } else {
             type = module->get_def(type.word(3));
         }
     }
@@ -2399,8 +2380,7 @@
     }
 
     case spv::OpTypeSampler:
-        return descriptor_type == VK_DESCRIPTOR_TYPE_SAMPLER ||
-            descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+        return descriptor_type == VK_DESCRIPTOR_TYPE_SAMPLER || descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
 
     case spv::OpTypeSampledImage:
         if (descriptor_type == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) {
@@ -2429,7 +2409,7 @@
             }
         } else if (sampled == 1) {
             return descriptor_type == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE ||
-                descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+                   descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
         } else {
             return descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
         }
@@ -2443,10 +2423,9 @@
 
 static bool require_feature(debug_report_data *report_data, VkBool32 feature, char const *feature_name) {
     if (!feature) {
-        if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                    __LINE__, SHADER_CHECKER_FEATURE_NOT_ENABLED, "SC",
-                    "Shader requires VkPhysicalDeviceFeatures::%s but is not "
-                    "enabled on the device",
+        if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                    SHADER_CHECKER_FEATURE_NOT_ENABLED, "SC", "Shader requires VkPhysicalDeviceFeatures::%s but is not "
+                                                              "enabled on the device",
                     feature_name)) {
             return false;
         }
@@ -2459,7 +2438,6 @@
                                          VkPhysicalDeviceFeatures const *enabledFeatures) {
     bool pass = true;
 
-
     for (auto insn : *src) {
         if (insn.opcode() == spv::OpCapability) {
             switch (insn.word(1)) {
@@ -2502,7 +2480,8 @@
                 break;
 
             case spv::CapabilityStorageImageMultisample:
-                pass &= require_feature(report_data, enabledFeatures->shaderStorageImageMultisample, "shaderStorageImageMultisample");
+                pass &=
+                    require_feature(report_data, enabledFeatures->shaderStorageImageMultisample, "shaderStorageImageMultisample");
                 break;
 
             case spv::CapabilityUniformBufferArrayDynamicIndexing:
@@ -2554,7 +2533,8 @@
                 break;
 
             case spv::CapabilityImageMSArray:
-                pass &= require_feature(report_data, enabledFeatures->shaderStorageImageMultisample, "shaderStorageImageMultisample");
+                pass &=
+                    require_feature(report_data, enabledFeatures->shaderStorageImageMultisample, "shaderStorageImageMultisample");
                 break;
 
             case spv::CapabilityStorageImageExtendedFormats:
@@ -2581,9 +2561,8 @@
                 break;
 
             default:
-                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                            __LINE__, SHADER_CHECKER_BAD_CAPABILITY, "SC",
-                            "Shader declares capability %u, not supported in Vulkan.",
+                if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                            SHADER_CHECKER_BAD_CAPABILITY, "SC", "Shader declares capability %u, not supported in Vulkan.",
                             insn.word(1)))
                     pass = false;
                 break;
@@ -2594,7 +2573,6 @@
     return pass;
 }
 
-
 static uint32_t descriptor_type_to_reqs(shader_module const *module, uint32_t type_id) {
     auto type = module->get_def(type_id);
 
@@ -2617,14 +2595,14 @@
                 return arrayed ? DESCRIPTOR_REQ_VIEW_TYPE_1D_ARRAY : DESCRIPTOR_REQ_VIEW_TYPE_1D;
             case spv::Dim2D:
                 return (msaa ? DESCRIPTOR_REQ_MULTI_SAMPLE : DESCRIPTOR_REQ_SINGLE_SAMPLE) |
-                    (arrayed ? DESCRIPTOR_REQ_VIEW_TYPE_2D_ARRAY : DESCRIPTOR_REQ_VIEW_TYPE_2D);
+                       (arrayed ? DESCRIPTOR_REQ_VIEW_TYPE_2D_ARRAY : DESCRIPTOR_REQ_VIEW_TYPE_2D);
             case spv::Dim3D:
                 return DESCRIPTOR_REQ_VIEW_TYPE_3D;
             case spv::DimCube:
                 return arrayed ? DESCRIPTOR_REQ_VIEW_TYPE_CUBE_ARRAY : DESCRIPTOR_REQ_VIEW_TYPE_CUBE;
             case spv::DimSubpassData:
                 return msaa ? DESCRIPTOR_REQ_MULTI_SAMPLE : DESCRIPTOR_REQ_SINGLE_SAMPLE;
-            default:  // buffer, etc.
+            default: // buffer, etc.
                 return 0;
             }
         }
@@ -2649,7 +2627,7 @@
         if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__, VALIDATION_ERROR_00510,
                     "SC", "No entrypoint found named `%s` for stage %s. %s.", pStage->pName,
                     string_VkShaderStageFlagBits(pStage->stage), validation_error_map[VALIDATION_ERROR_00510])) {
-            return false;   // no point continuing beyond here, any analysis is just going to be garbage.
+            return false; // no point continuing beyond here, any analysis is just going to be garbage.
         }
     }
 
@@ -2670,7 +2648,7 @@
     // Validate descriptor use
     for (auto use : descriptor_uses) {
         // While validating shaders capture which slots are used by the pipeline
-        auto & reqs = pipeline->active_slots[use.first.first][use.first.second];
+        auto &reqs = pipeline->active_slots[use.first.first][use.first.second];
         reqs = descriptor_req(reqs | descriptor_type_to_reqs(module, use.second.type_id));
 
         // Verify given pipelineLayout has requested setLayout with requested binding
@@ -2678,24 +2656,22 @@
         unsigned required_descriptor_count;
 
         if (!binding) {
-            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                        __LINE__, SHADER_CHECKER_MISSING_DESCRIPTOR, "SC",
+            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
+                        SHADER_CHECKER_MISSING_DESCRIPTOR, "SC",
                         "Shader uses descriptor slot %u.%u (used as type `%s`) but not declared in pipeline layout",
                         use.first.first, use.first.second, describe_type(module, use.second.type_id).c_str())) {
                 pass = false;
             }
         } else if (~binding->stageFlags & pStage->stage) {
-            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
-                        0, __LINE__, SHADER_CHECKER_DESCRIPTOR_NOT_ACCESSIBLE_FROM_STAGE, "SC",
-                        "Shader uses descriptor slot %u.%u (used "
-                        "as type `%s`) but descriptor not "
-                        "accessible from stage %s",
+            if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, __LINE__,
+                        SHADER_CHECKER_DESCRIPTOR_NOT_ACCESSIBLE_FROM_STAGE, "SC", "Shader uses descriptor slot %u.%u (used "
+                                                                                   "as type `%s`) but descriptor not "
+                                                                                   "accessible from stage %s",
                         use.first.first, use.first.second, describe_type(module, use.second.type_id).c_str(),
                         string_VkShaderStageFlagBits(pStage->stage))) {
                 pass = false;
             }
-        } else if (!descriptor_type_match(module, use.second.type_id, binding->descriptorType,
-                                          required_descriptor_count)) {
+        } else if (!descriptor_type_match(module, use.second.type_id, binding->descriptorType, required_descriptor_count)) {
             if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
                         SHADER_CHECKER_DESCRIPTOR_TYPE_MISMATCH, "SC", "Type mismatch on descriptor slot "
                                                                        "%u.%u (used as type `%s`) but "
@@ -2724,24 +2700,21 @@
 
         for (auto use : input_attachment_uses) {
             auto input_attachments = rpci->pSubpasses[subpass].pInputAttachments;
-            auto index = (input_attachments && use.first < rpci->pSubpasses[subpass].inputAttachmentCount) ?
-                    input_attachments[use.first].attachment : VK_ATTACHMENT_UNUSED;
+            auto index = (input_attachments && use.first < rpci->pSubpasses[subpass].inputAttachmentCount)
+                             ? input_attachments[use.first].attachment
+                             : VK_ATTACHMENT_UNUSED;
 
             if (index == VK_ATTACHMENT_UNUSED) {
                 if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
                             SHADER_CHECKER_MISSING_INPUT_ATTACHMENT, "SC",
-                            "Shader consumes input attachment index %d but not provided in subpass",
-                            use.first)) {
+                            "Shader consumes input attachment index %d but not provided in subpass", use.first)) {
                     pass = false;
                 }
-            }
-            else if (get_format_type(rpci->pAttachments[index].format) !=
-                    get_fundamental_type(module, use.second.type_id)) {
+            } else if (get_format_type(rpci->pAttachments[index].format) != get_fundamental_type(module, use.second.type_id)) {
                 if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
                             SHADER_CHECKER_INPUT_ATTACHMENT_TYPE_MISMATCH, "SC",
-                            "Subpass input attachment %u format of %s does not match type used in shader `%s`",
-                            use.first, string_VkFormat(rpci->pAttachments[index].format),
-                            describe_type(module, use.second.type_id).c_str())) {
+                            "Subpass input attachment %u format of %s does not match type used in shader `%s`", use.first,
+                            string_VkFormat(rpci->pAttachments[index].format), describe_type(module, use.second.type_id).c_str())) {
                     pass = false;
                 }
             }
@@ -2751,7 +2724,6 @@
     return pass;
 }
 
-
 // Validate that the shaders used by the given pipeline and store the active_slots
 //  that are actually used by the pipeline into pPipeline->active_slots
 static bool
@@ -2772,8 +2744,7 @@
     for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) {
         auto pStage = &pCreateInfo->pStages[i];
         auto stage_id = get_shader_stage_id(pStage->stage);
-        pass &= validate_pipeline_shader_stage(report_data, pStage, pPipeline,
-                                               &shaders[stage_id], &entrypoints[stage_id],
+        pass &= validate_pipeline_shader_stage(report_data, pStage, pPipeline, &shaders[stage_id], &entrypoints[stage_id],
                                                enabledFeatures, shaderModuleMap);
     }
 
@@ -2802,9 +2773,9 @@
     for (; producer != fragment_stage && consumer <= fragment_stage; consumer++) {
         assert(shaders[producer]);
         if (shaders[consumer]) {
-            pass &= validate_interface_between_stages(report_data,
-                                                      shaders[producer], entrypoints[producer], &shader_stage_attribs[producer],
-                                                      shaders[consumer], entrypoints[consumer], &shader_stage_attribs[consumer]);
+            pass &= validate_interface_between_stages(report_data, shaders[producer], entrypoints[producer],
+                                                      &shader_stage_attribs[producer], shaders[consumer], entrypoints[consumer],
+                                                      &shader_stage_attribs[consumer]);
 
             producer = consumer;
         }
@@ -2826,8 +2797,8 @@
     shader_module *module;
     spirv_inst_iter entrypoint;
 
-    return validate_pipeline_shader_stage(report_data, &pCreateInfo->stage, pPipeline,
-                                          &module, &entrypoint, enabledFeatures, shaderModuleMap);
+    return validate_pipeline_shader_stage(report_data, &pCreateInfo->stage, pPipeline, &module, &entrypoint, enabledFeatures,
+                                          shaderModuleMap);
 }
 // Return Set node ptr for specified set or else NULL
 cvdescriptorset::DescriptorSet *getSetNode(const layer_data *my_data, VkDescriptorSet set) {
@@ -2847,7 +2818,7 @@
     return VK_SAMPLE_COUNT_1_BIT;
 }
 
-static void list_bits(std::ostream& s, uint32_t bits) {
+static void list_bits(std::ostream &s, uint32_t bits) {
     for (int i = 0; i < 32 && bits; i++) {
         if (bits & (1 << i)) {
             s << i;
@@ -2905,8 +2876,7 @@
                 list_bits(ss, missingViewportMask);
                 ss << " are used by pipeline state object, but were not provided via calls to vkCmdSetViewport().";
                 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                                     __LINE__, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS",
-                                     "%s", ss.str().c_str());
+                                     __LINE__, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", "%s", ss.str().c_str());
             }
         }
 
@@ -2919,8 +2889,7 @@
                 list_bits(ss, missingScissorMask);
                 ss << " are used by pipeline state object, but were not provided via calls to vkCmdSetScissor().";
                 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
-                                     __LINE__, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS",
-                                     "%s", ss.str().c_str());
+                                     __LINE__, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", "%s", ss.str().c_str());
             }
         }
     }
@@ -2939,13 +2908,13 @@
             if ((color_blend_state != NULL) && (pCB->activeSubpass == pPipeline->graphicsPipelineCI.subpass) &&
                 (color_blend_state->attachmentCount != subpass_desc->colorAttachmentCount)) {
                 skip_call |=
-                        log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
-                                reinterpret_cast<const uint64_t &>(pPipeline->pipeline), __LINE__, DRAWSTATE_INVALID_RENDERPASS, "DS",
-                                "Render pass subpass %u mismatch with blending state defined and blend state attachment "
-                                "count %u while subpass color attachment count %u in Pipeline (0x%" PRIxLEAST64 ")!  These "
-                                "must be the same at draw-time.",
-                                pCB->activeSubpass, color_blend_state->attachmentCount, subpass_desc->colorAttachmentCount,
-                                reinterpret_cast<const uint64_t &>(pPipeline->pipeline));
+                    log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
+                            reinterpret_cast<const uint64_t &>(pPipeline->pipeline), __LINE__, DRAWSTATE_INVALID_RENDERPASS, "DS",
+                            "Render pass subpass %u mismatch with blending state defined and blend state attachment "
+                            "count %u while subpass color attachment count %u in Pipeline (0x%" PRIxLEAST64 ")!  These "
+                            "must be the same at draw-time.",
+                            pCB->activeSubpass, color_blend_state->attachmentCount, subpass_desc->colorAttachmentCount,
+                            reinterpret_cast<const uint64_t &>(pPipeline->pipeline));
             }
 
             unsigned subpass_num_samples = 0;
@@ -2964,17 +2933,17 @@
 
             if (subpass_num_samples && static_cast<unsigned>(pso_num_samples) != subpass_num_samples) {
                 skip_call |=
-                        log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
-                                reinterpret_cast<const uint64_t &>(pPipeline->pipeline), __LINE__, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS",
-                                "Num samples mismatch! At draw-time in Pipeline (0x%" PRIxLEAST64
-                                ") with %u samples while current RenderPass (0x%" PRIxLEAST64 ") w/ %u samples!",
-                                reinterpret_cast<const uint64_t &>(pPipeline->pipeline), pso_num_samples,
-                                reinterpret_cast<const uint64_t &>(pCB->activeRenderPass->renderPass), subpass_num_samples);
+                    log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
+                            reinterpret_cast<const uint64_t &>(pPipeline->pipeline), __LINE__, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS",
+                            "Num samples mismatch! At draw-time in Pipeline (0x%" PRIxLEAST64
+                            ") with %u samples while current RenderPass (0x%" PRIxLEAST64 ") w/ %u samples!",
+                            reinterpret_cast<const uint64_t &>(pPipeline->pipeline), pso_num_samples,
+                            reinterpret_cast<const uint64_t &>(pCB->activeRenderPass->renderPass), subpass_num_samples);
             }
         } else {
             skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
-                                 reinterpret_cast<const uint64_t &>(pPipeline->pipeline), __LINE__, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS",
-                                 "No active render pass found at draw-time in Pipeline (0x%" PRIxLEAST64 ")!",
+                                 reinterpret_cast<const uint64_t &>(pPipeline->pipeline), __LINE__, DRAWSTATE_NUM_SAMPLES_MISMATCH,
+                                 "DS", "No active render pass found at draw-time in Pipeline (0x%" PRIxLEAST64 ")!",
                                  reinterpret_cast<const uint64_t &>(pPipeline->pipeline));
         }
     }
@@ -3039,8 +3008,8 @@
             if ((state.boundDescriptorSets.size() <= setIndex) || (!state.boundDescriptorSets[setIndex])) {
                 result |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
                                   DRAWSTATE_DESCRIPTOR_SET_NOT_BOUND, "DS",
-                                  "VkPipeline 0x%" PRIxLEAST64 " uses set #%u but that set is not bound.", (uint64_t)pPipe->pipeline,
-                                  setIndex);
+                                  "VkPipeline 0x%" PRIxLEAST64 " uses set #%u but that set is not bound.",
+                                  (uint64_t)pPipe->pipeline, setIndex);
             } else if (!verify_set_layout_compatibility(my_data, state.boundDescriptorSets[setIndex], &pipeline_layout, setIndex,
                                                         errorString)) {
                 // Set is bound but not compatible w/ overlapping pipeline_layout from PSO
@@ -3197,8 +3166,7 @@
                 }
             }
         }
-        if (!my_data->enabled_features.logicOp &&
-            (pPipeline->graphicsPipelineCI.pColorBlendState->logicOpEnable != VK_FALSE)) {
+        if (!my_data->enabled_features.logicOp && (pPipeline->graphicsPipelineCI.pColorBlendState->logicOpEnable != VK_FALSE)) {
             skip_call |=
                 log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
                         VALIDATION_ERROR_01533, "DS",
@@ -3417,8 +3385,9 @@
     }
     return skip_call;
 }
-//TODO: Consolidate functions
-bool FindLayout(const GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, IMAGE_CMD_BUF_LAYOUT_NODE &node, const VkImageAspectFlags aspectMask) {
+// TODO: Consolidate functions
+bool FindLayout(const GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, IMAGE_CMD_BUF_LAYOUT_NODE &node,
+                const VkImageAspectFlags aspectMask) {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(pCB->commandBuffer), layer_data_map);
     if (!(imgpair.subresource.aspectMask & aspectMask)) {
         return false;
@@ -3431,21 +3400,25 @@
     }
     if (node.layout != VK_IMAGE_LAYOUT_MAX_ENUM && node.layout != imgsubIt->second.layout) {
         log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                reinterpret_cast<uint64_t&>(imgpair.image), __LINE__, DRAWSTATE_INVALID_LAYOUT, "DS",
+                reinterpret_cast<uint64_t &>(imgpair.image), __LINE__, DRAWSTATE_INVALID_LAYOUT, "DS",
                 "Cannot query for VkImage 0x%" PRIx64 " layout when combined aspect mask %d has multiple layout types: %s and %s",
-                reinterpret_cast<uint64_t&>(imgpair.image), oldAspectMask, string_VkImageLayout(node.layout), string_VkImageLayout(imgsubIt->second.layout));
+                reinterpret_cast<uint64_t &>(imgpair.image), oldAspectMask, string_VkImageLayout(node.layout),
+                string_VkImageLayout(imgsubIt->second.layout));
     }
     if (node.initialLayout != VK_IMAGE_LAYOUT_MAX_ENUM && node.initialLayout != imgsubIt->second.initialLayout) {
         log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                reinterpret_cast<uint64_t&>(imgpair.image), __LINE__, DRAWSTATE_INVALID_LAYOUT, "DS",
-                "Cannot query for VkImage 0x%" PRIx64 " layout when combined aspect mask %d has multiple initial layout types: %s and %s",
-                reinterpret_cast<uint64_t&>(imgpair.image), oldAspectMask, string_VkImageLayout(node.initialLayout), string_VkImageLayout(imgsubIt->second.initialLayout));
+                reinterpret_cast<uint64_t &>(imgpair.image), __LINE__, DRAWSTATE_INVALID_LAYOUT, "DS",
+                "Cannot query for VkImage 0x%" PRIx64
+                " layout when combined aspect mask %d has multiple initial layout types: %s and %s",
+                reinterpret_cast<uint64_t &>(imgpair.image), oldAspectMask, string_VkImageLayout(node.initialLayout),
+                string_VkImageLayout(imgsubIt->second.initialLayout));
     }
     node = imgsubIt->second;
     return true;
 }
 
-bool FindLayout(const layer_data *my_data, ImageSubresourcePair imgpair, VkImageLayout &layout, const VkImageAspectFlags aspectMask) {
+bool FindLayout(const layer_data *my_data, ImageSubresourcePair imgpair, VkImageLayout &layout,
+                const VkImageAspectFlags aspectMask) {
     if (!(imgpair.subresource.aspectMask & aspectMask)) {
         return false;
     }
@@ -3457,9 +3430,10 @@
     }
     if (layout != VK_IMAGE_LAYOUT_MAX_ENUM && layout != imgsubIt->second.layout) {
         log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                reinterpret_cast<uint64_t&>(imgpair.image), __LINE__, DRAWSTATE_INVALID_LAYOUT, "DS",
+                reinterpret_cast<uint64_t &>(imgpair.image), __LINE__, DRAWSTATE_INVALID_LAYOUT, "DS",
                 "Cannot query for VkImage 0x%" PRIx64 " layout when combined aspect mask %d has multiple layout types: %s and %s",
-                reinterpret_cast<uint64_t&>(imgpair.image), oldAspectMask, string_VkImageLayout(layout), string_VkImageLayout(imgsubIt->second.layout));
+                reinterpret_cast<uint64_t &>(imgpair.image), oldAspectMask, string_VkImageLayout(layout),
+                string_VkImageLayout(imgsubIt->second.layout));
     }
     layout = imgsubIt->second.layout;
     return true;
@@ -4051,7 +4025,6 @@
 static void init_core_validation(instance_layer_data *instance_data, const VkAllocationCallbacks *pAllocator) {
 
     layer_debug_actions(instance_data->report_data, instance_data->logging_callback, pAllocator, "lunarg_core_validation");
-
 }
 
 static void checkInstanceRegisterExtensions(const VkInstanceCreateInfo *pCreateInfo, instance_layer_data *instance_data) {
@@ -4087,8 +4060,8 @@
     }
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
+                                              VkInstance *pInstance) {
     VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
 
     assert(chain_info->u.pLayerInfo);
@@ -4161,8 +4134,8 @@
     auto physical_device_state = getPhysicalDeviceState(instance_data, gpu);
     // First check is app has actually requested queueFamilyProperties
     if (!physical_device_state) {
-        skip_call |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
-                             0, __LINE__, DEVLIMITS_MUST_QUERY_COUNT, "DL",
+        skip_call |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                             VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DEVLIMITS_MUST_QUERY_COUNT, "DL",
                              "Invalid call to vkCreateDevice() w/o first calling vkEnumeratePhysicalDevices().");
     } else if (QUERY_DETAILS != physical_device_state->vkGetPhysicalDeviceQueueFamilyPropertiesState) {
         // TODO: This is not called out as an invalid use in the spec so make more informative recommendation.
@@ -4181,10 +4154,10 @@
             } else if (create_info->pQueueCreateInfos[i].queueCount >
                        physical_device_state->queue_family_properties[requestedIndex].queueCount) {
                 skip_call |=
-                    log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
-                            0, __LINE__, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL",
-                            "Invalid queue create request in vkCreateDevice(). QueueFamilyIndex %u only has %u queues, but "
-                            "requested queueCount is %u.",
+                    log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST,
+                            "DL", "Invalid queue create request in vkCreateDevice(). QueueFamilyIndex %u only has %u queues, but "
+                                  "requested queueCount is %u.",
                             requestedIndex, physical_device_state->queue_family_properties[requestedIndex].queueCount,
                             create_info->pQueueCreateInfos[i].queueCount);
             }
@@ -4194,7 +4167,8 @@
 }
 
 // Verify that features have been queried and that they are available
-static bool ValidateRequestedFeatures(instance_layer_data *dev_data, VkPhysicalDevice phys, const VkPhysicalDeviceFeatures *requested_features) {
+static bool ValidateRequestedFeatures(instance_layer_data *dev_data, VkPhysicalDevice phys,
+                                      const VkPhysicalDeviceFeatures *requested_features) {
     bool skip_call = false;
 
     auto phys_device_state = getPhysicalDeviceState(dev_data, phys);
@@ -4209,20 +4183,20 @@
         if (requested[i] > actual[i]) {
             // TODO: Add index to struct member name helper to be able to include a feature name
             skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DEVLIMITS_INVALID_FEATURE_REQUESTED,
-                "DL", "While calling vkCreateDevice(), requesting feature #%u in VkPhysicalDeviceFeatures struct, "
-                "which is not available on this device.",
-                i);
+                                 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DEVLIMITS_INVALID_FEATURE_REQUESTED,
+                                 "DL", "While calling vkCreateDevice(), requesting feature #%u in VkPhysicalDeviceFeatures struct, "
+                                       "which is not available on this device.",
+                                 i);
             errors++;
         }
     }
     if (errors && (UNCALLED == phys_device_state->vkGetPhysicalDeviceFeaturesState)) {
         // If user didn't request features, notify them that they should
         // TODO: Verify this against the spec. I believe this is an invalid use of the API and should return an error
-        skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                             VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DEVLIMITS_INVALID_FEATURE_REQUESTED,
-                             "DL", "You requested features that are unavailable on this device. You should first query feature "
-                                   "availability by calling vkGetPhysicalDeviceFeatures().");
+        skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
+                             0, __LINE__, DEVLIMITS_INVALID_FEATURE_REQUESTED, "DL",
+                             "You requested features that are unavailable on this device. You should first query feature "
+                             "availability by calling vkGetPhysicalDeviceFeatures().");
     }
     return skip_call;
 }
@@ -4367,10 +4341,10 @@
     for (auto cb_image_data : pCB->imageLayoutMap) {
         VkImageLayout imageLayout;
         if (!FindLayout(dev_data, cb_image_data.first, imageLayout)) {
-            skip_call |=
-                log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
-                        __LINE__, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Cannot submit cmd buffer using deleted image 0x%" PRIx64 ".",
-                        reinterpret_cast<const uint64_t &>(cb_image_data.first));
+            skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS",
+                                 "Cannot submit cmd buffer using deleted image 0x%" PRIx64 ".",
+                                 reinterpret_cast<const uint64_t &>(cb_image_data.first));
         } else {
             if (cb_image_data.second.initialLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
                 // TODO: Set memory invalid which is in mem_tracker currently
@@ -4379,12 +4353,12 @@
                     skip_call |= log_msg(
                         dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                         reinterpret_cast<uint64_t &>(pCB->commandBuffer), __LINE__, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS",
-                        "Cannot submit cmd buffer using image (0x%" PRIx64 ") [sub-resource: aspectMask 0x%X array layer %u, mip level %u], "
+                        "Cannot submit cmd buffer using image (0x%" PRIx64
+                        ") [sub-resource: aspectMask 0x%X array layer %u, mip level %u], "
                         "with layout %s when first use is %s.",
                         reinterpret_cast<const uint64_t &>(cb_image_data.first.image), cb_image_data.first.subresource.aspectMask,
-                                cb_image_data.first.subresource.arrayLayer,
-                                cb_image_data.first.subresource.mipLevel, string_VkImageLayout(imageLayout),
-                        string_VkImageLayout(cb_image_data.second.initialLayout));
+                        cb_image_data.first.subresource.arrayLayer, cb_image_data.first.subresource.mipLevel,
+                        string_VkImageLayout(imageLayout), string_VkImageLayout(cb_image_data.second.initialLayout));
                 } else {
                     skip_call |= log_msg(
                         dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
@@ -4601,18 +4575,18 @@
 
     // Roll this queue forward, one submission at a time.
     while (pQueue->seq < seq) {
-        auto & submission = pQueue->submissions.front();
+        auto &submission = pQueue->submissions.front();
 
-        for (auto & wait : submission.waitSemaphores) {
+        for (auto &wait : submission.waitSemaphores) {
             auto pSemaphore = getSemaphoreNode(dev_data, wait.semaphore);
             if (pSemaphore) {
                 pSemaphore->in_use.fetch_sub(1);
             }
-            auto & lastSeq = otherQueueSeqs[wait.queue];
+            auto &lastSeq = otherQueueSeqs[wait.queue];
             lastSeq = std::max(lastSeq, wait.seq);
         }
 
-        for (auto & semaphore : submission.signalSemaphores) {
+        for (auto &semaphore : submission.signalSemaphores) {
             auto pSemaphore = getSemaphoreNode(dev_data, semaphore);
             if (pSemaphore) {
                 pSemaphore->in_use.fetch_sub(1);
@@ -4665,7 +4639,6 @@
     }
 }
 
-
 // Submit a fence to a queue, delimiting previous fences and previous untracked
 // work by it.
 static void SubmitFence(QUEUE_STATE *pQueue, FENCE_NODE *pFence, uint64_t submitCount) {
@@ -4775,9 +4748,7 @@
     return skip_call;
 }
 
-static bool
-ValidateFenceForSubmit(layer_data *dev_data, FENCE_NODE *pFence)
-{
+static bool ValidateFenceForSubmit(layer_data *dev_data, FENCE_NODE *pFence) {
     bool skip_call = false;
 
     if (pFence) {
@@ -4801,9 +4772,7 @@
     return skip_call;
 }
 
-
-VKAPI_ATTR VkResult VKAPI_CALL
-QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) {
+VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
     VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
@@ -4909,9 +4878,7 @@
         // If no submissions, but just dropping a fence on the end of the queue,
         // record an empty submission with just the fence, so we can determine
         // its completion.
-        pQueue->submissions.emplace_back(std::vector<VkCommandBuffer>(),
-                                         std::vector<SEMAPHORE_WAIT>(),
-                                         std::vector<VkSemaphore>(),
+        pQueue->submissions.emplace_back(std::vector<VkCommandBuffer>(), std::vector<SEMAPHORE_WAIT>(), std::vector<VkSemaphore>(),
                                          fence);
     }
 
@@ -5123,11 +5090,13 @@
             // From spec: (ppData - offset) must be aligned to at least limits::minMemoryMapAlignment.
             uint64_t start_offset = offset % map_alignment;
             // Data passed to driver will be wrapped by a guardband of data to detect over- or under-writes.
-            mem_info->shadow_copy_base = malloc(static_cast<size_t>(2 * mem_info->shadow_pad_size + size + map_alignment + start_offset));
+            mem_info->shadow_copy_base =
+                malloc(static_cast<size_t>(2 * mem_info->shadow_pad_size + size + map_alignment + start_offset));
 
             mem_info->shadow_copy =
                 reinterpret_cast<char *>((reinterpret_cast<uintptr_t>(mem_info->shadow_copy_base) + map_alignment) &
-                                         ~(map_alignment - 1)) + start_offset;
+                                         ~(map_alignment - 1)) +
+                start_offset;
             assert(vk_safe_modulo(reinterpret_cast<uintptr_t>(mem_info->shadow_copy) + mem_info->shadow_pad_size - start_offset,
                                   map_alignment) == 0);
 
@@ -5161,8 +5130,7 @@
     if (pFence->signaler.first != VK_NULL_HANDLE) {
         // Fence signaller is a queue -- use this as proof that prior operations on that queue have completed.
         RetireWorkOnQueue(dev_data, getQueueState(dev_data, pFence->signaler.first), pFence->signaler.second);
-    }
-    else {
+    } else {
         // Fence signaller is the WSI. We're not tracking what the WSI op actually /was/ in CV yet, but we need to mark
         // the fence as retired.
         pFence->state = FENCE_RETIRED;
@@ -5192,8 +5160,8 @@
     //  vkGetFenceStatus() at which point we'll clean/remove their CBs if complete.
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout) {
+VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll,
+                                             uint64_t timeout) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     // Verify fence status of submitted fences
     std::unique_lock<std::mutex> lock(global_lock);
@@ -5248,8 +5216,7 @@
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
-                                                            VkQueue *pQueue) {
+VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->dispatch_table.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
     std::lock_guard<std::mutex> lock(global_lock);
@@ -5366,8 +5333,7 @@
 
 static void PostCallRecordDestroySemaphore(layer_data *dev_data, VkSemaphore sema) { dev_data->semaphoreMap.erase(sema); }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     SEMAPHORE_NODE *sema_node;
     VK_OBJECT obj_struct;
@@ -5425,13 +5391,13 @@
     return skip;
 }
 
-static void PostCallRecordDestroyQueryPool(layer_data *dev_data, VkQueryPool query_pool, QUERY_POOL_NODE *qp_state, VK_OBJECT obj_struct) {
+static void PostCallRecordDestroyQueryPool(layer_data *dev_data, VkQueryPool query_pool, QUERY_POOL_NODE *qp_state,
+                                           VK_OBJECT obj_struct) {
     invalidateCommandBuffers(dev_data, qp_state->cb_bindings, obj_struct);
     dev_data->queryPoolMap.erase(query_pool);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     QUERY_POOL_NODE *qp_state = nullptr;
     VK_OBJECT obj_struct;
@@ -5736,8 +5702,7 @@
     dev_data->bufferMap.erase(buffer_state->buffer);
 }
 
-VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer,
-                                         const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     BUFFER_STATE *buffer_state = nullptr;
     VK_OBJECT obj_struct;
@@ -5771,8 +5736,7 @@
     dev_data->bufferViewMap.erase(buffer_view);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     // Common data objects used pre & post call
     BUFFER_VIEW_STATE *buffer_view_state = nullptr;
@@ -5851,8 +5815,7 @@
     return skip_call;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset) {
+VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
     std::unique_lock<std::mutex> lock(global_lock);
@@ -5900,28 +5863,18 @@
         // Validate device limits alignments
         static const VkBufferUsageFlagBits usage_list[3] = {
             static_cast<VkBufferUsageFlagBits>(VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT),
-            VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
-            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT};
-        static const char *memory_type[3] = {"texel",
-                                             "uniform",
-                                             "storage"};
-        static const char *offset_name[3] = {
-            "minTexelBufferOffsetAlignment",
-            "minUniformBufferOffsetAlignment",
-            "minStorageBufferOffsetAlignment"
-        };
-        static const UNIQUE_VALIDATION_ERROR_CODE msgCode[3] = {
-            VALIDATION_ERROR_00794,
-            VALIDATION_ERROR_00795,
-            VALIDATION_ERROR_00796
-        };
+            VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT};
+        static const char *memory_type[3] = {"texel", "uniform", "storage"};
+        static const char *offset_name[3] = {"minTexelBufferOffsetAlignment", "minUniformBufferOffsetAlignment",
+                                             "minStorageBufferOffsetAlignment"};
+        static const UNIQUE_VALIDATION_ERROR_CODE msgCode[3] = {VALIDATION_ERROR_00794, VALIDATION_ERROR_00795,
+                                                                VALIDATION_ERROR_00796};
 
         // Keep this one fresh!
         const VkDeviceSize offset_requirement[3] = {
             dev_data->phys_dev_properties.properties.limits.minTexelBufferOffsetAlignment,
             dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment,
-            dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment
-        };
+            dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment};
         VkBufferUsageFlags usage = dev_data->bufferMap[buffer].get()->createInfo.usage;
 
         for (int i = 0; i < 3; i++) {
@@ -5944,8 +5897,8 @@
     return result;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) {
+VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+                                                       VkMemoryRequirements *pMemoryRequirements) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
     auto buffer_state = getBufferState(dev_data, buffer);
@@ -5955,8 +5908,7 @@
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL
-GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) {
+VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements);
     auto image_state = getImageState(dev_data, image);
@@ -5986,8 +5938,7 @@
     dev_data->imageViewMap.erase(image_view);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     // Common data objects used pre & post call
     IMAGE_VIEW_STATE *image_view_state = nullptr;
@@ -6002,8 +5953,8 @@
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
+                                               const VkAllocationCallbacks *pAllocator) {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
 
     std::unique_lock<std::mutex> lock(global_lock);
@@ -6033,8 +5984,7 @@
     dev_data->pipelineMap.erase(pipeline);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     PIPELINE_STATE *pipeline_state = nullptr;
     VK_OBJECT obj_struct;
@@ -6048,8 +5998,8 @@
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
+                                                 const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
     dev_data->pipelineLayoutMap.erase(pipelineLayout);
@@ -6079,8 +6029,7 @@
     dev_data->samplerMap.erase(sampler);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     SAMPLER_STATE *sampler_state = nullptr;
     VK_OBJECT obj_struct;
@@ -6098,8 +6047,8 @@
     dev_data->descriptorSetLayoutMap.erase(ds_layout);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
+                                                      const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->dispatch_table.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -6130,8 +6079,8 @@
     dev_data->descriptorPoolMap.erase(descriptorPool);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                                                 const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     DESCRIPTOR_POOL_STATE *desc_pool_state = nullptr;
     VK_OBJECT obj_struct;
@@ -6183,8 +6132,8 @@
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL
-FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) {
+VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
+                                              const VkCommandBuffer *pCommandBuffers) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     bool skip_call = false;
     std::unique_lock<std::mutex> lock(global_lock);
@@ -6221,8 +6170,7 @@
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
-                                                 const VkAllocationCallbacks *pAllocator,
-                                                 VkCommandPool *pCommandPool) {
+                                                 const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
 
     VkResult result = dev_data->dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
@@ -6310,8 +6258,7 @@
     }
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
+VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     bool skip_call = false;
 
@@ -6403,8 +6350,7 @@
     dev_data->frameBufferMap.erase(framebuffer);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     FRAMEBUFFER_STATE *framebuffer_state = nullptr;
     VK_OBJECT obj_struct;
@@ -6437,8 +6383,7 @@
     dev_data->renderPassMap.erase(render_pass);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     RENDER_PASS_STATE *rp_state = nullptr;
     VK_OBJECT obj_struct;
@@ -6714,8 +6659,8 @@
     return result;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
+                                           const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence);
     if (VK_SUCCESS == result) {
@@ -6736,21 +6681,21 @@
     return result;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
+                                                const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->dispatch_table.DestroyPipelineCache(device, pipelineCache, pAllocator);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData) {
+VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize,
+                                                    void *pData) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
     return result;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) {
+VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount,
+                                                   const VkPipelineCache *pSrcCaches) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->dispatch_table.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
     return result;
@@ -6780,7 +6725,8 @@
 static bool PreCallCreateGraphicsPipelines(layer_data *device_data, uint32_t count,
                                            const VkGraphicsPipelineCreateInfo *create_infos, vector<PIPELINE_STATE *> &pipe_state) {
     bool skip = false;
-    instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(device_data->instance_data->instance), instance_layer_data_map);
+    instance_layer_data *instance_data =
+        get_my_data_ptr(get_dispatch_key(device_data->instance_data->instance), instance_layer_data_map);
 
     for (uint32_t i = 0; i < count; i++) {
         skip |= verifyPipelineCreateState(device_data, pipe_state, i);
@@ -6804,10 +6750,9 @@
     return skip;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
-                        const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator,
-                        VkPipeline *pPipelines) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
+                                                       const VkGraphicsPipelineCreateInfo *pCreateInfos,
+                                                       const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
     // TODO What to do with pipelineCache?
     // The order of operations here is a little convoluted but gets the job done
     //  1. Pipeline create state is first shadowed into PIPELINE_STATE struct
@@ -6838,13 +6783,13 @@
     }
 
     lock.unlock();
-    auto result = dev_data->dispatch_table.CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
+    auto result =
+        dev_data->dispatch_table.CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
     lock.lock();
     for (i = 0; i < count; i++) {
         if (pPipelines[i] == VK_NULL_HANDLE) {
             delete pipe_state[i];
-        }
-        else {
+        } else {
             pipe_state[i]->pipeline = pPipelines[i];
             dev_data->pipelineMap[pipe_state[i]->pipeline] = pipe_state[i];
         }
@@ -6853,10 +6798,9 @@
     return result;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
-                       const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator,
-                       VkPipeline *pPipelines) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
+                                                      const VkComputePipelineCreateInfo *pCreateInfos,
+                                                      const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
     bool skip = false;
 
     // TODO : Improve this data struct w/ unique_ptrs so cleanup below is automatic
@@ -6875,7 +6819,7 @@
 
         // TODO: Add Compute Pipeline Verification
         skip |= !validate_compute_pipeline(dev_data->report_data, pPipeState[i], &dev_data->enabled_features,
-                                                dev_data->shaderModuleMap);
+                                           dev_data->shaderModuleMap);
         // skip |= verifyPipelineCreateState(dev_data, pPipeState[i]);
     }
 
@@ -6889,13 +6833,13 @@
     }
 
     lock.unlock();
-    auto result = dev_data->dispatch_table.CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
+    auto result =
+        dev_data->dispatch_table.CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
     lock.lock();
     for (i = 0; i < count; i++) {
         if (pPipelines[i] == VK_NULL_HANDLE) {
             delete pPipeState[i];
-        }
-        else {
+        } else {
             pPipeState[i]->pipeline = pPipelines[i];
             dev_data->pipelineMap[pPipeState[i]->pipeline] = pPipeState[i];
         }
@@ -6927,9 +6871,9 @@
     dev_data->descriptorSetLayoutMap[set_layout] = new cvdescriptorset::DescriptorSetLayout(create_info, set_layout);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
-                          const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
+                                                         const VkAllocationCallbacks *pAllocator,
+                                                         VkDescriptorSetLayout *pSetLayout) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7045,8 +6989,7 @@
     return skip_call;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo,
+VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo,
                                                     const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -7100,9 +7043,8 @@
     return result;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
-                     VkDescriptorPool *pDescriptorPool) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo,
+                                                    const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->dispatch_table.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
     if (VK_SUCCESS == result) {
@@ -7126,8 +7068,8 @@
     return result;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
+VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                                                   VkDescriptorPoolResetFlags flags) {
     // TODO : Add checks for VALIDATION_ERROR_00928
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->dispatch_table.ResetDescriptorPool(device, descriptorPool, flags);
@@ -7156,8 +7098,8 @@
                                                    &dev_data->setMap, dev_data);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets) {
+VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
+                                                      VkDescriptorSet *pDescriptorSets) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
     cvdescriptorset::AllocateDescriptorSetsData common_data(pAllocateInfo->descriptorSetCount);
@@ -7218,8 +7160,8 @@
     }
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet *pDescriptorSets) {
+VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count,
+                                                  const VkDescriptorSet *pDescriptorSets) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     // Make sure that no sets being destroyed are in-flight
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7263,9 +7205,9 @@
                                                  pDescriptorCopies);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites,
-                     uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies) {
+VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+                                                const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount,
+                                                const VkCopyDescriptorSet *pDescriptorCopies) {
     // Only map look-up at top level is for device-level layer_data
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7282,8 +7224,8 @@
     }
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pCreateInfo, VkCommandBuffer *pCommandBuffer) {
+VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pCreateInfo,
+                                                      VkCommandBuffer *pCommandBuffer) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->dispatch_table.AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
     if (VK_SUCCESS == result) {
@@ -7326,8 +7268,7 @@
     }
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) {
+VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7351,8 +7292,8 @@
                 skip_call |=
                     log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                             reinterpret_cast<uint64_t>(commandBuffer), __LINE__, VALIDATION_ERROR_00106, "DS",
-                            "vkBeginCommandBuffer(): Secondary Command Buffer (0x%p) must have inheritance info. %s",
-                            commandBuffer, validation_error_map[VALIDATION_ERROR_00106]);
+                            "vkBeginCommandBuffer(): Secondary Command Buffer (0x%p) must have inheritance info. %s", commandBuffer,
+                            validation_error_map[VALIDATION_ERROR_00106]);
             } else {
                 if (pBeginInfo->flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) {
                     // Object_tracker makes sure these objects are valid
@@ -7397,9 +7338,8 @@
                 if (renderPass) {
                     if (pInfo->subpass >= renderPass->createInfo.subpassCount) {
                         skip_call |= log_msg(
-                            dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                            VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__,
-                            VALIDATION_ERROR_00111, "DS",
+                            dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                            (uint64_t)commandBuffer, __LINE__, VALIDATION_ERROR_00111, "DS",
                             "vkBeginCommandBuffer(): Secondary Command Buffers (0x%p) must have a subpass index (%d) "
                             "that is less than the number of subpasses (%d). %s",
                             commandBuffer, pInfo->subpass, renderPass->createInfo.subpassCount,
@@ -7409,12 +7349,11 @@
             }
         }
         if (CB_RECORDING == cb_node->state) {
-            skip_call |=
-                log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                        (uint64_t)commandBuffer, __LINE__, VALIDATION_ERROR_00103, "DS",
-                        "vkBeginCommandBuffer(): Cannot call Begin on command buffer (0x%p"
-                        ") in the RECORDING state. Must first call vkEndCommandBuffer(). %s",
-                        commandBuffer, validation_error_map[VALIDATION_ERROR_00103]);
+            skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__,
+                                 VALIDATION_ERROR_00103, "DS", "vkBeginCommandBuffer(): Cannot call Begin on command buffer (0x%p"
+                                                               ") in the RECORDING state. Must first call vkEndCommandBuffer(). %s",
+                                 commandBuffer, validation_error_map[VALIDATION_ERROR_00103]);
         } else if (CB_RECORDED == cb_node->state || (CB_INVALID == cb_node->state && CMD_END == cb_node->last_cmd)) {
             VkCommandPool cmdPool = cb_node->createInfo.commandPool;
             auto pPool = getCommandPoolNode(dev_data, cmdPool);
@@ -7492,8 +7431,7 @@
     return result;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
+VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7521,8 +7459,8 @@
     return result;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                           VkPipeline pipeline) {
     bool skip = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7567,8 +7505,8 @@
         dev_data->dispatch_table.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports) {
+VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
+                                          const VkViewport *pViewports) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7576,15 +7514,15 @@
     if (pCB) {
         skip_call |= ValidateCmd(dev_data, pCB, CMD_SETVIEWPORTSTATE, "vkCmdSetViewport()");
         UpdateCmdBufferLastCmd(dev_data, pCB, CMD_SETVIEWPORTSTATE);
-        pCB->viewportMask |= ((1u<<viewportCount) - 1u) << firstViewport;
+        pCB->viewportMask |= ((1u << viewportCount) - 1u) << firstViewport;
     }
     lock.unlock();
     if (!skip_call)
         dev_data->dispatch_table.CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors) {
+VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount,
+                                         const VkRect2D *pScissors) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7592,7 +7530,7 @@
     if (pCB) {
         skip_call |= ValidateCmd(dev_data, pCB, CMD_SETSCISSORSTATE, "vkCmdSetScissor()");
         UpdateCmdBufferLastCmd(dev_data, pCB, CMD_SETSCISSORSTATE);
-        pCB->scissorMask |= ((1u<<scissorCount) - 1u) << firstScissor;
+        pCB->scissorMask |= ((1u << scissorCount) - 1u) << firstScissor;
     }
     lock.unlock();
     if (!skip_call)
@@ -7625,8 +7563,8 @@
         dev_data->dispatch_table.CmdSetLineWidth(commandBuffer, lineWidth);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
+VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp,
+                                           float depthBiasSlopeFactor) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7656,8 +7594,7 @@
         dev_data->dispatch_table.CmdSetBlendConstants(commandBuffer, blendConstants);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
+VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7672,8 +7609,8 @@
         dev_data->dispatch_table.CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
+VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                                    uint32_t compareMask) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7688,8 +7625,7 @@
         dev_data->dispatch_table.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
+VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7704,8 +7640,7 @@
         dev_data->dispatch_table.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
+VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7720,10 +7655,10 @@
         dev_data->dispatch_table.CmdSetStencilReference(commandBuffer, faceMask, reference);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
-                      uint32_t firstSet, uint32_t setCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
-                      const uint32_t *pDynamicOffsets) {
+VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                 VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount,
+                                                 const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
+                                                 const uint32_t *pDynamicOffsets) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -7824,15 +7759,13 @@
                                                       pDynamicOffsets + totalDynamicDescriptors + setDynamicDescriptorCount);
                             // Keep running total of dynamic descriptor count to verify at the end
                             totalDynamicDescriptors += setDynamicDescriptorCount;
-
                         }
                     }
                 } else {
-                    skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                                         VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pDescriptorSets[i], __LINE__,
-                                         DRAWSTATE_INVALID_SET, "DS", "Attempt to bind descriptor set 0x%" PRIxLEAST64
-                                         " that doesn't exist!",
-                                         (uint64_t)pDescriptorSets[i]);
+                    skip_call |= log_msg(
+                        dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+                        (uint64_t)pDescriptorSets[i], __LINE__, DRAWSTATE_INVALID_SET, "DS",
+                        "Attempt to bind descriptor set 0x%" PRIxLEAST64 " that doesn't exist!", (uint64_t)pDescriptorSets[i]);
                 }
                 skip_call |= ValidateCmd(dev_data, pCB, CMD_BINDDESCRIPTORSETS, "vkCmdBindDescriptorSets()");
                 UpdateCmdBufferLastCmd(dev_data, pCB, CMD_BINDDESCRIPTORSETS);
@@ -7891,8 +7824,8 @@
                                                        pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                              VkIndexType indexType) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // TODO : Somewhere need to verify that IBs have correct usage state flagged
@@ -7947,9 +7880,8 @@
 
 static inline void updateResourceTrackingOnDraw(GLOBAL_CB_NODE *pCB) { pCB->drawData.push_back(pCB->currentDrawData); }
 
-VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
-                                                uint32_t bindingCount, const VkBuffer *pBuffers,
-                                                const VkDeviceSize *pOffsets) {
+VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
+                                                const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // TODO : Somewhere need to verify that VBs have correct usage state flagged
@@ -8069,9 +8001,8 @@
     UpdateStateCmdDrawType(dev_data, cb_state, bind_point, CMD_DRAWINDEXED, DRAW_INDEXED);
 }
 
-VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
-                                          uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
-                                                            uint32_t firstInstance) {
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
+                                          uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     GLOBAL_CB_NODE *cb_state = nullptr;
     std::unique_lock<std::mutex> lock(global_lock);
@@ -8102,8 +8033,8 @@
     AddCommandBufferBindingBuffer(dev_data, cb_state, buffer_state);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
+                                           uint32_t stride) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     GLOBAL_CB_NODE *cb_state = nullptr;
     BUFFER_STATE *buffer_state = nullptr;
@@ -8135,8 +8066,8 @@
     AddCommandBufferBindingBuffer(dev_data, cb_state, buffer_state);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
+VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                  uint32_t count, uint32_t stride) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     GLOBAL_CB_NODE *cb_state = nullptr;
     BUFFER_STATE *buffer_state = nullptr;
@@ -8193,8 +8124,7 @@
     AddCommandBufferBindingBuffer(dev_data, cb_state, buffer_state);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
+VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     GLOBAL_CB_NODE *cb_state = nullptr;
     BUFFER_STATE *buffer_state = nullptr;
@@ -8421,7 +8351,7 @@
 // Returns the image transfer granularity for a specific image scaled by compressed block size if necessary.
 static inline VkExtent3D GetScaledItg(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *img) {
     // Default to (0, 0, 0) granularity in case we can't find the real granularity for the physical device.
-    VkExtent3D granularity = { 0, 0, 0 };
+    VkExtent3D granularity = {0, 0, 0};
     auto pPool = getCommandPoolNode(dev_data, cb_node->createInfo.commandPool);
     if (pPool) {
         granularity = dev_data->phys_dev_properties.queue_family_properties[pPool->queueFamilyIndex].minImageTransferGranularity;
@@ -8589,9 +8519,9 @@
     return skip;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
-             VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) {
+VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                        VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
+                                        const VkImageCopy *pRegions) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -8655,9 +8585,9 @@
     return skip;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
-             VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter) {
+VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                        VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
+                                        const VkImageBlit *pRegions, VkFilter filter) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -8702,9 +8632,9 @@
                                               pRegions, filter);
 }
 
-VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
-                                                VkImage dstImage, VkImageLayout dstImageLayout,
-                                                uint32_t regionCount, const VkBufferImageCopy *pRegions) {
+VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
+                                                VkImageLayout dstImageLayout, uint32_t regionCount,
+                                                const VkBufferImageCopy *pRegions) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -8749,9 +8679,8 @@
         dev_data->dispatch_table.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
-                                                VkImageLayout srcImageLayout, VkBuffer dstBuffer,
-                                                uint32_t regionCount, const VkBufferImageCopy *pRegions) {
+VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                                VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -8800,8 +8729,8 @@
         dev_data->dispatch_table.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 }
 
-VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
-                                           VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t *pData) {
+VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                           VkDeviceSize dataSize, const uint32_t *pData) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -8832,8 +8761,8 @@
         dev_data->dispatch_table.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                         VkDeviceSize size, uint32_t data) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -8866,10 +8795,8 @@
 
 // Returns true if sub_rect is entirely contained within rect
 static inline bool ContainsRect(VkRect2D rect, VkRect2D sub_rect) {
-    if ((sub_rect.offset.x < rect.offset.x) ||
-        (sub_rect.offset.x + sub_rect.extent.width > rect.offset.x + rect.extent.width) ||
-        (sub_rect.offset.y < rect.offset.y) ||
-        (sub_rect.offset.y + sub_rect.extent.height > rect.offset.y + rect.extent.height))
+    if ((sub_rect.offset.x < rect.offset.x) || (sub_rect.offset.x + sub_rect.extent.width > rect.offset.x + rect.extent.width) ||
+        (sub_rect.offset.y < rect.offset.y) || (sub_rect.offset.y + sub_rect.extent.height > rect.offset.y + rect.extent.height))
         return false;
     return true;
 }
@@ -8983,9 +8910,9 @@
         dev_data->dispatch_table.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 }
 
-VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
-                                              VkImageLayout imageLayout, const VkClearColorValue *pColor,
-                                              uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
+VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
+                                              const VkClearColorValue *pColor, uint32_t rangeCount,
+                                              const VkImageSubresourceRange *pRanges) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -9016,10 +8943,9 @@
         dev_data->dispatch_table.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
-                          const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
-                          const VkImageSubresourceRange *pRanges) {
+VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
+                                                     const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
+                                                     const VkImageSubresourceRange *pRanges) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -9050,9 +8976,9 @@
         dev_data->dispatch_table.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
-                VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions) {
+VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                           VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
+                                           const VkImageResolve *pRegions) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -9101,8 +9027,7 @@
     return false;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -9132,8 +9057,7 @@
         dev_data->dispatch_table.CmdSetEvent(commandBuffer, event, stageMask);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -9165,26 +9089,24 @@
 }
 
 static bool TransitionImageAspectLayout(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkImageMemoryBarrier *mem_barrier,
-                                        uint32_t level, uint32_t layer, VkImageAspectFlags aspect)
-{
+                                        uint32_t level, uint32_t layer, VkImageAspectFlags aspect) {
     if (!(mem_barrier->subresourceRange.aspectMask & aspect)) {
         return false;
     }
     VkImageSubresource sub = {aspect, level, layer};
     IMAGE_CMD_BUF_LAYOUT_NODE node;
     if (!FindLayout(pCB, mem_barrier->image, sub, node)) {
-        SetLayout(pCB, mem_barrier->image, sub,
-                  IMAGE_CMD_BUF_LAYOUT_NODE(mem_barrier->oldLayout, mem_barrier->newLayout));
+        SetLayout(pCB, mem_barrier->image, sub, IMAGE_CMD_BUF_LAYOUT_NODE(mem_barrier->oldLayout, mem_barrier->newLayout));
         return false;
     }
     bool skip = false;
     if (mem_barrier->oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
         // TODO: Set memory invalid which is in mem_tracker currently
     } else if (node.layout != mem_barrier->oldLayout) {
-        skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
-                        __LINE__, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS",
-                        "You cannot transition the layout of aspect %d from %s when current layout is %s.",
-                        aspect, string_VkImageLayout(mem_barrier->oldLayout), string_VkImageLayout(node.layout));
+        skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                        DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS",
+                        "You cannot transition the layout of aspect %d from %s when current layout is %s.", aspect,
+                        string_VkImageLayout(mem_barrier->oldLayout), string_VkImageLayout(node.layout));
     }
     SetLayout(pCB, mem_barrier->image, sub, mem_barrier->newLayout);
     return skip;
@@ -9252,10 +9174,10 @@
     if ((accessMask & required_bit) || (!required_bit && (accessMask & optional_bits))) {
         if (accessMask & ~(required_bit | optional_bits)) {
             // TODO: Verify against Valid Use
-            skip_call |=
-                log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
-                        DRAWSTATE_INVALID_BARRIER, "DS", "Additional bits in %s accessMask 0x%X %s are specified when layout is %s.",
-                        type, accessMask, string_VkAccessFlags(accessMask).c_str(), string_VkImageLayout(layout));
+            skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                                 DRAWSTATE_INVALID_BARRIER, "DS",
+                                 "Additional bits in %s accessMask 0x%X %s are specified when layout is %s.", type, accessMask,
+                                 string_VkAccessFlags(accessMask).c_str(), string_VkImageLayout(layout));
         }
     } else {
         if (!required_bit) {
@@ -9302,9 +9224,9 @@
         break;
     }
     case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: {
-        skip_call |= ValidateMaskBits(my_data, cmdBuffer, accessMask, layout, 0,
-                                      VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
-                                      VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, type);
+        skip_call |= ValidateMaskBits(
+            my_data, cmdBuffer, accessMask, layout, 0,
+            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, type);
         break;
     }
     case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: {
@@ -9323,10 +9245,10 @@
     case VK_IMAGE_LAYOUT_UNDEFINED: {
         if (accessMask != 0) {
             // TODO: Verify against Valid Use section spec
-            skip_call |=
-                log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
-                        DRAWSTATE_INVALID_BARRIER, "DS", "Additional bits in %s accessMask 0x%X %s are specified when layout is %s.",
-                        type, accessMask, string_VkAccessFlags(accessMask).c_str(), string_VkImageLayout(layout));
+            skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                                 DRAWSTATE_INVALID_BARRIER, "DS",
+                                 "Additional bits in %s accessMask 0x%X %s are specified when layout is %s.", type, accessMask,
+                                 string_VkAccessFlags(accessMask).c_str(), string_VkImageLayout(layout));
         }
         break;
     }
@@ -9504,7 +9426,8 @@
     return skip;
 }
 
-bool validateEventStageMask(VkQueue queue, GLOBAL_CB_NODE *pCB, uint32_t eventCount, size_t firstEventIndex, VkPipelineStageFlags sourceStageMask) {
+bool validateEventStageMask(VkQueue queue, GLOBAL_CB_NODE *pCB, uint32_t eventCount, size_t firstEventIndex,
+                            VkPipelineStageFlags sourceStageMask) {
     bool skip_call = false;
     VkPipelineStageFlags stageMask = 0;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
@@ -9712,8 +9635,7 @@
     return false;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) {
+VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -9765,8 +9687,8 @@
         dev_data->dispatch_table.CmdEndQuery(commandBuffer, queryPool, slot);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
+VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                                             uint32_t queryCount) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -9827,9 +9749,9 @@
     return skip_call;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount,
-                        VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
+VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                                                   uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                                   VkDeviceSize stride, VkQueryResultFlags flags) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -9870,9 +9792,8 @@
                                                          stride, flags);
 }
 
-VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
-                                            VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
-                                            const void *pValues) {
+VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags,
+                                            uint32_t offset, uint32_t size, const void *pValues) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -9963,8 +9884,8 @@
         dev_data->dispatch_table.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
+VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
+                                             VkQueryPool queryPool, uint32_t slot) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -10192,8 +10113,7 @@
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
-                                                 const VkAllocationCallbacks *pAllocator,
-                                                 VkFramebuffer *pFramebuffer) {
+                                                 const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
     bool skip_call = PreCallValidateCreateFramebuffer(dev_data, pCreateInfo);
@@ -10246,7 +10166,7 @@
             // If no dependency exits an implicit dependency still might. If not, throw an error.
             std::unordered_set<uint32_t> processed_nodes;
             if (!(FindDependency(subpass, dependent_subpasses[k], subpass_to_node, processed_nodes) ||
-                FindDependency(dependent_subpasses[k], subpass, subpass_to_node, processed_nodes))) {
+                  FindDependency(dependent_subpasses[k], subpass, subpass_to_node, processed_nodes))) {
                 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
                                      __LINE__, DRAWSTATE_INVALID_RENDERPASS, "DS",
                                      "A dependency between subpasses %d and %d must exist but one is not specified.", subpass,
@@ -10311,7 +10231,7 @@
     bool skip_call = false;
     auto const pFramebufferInfo = framebuffer->createInfo.ptr();
     auto const pCreateInfo = renderPass->createInfo.ptr();
-    auto const & subpass_to_node = renderPass->subpassToNode;
+    auto const &subpass_to_node = renderPass->subpassToNode;
     std::vector<std::vector<uint32_t>> output_attachment_to_subpass(pCreateInfo->attachmentCount);
     std::vector<std::vector<uint32_t>> input_attachment_to_subpass(pCreateInfo->attachmentCount);
     std::vector<std::vector<uint32_t>> overlapping_attachments(pCreateInfo->attachmentCount);
@@ -10593,16 +10513,14 @@
     return skip_call;
 }
 
-
 VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo,
-                                                  const VkAllocationCallbacks *pAllocator,
-                                                  VkShaderModule *pShaderModule) {
+                                                  const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     bool skip_call = false;
 
     // Use SPIRV-Tools validator to try and catch any issues with the module itself
     spv_context ctx = spvContextCreate(SPV_ENV_VULKAN_1_0);
-    spv_const_binary_t binary { pCreateInfo->pCode, pCreateInfo->codeSize / sizeof(uint32_t) };
+    spv_const_binary_t binary{pCreateInfo->pCode, pCreateInfo->codeSize / sizeof(uint32_t)};
     spv_diagnostic diag = nullptr;
 
     auto result = spvValidate(ctx, &binary, &diag);
@@ -10633,15 +10551,13 @@
     if (attachment >= attachment_count && attachment != VK_ATTACHMENT_UNUSED) {
         skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
                              VALIDATION_ERROR_00325, "DS",
-                             "CreateRenderPass: %s attachment %d must be less than the total number of attachments %d. %s",
-                             type, attachment, attachment_count, validation_error_map[VALIDATION_ERROR_00325]);
+                             "CreateRenderPass: %s attachment %d must be less than the total number of attachments %d. %s", type,
+                             attachment, attachment_count, validation_error_map[VALIDATION_ERROR_00325]);
     }
     return skip_call;
 }
 
-static bool IsPowerOfTwo(unsigned x) {
-    return x && !(x & (x-1));
-}
+static bool IsPowerOfTwo(unsigned x) { return x && !(x & (x - 1)); }
 
 static bool ValidateRenderpassAttachmentUsage(layer_data *dev_data, const VkRenderPassCreateInfo *pCreateInfo) {
     bool skip_call = false;
@@ -10665,9 +10581,10 @@
             }
         }
 
-        auto subpass_performs_resolve = subpass.pResolveAttachments && std::any_of(
-            subpass.pResolveAttachments, subpass.pResolveAttachments + subpass.colorAttachmentCount,
-            [](VkAttachmentReference ref) { return ref.attachment != VK_ATTACHMENT_UNUSED; });
+        auto subpass_performs_resolve =
+            subpass.pResolveAttachments &&
+            std::any_of(subpass.pResolveAttachments, subpass.pResolveAttachments + subpass.colorAttachmentCount,
+                        [](VkAttachmentReference ref) { return ref.attachment != VK_ATTACHMENT_UNUSED; });
 
         unsigned sample_count = 0;
 
@@ -10693,8 +10610,7 @@
             if (!skip_call && attachment != VK_ATTACHMENT_UNUSED) {
                 sample_count |= (unsigned)pCreateInfo->pAttachments[attachment].samples;
 
-                if (subpass_performs_resolve &&
-                    pCreateInfo->pAttachments[attachment].samples == VK_SAMPLE_COUNT_1_BIT) {
+                if (subpass_performs_resolve && pCreateInfo->pAttachments[attachment].samples == VK_SAMPLE_COUNT_1_BIT) {
                     skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
                                          __LINE__, VALIDATION_ERROR_00351, "DS",
                                          "CreateRenderPass:  Subpass %u requests multisample resolve from attachment %u "
@@ -10800,10 +10716,11 @@
     return result;
 }
 
-static bool VerifyFramebufferAndRenderPassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin) {
+static bool VerifyFramebufferAndRenderPassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB,
+                                                  const VkRenderPassBeginInfo *pRenderPassBegin) {
     bool skip_call = false;
     auto const pRenderPassInfo = getRenderPassState(dev_data, pRenderPassBegin->renderPass)->createInfo.ptr();
-    auto const & framebufferInfo = dev_data->frameBufferMap[pRenderPassBegin->framebuffer]->createInfo;
+    auto const &framebufferInfo = dev_data->frameBufferMap[pRenderPassBegin->framebuffer]->createInfo;
     if (pRenderPassInfo->attachmentCount != framebufferInfo.attachmentCount) {
         skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
                              DRAWSTATE_INVALID_RENDERPASS, "DS", "You cannot start a render pass using a framebuffer "
@@ -10828,17 +10745,15 @@
                     SetLayout(pCB, image, sub, newNode);
                     continue;
                 }
-                if (newNode.layout != VK_IMAGE_LAYOUT_UNDEFINED &&
-                    newNode.layout != node.layout) {
-                    skip_call |=
-                        log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
-                                DRAWSTATE_INVALID_RENDERPASS, "DS",
-                                "You cannot start a render pass using attachment %u "
-                                "where the render pass initial layout is %s and the previous "
-                                "known layout of the attachment is %s. The layouts must match, or "
-                                "the render pass initial layout for the attachment must be "
-                                "VK_IMAGE_LAYOUT_UNDEFINED",
-                                i, string_VkImageLayout(newNode.layout), string_VkImageLayout(node.layout));
+                if (newNode.layout != VK_IMAGE_LAYOUT_UNDEFINED && newNode.layout != node.layout) {
+                    skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
+                                         __LINE__, DRAWSTATE_INVALID_RENDERPASS, "DS",
+                                         "You cannot start a render pass using attachment %u "
+                                         "where the render pass initial layout is %s and the previous "
+                                         "known layout of the attachment is %s. The layouts must match, or "
+                                         "the render pass initial layout for the attachment must be "
+                                         "VK_IMAGE_LAYOUT_UNDEFINED",
+                                         i, string_VkImageLayout(newNode.layout), string_VkImageLayout(node.layout));
                 }
             }
         }
@@ -10887,7 +10802,8 @@
     return skip_call;
 }
 
-static void TransitionFinalSubpassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin) {
+static void TransitionFinalSubpassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB,
+                                          const VkRenderPassBeginInfo *pRenderPassBegin) {
     auto renderPass = getRenderPassState(dev_data, pRenderPassBegin->renderPass);
     if (!renderPass)
         return;
@@ -10937,8 +10853,8 @@
             ((check_stencil_load_op == true) && (stencil_op == op)));
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents) {
+VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
+                                              VkSubpassContents contents) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -10952,8 +10868,7 @@
             for (uint32_t i = 0; i < renderPass->createInfo.attachmentCount; ++i) {
                 MT_FB_ATTACHMENT_INFO &fb_info = framebuffer->attachments[i];
                 auto pAttachment = &renderPass->createInfo.pAttachments[i];
-                if (FormatSpecificLoadAndStoreOpSettings(pAttachment->format, pAttachment->loadOp,
-                                                         pAttachment->stencilLoadOp,
+                if (FormatSpecificLoadAndStoreOpSettings(pAttachment->format, pAttachment->loadOp, pAttachment->stencilLoadOp,
                                                          VK_ATTACHMENT_LOAD_OP_CLEAR)) {
                     clear_op_size = static_cast<uint32_t>(i) + 1;
                     std::function<bool()> function = [=]() {
@@ -10962,16 +10877,14 @@
                     };
                     cb_node->validate_functions.push_back(function);
                 } else if (FormatSpecificLoadAndStoreOpSettings(pAttachment->format, pAttachment->loadOp,
-                                                                pAttachment->stencilLoadOp,
-                                                                VK_ATTACHMENT_LOAD_OP_DONT_CARE)) {
+                                                                pAttachment->stencilLoadOp, VK_ATTACHMENT_LOAD_OP_DONT_CARE)) {
                     std::function<bool()> function = [=]() {
                         SetImageMemoryValid(dev_data, getImageState(dev_data, fb_info.image), false);
                         return false;
                     };
                     cb_node->validate_functions.push_back(function);
                 } else if (FormatSpecificLoadAndStoreOpSettings(pAttachment->format, pAttachment->loadOp,
-                                                                pAttachment->stencilLoadOp,
-                                                                VK_ATTACHMENT_LOAD_OP_LOAD)) {
+                                                                pAttachment->stencilLoadOp, VK_ATTACHMENT_LOAD_OP_LOAD)) {
                     std::function<bool()> function = [=]() {
                         return ValidateImageMemoryIsValid(dev_data, getImageState(dev_data, fb_info.image),
                                                           "vkCmdBeginRenderPass()");
@@ -10989,12 +10902,12 @@
             if (clear_op_size > pRenderPassBegin->clearValueCount) {
                 skip_call |= log_msg(
                     dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
-                    reinterpret_cast<uint64_t &>(renderPass), __LINE__, VALIDATION_ERROR_00442,
-                    "DS", "In vkCmdBeginRenderPass() the VkRenderPassBeginInfo struct has a clearValueCount of %u but there must "
-                          "be at least %u entries in pClearValues array to account for the highest index attachment in renderPass "
-                          "0x%" PRIx64 " that uses VK_ATTACHMENT_LOAD_OP_CLEAR is %u. Note that the pClearValues array "
-                          "is indexed by attachment number so even if some pClearValues entries between 0 and %u correspond to "
-                          "attachments that aren't cleared they will be ignored. %s",
+                    reinterpret_cast<uint64_t &>(renderPass), __LINE__, VALIDATION_ERROR_00442, "DS",
+                    "In vkCmdBeginRenderPass() the VkRenderPassBeginInfo struct has a clearValueCount of %u but there must "
+                    "be at least %u entries in pClearValues array to account for the highest index attachment in renderPass "
+                    "0x%" PRIx64 " that uses VK_ATTACHMENT_LOAD_OP_CLEAR is %u. Note that the pClearValues array "
+                    "is indexed by attachment number so even if some pClearValues entries between 0 and %u correspond to "
+                    "attachments that aren't cleared they will be ignored. %s",
                     pRenderPassBegin->clearValueCount, clear_op_size, reinterpret_cast<uint64_t &>(renderPass), clear_op_size,
                     clear_op_size - 1, validation_error_map[VALIDATION_ERROR_00442]);
             }
@@ -11059,10 +10972,10 @@
     dev_data->dispatch_table.CmdNextSubpass(commandBuffer, contents);
 
     if (pCB) {
-      lock.lock();
-      pCB->activeSubpass++;
-      pCB->activeSubpassContents = contents;
-      TransitionSubpassLayouts(dev_data, pCB, &pCB->activeRenderPassBeginInfo, pCB->activeSubpass);
+        lock.lock();
+        pCB->activeSubpass++;
+        pCB->activeSubpassContents = contents;
+        TransitionSubpassLayouts(dev_data, pCB, &pCB->activeRenderPassBeginInfo, pCB->activeSubpass);
     }
 }
 
@@ -11085,16 +10998,15 @@
             for (size_t i = 0; i < rp_state->createInfo.attachmentCount; ++i) {
                 MT_FB_ATTACHMENT_INFO &fb_info = framebuffer->attachments[i];
                 auto pAttachment = &rp_state->createInfo.pAttachments[i];
-                if (FormatSpecificLoadAndStoreOpSettings(pAttachment->format, pAttachment->storeOp,
-                                                         pAttachment->stencilStoreOp, VK_ATTACHMENT_STORE_OP_STORE)) {
+                if (FormatSpecificLoadAndStoreOpSettings(pAttachment->format, pAttachment->storeOp, pAttachment->stencilStoreOp,
+                                                         VK_ATTACHMENT_STORE_OP_STORE)) {
                     std::function<bool()> function = [=]() {
                         SetImageMemoryValid(dev_data, getImageState(dev_data, fb_info.image), true);
                         return false;
                     };
                     pCB->validate_functions.push_back(function);
                 } else if (FormatSpecificLoadAndStoreOpSettings(pAttachment->format, pAttachment->storeOp,
-                                                                pAttachment->stencilStoreOp,
-                                                                VK_ATTACHMENT_STORE_OP_DONT_CARE)) {
+                                                                pAttachment->stencilStoreOp, VK_ATTACHMENT_STORE_OP_DONT_CARE)) {
                     std::function<bool()> function = [=]() {
                         SetImageMemoryValid(dev_data, getImageState(dev_data, fb_info.image), false);
                         return false;
@@ -11270,11 +11182,11 @@
         }
         auto fb = getFramebufferState(dev_data, secondary_fb);
         if (!fb) {
-            skip_call |=
-                log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
-                        DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS", "vkCmdExecuteCommands() called w/ invalid Cmd Buffer 0x%p "
-                                                                          "which has invalid framebuffer 0x%" PRIx64 ".",
-                        (void *)secondaryBuffer, (uint64_t)(secondary_fb));
+            skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                                 DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS",
+                                 "vkCmdExecuteCommands() called w/ invalid Cmd Buffer 0x%p "
+                                 "which has invalid framebuffer 0x%" PRIx64 ".",
+                                 (void *)secondaryBuffer, (uint64_t)(secondary_fb));
             return skip_call;
         }
         auto cb_renderpass = getRenderPassState(dev_data, pSubCB->beginInfo.pInheritanceInfo->renderPass);
@@ -11337,8 +11249,8 @@
     return skip_call;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer *pCommandBuffers) {
+VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
+                                              const VkCommandBuffer *pCommandBuffers) {
     bool skip_call = false;
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
@@ -11474,8 +11386,8 @@
     return skip_call;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void **ppData) {
+VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags,
+                                         void **ppData) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
 
     bool skip_call = false;
@@ -11765,8 +11677,8 @@
     return result;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) {
+VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo,
+                                               VkFence fence) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
     VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
     bool skip_call = false;
@@ -11847,8 +11759,7 @@
                                 "vkQueueBindSparse: Queue 0x%p is signaling semaphore 0x%" PRIx64
                                 ", but that semaphore is already signaled.",
                                 queue, reinterpret_cast<const uint64_t &>(semaphore));
-                }
-                else {
+                } else {
                     pSemaphore->signaler.first = queue;
                     pSemaphore->signaler.second = pQueue->seq + pQueue->submissions.size() + 1;
                     pSemaphore->signaled = true;
@@ -11858,17 +11769,13 @@
             }
         }
 
-        pQueue->submissions.emplace_back(std::vector<VkCommandBuffer>(),
-                                         semaphore_waits,
-                                         semaphore_signals,
+        pQueue->submissions.emplace_back(std::vector<VkCommandBuffer>(), semaphore_waits, semaphore_signals,
                                          bindIdx == bindInfoCount - 1 ? fence : VK_NULL_HANDLE);
     }
 
     if (pFence && !bindInfoCount) {
         // No work to do, just dropping a fence in the queue by itself.
-        pQueue->submissions.emplace_back(std::vector<VkCommandBuffer>(),
-                                         std::vector<SEMAPHORE_WAIT>(),
-                                         std::vector<VkSemaphore>(),
+        pQueue->submissions.emplace_back(std::vector<VkCommandBuffer>(), std::vector<SEMAPHORE_WAIT>(), std::vector<VkSemaphore>(),
                                          fence);
     }
 
@@ -11886,7 +11793,7 @@
     VkResult result = dev_data->dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
     if (result == VK_SUCCESS) {
         std::lock_guard<std::mutex> lock(global_lock);
-        SEMAPHORE_NODE* sNode = &dev_data->semaphoreMap[*pSemaphore];
+        SEMAPHORE_NODE *sNode = &dev_data->semaphoreMap[*pSemaphore];
         sNode->signaler.first = VK_NULL_HANDLE;
         sNode->signaler.second = 0;
         sNode->signaled = false;
@@ -11894,8 +11801,8 @@
     return result;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
+                                           const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent);
     if (result == VK_SUCCESS) {
@@ -12085,15 +11992,15 @@
             if (!foundFormat) {
                 if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
                             reinterpret_cast<uint64_t>(dev_data->device), __LINE__, VALIDATION_ERROR_02333, "DS",
-                            "%s called with a non-supported pCreateInfo->imageFormat (i.e. %d). %s",
-                            func_name, pCreateInfo->imageFormat, validation_error_map[VALIDATION_ERROR_02333]))
+                            "%s called with a non-supported pCreateInfo->imageFormat (i.e. %d). %s", func_name,
+                            pCreateInfo->imageFormat, validation_error_map[VALIDATION_ERROR_02333]))
                     return true;
             }
             if (!foundColorSpace) {
                 if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
                             reinterpret_cast<uint64_t>(dev_data->device), __LINE__, VALIDATION_ERROR_02333, "DS",
-                            "%s called with a non-supported pCreateInfo->imageColorSpace (i.e. %d). %s",
-                            func_name, pCreateInfo->imageColorSpace, validation_error_map[VALIDATION_ERROR_02333]))
+                            "%s called with a non-supported pCreateInfo->imageColorSpace (i.e. %d). %s", func_name,
+                            pCreateInfo->imageColorSpace, validation_error_map[VALIDATION_ERROR_02333]))
                     return true;
             }
         }
@@ -12110,8 +12017,7 @@
         }
     } else {
         // Validate pCreateInfo->presentMode against vkGetPhysicalDeviceSurfacePresentModesKHR():
-        bool foundMatch = std::find(physical_device_state->present_modes.begin(),
-                                    physical_device_state->present_modes.end(),
+        bool foundMatch = std::find(physical_device_state->present_modes.begin(), physical_device_state->present_modes.end(),
                                     pCreateInfo->presentMode) != physical_device_state->present_modes.end();
         if (!foundMatch) {
             if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
@@ -12161,8 +12067,7 @@
     return result;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     bool skip_call = false;
 
@@ -12202,8 +12107,8 @@
         dev_data->dispatch_table.DestroySwapchainKHR(device, swapchain, pAllocator);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pCount, VkImage *pSwapchainImages) {
+VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pCount,
+                                                     VkImage *pSwapchainImages) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->dispatch_table.GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
 
@@ -12276,21 +12181,22 @@
         auto swapchain_data = getSwapchainNode(dev_data, pPresentInfo->pSwapchains[i]);
         if (swapchain_data) {
             if (pPresentInfo->pImageIndices[i] >= swapchain_data->images.size()) {
-                skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
-                                     reinterpret_cast<uint64_t const &>(pPresentInfo->pSwapchains[i]), __LINE__, DRAWSTATE_SWAPCHAIN_INVALID_IMAGE,
-                                     "DS", "vkQueuePresentKHR: Swapchain image index too large (%u). There are only %u images in this swapchain.",
-                                     pPresentInfo->pImageIndices[i], (uint32_t)swapchain_data->images.size());
-            }
-            else {
+                skip_call |= log_msg(
+                    dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
+                    reinterpret_cast<uint64_t const &>(pPresentInfo->pSwapchains[i]), __LINE__, DRAWSTATE_SWAPCHAIN_INVALID_IMAGE,
+                    "DS", "vkQueuePresentKHR: Swapchain image index too large (%u). There are only %u images in this swapchain.",
+                    pPresentInfo->pImageIndices[i], (uint32_t)swapchain_data->images.size());
+            } else {
                 auto image = swapchain_data->images[pPresentInfo->pImageIndices[i]];
                 auto image_state = getImageState(dev_data, image);
                 skip_call |= ValidateImageMemoryIsValid(dev_data, image_state, "vkQueuePresentKHR()");
 
                 if (!image_state->acquired) {
-                    skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
-                                         reinterpret_cast<uint64_t const &>(pPresentInfo->pSwapchains[i]), __LINE__, DRAWSTATE_SWAPCHAIN_IMAGE_NOT_ACQUIRED,
-                                         "DS", "vkQueuePresentKHR: Swapchain image index %u has not been acquired.",
-                                         pPresentInfo->pImageIndices[i]);
+                    skip_call |= log_msg(
+                        dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
+                        reinterpret_cast<uint64_t const &>(pPresentInfo->pSwapchains[i]), __LINE__,
+                        DRAWSTATE_SWAPCHAIN_IMAGE_NOT_ACQUIRED, "DS",
+                        "vkQueuePresentKHR: Swapchain image index %u has not been acquired.", pPresentInfo->pImageIndices[i]);
                 }
 
                 vector<VkImageLayout> layouts;
@@ -12385,7 +12291,8 @@
             old_swapchain_state.push_back(getSwapchainNode(dev_data, pCreateInfos[i].oldSwapchain));
             std::stringstream func_name;
             func_name << "vkCreateSharedSwapchainsKHR[" << swapchainCount << "]";
-                if (PreCallValidateCreateSwapchainKHR(dev_data, func_name.str().c_str(), &pCreateInfos[i], surface_state[i], old_swapchain_state[i])) {
+            if (PreCallValidateCreateSwapchainKHR(dev_data, func_name.str().c_str(), &pCreateInfos[i], surface_state[i],
+                                                  old_swapchain_state[i])) {
                 return true;
             }
         }
@@ -12506,7 +12413,7 @@
     if (result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR) {
         if (pFence) {
             pFence->state = FENCE_INFLIGHT;
-            pFence->signaler.first = VK_NULL_HANDLE;   // ANI isn't on a queue, so this can't participate in a completion proof.
+            pFence->signaler.first = VK_NULL_HANDLE; // ANI isn't on a queue, so this can't participate in a completion proof.
         }
 
         // A successful call to AcquireNextImageKHR counts as a signal operation on semaphore
@@ -12570,25 +12477,24 @@
     return result;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
-    VkQueueFamilyProperties *pQueueFamilyProperties) {
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
+                                                                  VkQueueFamilyProperties *pQueueFamilyProperties) {
     bool skip_call = false;
     instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
     auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice);
     if (physical_device_state) {
         if (!pQueueFamilyProperties) {
             physical_device_state->vkGetPhysicalDeviceQueueFamilyPropertiesState = QUERY_COUNT;
-        }
-        else {
+        } else {
             // Verify that for each physical device, this function is called first with NULL pQueueFamilyProperties ptr in order to
             // get count
             if (UNCALLED == physical_device_state->vkGetPhysicalDeviceQueueFamilyPropertiesState) {
-                skip_call |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT,
-                    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DEVLIMITS_MISSING_QUERY_COUNT, "DL",
-                    "Call sequence has vkGetPhysicalDeviceQueueFamilyProperties() w/ non-NULL "
-                    "pQueueFamilyProperties. You should first call vkGetPhysicalDeviceQueueFamilyProperties() w/ "
-                    "NULL pQueueFamilyProperties to query pCount.");
+                skip_call |=
+                    log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT,
+                            VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DEVLIMITS_MISSING_QUERY_COUNT, "DL",
+                            "Call sequence has vkGetPhysicalDeviceQueueFamilyProperties() w/ non-NULL "
+                            "pQueueFamilyProperties. You should first call vkGetPhysicalDeviceQueueFamilyProperties() w/ "
+                            "NULL pQueueFamilyProperties to query pCount.");
             }
             // Then verify that pCount that is passed in on second call matches what was returned
             if (physical_device_state->queueFamilyPropertiesCount != *pCount) {
@@ -12596,10 +12502,10 @@
                 // TODO: this is not a requirement of the Valid Usage section for vkGetPhysicalDeviceQueueFamilyProperties, so
                 // provide as warning
                 skip_call |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT,
-                    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DEVLIMITS_COUNT_MISMATCH, "DL",
-                    "Call to vkGetPhysicalDeviceQueueFamilyProperties() w/ pCount value %u, but actual count "
-                    "supported by this physicalDevice is %u.",
-                    *pCount, physical_device_state->queueFamilyPropertiesCount);
+                                     VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DEVLIMITS_COUNT_MISMATCH, "DL",
+                                     "Call to vkGetPhysicalDeviceQueueFamilyProperties() w/ pCount value %u, but actual count "
+                                     "supported by this physicalDevice is %u.",
+                                     *pCount, physical_device_state->queueFamilyPropertiesCount);
             }
             physical_device_state->vkGetPhysicalDeviceQueueFamilyPropertiesState = QUERY_DETAILS;
         }
@@ -12609,16 +12515,14 @@
         instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
         if (!pQueueFamilyProperties) {
             physical_device_state->queueFamilyPropertiesCount = *pCount;
-        }
-        else { // Save queue family properties
+        } else { // Save queue family properties
             if (physical_device_state->queue_family_properties.size() < *pCount)
                 physical_device_state->queue_family_properties.resize(*pCount);
             for (uint32_t i = 0; i < *pCount; i++) {
                 physical_device_state->queue_family_properties[i] = pQueueFamilyProperties[i];
             }
         }
-    }
-    else {
+    } else {
         log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0,
                 __LINE__, VALIDATION_ERROR_00028, "DL",
                 "Invalid physicalDevice (0x%p) passed into vkGetPhysicalDeviceQueueFamilyProperties(). %s", physicalDevice,
@@ -12626,11 +12530,9 @@
     }
 }
 
-template<typename TCreateInfo, typename FPtr>
-static VkResult CreateSurface(VkInstance instance, TCreateInfo const *pCreateInfo,
-                              VkAllocationCallbacks const *pAllocator, VkSurfaceKHR *pSurface,
-                              FPtr fptr)
-{
+template <typename TCreateInfo, typename FPtr>
+static VkResult CreateSurface(VkInstance instance, TCreateInfo const *pCreateInfo, VkAllocationCallbacks const *pAllocator,
+                              VkSurfaceKHR *pSurface, FPtr fptr) {
     instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
 
     // Call down the call chain:
@@ -12705,12 +12607,11 @@
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
 VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
-                                                   const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+                                                    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
     return CreateSurface(instance, pCreateInfo, pAllocator, pSurface, &VkLayerInstanceDispatchTable::CreateXlibSurfaceKHR);
 }
 #endif // VK_USE_PLATFORM_XLIB_KHR
 
-
 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
                                                                        VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
     auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
@@ -12719,8 +12620,8 @@
     auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice);
     lock.unlock();
 
-    auto result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface,
-                                                                                        pSurfaceCapabilities);
+    auto result =
+        instance_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
 
     if (result == VK_SUCCESS) {
         physical_device_state->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState = QUERY_DETAILS;
@@ -12730,7 +12631,6 @@
     return result;
 }
 
-
 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
                                                                   VkSurfaceKHR surface, VkBool32 *pSupported) {
     auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
@@ -12738,8 +12638,8 @@
     auto surface_state = getSurfaceState(instance_data, surface);
     lock.unlock();
 
-    auto result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface,
-                                                                                   pSupported);
+    auto result =
+        instance_data->dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
 
     if (result == VK_SUCCESS) {
         surface_state->gpu_queue_support[{physicalDevice, queueFamilyIndex}] = (*pSupported != 0);
@@ -12748,7 +12648,6 @@
     return result;
 }
 
-
 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
                                                                        uint32_t *pPresentModeCount,
                                                                        VkPresentModeKHR *pPresentModes) {
@@ -12757,11 +12656,11 @@
     std::unique_lock<std::mutex> lock(global_lock);
     // TODO: this isn't quite right. available modes may differ by surface AND physical device.
     auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice);
-    auto & call_state = physical_device_state->vkGetPhysicalDeviceSurfacePresentModesKHRState;
+    auto &call_state = physical_device_state->vkGetPhysicalDeviceSurfacePresentModesKHRState;
 
     if (pPresentModes) {
         // Compare the preliminary value of *pPresentModeCount with the value this time:
-        auto prev_mode_count = (uint32_t) physical_device_state->present_modes.size();
+        auto prev_mode_count = (uint32_t)physical_device_state->present_modes.size();
         switch (call_state) {
         case UNCALLED:
             skip_call |= log_msg(
@@ -12774,11 +12673,11 @@
             // both query count and query details
             if (*pPresentModeCount != prev_mode_count) {
                 skip_call |= log_msg(
-                        instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
-                        reinterpret_cast<uint64_t>(physicalDevice), __LINE__, DEVLIMITS_COUNT_MISMATCH, "DL",
-                        "vkGetPhysicalDeviceSurfacePresentModesKHR() called with *pPresentModeCount (%u) that differs from the value "
-                        "(%u) that was returned when pPresentModes was NULL.",
-                        *pPresentModeCount, prev_mode_count);
+                    instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
+                    reinterpret_cast<uint64_t>(physicalDevice), __LINE__, DEVLIMITS_COUNT_MISMATCH, "DL",
+                    "vkGetPhysicalDeviceSurfacePresentModesKHR() called with *pPresentModeCount (%u) that differs from the value "
+                    "(%u) that was returned when pPresentModes was NULL.",
+                    *pPresentModeCount, prev_mode_count);
             }
             break;
         }
@@ -12788,19 +12687,22 @@
     if (skip_call)
         return VK_ERROR_VALIDATION_FAILED_EXT;
 
-    auto result = instance_data->dispatch_table.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+    auto result = instance_data->dispatch_table.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount,
+                                                                                        pPresentModes);
 
     if (result == VK_SUCCESS || result == VK_INCOMPLETE) {
 
         lock.lock();
 
         if (*pPresentModeCount) {
-            if (call_state < QUERY_COUNT) call_state = QUERY_COUNT;
+            if (call_state < QUERY_COUNT)
+                call_state = QUERY_COUNT;
             if (*pPresentModeCount > physical_device_state->present_modes.size())
                 physical_device_state->present_modes.resize(*pPresentModeCount);
         }
         if (pPresentModes) {
-            if (call_state < QUERY_DETAILS) call_state = QUERY_DETAILS;
+            if (call_state < QUERY_DETAILS)
+                call_state = QUERY_DETAILS;
             for (uint32_t i = 0; i < *pPresentModeCount; i++) {
                 physical_device_state->present_modes[i] = pPresentModes[i];
             }
@@ -12810,7 +12712,6 @@
     return result;
 }
 
-
 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
                                                                   uint32_t *pSurfaceFormatCount,
                                                                   VkSurfaceFormatKHR *pSurfaceFormats) {
@@ -12818,10 +12719,10 @@
     auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
     std::unique_lock<std::mutex> lock(global_lock);
     auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice);
-    auto & call_state = physical_device_state->vkGetPhysicalDeviceSurfaceFormatsKHRState;
+    auto &call_state = physical_device_state->vkGetPhysicalDeviceSurfaceFormatsKHRState;
 
     if (pSurfaceFormats) {
-        auto prev_format_count = (uint32_t) physical_device_state->surface_formats.size();
+        auto prev_format_count = (uint32_t)physical_device_state->surface_formats.size();
 
         switch (call_state) {
         case UNCALLED:
@@ -12836,11 +12737,12 @@
         default:
             if (prev_format_count != *pSurfaceFormatCount) {
                 skip_call |= log_msg(
-                        instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
-                        reinterpret_cast<uint64_t>(physicalDevice), __LINE__, DEVLIMITS_COUNT_MISMATCH, "DL",
-                        "vkGetPhysicalDeviceSurfaceFormatsKHR() called with non-NULL pSurfaceFormatCount, and with pSurfaceFormats set to "
-                        "a value (%u) that is greater than the value (%u) that was returned when pSurfaceFormatCount was NULL.",
-                        *pSurfaceFormatCount, prev_format_count);
+                    instance_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
+                    reinterpret_cast<uint64_t>(physicalDevice), __LINE__, DEVLIMITS_COUNT_MISMATCH, "DL",
+                    "vkGetPhysicalDeviceSurfaceFormatsKHR() called with non-NULL pSurfaceFormatCount, and with pSurfaceFormats set "
+                    "to "
+                    "a value (%u) that is greater than the value (%u) that was returned when pSurfaceFormatCount was NULL.",
+                    *pSurfaceFormatCount, prev_format_count);
             }
             break;
         }
@@ -12859,12 +12761,14 @@
         lock.lock();
 
         if (*pSurfaceFormatCount) {
-            if (call_state < QUERY_COUNT) call_state = QUERY_COUNT;
+            if (call_state < QUERY_COUNT)
+                call_state = QUERY_COUNT;
             if (*pSurfaceFormatCount > physical_device_state->surface_formats.size())
                 physical_device_state->surface_formats.resize(*pSurfaceFormatCount);
         }
         if (pSurfaceFormats) {
-            if (call_state < QUERY_DETAILS) call_state = QUERY_DETAILS;
+            if (call_state < QUERY_DETAILS)
+                call_state = QUERY_DETAILS;
             for (uint32_t i = 0; i < *pSurfaceFormatCount; i++) {
                 physical_device_state->surface_formats[i] = pSurfaceFormats[i];
             }
@@ -12873,10 +12777,10 @@
     return result;
 }
 
-
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                             const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance,
+                                                            const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                                            const VkAllocationCallbacks *pAllocator,
+                                                            VkDebugReportCallbackEXT *pMsgCallback) {
     instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
     VkResult res = instance_data->dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
     if (VK_SUCCESS == res) {
@@ -12886,8 +12790,7 @@
     return res;
 }
 
-VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance,
-                                                         VkDebugReportCallbackEXT msgCallback,
+VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
                                                          const VkAllocationCallbacks *pAllocator) {
     instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
     instance_data->dispatch_table.DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
@@ -12895,34 +12798,32 @@
     layer_destroy_msg_callback(instance_data->report_data, msgCallback, pAllocator);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object,
-                      size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
+VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+                                                 VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
+                                                 int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
     instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
     instance_data->dispatch_table.DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
     return util_GetLayerProperties(1, &global_layer, pCount, pProperties);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
+                                                              VkLayerProperties *pProperties) {
     return util_GetLayerProperties(1, &global_layer, pCount, pProperties);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
+                                                                    VkExtensionProperties *pProperties) {
     if (pLayerName && !strcmp(pLayerName, global_layer.layerName))
         return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties);
 
     return VK_ERROR_LAYER_NOT_PRESENT;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
-                                                                  const char *pLayerName, uint32_t *pCount,
-                                                                  VkExtensionProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName,
+                                                                  uint32_t *pCount, VkExtensionProperties *pProperties) {
     if (pLayerName && !strcmp(pLayerName, global_layer.layerName))
         return util_GetExtensionProperties(0, NULL, pCount, pProperties);
 
@@ -12932,20 +12833,15 @@
     return instance_data->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
 }
 
-static PFN_vkVoidFunction
-intercept_core_instance_command(const char *name);
+static PFN_vkVoidFunction intercept_core_instance_command(const char *name);
 
-static PFN_vkVoidFunction
-intercept_core_device_command(const char *name);
+static PFN_vkVoidFunction intercept_core_device_command(const char *name);
 
-static PFN_vkVoidFunction
-intercept_khr_swapchain_command(const char *name, VkDevice dev);
+static PFN_vkVoidFunction intercept_khr_swapchain_command(const char *name, VkDevice dev);
 
-static PFN_vkVoidFunction
-intercept_khr_surface_command(const char *name, VkInstance instance);
+static PFN_vkVoidFunction intercept_khr_surface_command(const char *name, VkInstance instance);
 
-static PFN_vkVoidFunction
-intercept_extension_instance_commands(const char *name, VkInstance instance);
+static PFN_vkVoidFunction intercept_extension_instance_commands(const char *name, VkInstance instance);
 
 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice dev, const char *funcName) {
     PFN_vkVoidFunction proc = intercept_core_device_command(funcName);
@@ -13005,24 +12901,23 @@
     return table.GetPhysicalDeviceProcAddr(instance, funcName);
 }
 
-static PFN_vkVoidFunction
-intercept_core_instance_command(const char *name) {
+static PFN_vkVoidFunction intercept_core_instance_command(const char *name) {
     static const struct {
         const char *name;
         PFN_vkVoidFunction proc;
     } core_instance_commands[] = {
-        { "vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr) },
-        { "vk_layerGetPhysicalDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceProcAddr) },
-        { "vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr) },
-        { "vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(CreateInstance) },
-        { "vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(CreateDevice) },
-        { "vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDevices) },
-        { "vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceQueueFamilyProperties) },
-        { "vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance) },
-        { "vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceLayerProperties) },
-        { "vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceLayerProperties) },
-        { "vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties) },
-        { "vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties) },
+        {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr)},
+        {"vk_layerGetPhysicalDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceProcAddr)},
+        {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr)},
+        {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(CreateInstance)},
+        {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(CreateDevice)},
+        {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDevices)},
+        {"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceQueueFamilyProperties)},
+        {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance)},
+        {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceLayerProperties)},
+        {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceLayerProperties)},
+        {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties)},
+        {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties)},
     };
 
     for (size_t i = 0; i < ARRAY_SIZE(core_instance_commands); i++) {
@@ -13033,8 +12928,7 @@
     return nullptr;
 }
 
-static PFN_vkVoidFunction
-intercept_core_device_command(const char *name) {
+static PFN_vkVoidFunction intercept_core_device_command(const char *name) {
     static const struct {
         const char *name;
         PFN_vkVoidFunction proc;
@@ -13165,17 +13059,16 @@
     return nullptr;
 }
 
-static PFN_vkVoidFunction
-intercept_khr_swapchain_command(const char *name, VkDevice dev) {
+static PFN_vkVoidFunction intercept_khr_swapchain_command(const char *name, VkDevice dev) {
     static const struct {
         const char *name;
         PFN_vkVoidFunction proc;
     } khr_swapchain_commands[] = {
-        { "vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR) },
-        { "vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR) },
-        { "vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR) },
-        { "vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR) },
-        { "vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR) },
+        {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR)},
+        {"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR)},
+        {"vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR)},
+        {"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR)},
+        {"vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR)},
     };
     layer_data *dev_data = nullptr;
 
@@ -13201,8 +13094,7 @@
     return nullptr;
 }
 
-static PFN_vkVoidFunction
-intercept_khr_surface_command(const char *name, VkInstance instance) {
+static PFN_vkVoidFunction intercept_khr_surface_command(const char *name, VkInstance instance) {
     static const struct {
         const char *name;
         PFN_vkVoidFunction proc;
@@ -13210,40 +13102,40 @@
     } khr_surface_commands[] = {
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
         {"vkCreateAndroidSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateAndroidSurfaceKHR),
-            &instance_layer_data::androidSurfaceExtensionEnabled},
+         &instance_layer_data::androidSurfaceExtensionEnabled},
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 #ifdef VK_USE_PLATFORM_MIR_KHR
         {"vkCreateMirSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateMirSurfaceKHR),
-            &instance_layer_data::mirSurfaceExtensionEnabled},
+         &instance_layer_data::mirSurfaceExtensionEnabled},
 #endif // VK_USE_PLATFORM_MIR_KHR
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
         {"vkCreateWaylandSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateWaylandSurfaceKHR),
-            &instance_layer_data::waylandSurfaceExtensionEnabled},
+         &instance_layer_data::waylandSurfaceExtensionEnabled},
 #endif // VK_USE_PLATFORM_WAYLAND_KHR
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         {"vkCreateWin32SurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateWin32SurfaceKHR),
-            &instance_layer_data::win32SurfaceExtensionEnabled},
+         &instance_layer_data::win32SurfaceExtensionEnabled},
 #endif // VK_USE_PLATFORM_WIN32_KHR
 #ifdef VK_USE_PLATFORM_XCB_KHR
         {"vkCreateXcbSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateXcbSurfaceKHR),
-            &instance_layer_data::xcbSurfaceExtensionEnabled},
+         &instance_layer_data::xcbSurfaceExtensionEnabled},
 #endif // VK_USE_PLATFORM_XCB_KHR
 #ifdef VK_USE_PLATFORM_XLIB_KHR
         {"vkCreateXlibSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateXlibSurfaceKHR),
-            &instance_layer_data::xlibSurfaceExtensionEnabled},
+         &instance_layer_data::xlibSurfaceExtensionEnabled},
 #endif // VK_USE_PLATFORM_XLIB_KHR
-        { "vkCreateDisplayPlaneSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateDisplayPlaneSurfaceKHR),
-            &instance_layer_data::displayExtensionEnabled},
+        {"vkCreateDisplayPlaneSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateDisplayPlaneSurfaceKHR),
+         &instance_layer_data::displayExtensionEnabled},
         {"vkDestroySurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(DestroySurfaceKHR),
-            &instance_layer_data::surfaceExtensionEnabled},
+         &instance_layer_data::surfaceExtensionEnabled},
         {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilitiesKHR),
-            &instance_layer_data::surfaceExtensionEnabled},
+         &instance_layer_data::surfaceExtensionEnabled},
         {"vkGetPhysicalDeviceSurfaceSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceSupportKHR),
-            &instance_layer_data::surfaceExtensionEnabled},
+         &instance_layer_data::surfaceExtensionEnabled},
         {"vkGetPhysicalDeviceSurfacePresentModesKHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfacePresentModesKHR),
-            &instance_layer_data::surfaceExtensionEnabled},
+         &instance_layer_data::surfaceExtensionEnabled},
         {"vkGetPhysicalDeviceSurfaceFormatsKHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormatsKHR),
-            &instance_layer_data::surfaceExtensionEnabled},
+         &instance_layer_data::surfaceExtensionEnabled},
     };
 
     instance_layer_data *instance_data = nullptr;
@@ -13262,48 +13154,44 @@
     return nullptr;
 }
 
-static PFN_vkVoidFunction
-intercept_extension_instance_commands(const char *name, VkInstance instance) {
-    return NULL;
-}
+static PFN_vkVoidFunction intercept_extension_instance_commands(const char *name, VkInstance instance) { return NULL; }
 
 } // namespace core_validation
 
 // vk_layer_logging.h expects these to be defined
 
-VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                               const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance,
+                                                              const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                                              const VkAllocationCallbacks *pAllocator,
+                                                              VkDebugReportCallbackEXT *pMsgCallback) {
     return core_validation::CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-vkDestroyDebugReportCallbackEXT(VkInstance instance,
-                                VkDebugReportCallbackEXT msgCallback,
-                                const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
+                                                           const VkAllocationCallbacks *pAllocator) {
     core_validation::DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object,
-                        size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
+VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+                                                   VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
+                                                   int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
     core_validation::DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
 }
 
 // loader-layer interface v0, just wrappers since there is only a layer
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) {
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
+                                                                                      VkExtensionProperties *pProperties) {
     return core_validation::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount,
+                                                                                  VkLayerProperties *pProperties) {
     return core_validation::EnumerateInstanceLayerProperties(pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) {
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
+                                                                                VkLayerProperties *pProperties) {
     // the layer command handles VK_NULL_HANDLE just fine internally
     assert(physicalDevice == VK_NULL_HANDLE);
     return core_validation::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties);
@@ -13325,7 +13213,8 @@
     return core_validation::GetInstanceProcAddr(instance, funcName);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance,
+                                                                                           const char *funcName) {
     return core_validation::GetPhysicalDeviceProcAddr(instance, funcName);
 }
 
@@ -13348,4 +13237,3 @@
 
     return VK_SUCCESS;
 }
-
diff --git a/layers/core_validation.h b/layers/core_validation.h
index fe850ec..dc0e0ff 100644
--- a/layers/core_validation.h
+++ b/layers/core_validation.h
@@ -69,21 +69,21 @@
 struct CHECK_DISABLED {
     bool command_buffer_state;
     bool create_descriptor_set_layout;
-    bool destroy_buffer_view; // Skip validation at DestroyBufferView time
-    bool destroy_image_view;  // Skip validation at DestroyImageView time
-    bool destroy_pipeline;    // Skip validation at DestroyPipeline time
-    bool destroy_descriptor_pool; // Skip validation at DestroyDescriptorPool time
-    bool destroy_framebuffer;     // Skip validation at DestroyFramebuffer time
-    bool destroy_renderpass;      // Skip validation at DestroyRenderpass time
-    bool destroy_image;           // Skip validation at DestroyImage time
-    bool destroy_sampler;         // Skip validation at DestroySampler time
-    bool destroy_command_pool;    // Skip validation at DestroyCommandPool time
-    bool destroy_event;           // Skip validation at DestroyEvent time
-    bool free_memory;             // Skip validation at FreeMemory time
-    bool object_in_use;       // Skip all object in_use checking
-    bool idle_descriptor_set; // Skip check to verify that descriptor set is no in-use
-    bool push_constant_range; // Skip push constant range checks
-    bool free_descriptor_sets; // Skip validation prior to vkFreeDescriptorSets()
+    bool destroy_buffer_view;      // Skip validation at DestroyBufferView time
+    bool destroy_image_view;       // Skip validation at DestroyImageView time
+    bool destroy_pipeline;         // Skip validation at DestroyPipeline time
+    bool destroy_descriptor_pool;  // Skip validation at DestroyDescriptorPool time
+    bool destroy_framebuffer;      // Skip validation at DestroyFramebuffer time
+    bool destroy_renderpass;       // Skip validation at DestroyRenderpass time
+    bool destroy_image;            // Skip validation at DestroyImage time
+    bool destroy_sampler;          // Skip validation at DestroySampler time
+    bool destroy_command_pool;     // Skip validation at DestroyCommandPool time
+    bool destroy_event;            // Skip validation at DestroyEvent time
+    bool free_memory;              // Skip validation at FreeMemory time
+    bool object_in_use;            // Skip all object in_use checking
+    bool idle_descriptor_set;      // Skip check to verify that descriptor set is no in-use
+    bool push_constant_range;      // Skip push constant range checks
+    bool free_descriptor_sets;     // Skip validation prior to vkFreeDescriptorSets()
     bool allocate_descriptor_sets; // Skip validation prior to vkAllocateDescriptorSets()
     bool update_descriptor_sets;   // Skip validation prior to vkUpdateDescriptorSets()
     bool wait_for_fences;
@@ -236,7 +236,7 @@
     uint32_t queue_family_index;
 };
 
-inline bool operator==(GpuQueue const & lhs, GpuQueue const & rhs) {
+inline bool operator==(GpuQueue const &lhs, GpuQueue const &rhs) {
     return (lhs.gpu == rhs.gpu && lhs.queue_family_index == rhs.queue_family_index);
 }
 
@@ -255,6 +255,5 @@
     std::unordered_map<GpuQueue, bool> gpu_queue_support;
 
     SURFACE_STATE() {}
-    SURFACE_STATE(VkSurfaceKHR surface)
-        : surface(surface) {}
+    SURFACE_STATE(VkSurfaceKHR surface) : surface(surface) {}
 };
diff --git a/layers/core_validation_types.h b/layers/core_validation_types.h
index 2523be3..d64d30f 100644
--- a/layers/core_validation_types.h
+++ b/layers/core_validation_types.h
@@ -92,7 +92,6 @@
 };
 }
 
-
 // Flags describing requirements imposed by the pipeline on a descriptor. These
 // can't be checked at pipeline creation time as they depend on the Image or
 // ImageView bound.
@@ -226,8 +225,8 @@
   public:
     VkImage image;
     VkImageCreateInfo createInfo;
-    bool valid; // If this is a swapchain image backing memory track valid here as it doesn't have DEVICE_MEM_INFO
-    bool acquired;  // If this is a swapchain image, has it been acquired by the app.
+    bool valid;    // If this is a swapchain image backing memory track valid here as it doesn't have DEVICE_MEM_INFO
+    bool acquired; // If this is a swapchain image, has it been acquired by the app.
     IMAGE_STATE(VkImage img, const VkImageCreateInfo *pCreateInfo)
         : image(img), createInfo(*pCreateInfo), valid(false), acquired(false) {
         if (createInfo.flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) {
@@ -253,7 +252,7 @@
 
 struct MEMORY_RANGE {
     uint64_t handle;
-    bool image; // True for image, false for buffer
+    bool image;  // True for image, false for buffer
     bool linear; // True for buffers and linear images
     bool valid;  // True if this range is know to be valid
     VkDeviceMemory memory;
@@ -266,22 +265,22 @@
 
 // Data struct for tracking memory object
 struct DEVICE_MEM_INFO : public BASE_NODE {
-    void *object; // Dispatchable object used to create this memory (device of swapchain)
+    void *object;      // Dispatchable object used to create this memory (device of swapchain)
     bool global_valid; // If allocation is mapped, set to "true" to be picked up by subsequently bound ranges
     VkDeviceMemory mem;
     VkMemoryAllocateInfo alloc_info;
-    std::unordered_set<VK_OBJECT> obj_bindings;         // objects bound to this memory
-    std::unordered_map<uint64_t, MEMORY_RANGE> bound_ranges;     // Map of object to its binding range
+    std::unordered_set<VK_OBJECT> obj_bindings;              // objects bound to this memory
+    std::unordered_map<uint64_t, MEMORY_RANGE> bound_ranges; // Map of object to its binding range
     // Convenience vectors image/buff handles to speed up iterating over images or buffers independently
     std::unordered_set<uint64_t> bound_images;
     std::unordered_set<uint64_t> bound_buffers;
 
     MemRange mem_range;
-    void *shadow_copy_base;     // Base of layer's allocation for guard band, data, and alignment space
-    void *shadow_copy;          // Pointer to start of guard-band data before mapped region
-    uint64_t shadow_pad_size;   // Size of the guard-band data before and after actual data. It MUST be a
-                                // multiple of limits.minMemoryMapAlignment
-    void *p_driver_data;        // Pointer to application's actual memory
+    void *shadow_copy_base;   // Base of layer's allocation for guard band, data, and alignment space
+    void *shadow_copy;        // Pointer to start of guard-band data before mapped region
+    uint64_t shadow_pad_size; // Size of the guard-band data before and after actual data. It MUST be a
+                              // multiple of limits.minMemoryMapAlignment
+    void *p_driver_data;      // Pointer to application's actual memory
 
     DEVICE_MEM_INFO(void *disp_object, const VkDeviceMemory in_mem, const VkMemoryAllocateInfo *p_alloc_info)
         : object(disp_object), global_valid(false), mem(in_mem), alloc_info(*p_alloc_info), mem_range{}, shadow_copy_base(0),
@@ -431,7 +430,9 @@
     }
 };
 }
-struct DRAW_DATA { std::vector<VkBuffer> buffers; };
+struct DRAW_DATA {
+    std::vector<VkBuffer> buffers;
+};
 
 struct ImageSubresourcePair {
     VkImage image;
@@ -631,7 +632,8 @@
 };
 
 struct CB_SUBMISSION {
-    CB_SUBMISSION(std::vector<VkCommandBuffer> const &cbs, std::vector<SEMAPHORE_WAIT> const &waitSemaphores, std::vector<VkSemaphore> const &signalSemaphores, VkFence fence)
+    CB_SUBMISSION(std::vector<VkCommandBuffer> const &cbs, std::vector<SEMAPHORE_WAIT> const &waitSemaphores,
+                  std::vector<VkSemaphore> const &signalSemaphores, VkFence fence)
         : cbs(cbs), waitSemaphores(waitSemaphores), signalSemaphores(signalSemaphores), fence(fence) {}
 
     std::vector<VkCommandBuffer> cbs;
diff --git a/layers/descriptor_sets.cpp b/layers/descriptor_sets.cpp
index 6d7ef55..6ad8dc0 100644
--- a/layers/descriptor_sets.cpp
+++ b/layers/descriptor_sets.cpp
@@ -362,16 +362,14 @@
     }
 }
 
-cvdescriptorset::DescriptorSet::~DescriptorSet() {
-    InvalidateBoundCmdBuffers();
-}
-
+cvdescriptorset::DescriptorSet::~DescriptorSet() { InvalidateBoundCmdBuffers(); }
 
 static std::string string_descriptor_req_view_type(descriptor_req req) {
     std::string result("");
     for (unsigned i = 0; i <= VK_IMAGE_VIEW_TYPE_END_RANGE; i++) {
         if (req & (1 << i)) {
-            if (result.size()) result += ", ";
+            if (result.size())
+                result += ", ";
             result += string_VkImageViewType(VkImageViewType(i));
         }
     }
@@ -382,7 +380,6 @@
     return result;
 }
 
-
 // Is this sets underlying layout compatible with passed in layout according to "Pipeline Layout Compatibility" in spec?
 bool cvdescriptorset::DescriptorSet::IsCompatible(const DescriptorSetLayout *layout, std::string *error) const {
     return layout->IsCompatible(p_layout_, error);
@@ -469,11 +466,10 @@
                                 }
                             }
                         }
-                    }
-                    else if (descriptor_class == ImageSampler || descriptor_class == Image) {
+                    } else if (descriptor_class == ImageSampler || descriptor_class == Image) {
                         auto image_view = (descriptor_class == ImageSampler)
-                                ? static_cast<ImageSamplerDescriptor *>(descriptors_[i].get())->GetImageView()
-                                : static_cast<ImageDescriptor *>(descriptors_[i].get())->GetImageView();
+                                              ? static_cast<ImageSamplerDescriptor *>(descriptors_[i].get())->GetImageView()
+                                              : static_cast<ImageDescriptor *>(descriptors_[i].get())->GetImageView();
                         auto reqs = binding_pair.second;
 
                         auto image_view_state = getImageViewState(device_data_, image_view);
@@ -484,8 +480,8 @@
                             // bad view type
                             std::stringstream error_str;
                             error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i
-                                      << " requires an image view of type " << string_descriptor_req_view_type(reqs)
-                                      << " but got " << string_VkImageViewType(image_view_ci.viewType) << ".";
+                                      << " requires an image view of type " << string_descriptor_req_view_type(reqs) << " but got "
+                                      << string_VkImageViewType(image_view_ci.viewType) << ".";
                             *error = error_str.str();
                             return false;
                         }
@@ -493,8 +489,7 @@
                         auto image_node = getImageState(device_data_, image_view_ci.image);
                         assert(image_node);
 
-                        if ((reqs & DESCRIPTOR_REQ_SINGLE_SAMPLE) &&
-                            image_node->createInfo.samples != VK_SAMPLE_COUNT_1_BIT) {
+                        if ((reqs & DESCRIPTOR_REQ_SINGLE_SAMPLE) && image_node->createInfo.samples != VK_SAMPLE_COUNT_1_BIT) {
                             std::stringstream error_str;
                             error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i
                                       << " requires bound image to have VK_SAMPLE_COUNT_1_BIT but got "
@@ -503,8 +498,7 @@
                             return false;
                         }
 
-                        if ((reqs & DESCRIPTOR_REQ_MULTI_SAMPLE) &&
-                            image_node->createInfo.samples == VK_SAMPLE_COUNT_1_BIT) {
+                        if ((reqs & DESCRIPTOR_REQ_MULTI_SAMPLE) && image_node->createInfo.samples == VK_SAMPLE_COUNT_1_BIT) {
                             std::stringstream error_str;
                             error_str << "Descriptor in binding #" << binding << " at global descriptor index " << i
                                       << " requires bound image to have multiple samples, but got VK_SAMPLE_COUNT_1_BIT.";
diff --git a/layers/image.cpp b/layers/image.cpp
index bba0ffd..08c9b0a 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -89,9 +89,10 @@
     return &it->second;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                             const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance,
+                                                            const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                                            const VkAllocationCallbacks *pAllocator,
+                                                            VkDebugReportCallbackEXT *pMsgCallback) {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     VkResult res = my_data->instance_dispatch_table->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
     if (res == VK_SUCCESS) {
@@ -100,24 +101,23 @@
     return res;
 }
 
-VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance,
-                                                         VkDebugReportCallbackEXT msgCallback,
+VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
                                                          const VkAllocationCallbacks *pAllocator) {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
     layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object,
-                      size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
+VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+                                                 VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
+                                                 int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     my_data->instance_dispatch_table->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix,
                                                             pMsg);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
+                                              VkInstance *pInstance) {
     VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
 
     assert(chain_info->u.pLayerInfo);
@@ -165,8 +165,7 @@
     layer_data_map.erase(key);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice,
-                                            const VkDeviceCreateInfo *pCreateInfo,
+VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
                                             const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
     layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
@@ -560,13 +559,13 @@
             ((offset->z + static_cast<int32_t>(extent->depth)) < 0)) {
             result = true;
         }
-        // Intentionally fall through to 2D case to check height
+    // Intentionally fall through to 2D case to check height
     case VK_IMAGE_TYPE_2D: // Validate y and height
         if ((offset->y + extent->height > image->extent.height) || (offset->y < 0) ||
             ((offset->y + static_cast<int32_t>(extent->height)) < 0)) {
             result = true;
         }
-        // Intentionally fall through to 1D case to check width
+    // Intentionally fall through to 1D case to check width
     case VK_IMAGE_TYPE_1D: // Validate x and width
         if ((offset->x + extent->width > image->extent.width) || (offset->x < 0) ||
             ((offset->x + static_cast<int32_t>(extent->width)) < 0)) {
@@ -768,9 +767,8 @@
     return skip;
 }
 
-VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
-                                        VkImageLayout srcImageLayout, VkImage dstImage,
-                                        VkImageLayout dstImageLayout, uint32_t regionCount,
+VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                        VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
                                         const VkImageCopy *pRegions) {
 
     bool skip = false;
@@ -1097,11 +1095,11 @@
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL
-CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
-                   VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
-                   uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
-                   uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) {
+VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
+                                              VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
+                                              uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
+                                              uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
+                                              uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) {
     bool skipCall = false;
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
 
@@ -1239,33 +1237,30 @@
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL
-GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) {
+VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) {
     layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     phy_dev_data->instance_dispatch_table->GetPhysicalDeviceProperties(physicalDevice, pProperties);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
     return util_GetLayerProperties(1, &global_layer, pCount, pProperties);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
+                                                              VkLayerProperties *pProperties) {
     return util_GetLayerProperties(1, &global_layer, pCount, pProperties);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
+                                                                    VkExtensionProperties *pProperties) {
     if (pLayerName && !strcmp(pLayerName, global_layer.layerName))
         return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties);
 
     return VK_ERROR_LAYER_NOT_PRESENT;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
-                                                                  const char *pLayerName, uint32_t *pCount,
-                                                                  VkExtensionProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName,
+                                                                  uint32_t *pCount, VkExtensionProperties *pProperties) {
     // Image does not have any physical device extensions
     if (pLayerName && !strcmp(pLayerName, global_layer.layerName))
         return util_GetExtensionProperties(0, NULL, pCount, pProperties);
@@ -1278,10 +1273,8 @@
     return pTable->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
 }
 
-static PFN_vkVoidFunction
-intercept_core_instance_command(const char *name);
-static PFN_vkVoidFunction
-intercept_core_device_command(const char *name);
+static PFN_vkVoidFunction intercept_core_instance_command(const char *name);
+static PFN_vkVoidFunction intercept_core_device_command(const char *name);
 
 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) {
     PFN_vkVoidFunction proc = intercept_core_device_command(funcName);
@@ -1331,22 +1324,21 @@
     return pTable->GetPhysicalDeviceProcAddr(instance, funcName);
 }
 
-static PFN_vkVoidFunction
-intercept_core_instance_command(const char *name) {
+static PFN_vkVoidFunction intercept_core_instance_command(const char *name) {
     static const struct {
         const char *name;
         PFN_vkVoidFunction proc;
     } core_instance_commands[] = {
-        { "vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr) },
-        { "vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(CreateInstance) },
-        { "vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance) },
-        { "vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(CreateDevice) },
-        { "vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceLayerProperties) },
-        { "vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceLayerProperties) },
-        { "vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties) },
-        { "vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties) },
-        { "vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceProperties) },
-        { "vk_layerGetPhysicalDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceProcAddr) },
+        {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr)},
+        {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(CreateInstance)},
+        {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance)},
+        {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(CreateDevice)},
+        {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceLayerProperties)},
+        {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceLayerProperties)},
+        {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties)},
+        {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties)},
+        {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceProperties)},
+        {"vk_layerGetPhysicalDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceProcAddr)},
     };
 
     for (size_t i = 0; i < ARRAY_SIZE(core_instance_commands); i++) {
@@ -1357,8 +1349,7 @@
     return nullptr;
 }
 
-static PFN_vkVoidFunction
-intercept_core_device_command(const char *name) {
+static PFN_vkVoidFunction intercept_core_device_command(const char *name) {
     static const struct {
         const char *name;
         PFN_vkVoidFunction proc;
@@ -1392,39 +1383,38 @@
 
 // vk_layer_logging.h expects these to be defined
 
-VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                               const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance,
+                                                              const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                                              const VkAllocationCallbacks *pAllocator,
+                                                              VkDebugReportCallbackEXT *pMsgCallback) {
     return image::CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-vkDestroyDebugReportCallbackEXT(VkInstance instance,
-                                VkDebugReportCallbackEXT msgCallback,
-                                const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
+                                                           const VkAllocationCallbacks *pAllocator) {
     image::DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object,
-                        size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
+VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+                                                   VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
+                                                   int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
     image::DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
 }
 
 // loader-layer interface v0, just wrappers since there is only a layer
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) {
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
+                                                                                      VkExtensionProperties *pProperties) {
     return image::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount,
+                                                                                  VkLayerProperties *pProperties) {
     return image::EnumerateInstanceLayerProperties(pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) {
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
+                                                                                VkLayerProperties *pProperties) {
     // the layer command handles VK_NULL_HANDLE just fine internally
     assert(physicalDevice == VK_NULL_HANDLE);
     return image::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties);
@@ -1446,7 +1436,8 @@
     return image::GetInstanceProcAddr(instance, funcName);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance,
+                                                                                           const char *funcName) {
     return image::GetPhysicalDeviceProcAddr(instance, funcName);
 }
 
diff --git a/layers/image.h b/layers/image.h
index c225ea4..1c10d50 100644
--- a/layers/image.h
+++ b/layers/image.h
@@ -12,7 +12,7 @@
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
- * limitations under the License. 
+ * limitations under the License.
  *
  * Author: Mark Lobodzinski <mark@lunarg.com>
  * Author: Mike Stroyan <mike@LunarG.com>
diff --git a/layers/object_tracker.cpp b/layers/object_tracker.cpp
index fb3354b..e9a97bd 100644
--- a/layers/object_tracker.cpp
+++ b/layers/object_tracker.cpp
@@ -121,8 +121,9 @@
                                   VkDebugReportObjectTypeEXT object_type, VkCommandBufferLevel level) {
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
 
-    log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, object_type, reinterpret_cast<const uint64_t>(command_buffer),
-            __LINE__, OBJTRACK_NONE, LayerName, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++,
+    log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, object_type,
+            reinterpret_cast<const uint64_t>(command_buffer), __LINE__, OBJTRACK_NONE, LayerName,
+            "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++,
             string_VkDebugReportObjectTypeEXT(object_type), reinterpret_cast<const uint64_t>(command_buffer));
 
     OBJTRACK_NODE *pNewObjNode = new OBJTRACK_NODE;
@@ -249,17 +250,12 @@
     device_data->swapchainImageMap[reinterpret_cast<uint64_t &>(swapchain_image)] = pNewObjNode;
 }
 
-template<typename T>
-uint64_t handle_value(T handle) {
-    return reinterpret_cast<uint64_t &>(handle);
-}
-template<typename T>
-uint64_t handle_value(T *handle) {
-    return reinterpret_cast<uint64_t>(handle);
-}
+template <typename T> uint64_t handle_value(T handle) { return reinterpret_cast<uint64_t &>(handle); }
+template <typename T> uint64_t handle_value(T *handle) { return reinterpret_cast<uint64_t>(handle); }
 
 template <typename T1, typename T2>
-static void CreateObject(T1 dispatchable_object, T2 object, VkDebugReportObjectTypeEXT object_type, const VkAllocationCallbacks *pAllocator) {
+static void CreateObject(T1 dispatchable_object, T2 object, VkDebugReportObjectTypeEXT object_type,
+                         const VkAllocationCallbacks *pAllocator) {
     layer_data *instance_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map);
 
     auto object_handle = handle_value(object);
@@ -1802,8 +1798,8 @@
         skip_call |= ValidateObject(command_buffer, command_buffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
                                     VALIDATION_ERROR_00108);
         if (begin_info) {
-            OBJTRACK_NODE *pNode =
-                device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT][reinterpret_cast<const uint64_t>(command_buffer)];
+            OBJTRACK_NODE *pNode = device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT]
+                                                          [reinterpret_cast<const uint64_t>(command_buffer)];
             if ((begin_info->pInheritanceInfo) && (pNode->status & OBJSTATUS_COMMAND_BUFFER_SECONDARY) &&
                 (begin_info->flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) {
                 skip_call |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->framebuffer,
@@ -3006,8 +3002,8 @@
     if (skip_call) {
         return VK_ERROR_VALIDATION_FAILED_EXT;
     }
-    VkResult result =
-        get_dispatch_table(ot_device_table_map, device)->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
+    VkResult result = get_dispatch_table(ot_device_table_map, device)
+                          ->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
     {
         std::lock_guard<std::mutex> lock(global_lock);
         if (result == VK_SUCCESS) {
@@ -3090,7 +3086,7 @@
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
+                                                            const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
 
 static inline PFN_vkVoidFunction InterceptWsiEnabledCommand(const char *name, VkInstance instance) {
     VkLayerInstanceDispatchTable *pTable = get_dispatch_table(ot_instance_table_map, instance);
@@ -3823,7 +3819,7 @@
     }
     if (!skip) {
         result = get_dispatch_table(ot_instance_table_map, physicalDevice)
-            ->GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
+                     ->GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
     }
     return result;
 }
@@ -3839,7 +3835,7 @@
     }
     if (!skip) {
         result = get_dispatch_table(ot_instance_table_map, physicalDevice)
-            ->GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
+                     ->GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
     }
     return result;
 }
@@ -3872,8 +3868,7 @@
         std::unique_lock<std::mutex> lock(global_lock);
         skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false,
                                VALIDATION_ERROR_01861);
-        skip |= ValidateObject(physicalDevice, display, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, false,
-                               VALIDATION_ERROR_01862);
+        skip |= ValidateObject(physicalDevice, display, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, false, VALIDATION_ERROR_01862);
     }
     result = get_dispatch_table(ot_instance_table_map, physicalDevice)
                  ->GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
@@ -3890,8 +3885,7 @@
         std::unique_lock<std::mutex> lock(global_lock);
         skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false,
                                VALIDATION_ERROR_01865);
-        skip |= ValidateObject(physicalDevice, display, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, false,
-                               VALIDATION_ERROR_01866);
+        skip |= ValidateObject(physicalDevice, display, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, false, VALIDATION_ERROR_01866);
     }
     result = get_dispatch_table(ot_instance_table_map, physicalDevice)
                  ->CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
@@ -3912,8 +3906,8 @@
         std::unique_lock<std::mutex> lock(global_lock);
         skip |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false,
                                VALIDATION_ERROR_01875);
-        skip |= ValidateObject(physicalDevice, mode, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, false,
-                               VALIDATION_ERROR_01876);
+        skip |=
+            ValidateObject(physicalDevice, mode, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, false, VALIDATION_ERROR_01876);
     }
     result = get_dispatch_table(ot_instance_table_map, physicalDevice)
                  ->GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
@@ -3922,7 +3916,7 @@
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+                                                            const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
     bool skip_call = false;
     {
         std::lock_guard<std::mutex> lock(global_lock);
@@ -3932,7 +3926,7 @@
         return VK_ERROR_VALIDATION_FAILED_EXT;
     }
     VkResult result = get_dispatch_table(ot_instance_table_map, instance)
-        ->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+                          ->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     {
         std::lock_guard<std::mutex> lock(global_lock);
         if (result == VK_SUCCESS) {
@@ -4947,7 +4941,8 @@
     return object_tracker::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance,
+                                                                                           const char *funcName) {
     return object_tracker::GetPhysicalDeviceProcAddr(instance, funcName);
 }
 
diff --git a/layers/object_tracker.h b/layers/object_tracker.h
index d34bd03..327c527 100644
--- a/layers/object_tracker.h
+++ b/layers/object_tracker.h
@@ -164,7 +164,7 @@
     "Command Pool",          // VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT
     "SurfaceKHR",            // VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT
     "SwapchainKHR",          // VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT
-    "Debug Report" };        // VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT
+    "Debug Report"};         // VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT
 
 #include "vk_dispatch_table_helper.h"
 
diff --git a/layers/parameter_validation.cpp b/layers/parameter_validation.cpp
index 332fd8b..61949c6 100644
--- a/layers/parameter_validation.cpp
+++ b/layers/parameter_validation.cpp
@@ -91,9 +91,7 @@
         uint64_t padding[4];
     } enables;
 
-    layer_data() {
-        memset(enables.padding, 0, sizeof(uint64_t) * 4);
-    }
+    layer_data() { memset(enables.padding, 0, sizeof(uint64_t) * 4); }
 
     VkLayerDispatchTable dispatch_table = {};
 };
@@ -1232,12 +1230,12 @@
     } else if (result & VK_STRING_ERROR_LENGTH) {
 
         skip = log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
-                            INVALID_USAGE, LayerName, "%s: string %s exceeds max length %d", apiName, stringName.get_name().c_str(),
-                            MaxParamCheckerStringLength);
+                       INVALID_USAGE, LayerName, "%s: string %s exceeds max length %d", apiName, stringName.get_name().c_str(),
+                       MaxParamCheckerStringLength);
     } else if (result & VK_STRING_ERROR_BAD_DATA) {
         skip = log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
-                            INVALID_USAGE, LayerName, "%s: string %s contains invalid characters or is badly formed", apiName,
-                            stringName.get_name().c_str());
+                       INVALID_USAGE, LayerName, "%s: string %s contains invalid characters or is badly formed", apiName,
+                       stringName.get_name().c_str());
     }
     return skip;
 }
@@ -1250,14 +1248,14 @@
 
     if (index == VK_QUEUE_FAMILY_IGNORED) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, LayerName,
-                             "%s: %s cannot be VK_QUEUE_FAMILY_IGNORED.", function_name, parameter_name);
+                        "%s: %s cannot be VK_QUEUE_FAMILY_IGNORED.", function_name, parameter_name);
     } else {
         const auto &queue_data = device_data->queueFamilyIndexMap.find(index);
         if (queue_data == device_data->queueFamilyIndexMap.end()) {
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
-                                 LayerName, "%s: %s (%d) must be one of the indices specified when the device was created, via "
-                                            "the VkDeviceQueueCreateInfo structure.",
-                                 function_name, parameter_name, index);
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, LayerName,
+                            "%s: %s (%d) must be one of the indices specified when the device was created, via "
+                            "the VkDeviceQueueCreateInfo structure.",
+                            function_name, parameter_name, index);
             return false;
         }
     }
@@ -1275,14 +1273,14 @@
         for (uint32_t i = 0; i < count; i++) {
             if (indices[i] == VK_QUEUE_FAMILY_IGNORED) {
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
-                                     LayerName, "%s: %s[%d] cannot be VK_QUEUE_FAMILY_IGNORED.", function_name, parameter_name, i);
+                                LayerName, "%s: %s[%d] cannot be VK_QUEUE_FAMILY_IGNORED.", function_name, parameter_name, i);
             } else {
                 const auto &queue_data = device_data->queueFamilyIndexMap.find(indices[i]);
                 if (queue_data == device_data->queueFamilyIndexMap.end()) {
                     skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
-                                         LayerName, "%s: %s[%d] (%d) must be one of the indices specified when the device was "
-                                                    "created, via the VkDeviceQueueCreateInfo structure.",
-                                         function_name, parameter_name, i, indices[i]);
+                                    LayerName, "%s: %s[%d] (%d) must be one of the indices specified when the device was "
+                                               "created, via the VkDeviceQueueCreateInfo structure.",
+                                    function_name, parameter_name, i, indices[i]);
                     return false;
                 }
             }
@@ -1461,8 +1459,8 @@
     auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
     assert(my_data != NULL);
 
-    skip |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties(my_data->report_data, format, type, tiling, usage,
-                                                                               flags, pImageFormatProperties);
+    skip |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties(my_data->report_data, format, type, tiling, usage, flags,
+                                                                          pImageFormatProperties);
 
     if (!skip) {
         result = my_data->dispatch_table.GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags,
@@ -1494,7 +1492,7 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties(my_data->report_data, pQueueFamilyPropertyCount,
-                                                                               pQueueFamilyProperties);
+                                                                          pQueueFamilyProperties);
 
     if (!skip) {
         my_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
@@ -1516,7 +1514,7 @@
 }
 
 static void validateDeviceCreateInfo(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
-                              const std::vector<VkQueueFamilyProperties> properties) {
+                                     const std::vector<VkQueueFamilyProperties> properties) {
     std::unordered_set<uint32_t> set;
 
     auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
@@ -1671,14 +1669,14 @@
         if ((pCreateInfo->enabledLayerCount > 0) && (pCreateInfo->ppEnabledLayerNames != NULL)) {
             for (size_t i = 0; i < pCreateInfo->enabledLayerCount; i++) {
                 skip |= validate_string(my_instance_data->report_data, "vkCreateDevice", "pCreateInfo->ppEnabledLayerNames",
-                                             pCreateInfo->ppEnabledLayerNames[i]);
+                                        pCreateInfo->ppEnabledLayerNames[i]);
             }
         }
 
         if ((pCreateInfo->enabledExtensionCount > 0) && (pCreateInfo->ppEnabledExtensionNames != NULL)) {
             for (size_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-                skip |= validate_string(my_instance_data->report_data, "vkCreateDevice",
-                                             "pCreateInfo->ppEnabledExtensionNames", pCreateInfo->ppEnabledExtensionNames[i]);
+                skip |= validate_string(my_instance_data->report_data, "vkCreateDevice", "pCreateInfo->ppEnabledExtensionNames",
+                                        pCreateInfo->ppEnabledExtensionNames[i]);
             }
         }
     }
@@ -1917,8 +1915,7 @@
     skip |= parameter_validation_vkInvalidateMappedMemoryRanges(my_data->report_data, memoryRangeCount, pMemoryRanges);
 
     if (!skip) {
-        result =
-            my_data->dispatch_table.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+        result = my_data->dispatch_table.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
 
         validate_result(my_data->report_data, "vkInvalidateMappedMemoryRanges", result);
     }
@@ -2000,7 +1997,7 @@
 }
 
 static bool PostGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pNumRequirements,
-                                          VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
+                                                 VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     if (pSparseMemoryRequirements != nullptr) {
         if ((pSparseMemoryRequirements->formatProperties.aspectMask &
@@ -2024,18 +2021,20 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkGetImageSparseMemoryRequirements(my_data->report_data, image, pSparseMemoryRequirementCount,
-                                                                         pSparseMemoryRequirements);
+                                                                    pSparseMemoryRequirements);
 
     if (!skip) {
-        my_data->dispatch_table.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+        my_data->dispatch_table.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount,
+                                                                 pSparseMemoryRequirements);
 
         PostGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
     }
 }
 
 static bool PostGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-                                                      VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
-                                                      uint32_t *pNumProperties, VkSparseImageFormatProperties *pProperties) {
+                                                             VkSampleCountFlagBits samples, VkImageUsageFlags usage,
+                                                             VkImageTiling tiling, uint32_t *pNumProperties,
+                                                             VkSparseImageFormatProperties *pProperties) {
     auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
     if (pProperties != nullptr) {
         if ((pProperties->aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT |
@@ -2060,8 +2059,8 @@
     auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
     assert(my_data != NULL);
 
-    skip |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties(my_data->report_data, format, type, samples,
-                                                                                     usage, tiling, pPropertyCount, pProperties);
+    skip |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties(my_data->report_data, format, type, samples, usage,
+                                                                                tiling, pPropertyCount, pProperties);
 
     if (!skip) {
         my_data->dispatch_table.GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling,
@@ -2336,11 +2335,12 @@
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skip |= parameter_validation_vkGetQueryPoolResults(my_data->report_data, queryPool, firstQuery, queryCount, dataSize,
-                                                            pData, stride, flags);
+    skip |= parameter_validation_vkGetQueryPoolResults(my_data->report_data, queryPool, firstQuery, queryCount, dataSize, pData,
+                                                       stride, flags);
 
     if (!skip) {
-        result = my_data->dispatch_table.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+        result =
+            my_data->dispatch_table.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
 
         validate_result(my_data->report_data, "vkGetQueryPoolResults", result);
     }
@@ -2367,27 +2367,27 @@
         if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT) {
             // If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1
             if (pCreateInfo->queueFamilyIndexCount <= 1) {
-                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                     __LINE__, VALIDATION_ERROR_00665, LayerName,
-                                     "vkCreateBuffer: if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, "
-                                     "pCreateInfo->queueFamilyIndexCount must be greater than 1. %s",
-                                     validation_error_map[VALIDATION_ERROR_00665]);
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
+                                VALIDATION_ERROR_00665, LayerName,
+                                "vkCreateBuffer: if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, "
+                                "pCreateInfo->queueFamilyIndexCount must be greater than 1. %s",
+                                validation_error_map[VALIDATION_ERROR_00665]);
             }
 
             // If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a pointer to an array of
             // queueFamilyIndexCount uint32_t values
             if (pCreateInfo->pQueueFamilyIndices == nullptr) {
-                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                     __LINE__, VALIDATION_ERROR_00664, LayerName,
-                                     "vkCreateBuffer: if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, "
-                                     "pCreateInfo->pQueueFamilyIndices must be a pointer to an array of "
-                                     "pCreateInfo->queueFamilyIndexCount uint32_t values. %s",
-                                     validation_error_map[VALIDATION_ERROR_00664]);
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
+                                VALIDATION_ERROR_00664, LayerName,
+                                "vkCreateBuffer: if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, "
+                                "pCreateInfo->pQueueFamilyIndices must be a pointer to an array of "
+                                "pCreateInfo->queueFamilyIndexCount uint32_t values. %s",
+                                validation_error_map[VALIDATION_ERROR_00664]);
             }
 
             // Ensure that the queue family indices were specified at device creation
             skip |= validate_queue_family_indices(device_data, "vkCreateBuffer", "pCreateInfo->pQueueFamilyIndices",
-                                                       pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices);
+                                                  pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices);
         }
 
         // If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain
@@ -2487,13 +2487,12 @@
             }
 
             skip |= validate_queue_family_indices(device_data, "vkCreateImage", "pCreateInfo->pQueueFamilyIndices",
-                                                       pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices);
+                                                  pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices);
         }
 
         // width, height, and depth members of extent must be greater than 0
         skip |= ValidateGreaterThan(report_data, "vkCreateImage", "pCreateInfo->extent.width", pCreateInfo->extent.width, 0u);
-        skip |=
-            ValidateGreaterThan(report_data, "vkCreateImage", "pCreateInfo->extent.height", pCreateInfo->extent.height, 0u);
+        skip |= ValidateGreaterThan(report_data, "vkCreateImage", "pCreateInfo->extent.height", pCreateInfo->extent.height, 0u);
         skip |= ValidateGreaterThan(report_data, "vkCreateImage", "pCreateInfo->extent.depth", pCreateInfo->extent.depth, 0u);
 
         // mipLevels must be greater than 0
@@ -2622,45 +2621,45 @@
             if ((pCreateInfo->subresourceRange.layerCount != 1) &&
                 (pCreateInfo->subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS)) {
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
-                                     LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_%dD, "
-                                                "pCreateInfo->subresourceRange.layerCount must be 1",
-                                     ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D) ? 1 : 2));
+                                LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_%dD, "
+                                           "pCreateInfo->subresourceRange.layerCount must be 1",
+                                ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D) ? 1 : 2));
             }
         } else if ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY) ||
                    (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_2D_ARRAY)) {
             if ((pCreateInfo->subresourceRange.layerCount < 1) &&
                 (pCreateInfo->subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS)) {
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
-                                     LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_%dD_ARRAY, "
-                                                "pCreateInfo->subresourceRange.layerCount must be >= 1",
-                                     ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? 1 : 2));
+                                LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_%dD_ARRAY, "
+                                           "pCreateInfo->subresourceRange.layerCount must be >= 1",
+                                ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? 1 : 2));
             }
         } else if (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_CUBE) {
             if ((pCreateInfo->subresourceRange.layerCount != 6) &&
                 (pCreateInfo->subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS)) {
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
-                                     LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_CUBE, "
-                                                "pCreateInfo->subresourceRange.layerCount must be 6");
+                                LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_CUBE, "
+                                           "pCreateInfo->subresourceRange.layerCount must be 6");
             }
         } else if (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) {
             if (((pCreateInfo->subresourceRange.layerCount == 0) || ((pCreateInfo->subresourceRange.layerCount % 6) != 0)) &&
                 (pCreateInfo->subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS)) {
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
-                                     LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_CUBE_ARRAY, "
-                                                "pCreateInfo->subresourceRange.layerCount must be a multiple of 6");
+                                LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_CUBE_ARRAY, "
+                                           "pCreateInfo->subresourceRange.layerCount must be a multiple of 6");
             }
         } else if (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_3D) {
             if (pCreateInfo->subresourceRange.baseArrayLayer != 0) {
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
-                                     LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_3D, "
-                                                "pCreateInfo->subresourceRange.baseArrayLayer must be 0");
+                                LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_3D, "
+                                           "pCreateInfo->subresourceRange.baseArrayLayer must be 0");
             }
 
             if ((pCreateInfo->subresourceRange.layerCount != 1) &&
                 (pCreateInfo->subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS)) {
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
-                                     LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_3D, "
-                                                "pCreateInfo->subresourceRange.layerCount must be 1");
+                                LayerName, "vkCreateImageView: if pCreateInfo->viewType is VK_IMAGE_TYPE_3D, "
+                                           "pCreateInfo->subresourceRange.layerCount must be 1");
             }
         }
     }
@@ -2696,8 +2695,7 @@
     skip |= parameter_validation_vkCreateShaderModule(my_data->report_data, pCreateInfo, pAllocator, pShaderModule);
 
     if (!skip) {
-        result =
-            my_data->dispatch_table.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+        result = my_data->dispatch_table.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
 
         validate_result(my_data->report_data, "vkCreateShaderModule", result);
     }
@@ -2728,8 +2726,7 @@
     skip |= parameter_validation_vkCreatePipelineCache(my_data->report_data, pCreateInfo, pAllocator, pPipelineCache);
 
     if (!skip) {
-        result =
-            my_data->dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+        result = my_data->dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
 
         validate_result(my_data->report_data, "vkCreatePipelineCache", result);
     }
@@ -2858,8 +2855,8 @@
     assert(device_data != nullptr);
     debug_report_data *report_data = device_data->report_data;
 
-    skip |= parameter_validation_vkCreateGraphicsPipelines(report_data, pipelineCache, createInfoCount, pCreateInfos,
-                                                                pAllocator, pPipelines);
+    skip |= parameter_validation_vkCreateGraphicsPipelines(report_data, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+                                                           pPipelines);
 
     if (pCreateInfos != nullptr) {
         for (uint32_t i = 0; i < createInfoCount; ++i) {
@@ -2942,10 +2939,10 @@
 
                 if (pCreateInfos[i].pViewportState->sType != VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO) {
                     skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                         __LINE__, INVALID_STRUCT_STYPE, LayerName,
-                                         "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pViewportState->sType must be "
-                                         "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO",
-                                         i);
+                                    __LINE__, INVALID_STRUCT_STYPE, LayerName,
+                                    "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pViewportState->sType must be "
+                                    "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO",
+                                    i);
                 }
 
                 if (device_data->physical_device_features.multiViewport == false) {
@@ -3071,10 +3068,10 @@
 
                 if (pCreateInfos[i].pMultisampleState->sType != VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO) {
                     skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                         __LINE__, INVALID_STRUCT_STYPE, LayerName,
-                                         "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pMultisampleState->sType must be "
-                                         "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO",
-                                         i);
+                                    __LINE__, INVALID_STRUCT_STYPE, LayerName,
+                                    "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pMultisampleState->sType must be "
+                                    "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO",
+                                    i);
                 }
             }
 
@@ -3164,10 +3161,10 @@
 
                 if (pCreateInfos[i].pDepthStencilState->sType != VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO) {
                     skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                         __LINE__, INVALID_STRUCT_STYPE, LayerName,
-                                         "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pDepthStencilState->sType must be "
-                                         "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO",
-                                         i);
+                                    __LINE__, INVALID_STRUCT_STYPE, LayerName,
+                                    "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pDepthStencilState->sType must be "
+                                    "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO",
+                                    i);
                 }
             }
 
@@ -3197,11 +3194,10 @@
                 if (pCreateInfos[i].pColorBlendState->pAttachments != NULL) {
                     for (uint32_t attachmentIndex = 0; attachmentIndex < pCreateInfos[i].pColorBlendState->attachmentCount;
                          ++attachmentIndex) {
-                        skip |=
-                            validate_bool32(report_data, "vkCreateGraphicsPipelines",
-                                            ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].blendEnable",
-                                                          ParameterName::IndexVector{i, attachmentIndex}),
-                                            pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].blendEnable);
+                        skip |= validate_bool32(report_data, "vkCreateGraphicsPipelines",
+                                                ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].blendEnable",
+                                                              ParameterName::IndexVector{i, attachmentIndex}),
+                                                pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].blendEnable);
 
                         skip |= validate_ranged_enum(
                             report_data, "vkCreateGraphicsPipelines",
@@ -3256,10 +3252,10 @@
 
                 if (pCreateInfos[i].pColorBlendState->sType != VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO) {
                     skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                         __LINE__, INVALID_STRUCT_STYPE, LayerName,
-                                         "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pColorBlendState->sType must be "
-                                         "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO",
-                                         i);
+                                    __LINE__, INVALID_STRUCT_STYPE, LayerName,
+                                    "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pColorBlendState->sType must be "
+                                    "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO",
+                                    i);
                 }
 
                 // If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value
@@ -3276,7 +3272,8 @@
     if (!skip) {
         PreCreateGraphicsPipelines(device, pCreateInfos);
 
-        result = device_data->dispatch_table.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        result = device_data->dispatch_table.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos,
+                                                                     pAllocator, pPipelines);
 
         validate_result(report_data, "vkCreateGraphicsPipelines", result);
     }
@@ -3306,12 +3303,13 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkCreateComputePipelines(my_data->report_data, pipelineCache, createInfoCount, pCreateInfos,
-                                                               pAllocator, pPipelines);
+                                                          pAllocator, pPipelines);
 
     if (!skip) {
         PreCreateComputePipelines(device, pCreateInfos);
 
-        result = my_data->dispatch_table.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        result = my_data->dispatch_table.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+                                                                pPipelines);
 
         validate_result(my_data->report_data, "vkCreateComputePipelines", result);
     }
@@ -3341,8 +3339,7 @@
     skip |= parameter_validation_vkCreatePipelineLayout(my_data->report_data, pCreateInfo, pAllocator, pPipelineLayout);
 
     if (!skip) {
-        result =
-            my_data->dispatch_table.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+        result = my_data->dispatch_table.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 
         validate_result(my_data->report_data, "vkCreatePipelineLayout", result);
     }
@@ -3378,7 +3375,7 @@
         // If compareEnable is VK_TRUE, compareOp must be a valid VkCompareOp value
         if (pCreateInfo->compareEnable == VK_TRUE) {
             skip |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->compareOp", "VkCompareOp",
-                                              VK_COMPARE_OP_BEGIN_RANGE, VK_COMPARE_OP_END_RANGE, pCreateInfo->compareOp);
+                                         VK_COMPARE_OP_BEGIN_RANGE, VK_COMPARE_OP_END_RANGE, pCreateInfo->compareOp);
         }
 
         // If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, borderColor must be a
@@ -3387,7 +3384,7 @@
             (pCreateInfo->addressModeV == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER) ||
             (pCreateInfo->addressModeW == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER)) {
             skip |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->borderColor", "VkBorderColor",
-                                              VK_BORDER_COLOR_BEGIN_RANGE, VK_BORDER_COLOR_END_RANGE, pCreateInfo->borderColor);
+                                         VK_BORDER_COLOR_BEGIN_RANGE, VK_BORDER_COLOR_END_RANGE, pCreateInfo->borderColor);
         }
     }
 
@@ -3494,8 +3491,7 @@
     /* TODOVV: How do we validate maxSets? Probably belongs in the limits layer? */
 
     if (!skip) {
-        result =
-            my_data->dispatch_table.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+        result = my_data->dispatch_table.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
 
         validate_result(my_data->report_data, "vkCreateDescriptorPool", result);
     }
@@ -3566,7 +3562,7 @@
     // This is an array of handles, where the elements are allowed to be VK_NULL_HANDLE, and does not require any validation beyond
     // validate_array()
     skip |= validate_array(report_data, "vkFreeDescriptorSets", "descriptorSetCount", "pDescriptorSets", descriptorSetCount,
-                                pDescriptorSets, true, true);
+                           pDescriptorSets, true, true);
 
     if (!skip) {
         result = device_data->dispatch_table.FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
@@ -3585,8 +3581,8 @@
     assert(device_data != NULL);
     debug_report_data *report_data = device_data->report_data;
 
-    skip |= parameter_validation_vkUpdateDescriptorSets(report_data, descriptorWriteCount, pDescriptorWrites,
-                                                             descriptorCopyCount, pDescriptorCopies);
+    skip |= parameter_validation_vkUpdateDescriptorSets(report_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
+                                                        pDescriptorCopies);
 
     // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
     if (pDescriptorWrites != NULL) {
@@ -3623,14 +3619,14 @@
                     for (uint32_t descriptor_index = 0; descriptor_index < pDescriptorWrites[i].descriptorCount;
                          ++descriptor_index) {
                         skip |= validate_required_handle(report_data, "vkUpdateDescriptorSets",
-                                                              ParameterName("pDescriptorWrites[%i].pImageInfo[%i].imageView",
-                                                                            ParameterName::IndexVector{i, descriptor_index}),
-                                                              pDescriptorWrites[i].pImageInfo[descriptor_index].imageView);
+                                                         ParameterName("pDescriptorWrites[%i].pImageInfo[%i].imageView",
+                                                                       ParameterName::IndexVector{i, descriptor_index}),
+                                                         pDescriptorWrites[i].pImageInfo[descriptor_index].imageView);
                         skip |= validate_ranged_enum(report_data, "vkUpdateDescriptorSets",
-                                                          ParameterName("pDescriptorWrites[%i].pImageInfo[%i].imageLayout",
-                                                                        ParameterName::IndexVector{i, descriptor_index}),
-                                                          "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE,
-                                                          pDescriptorWrites[i].pImageInfo[descriptor_index].imageLayout);
+                                                     ParameterName("pDescriptorWrites[%i].pImageInfo[%i].imageLayout",
+                                                                   ParameterName::IndexVector{i, descriptor_index}),
+                                                     "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE,
+                                                     pDescriptorWrites[i].pImageInfo[descriptor_index].imageLayout);
                     }
                 }
             } else if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) ||
@@ -3651,9 +3647,9 @@
                 } else {
                     for (uint32_t descriptorIndex = 0; descriptorIndex < pDescriptorWrites[i].descriptorCount; ++descriptorIndex) {
                         skip |= validate_required_handle(report_data, "vkUpdateDescriptorSets",
-                                                              ParameterName("pDescriptorWrites[%i].pBufferInfo[%i].buffer",
-                                                                            ParameterName::IndexVector{i, descriptorIndex}),
-                                                              pDescriptorWrites[i].pBufferInfo[descriptorIndex].buffer);
+                                                         ParameterName("pDescriptorWrites[%i].pBufferInfo[%i].buffer",
+                                                                       ParameterName::IndexVector{i, descriptorIndex}),
+                                                         pDescriptorWrites[i].pBufferInfo[descriptorIndex].buffer);
                     }
                 }
             } else if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) ||
@@ -3671,9 +3667,9 @@
                     for (uint32_t descriptor_index = 0; descriptor_index < pDescriptorWrites[i].descriptorCount;
                          ++descriptor_index) {
                         skip |= validate_required_handle(report_data, "vkUpdateDescriptorSets",
-                                                              ParameterName("pDescriptorWrites[%i].pTexelBufferView[%i]",
-                                                                            ParameterName::IndexVector{i, descriptor_index}),
-                                                              pDescriptorWrites[i].pTexelBufferView[descriptor_index]);
+                                                         ParameterName("pDescriptorWrites[%i].pTexelBufferView[%i]",
+                                                                       ParameterName::IndexVector{i, descriptor_index}),
+                                                         pDescriptorWrites[i].pTexelBufferView[descriptor_index]);
                     }
                 }
             }
@@ -3715,7 +3711,8 @@
     }
 
     if (!skip) {
-        device_data->dispatch_table.UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+        device_data->dispatch_table.UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
+                                                         pDescriptorCopies);
     }
 }
 
@@ -3889,7 +3886,7 @@
     // This is an array of handles, where the elements are allowed to be VK_NULL_HANDLE, and does not require any validation beyond
     // validate_array()
     skip |= validate_array(report_data, "vkFreeCommandBuffers", "commandBufferCount", "pCommandBuffers", commandBufferCount,
-                                pCommandBuffers, true, true);
+                           pCommandBuffers, true, true);
 
     if (!skip) {
         device_data->dispatch_table.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
@@ -3929,15 +3926,15 @@
     // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
     // TODO: pBeginInfo->pInheritanceInfo must not be NULL if commandBuffer is a secondary command buffer
     skip |= validate_struct_type(report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo",
-                                      "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO", pBeginInfo->pInheritanceInfo,
-                                      VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, false);
+                                 "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO", pBeginInfo->pInheritanceInfo,
+                                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, false);
 
     if (pBeginInfo->pInheritanceInfo != NULL) {
         skip |= validate_struct_pnext(report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->pNext", NULL,
-                                           pBeginInfo->pInheritanceInfo->pNext, 0, NULL, GeneratedHeaderVersion);
+                                      pBeginInfo->pInheritanceInfo->pNext, 0, NULL, GeneratedHeaderVersion);
 
         skip |= validate_bool32(report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->occlusionQueryEnable",
-                                     pBeginInfo->pInheritanceInfo->occlusionQueryEnable);
+                                pBeginInfo->pInheritanceInfo->occlusionQueryEnable);
 
         // TODO: This only needs to be validated when the inherited queries feature is enabled
         // skip |= validate_flags(report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->queryFlags",
@@ -3945,8 +3942,8 @@
 
         // TODO: This must be 0 if the pipeline statistics queries feature is not enabled
         skip |= validate_flags(report_data, "vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->pipelineStatistics",
-                                    "VkQueryPipelineStatisticFlagBits", AllVkQueryPipelineStatisticFlagBits,
-                                    pBeginInfo->pInheritanceInfo->pipelineStatistics, false);
+                               "VkQueryPipelineStatisticFlagBits", AllVkQueryPipelineStatisticFlagBits,
+                               pBeginInfo->pInheritanceInfo->pipelineStatistics, false);
     }
 
     skip |= PreBeginCommandBuffer(device_data, commandBuffer, pBeginInfo);
@@ -4094,24 +4091,24 @@
 
         if (pScissor.offset.x < 0) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
-                                 VALIDATION_ERROR_01489, LayerName, "vkCmdSetScissor %d: offset.x (%d) must not be negative. %s",
-                                 scissorIndex, pScissor.offset.x, validation_error_map[VALIDATION_ERROR_01489]);
+                            VALIDATION_ERROR_01489, LayerName, "vkCmdSetScissor %d: offset.x (%d) must not be negative. %s",
+                            scissorIndex, pScissor.offset.x, validation_error_map[VALIDATION_ERROR_01489]);
         } else if (static_cast<int32_t>(pScissor.extent.width) > (INT_MAX - pScissor.offset.x)) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
-                                 VALIDATION_ERROR_01490, LayerName,
-                                 "vkCmdSetScissor %d: adding offset.x (%d) and extent.width (%u) will overflow. %s", scissorIndex,
-                                 pScissor.offset.x, pScissor.extent.width, validation_error_map[VALIDATION_ERROR_01490]);
+                            VALIDATION_ERROR_01490, LayerName,
+                            "vkCmdSetScissor %d: adding offset.x (%d) and extent.width (%u) will overflow. %s", scissorIndex,
+                            pScissor.offset.x, pScissor.extent.width, validation_error_map[VALIDATION_ERROR_01490]);
         }
 
         if (pScissor.offset.y < 0) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
-                                 VALIDATION_ERROR_01489, LayerName, "vkCmdSetScissor %d: offset.y (%d) must not be negative. %s",
-                                 scissorIndex, pScissor.offset.y, validation_error_map[VALIDATION_ERROR_01489]);
+                            VALIDATION_ERROR_01489, LayerName, "vkCmdSetScissor %d: offset.y (%d) must not be negative. %s",
+                            scissorIndex, pScissor.offset.y, validation_error_map[VALIDATION_ERROR_01489]);
         } else if (static_cast<int32_t>(pScissor.extent.height) > (INT_MAX - pScissor.offset.y)) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
-                                 VALIDATION_ERROR_01491, LayerName,
-                                 "vkCmdSetScissor %d: adding offset.y (%d) and extent.height (%u) will overflow. %s", scissorIndex,
-                                 pScissor.offset.y, pScissor.extent.height, validation_error_map[VALIDATION_ERROR_01491]);
+                            VALIDATION_ERROR_01491, LayerName,
+                            "vkCmdSetScissor %d: adding offset.y (%d) and extent.height (%u) will overflow. %s", scissorIndex,
+                            pScissor.offset.y, pScissor.extent.height, validation_error_map[VALIDATION_ERROR_01491]);
         }
     }
 
@@ -4193,13 +4190,12 @@
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skip |=
-        parameter_validation_vkCmdBindDescriptorSets(my_data->report_data, pipelineBindPoint, layout, firstSet, descriptorSetCount,
-                                                     pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+    skip |= parameter_validation_vkCmdBindDescriptorSets(my_data->report_data, pipelineBindPoint, layout, firstSet,
+                                                         descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 
     if (!skip) {
-        my_data->dispatch_table.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets,
-                                    dynamicOffsetCount, pDynamicOffsets);
+        my_data->dispatch_table.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount,
+                                                      pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
     }
 }
 
@@ -4230,7 +4226,7 @@
 }
 
 static bool PreCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
-                uint32_t firstInstance) {
+                       uint32_t firstInstance) {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     if (vertexCount == 0) {
         // TODO: Verify against Valid Usage section. I don't see a non-zero vertexCount listed, may need to add that and make
@@ -4355,12 +4351,13 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkCmdCopyImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout,
-                                                     regionCount, pRegions);
+                                                regionCount, pRegions);
 
     if (!skip) {
         PreCmdCopyImage(commandBuffer, pRegions);
 
-        my_data->dispatch_table.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+        my_data->dispatch_table.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
+                                             pRegions);
     }
 }
 
@@ -4394,12 +4391,13 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkCmdBlitImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout,
-                                                     regionCount, pRegions, filter);
+                                                regionCount, pRegions, filter);
 
     if (!skip) {
         PreCmdBlitImage(commandBuffer, pRegions);
 
-        my_data->dispatch_table.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+        my_data->dispatch_table.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
+                                             pRegions, filter);
     }
 }
 
@@ -4427,7 +4425,7 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkCmdCopyBufferToImage(my_data->report_data, srcBuffer, dstImage, dstImageLayout, regionCount,
-                                                             pRegions);
+                                                        pRegions);
 
     if (!skip) {
         PreCmdCopyBufferToImage(commandBuffer, pRegions);
@@ -4459,7 +4457,7 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkCmdCopyImageToBuffer(my_data->report_data, srcImage, srcImageLayout, dstBuffer, regionCount,
-                                                             pRegions);
+                                                        pRegions);
 
     if (!skip) {
         PreCmdCopyImageToBuffer(commandBuffer, pRegions);
@@ -4555,8 +4553,8 @@
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skip |= parameter_validation_vkCmdClearDepthStencilImage(my_data->report_data, image, imageLayout, pDepthStencil,
-                                                                  rangeCount, pRanges);
+    skip |= parameter_validation_vkCmdClearDepthStencilImage(my_data->report_data, image, imageLayout, pDepthStencil, rangeCount,
+                                                             pRanges);
 
     if (!skip) {
         my_data->dispatch_table.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
@@ -4609,12 +4607,13 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkCmdResolveImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout,
-                                                        regionCount, pRegions);
+                                                   regionCount, pRegions);
 
     if (!skip) {
         PreCmdResolveImage(commandBuffer, pRegions);
 
-        my_data->dispatch_table.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+        my_data->dispatch_table.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
+                                                pRegions);
     }
 }
 
@@ -4652,12 +4651,13 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkCmdWaitEvents(my_data->report_data, eventCount, pEvents, srcStageMask, dstStageMask,
-                                                      memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
-                                                      pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+                                                 memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+                                                 pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 
     if (!skip) {
-        my_data->dispatch_table.CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers,
-                            bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+        my_data->dispatch_table.CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount,
+                                              pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers,
+                                              imageMemoryBarrierCount, pImageMemoryBarriers);
     }
 }
 
@@ -4671,12 +4671,13 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkCmdPipelineBarrier(my_data->report_data, srcStageMask, dstStageMask, dependencyFlags,
-                                                           memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
-                                                           pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+                                                      memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+                                                      pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 
     if (!skip) {
-        my_data->dispatch_table.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers,
-                                 bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+        my_data->dispatch_table.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount,
+                                                   pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers,
+                                                   imageMemoryBarrierCount, pImageMemoryBarriers);
     }
 }
 
@@ -4749,10 +4750,11 @@
     assert(my_data != NULL);
 
     skip |= parameter_validation_vkCmdCopyQueryPoolResults(my_data->report_data, queryPool, firstQuery, queryCount, dstBuffer,
-                                                                dstOffset, stride, flags);
+                                                           dstOffset, stride, flags);
 
     if (!skip) {
-        my_data->dispatch_table.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+        my_data->dispatch_table.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset,
+                                                        stride, flags);
     }
 }
 
@@ -4841,13 +4843,12 @@
         ->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
 }
 
-static bool require_device_extension(layer_data *my_data, bool flag, char const *function_name, char const *extension_name)
-{
+static bool require_device_extension(layer_data *my_data, bool flag, char const *function_name, char const *extension_name) {
     if (!flag) {
-        return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                       __LINE__, EXTENSION_NOT_ENABLED, LayerName,
-                       "%s() called even though the %s extension was not enabled for this VkDevice.",
-                       function_name, extension_name);
+        return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
+                       EXTENSION_NOT_ENABLED, LayerName,
+                       "%s() called even though the %s extension was not enabled for this VkDevice.", function_name,
+                       extension_name);
     }
 
     return false;
@@ -4862,7 +4863,8 @@
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkCreateSwapchainKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+    skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkCreateSwapchainKHR",
+                                     VK_KHR_SWAPCHAIN_EXTENSION_NAME);
 
     skip |= parameter_validation_vkCreateSwapchainKHR(my_data->report_data, pCreateInfo, pAllocator, pSwapchain);
 
@@ -4882,10 +4884,10 @@
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkGetSwapchainImagesKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+    skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkGetSwapchainImagesKHR",
+                                     VK_KHR_SWAPCHAIN_EXTENSION_NAME);
 
-    skip |=
-        parameter_validation_vkGetSwapchainImagesKHR(my_data->report_data, swapchain, pSwapchainImageCount, pSwapchainImages);
+    skip |= parameter_validation_vkGetSwapchainImagesKHR(my_data->report_data, swapchain, pSwapchainImageCount, pSwapchainImages);
 
     if (!skip) {
         result = my_data->dispatch_table.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
@@ -4903,10 +4905,10 @@
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkAcquireNextImageKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+    skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkAcquireNextImageKHR",
+                                     VK_KHR_SWAPCHAIN_EXTENSION_NAME);
 
-    skip |=
-        parameter_validation_vkAcquireNextImageKHR(my_data->report_data, swapchain, timeout, semaphore, fence, pImageIndex);
+    skip |= parameter_validation_vkAcquireNextImageKHR(my_data->report_data, swapchain, timeout, semaphore, fence, pImageIndex);
 
     if (!skip) {
         result = my_data->dispatch_table.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
@@ -4923,7 +4925,8 @@
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
     assert(my_data != NULL);
 
-    skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkQueuePresentKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+    skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkQueuePresentKHR",
+                                     VK_KHR_SWAPCHAIN_EXTENSION_NAME);
 
     skip |= parameter_validation_vkQueuePresentKHR(my_data->report_data, pPresentInfo);
 
@@ -4941,7 +4944,8 @@
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkDestroySwapchainKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+    skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkDestroySwapchainKHR",
+                                     VK_KHR_SWAPCHAIN_EXTENSION_NAME);
 
     /* No generated validation function for this call */
 
@@ -4950,14 +4954,14 @@
     }
 }
 
-static bool require_instance_extension(void *instance, bool instance_extension_enables::*flag, char const *function_name, char const *extension_name)
-{
+static bool require_instance_extension(void *instance, bool instance_extension_enables::*flag, char const *function_name,
+                                       char const *extension_name) {
     auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
     if (!(my_data->extensions.*flag)) {
         return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
                        reinterpret_cast<uint64_t>(instance), __LINE__, EXTENSION_NOT_ENABLED, LayerName,
-                       "%s() called even though the %s extension was not enabled for this VkInstance.",
-                       function_name, extension_name);
+                       "%s() called even though the %s extension was not enabled for this VkInstance.", function_name,
+                       extension_name);
     }
 
     return false;
@@ -4971,10 +4975,9 @@
     assert(my_data != NULL);
 
     skip |= require_instance_extension(physicalDevice, &instance_extension_enables::surface_enabled,
-                                            "vkGetPhysicalDeviceSurfaceSupportKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+                                       "vkGetPhysicalDeviceSurfaceSupportKHR", VK_KHR_SURFACE_EXTENSION_NAME);
 
-    skip |=
-        parameter_validation_vkGetPhysicalDeviceSurfaceSupportKHR(my_data->report_data, queueFamilyIndex, surface, pSupported);
+    skip |= parameter_validation_vkGetPhysicalDeviceSurfaceSupportKHR(my_data->report_data, queueFamilyIndex, surface, pSupported);
 
     if (!skip) {
         result = my_data->dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
@@ -4993,10 +4996,9 @@
     assert(my_data != NULL);
 
     skip |= require_instance_extension(physicalDevice, &instance_extension_enables::surface_enabled,
-                                            "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+                                       "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", VK_KHR_SURFACE_EXTENSION_NAME);
 
-    skip |=
-        parameter_validation_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(my_data->report_data, surface, pSurfaceCapabilities);
+    skip |= parameter_validation_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(my_data->report_data, surface, pSurfaceCapabilities);
 
     if (!skip) {
         result = my_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
@@ -5016,10 +5018,10 @@
     assert(my_data != NULL);
 
     skip |= require_instance_extension(physicalDevice, &instance_extension_enables::surface_enabled,
-                                            "vkGetPhysicalDeviceSurfaceFormatsKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+                                       "vkGetPhysicalDeviceSurfaceFormatsKHR", VK_KHR_SURFACE_EXTENSION_NAME);
 
     skip |= parameter_validation_vkGetPhysicalDeviceSurfaceFormatsKHR(my_data->report_data, surface, pSurfaceFormatCount,
-                                                                           pSurfaceFormats);
+                                                                      pSurfaceFormats);
 
     if (!skip) {
         result = my_data->dispatch_table.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount,
@@ -5040,10 +5042,10 @@
     assert(my_data != NULL);
 
     skip |= require_instance_extension(physicalDevice, &instance_extension_enables::surface_enabled,
-                                            "vkGetPhysicalDeviceSurfacePresentModesKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+                                       "vkGetPhysicalDeviceSurfacePresentModesKHR", VK_KHR_SURFACE_EXTENSION_NAME);
 
     skip |= parameter_validation_vkGetPhysicalDeviceSurfacePresentModesKHR(my_data->report_data, surface, pPresentModeCount,
-                                                                                pPresentModes);
+                                                                           pPresentModes);
 
     if (!skip) {
         result = my_data->dispatch_table.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount,
@@ -5059,8 +5061,8 @@
     bool skip = false;
     auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
 
-    skip |= require_instance_extension(instance, &instance_extension_enables::surface_enabled,
-                                            "vkDestroySurfaceKHR", VK_KHR_SURFACE_EXTENSION_NAME);
+    skip |= require_instance_extension(instance, &instance_extension_enables::surface_enabled, "vkDestroySurfaceKHR",
+                                       VK_KHR_SURFACE_EXTENSION_NAME);
 
     if (!skip) {
         my_data->dispatch_table.DestroySurfaceKHR(instance, surface, pAllocator);
@@ -5076,8 +5078,8 @@
     assert(my_data != NULL);
     bool skip = false;
 
-    skip |= require_instance_extension(instance, &instance_extension_enables::win32_enabled,
-                                            "vkCreateWin32SurfaceKHR", VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
+    skip |= require_instance_extension(instance, &instance_extension_enables::win32_enabled, "vkCreateWin32SurfaceKHR",
+                                       VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
 
     skip |= parameter_validation_vkCreateWin32SurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
 
@@ -5091,8 +5093,7 @@
 }
 
 VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                            uint32_t queueFamilyIndex)
-{
+                                                                            uint32_t queueFamilyIndex) {
     VkBool32 result = false;
 
     auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
@@ -5100,10 +5101,10 @@
     bool skip = false;
 
     skip |= require_instance_extension(physicalDevice, &instance_extension_enables::win32_enabled,
-                                            "vkGetPhysicalDeviceWin32PresentationSupportKHR", VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
+                                       "vkGetPhysicalDeviceWin32PresentationSupportKHR", VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
 
     // TODO: codegen doesn't produce this function?
-    //skip |= parameter_validation_vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
+    // skip |= parameter_validation_vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
 
     if (!skip) {
         result = my_data->dispatch_table.GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
@@ -5122,8 +5123,8 @@
     assert(my_data != NULL);
     bool skip = false;
 
-    skip |= require_instance_extension(instance, &instance_extension_enables::xcb_enabled,
-                                            "vkCreateXcbSurfaceKHR", VK_KHR_XCB_SURFACE_EXTENSION_NAME);
+    skip |= require_instance_extension(instance, &instance_extension_enables::xcb_enabled, "vkCreateXcbSurfaceKHR",
+                                       VK_KHR_XCB_SURFACE_EXTENSION_NAME);
 
     skip |= parameter_validation_vkCreateXcbSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
 
@@ -5146,10 +5147,10 @@
     bool skip = false;
 
     skip |= require_instance_extension(physicalDevice, &instance_extension_enables::xcb_enabled,
-                                            "vkGetPhysicalDeviceXcbPresentationSupportKHR", VK_KHR_XCB_SURFACE_EXTENSION_NAME);
+                                       "vkGetPhysicalDeviceXcbPresentationSupportKHR", VK_KHR_XCB_SURFACE_EXTENSION_NAME);
 
-    skip |= parameter_validation_vkGetPhysicalDeviceXcbPresentationSupportKHR(my_data->report_data, queueFamilyIndex,
-                                                                                       connection, visual_id);
+    skip |= parameter_validation_vkGetPhysicalDeviceXcbPresentationSupportKHR(my_data->report_data, queueFamilyIndex, connection,
+                                                                              visual_id);
 
     if (!skip) {
         result = my_data->dispatch_table.GetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection,
@@ -5169,8 +5170,8 @@
     assert(my_data != NULL);
     bool skip = false;
 
-    skip |= require_instance_extension(instance, &instance_extension_enables::xlib_enabled,
-                                            "vkCreateXlibSurfaceKHR", VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+    skip |= require_instance_extension(instance, &instance_extension_enables::xlib_enabled, "vkCreateXlibSurfaceKHR",
+                                       VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
 
     skip |= parameter_validation_vkCreateXlibSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
 
@@ -5193,9 +5194,10 @@
     bool skip = false;
 
     skip |= require_instance_extension(physicalDevice, &instance_extension_enables::xlib_enabled,
-                                            "vkGetPhysicalDeviceXlibPresentationSupportKHR", VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+                                       "vkGetPhysicalDeviceXlibPresentationSupportKHR", VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
 
-    skip |= parameter_validation_vkGetPhysicalDeviceXlibPresentationSupportKHR(my_data->report_data, queueFamilyIndex, dpy, visualID);
+    skip |=
+        parameter_validation_vkGetPhysicalDeviceXlibPresentationSupportKHR(my_data->report_data, queueFamilyIndex, dpy, visualID);
 
     if (!skip) {
         result =
@@ -5214,8 +5216,8 @@
     assert(my_data != NULL);
     bool skip = false;
 
-    skip |= require_instance_extension(instance, &instance_extension_enables::mir_enabled,
-                                            "vkCreateMirSurfaceKHR", VK_KHR_MIR_SURFACE_EXTENSION_NAME);
+    skip |= require_instance_extension(instance, &instance_extension_enables::mir_enabled, "vkCreateMirSurfaceKHR",
+                                       VK_KHR_MIR_SURFACE_EXTENSION_NAME);
 
     skip |= parameter_validation_vkCreateMirSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
 
@@ -5238,7 +5240,7 @@
     bool skip = false;
 
     skip |= require_instance_extension(physicalDevice, &instance_extension_enables::mir_enabled,
-                                            "vkGetPhysicalDeviceMirPresentationSupportKHR", VK_KHR_MIR_SURFACE_EXTENSION_NAME);
+                                       "vkGetPhysicalDeviceMirPresentationSupportKHR", VK_KHR_MIR_SURFACE_EXTENSION_NAME);
 
     skip |= parameter_validation_vkGetPhysicalDeviceMirPresentationSupportKHR(my_data->report_data, queueFamilyIndex, connection);
 
@@ -5258,8 +5260,8 @@
     assert(my_data != NULL);
     bool skip = false;
 
-    skip |= require_instance_extension(instance, &instance_extension_enables::wayland_enabled,
-                                            "vkCreateWaylandSurfaceKHR", VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
+    skip |= require_instance_extension(instance, &instance_extension_enables::wayland_enabled, "vkCreateWaylandSurfaceKHR",
+                                       VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
 
     skip |= parameter_validation_vkCreateWaylandSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
 
@@ -5282,10 +5284,9 @@
     bool skip = false;
 
     skip |= require_instance_extension(physicalDevice, &instance_extension_enables::wayland_enabled,
-                                            "vkGetPhysicalDeviceWaylandPresentationSupportKHR", VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
+                                       "vkGetPhysicalDeviceWaylandPresentationSupportKHR", VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
 
-    skip |=
-        parameter_validation_vkGetPhysicalDeviceWaylandPresentationSupportKHR(my_data->report_data, queueFamilyIndex, display);
+    skip |= parameter_validation_vkGetPhysicalDeviceWaylandPresentationSupportKHR(my_data->report_data, queueFamilyIndex, display);
 
     if (!skip) {
         result = my_data->dispatch_table.GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
@@ -5786,8 +5787,7 @@
     bool skip = false;
     skip |= require_instance_extension(physicalDevice, &instance_extension_enables::ext_display_surface_counter_enabled,
                                        "vkGetPhysicalDeviceSurfaceCapabilities2EXT", VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
-    skip |=
-        parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2EXT(my_data->report_data, surface, pSurfaceCapabilities);
+    skip |= parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2EXT(my_data->report_data, surface, pSurfaceCapabilities);
     if (!skip) {
         result = my_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
         validate_result(my_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilities2EXT", result);
@@ -6300,23 +6300,28 @@
         {"vkCreateDisplayPlaneSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateDisplayPlaneSurfaceKHR)},
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         {"vkCreateWin32SurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateWin32SurfaceKHR)},
-        {"vkGetPhysicalDeviceWin32PresentationSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceWin32PresentationSupportKHR)},
+        {"vkGetPhysicalDeviceWin32PresentationSupportKHR",
+         reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceWin32PresentationSupportKHR)},
 #endif
 #ifdef VK_USE_PLATFORM_XCB_KHR
         {"vkCreateXcbSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateXcbSurfaceKHR)},
-        {"vkGetPhysicalDeviceXcbPresentationSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceXcbPresentationSupportKHR)},
+        {"vkGetPhysicalDeviceXcbPresentationSupportKHR",
+         reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceXcbPresentationSupportKHR)},
 #endif
 #ifdef VK_USE_PLATFORM_XLIB_KHR
         {"vkCreateXlibSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateXlibSurfaceKHR)},
-        {"vkGetPhysicalDeviceXlibPresentationSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceXlibPresentationSupportKHR)},
+        {"vkGetPhysicalDeviceXlibPresentationSupportKHR",
+         reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceXlibPresentationSupportKHR)},
 #endif
 #ifdef VK_USE_PLATFORM_MIR_KHR
         {"vkCreateMirSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateMirSurfaceKHR)},
-        {"vkGetPhysicalDeviceMirPresentationSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceMirPresentationSupportKHR)},
+        {"vkGetPhysicalDeviceMirPresentationSupportKHR",
+         reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceMirPresentationSupportKHR)},
 #endif
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
         {"vkCreateWaylandSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateWaylandSurfaceKHR)},
-        {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceWaylandPresentationSupportKHR)},
+        {"vkGetPhysicalDeviceWaylandPresentationSupportKHR",
+         reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceWaylandPresentationSupportKHR)},
 #endif
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
         {"vkCreateAndroidSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateAndroidSurfaceKHR)},
@@ -6339,15 +6344,19 @@
         {"vkGetPhysicalDeviceFeatures2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceFeatures2KHR)},
         {"vkGetPhysicalDeviceProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceProperties2KHR)},
         {"vkGetPhysicalDeviceFormatProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceFormatProperties2KHR)},
-        {"vkGetPhysicalDeviceImageFormatProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceImageFormatProperties2KHR)},
-        {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceQueueFamilyProperties2KHR)},
+        {"vkGetPhysicalDeviceImageFormatProperties2KHR",
+         reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceImageFormatProperties2KHR)},
+        {"vkGetPhysicalDeviceQueueFamilyProperties2KHR",
+         reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceQueueFamilyProperties2KHR)},
         {"vkGetPhysicalDeviceMemoryProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceMemoryProperties2KHR)},
-        {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSparseImageFormatProperties2KHR)},
+        {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR",
+         reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSparseImageFormatProperties2KHR)},
         // NV_external_memory_capabilities
         {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV",
          reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceExternalImageFormatPropertiesNV)},
         // NVX_device_generated_commands
-        {"vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceGeneratedCommandsPropertiesNVX)},
+        {"vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX",
+         reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceGeneratedCommandsPropertiesNVX)},
     };
 
     for (size_t i = 0; i < ARRAY_SIZE(extension_instance_commands); i++) {
@@ -6452,7 +6461,8 @@
     return parameter_validation::GetInstanceProcAddr(instance, funcName);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance,
+                                                                                           const char *funcName) {
     return parameter_validation::GetPhysicalDeviceProcAddr(instance, funcName);
 }
 
diff --git a/layers/parameter_validation_utils.h b/layers/parameter_validation_utils.h
index 7c6e605..3cc85c0 100644
--- a/layers/parameter_validation_utils.h
+++ b/layers/parameter_validation_utils.h
@@ -35,32 +35,32 @@
 namespace parameter_validation {
 
 enum ErrorCode {
-    NONE,                 // Used for INFO & other non-error messages
-    INVALID_USAGE,        // The value of a parameter is not consistent
-                          // with the valid usage criteria defined in
-                          // the Vulkan specification.
-    INVALID_STRUCT_STYPE, // The sType field of a Vulkan structure does
-                          // not contain the value expected for a structure
-                          // of that type.
-    INVALID_STRUCT_PNEXT, // The pNext field of a Vulkan structure references
-                          // a value that is not compatible with a structure of
-                          // that type or is not NULL when a structure of that
-                          // type has no compatible pNext values.
-    REQUIRED_PARAMETER,   // A required parameter was specified as 0 or NULL.
-    RESERVED_PARAMETER,   // A parameter reserved for future use was not
-                          // specified as 0 or NULL.
-    UNRECOGNIZED_VALUE,   // A Vulkan enumeration, VkFlags, or VkBool32 parameter
-                          // contains a value that is not recognized as valid for
-                          // that type.
-    DEVICE_LIMIT,         // A specified parameter exceeds the limits returned
-                          // by the physical device
-    DEVICE_FEATURE,       // Use of a requested feature is not supported by
-                          // the device
-    FAILURE_RETURN_CODE,  // A Vulkan return code indicating a failure condition
-                          // was encountered.
-    EXTENSION_NOT_ENABLED,// An extension entrypoint was called, but the required
-                          // extension was not enabled at CreateInstance or
-                          // CreateDevice time.
+    NONE,                  // Used for INFO & other non-error messages
+    INVALID_USAGE,         // The value of a parameter is not consistent
+                           // with the valid usage criteria defined in
+                           // the Vulkan specification.
+    INVALID_STRUCT_STYPE,  // The sType field of a Vulkan structure does
+                           // not contain the value expected for a structure
+                           // of that type.
+    INVALID_STRUCT_PNEXT,  // The pNext field of a Vulkan structure references
+                           // a value that is not compatible with a structure of
+                           // that type or is not NULL when a structure of that
+                           // type has no compatible pNext values.
+    REQUIRED_PARAMETER,    // A required parameter was specified as 0 or NULL.
+    RESERVED_PARAMETER,    // A parameter reserved for future use was not
+                           // specified as 0 or NULL.
+    UNRECOGNIZED_VALUE,    // A Vulkan enumeration, VkFlags, or VkBool32 parameter
+                           // contains a value that is not recognized as valid for
+                           // that type.
+    DEVICE_LIMIT,          // A specified parameter exceeds the limits returned
+                           // by the physical device
+    DEVICE_FEATURE,        // Use of a requested feature is not supported by
+                           // the device
+    FAILURE_RETURN_CODE,   // A Vulkan return code indicating a failure condition
+                           // was encountered.
+    EXTENSION_NOT_ENABLED, // An extension entrypoint was called, but the required
+                           // extension was not enabled at CreateInstance or
+                           // CreateDevice time.
 };
 
 struct GenericHeader {
@@ -186,15 +186,15 @@
     // Count parameters not tagged as optional cannot be 0
     if (countRequired && (count == 0)) {
         skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
-                            REQUIRED_PARAMETER, LayerName, "%s: parameter %s must be greater than 0", apiName,
-                            countName.get_name().c_str());
+                             REQUIRED_PARAMETER, LayerName, "%s: parameter %s must be greater than 0", apiName,
+                             countName.get_name().c_str());
     }
 
     // Array parameters not tagged as optional cannot be NULL, unless the count is 0
     if ((array == NULL) && arrayRequired && (count != 0)) {
         skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
-                            REQUIRED_PARAMETER, LayerName, "%s: required parameter %s specified as NULL", apiName,
-                            arrayName.get_name().c_str());
+                             REQUIRED_PARAMETER, LayerName, "%s: required parameter %s specified as NULL", apiName,
+                             arrayName.get_name().c_str());
     }
 
     return skip_call;
@@ -232,8 +232,7 @@
                                  REQUIRED_PARAMETER, LayerName, "%s: required parameter %s specified as NULL", apiName,
                                  countName.get_name().c_str());
         }
-    }
-    else {
+    } else {
         skip_call |= validate_array(report_data, apiName, countName, arrayName, (*count), array, countValueRequired, arrayRequired);
     }
 
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 80eefcd..29ec8b4 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -1067,7 +1067,6 @@
                                  "However, vkGetPhysicalDeviceSurfaceSupportKHR() was never called with this surface. %s",
                                  validation_error_map[VALIDATION_ERROR_01922]);
         }
-
     }
 
     // Validate pCreateInfo->imageSharingMode and related values:
@@ -1228,8 +1227,7 @@
     return VK_ERROR_VALIDATION_FAILED_EXT;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
+VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
     bool skip_call = false;
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
 
@@ -1552,7 +1550,8 @@
     return swapchain::GetInstanceProcAddr(instance, funcName);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance,
+                                                                                           const char *funcName) {
     return swapchain::GetPhysicalDeviceProcAddr(instance, funcName);
 }
 
diff --git a/layers/swapchain.h b/layers/swapchain.h
index 98e84ea..2346d1e 100644
--- a/layers/swapchain.h
+++ b/layers/swapchain.h
@@ -51,27 +51,27 @@
     SWAPCHAIN_CREATE_SWAP_BAD_SHARING_MODE,     // Called vkCreateSwapchainKHR() with a non-supported imageSharingMode
     SWAPCHAIN_CREATE_SWAP_BAD_SHARING_VALUES,   // Called vkCreateSwapchainKHR() with bad values when imageSharingMode is
                                                 // VK_SHARING_MODE_CONCURRENT
-    SWAPCHAIN_BAD_BOOL,                 // VkBool32 that doesn't have value of VK_TRUE or VK_FALSE (e.g. is a non-zero form of true)
-    SWAPCHAIN_PRIOR_COUNT,              // Query must be called first to get value of pCount, then called second time
-    SWAPCHAIN_INVALID_COUNT,            // Second time a query called, the pCount value didn't match first time
-    SWAPCHAIN_WRONG_STYPE,              // The sType for a struct has the wrong value
-    SWAPCHAIN_WRONG_NEXT,               // The pNext for a struct is not NULL
-    SWAPCHAIN_ZERO_VALUE,               // A value should be non-zero
+    SWAPCHAIN_BAD_BOOL,      // VkBool32 that doesn't have value of VK_TRUE or VK_FALSE (e.g. is a non-zero form of true)
+    SWAPCHAIN_PRIOR_COUNT,   // Query must be called first to get value of pCount, then called second time
+    SWAPCHAIN_INVALID_COUNT, // Second time a query called, the pCount value didn't match first time
+    SWAPCHAIN_WRONG_STYPE,   // The sType for a struct has the wrong value
+    SWAPCHAIN_WRONG_NEXT,    // The pNext for a struct is not NULL
+    SWAPCHAIN_ZERO_VALUE,    // A value should be non-zero
     SWAPCHAIN_DID_NOT_QUERY_QUEUE_FAMILIES,     // A function using a queueFamilyIndex was called before
                                                 // vkGetPhysicalDeviceQueueFamilyProperties() was called
     SWAPCHAIN_QUEUE_FAMILY_INDEX_TOO_LARGE,     // A queueFamilyIndex value is not less than pQueueFamilyPropertyCount returned by
                                                 // vkGetPhysicalDeviceQueueFamilyProperties()
     SWAPCHAIN_SURFACE_NOT_SUPPORTED_WITH_QUEUE, // A surface is not supported by a given queueFamilyIndex, as seen by
                                                 // vkGetPhysicalDeviceSurfaceSupportKHR()
-    SWAPCHAIN_GET_SUPPORTED_DISPLAYS_WITHOUT_QUERY,     // vkGetDisplayPlaneSupportedDisplaysKHR should be called after querying 
-                                                        // device display plane properties
-    SWAPCHAIN_PLANE_INDEX_TOO_LARGE,    // a planeIndex value is larger than what vkGetDisplayPlaneSupportedDisplaysKHR returns
+    SWAPCHAIN_GET_SUPPORTED_DISPLAYS_WITHOUT_QUERY, // vkGetDisplayPlaneSupportedDisplaysKHR should be called after querying
+                                                    // device display plane properties
+    SWAPCHAIN_PLANE_INDEX_TOO_LARGE, // a planeIndex value is larger than what vkGetDisplayPlaneSupportedDisplaysKHR returns
 };
 
 // The following is for logging error messages:
-const char * swapchain_layer_name = "Swapchain";
+const char *swapchain_layer_name = "Swapchain";
 
-#define LAYER_NAME (char *) "Swapchain"
+#define LAYER_NAME (char *)"Swapchain"
 
 // NOTE: The following struct's/typedef's are for keeping track of
 // info that is used for validating the WSI extensions.
diff --git a/layers/threading.cpp b/layers/threading.cpp
index 2f931e7..1997f78 100644
--- a/layers/threading.cpp
+++ b/layers/threading.cpp
@@ -46,8 +46,8 @@
     layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "google_threading");
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
+                                              VkInstance *pInstance) {
     VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
 
     assert(chain_info->u.pLayerInfo);
@@ -190,27 +190,25 @@
     return NULL;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
     return util_GetLayerProperties(1, &layerProps, pCount, pProperties);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
+                                                              VkLayerProperties *pProperties) {
     return util_GetLayerProperties(1, &layerProps, pCount, pProperties);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
+                                                                    VkExtensionProperties *pProperties) {
     if (pLayerName && !strcmp(pLayerName, layerProps.layerName))
         return util_GetExtensionProperties(1, threading_extensions, pCount, pProperties);
 
     return VK_ERROR_LAYER_NOT_PRESENT;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
-                                                                  const char *pLayerName, uint32_t *pCount,
-                                                                  VkExtensionProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName,
+                                                                  uint32_t *pCount, VkExtensionProperties *pProperties) {
     // Threading layer does not have any device extensions
     if (pLayerName && !strcmp(pLayerName, layerProps.layerName))
         return util_GetExtensionProperties(0, nullptr, pCount, pProperties);
@@ -308,9 +306,10 @@
     return pTable->GetPhysicalDeviceProcAddr(instance, funcName);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                             const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {
+VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance,
+                                                            const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                                            const VkAllocationCallbacks *pAllocator,
+                                                            VkDebugReportCallbackEXT *pMsgCallback) {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     bool threadChecks = startMultiThread();
     if (threadChecks) {
@@ -329,8 +328,8 @@
     return result;
 }
 
-VKAPI_ATTR void VKAPI_CALL
-DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
+                                                         const VkAllocationCallbacks *pAllocator) {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     bool threadChecks = startMultiThread();
     if (threadChecks) {
@@ -347,8 +346,8 @@
     }
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers) {
+VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo,
+                                                      VkCommandBuffer *pCommandBuffers) {
     dispatch_key key = get_dispatch_key(device);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
     VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
@@ -413,38 +412,38 @@
 
 // vk_layer_logging.h expects these to be defined
 
-VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                               const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance,
+                                                              const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                                              const VkAllocationCallbacks *pAllocator,
+                                                              VkDebugReportCallbackEXT *pMsgCallback) {
     return threading::CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance,
-                                                           VkDebugReportCallbackEXT msgCallback,
+VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
                                                            const VkAllocationCallbacks *pAllocator) {
     threading::DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object,
-                        size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
+VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+                                                   VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
+                                                   int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
     threading::DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
 }
 
 // loader-layer interface v0, just wrappers since there is only a layer
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) {
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
+                                                                                      VkExtensionProperties *pProperties) {
     return threading::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount,
+                                                                                  VkLayerProperties *pProperties) {
     return threading::EnumerateInstanceLayerProperties(pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) {
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
+                                                                                VkLayerProperties *pProperties) {
     // the layer command handles VK_NULL_HANDLE just fine internally
     assert(physicalDevice == VK_NULL_HANDLE);
     return threading::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties);
@@ -466,7 +465,8 @@
     return threading::GetInstanceProcAddr(instance, funcName);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance,
+                                                                                           const char *funcName) {
     return threading::GetPhysicalDeviceProcAddr(instance, funcName);
 }
 
diff --git a/layers/threading.h b/layers/threading.h
index 98bb4e7..9bd8424 100644
--- a/layers/threading.h
+++ b/layers/threading.h
@@ -90,8 +90,8 @@
             if (use_data->reader_count == 0) {
                 // There are no readers.  Two writers just collided.
                 if (use_data->thread != tid) {
-                    skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
-                                        0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
+                    skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), 0,
+                                        THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
                                         "THREADING ERROR : object of type %s is simultaneously used in thread %ld and thread %ld",
                                         typeName, use_data->thread, tid);
                     if (skipCall) {
@@ -117,8 +117,8 @@
             } else {
                 // There are readers.  This writer collided with them.
                 if (use_data->thread != tid) {
-                    skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
-                                        0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
+                    skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), 0,
+                                        THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
                                         "THREADING ERROR : object of type %s is simultaneously used in thread %ld and thread %ld",
                                         typeName, use_data->thread, tid);
                     if (skipCall) {
@@ -169,8 +169,8 @@
             use_data->thread = tid;
         } else if (uses[object].writer_count > 0 && uses[object].thread != tid) {
             // There is a writer of the object.
-            skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
-                                0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
+            skipCall |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), 0,
+                                THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",
                                 "THREADING ERROR : object of type %s is simultaneously used in thread %ld and thread %ld", typeName,
                                 uses[object].thread, tid);
             if (skipCall) {
@@ -246,7 +246,7 @@
     counter<VkShaderModule> c_VkShaderModule;
     counter<VkDebugReportCallbackEXT> c_VkDebugReportCallbackEXT;
     counter<VkObjectTableNVX> c_VkObjectTableNVX;
-    counter<VkIndirectCommandsLayoutNVX>c_VkIndirectCommandsLayoutNVX;
+    counter<VkIndirectCommandsLayoutNVX> c_VkIndirectCommandsLayoutNVX;
 #else  // DISTINCT_NONDISPATCHABLE_HANDLES
     counter<uint64_t> c_uint64_t;
 #endif // DISTINCT_NONDISPATCHABLE_HANDLES
@@ -327,7 +327,6 @@
 WRAPPER(uint64_t)
 #endif // DISTINCT_NONDISPATCHABLE_HANDLES
 
-
 static std::unordered_map<void *, layer_data *> layer_data_map;
 static std::mutex command_pool_lock;
 static std::unordered_map<VkCommandBuffer, VkCommandPool> command_pool_map;
diff --git a/layers/unique_objects.cpp b/layers/unique_objects.cpp
index dabdc04..08f1ded 100644
--- a/layers/unique_objects.cpp
+++ b/layers/unique_objects.cpp
@@ -769,7 +769,8 @@
     return unique_objects::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance,
+                                                                                           const char *funcName) {
     return unique_objects::GetPhysicalDeviceProcAddr(instance, funcName);
 }
 
diff --git a/layers/vk_layer_config.cpp b/layers/vk_layer_config.cpp
index d8fe87d..49cbb9d 100644
--- a/layers/vk_layer_config.cpp
+++ b/layers/vk_layer_config.cpp
@@ -144,13 +144,20 @@
 
 #ifdef WIN32
     // For Windows, enable message logging AND OutputDebugString
-    m_valueMap["lunarg_core_validation.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
-    m_valueMap["lunarg_image.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
-    m_valueMap["lunarg_object_tracker.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
-    m_valueMap["lunarg_parameter_validation.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
-    m_valueMap["lunarg_swapchain.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
-    m_valueMap["google_threading.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
-    m_valueMap["google_unique_objects.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
+    m_valueMap["lunarg_core_validation.debug_action"] =
+        "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
+    m_valueMap["lunarg_image.debug_action"] =
+        "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
+    m_valueMap["lunarg_object_tracker.debug_action"] =
+        "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
+    m_valueMap["lunarg_parameter_validation.debug_action"] =
+        "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
+    m_valueMap["lunarg_swapchain.debug_action"] =
+        "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
+    m_valueMap["google_threading.debug_action"] =
+        "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
+    m_valueMap["google_unique_objects.debug_action"] =
+        "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT";
 #else  // WIN32
     m_valueMap["lunarg_core_validation.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG";
     m_valueMap["lunarg_image.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG";
@@ -227,7 +234,6 @@
         return;
     }
 
-
     // read tokens from the file and form option, value pairs
     file.getline(buf, MAX_CHARS_PER_LINE);
     while (!file.eof()) {
diff --git a/layers/vk_layer_config.h b/layers/vk_layer_config.h
index 2f68054..4e6d0e4 100644
--- a/layers/vk_layer_config.h
+++ b/layers/vk_layer_config.h
@@ -60,7 +60,7 @@
 const char *getLayerOption(const char *_option);
 FILE *getLayerLogOutput(const char *_option, const char *layerName);
 VkFlags GetLayerOptionFlags(std::string _option, std::unordered_map<std::string, VkFlags> const &enum_data,
-                                          uint32_t option_default);
+                            uint32_t option_default);
 
 void setLayerOption(const char *_option, const char *_val);
 void print_msg_flags(VkFlags msgFlags, char *msg_flags);
diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h
index f05d97d..542ee26 100644
--- a/layers/vk_layer_logging.h
+++ b/layers/vk_layer_logging.h
@@ -315,11 +315,11 @@
     *strp = nullptr;
     int size = _vscprintf(fmt, ap);
     if (size >= 0) {
-        *strp = (char *)malloc(size+1);
+        *strp = (char *)malloc(size + 1);
         if (!*strp) {
             return -1;
         }
-        _vsnprintf(*strp, size+1, fmt, ap);
+        _vsnprintf(*strp, size + 1, fmt, ap);
     }
     return size;
 }
diff --git a/layers/vk_layer_table.cpp b/layers/vk_layer_table.cpp
index bc9062e..fed66bf 100644
--- a/layers/vk_layer_table.cpp
+++ b/layers/vk_layer_table.cpp
@@ -40,10 +40,11 @@
     instance_table_map::const_iterator it = tableInstanceMap.find((void *)key);
 #if DISPATCH_MAP_DEBUG
     if (it != tableInstanceMap.end()) {
-        fprintf(stderr, "instance_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table:  0x%p\n", &tableInstanceMap, object, key,
-                it->second);
+        fprintf(stderr, "instance_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table:  0x%p\n", &tableInstanceMap, object,
+                key, it->second);
     } else {
-        fprintf(stderr, "instance_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table: UNKNOWN\n", &tableInstanceMap, object, key);
+        fprintf(stderr, "instance_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table: UNKNOWN\n", &tableInstanceMap,
+                object, key);
     }
 #endif
     assert(it != tableInstanceMap.end() && "Not able to find instance dispatch entry");
@@ -85,10 +86,11 @@
     device_table_map::const_iterator it = map.find((void *)key);
 #if DISPATCH_MAP_DEBUG
     if (it != map.end()) {
-        fprintf(stderr, "device_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table:  0x%p\n", &tableInstanceMap, object, key,
-                it->second);
+        fprintf(stderr, "device_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table:  0x%p\n", &tableInstanceMap, object,
+                key, it->second);
     } else {
-        fprintf(stderr, "device_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table: UNKNOWN\n", &tableInstanceMap, object, key);
+        fprintf(stderr, "device_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table: UNKNOWN\n", &tableInstanceMap, object,
+                key);
     }
 #endif
     assert(it != map.end() && "Not able to find device dispatch entry");
@@ -100,10 +102,11 @@
     instance_table_map::const_iterator it = map.find((void *)key);
 #if DISPATCH_MAP_DEBUG
     if (it != map.end()) {
-        fprintf(stderr, "instance_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table:  0x%p\n", &tableInstanceMap, object, key,
-                it->second);
+        fprintf(stderr, "instance_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table:  0x%p\n", &tableInstanceMap, object,
+                key, it->second);
     } else {
-        fprintf(stderr, "instance_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table: UNKNOWN\n", &tableInstanceMap, object, key);
+        fprintf(stderr, "instance_dispatch_table: map:  0x%p, object:  0x%p, key:  0x%p, table: UNKNOWN\n", &tableInstanceMap,
+                object, key);
     }
 #endif
     assert(it != map.end() && "Not able to find instance dispatch entry");
diff --git a/layers/vk_layer_utils.cpp b/layers/vk_layer_utils.cpp
index c82d204..00ea4cf 100644
--- a/layers/vk_layer_utils.cpp
+++ b/layers/vk_layer_utils.cpp
@@ -561,7 +561,7 @@
 
 // Return compressed block sizes for block compressed formats
 VK_LAYER_EXPORT VkExtent2D vk_format_compressed_block_size(VkFormat format) {
-    VkExtent2D block_size = { 1, 1 };
+    VkExtent2D block_size = {1, 1};
     switch (format) {
     case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
     case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
@@ -591,59 +591,59 @@
     case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
     case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
     case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
-        block_size = { 4, 4 };
+        block_size = {4, 4};
         break;
     case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
     case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
-        block_size = { 5, 4 };
+        block_size = {5, 4};
         break;
     case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
     case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
-        block_size = { 5, 5 };
+        block_size = {5, 5};
         break;
     case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
     case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
-        block_size = { 6, 5 };
+        block_size = {6, 5};
         break;
     case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
     case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
-        block_size = { 6, 6 };
+        block_size = {6, 6};
         break;
     case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
     case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
-        block_size = { 8, 5 };
+        block_size = {8, 5};
         break;
     case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
     case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
-        block_size = { 8, 6 };
+        block_size = {8, 6};
         break;
     case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
     case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
-        block_size = { 8, 8 };
+        block_size = {8, 8};
         break;
     case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
     case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
-        block_size = { 10, 5 };
+        block_size = {10, 5};
         break;
     case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
     case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
-        block_size = { 10, 6 };
+        block_size = {10, 6};
         break;
     case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
     case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
-        block_size = { 10, 8 };
+        block_size = {10, 8};
         break;
     case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
     case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
-        block_size = { 10, 10 };
+        block_size = {10, 10};
         break;
     case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
     case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
-        block_size = { 12, 10 };
+        block_size = {12, 10};
         break;
     case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
     case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
-        block_size = { 12, 12 };
+        block_size = {12, 12};
         break;
     default:
         break;
@@ -705,8 +705,8 @@
         if (utf8[i] == 0) {
             break;
         } else if (i == max_length) {
-          result = VK_STRING_ERROR_LENGTH;
-          break;
+            result = VK_STRING_ERROR_LENGTH;
+            break;
         } else if ((utf8[i] >= 0xa) && (utf8[i] < 0x7f)) {
             num_char_bytes = 0;
         } else if ((utf8[i] & UTF8_ONE_BYTE_MASK) == UTF8_ONE_BYTE_CODE) {
diff --git a/layers/vk_layer_utils.h b/layers/vk_layer_utils.h
index b4f6162..a70ae6b 100644
--- a/layers/vk_layer_utils.h
+++ b/layers/vk_layer_utils.h
@@ -26,7 +26,7 @@
 #ifndef WIN32
 #include <strings.h> // For ffs()
 #else
-#include <intrin.h>  // For __lzcnt()
+#include <intrin.h> // For __lzcnt()
 #endif
 
 #ifdef __cplusplus
diff --git a/loader/cJSON.c b/loader/cJSON.c
index e7266c3..9c800e1 100644
--- a/loader/cJSON.c
+++ b/loader/cJSON.c
@@ -88,9 +88,7 @@
     }
 }
 
-void cJSON_Free(void *p) {
-    cJSON_free(p);
-}
+void cJSON_Free(void *p) { cJSON_free(p); }
 
 /* Parse the input text to generate a number, and populate the result into item.
  */
@@ -123,10 +121,9 @@
             subscale = (subscale * 10) + (*num++ - '0'); /* Number? */
     }
 
-    n = sign * n *
-        pow(10.0, (scale + subscale * signsubscale)); /* number = +/-
-                                                         number.fraction *
-                                                         10^+/- exponent */
+    n = sign * n * pow(10.0, (scale + subscale * signsubscale)); /* number = +/-
+                                                                    number.fraction *
+                                                                    10^+/- exponent */
 
     item->valuedouble = n;
     item->valueint = (int)n;
@@ -193,13 +190,11 @@
             str = (char *)cJSON_malloc(2); /* special case for 0. */
         if (str)
             strcpy(str, "0");
-    } else if (fabs(((double)item->valueint) - d) <= DBL_EPSILON &&
-               d <= INT_MAX && d >= INT_MIN) {
+    } else if (fabs(((double)item->valueint) - d) <= DBL_EPSILON && d <= INT_MAX && d >= INT_MIN) {
         if (p)
             str = ensure(p, 21);
         else
-            str = (char *)cJSON_malloc(
-                21); /* 2^64+1 can be represented in 21 chars. */
+            str = (char *)cJSON_malloc(21); /* 2^64+1 can be represented in 21 chars. */
         if (str)
             sprintf(str, "%d", item->valueint);
     } else {
@@ -263,8 +258,7 @@
 }
 
 /* Parse the input text into an unescaped cstring, and populate item. */
-static const unsigned char firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0,
-                                               0xF0, 0xF8, 0xFC};
+static const unsigned char firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC};
 static const char *parse_string(cJSON *item, const char *str) {
     const char *ptr = str + 1;
     char *ptr2;
@@ -280,8 +274,7 @@
         if (*ptr++ == '\\')
             ptr++; /* Skip escaped quotes. */
 
-    out = (char *)cJSON_malloc(
-        len + 1); /* This is how long we need for the string, roughly. */
+    out = (char *)cJSON_malloc(len + 1); /* This is how long we need for the string, roughly. */
     if (!out)
         return 0;
 
@@ -315,8 +308,7 @@
                 if ((uc >= 0xDC00 && uc <= 0xDFFF) || uc == 0)
                     break; /* check for invalid.	*/
 
-                if (uc >= 0xD800 &&
-                    uc <= 0xDBFF) /* UTF16 surrogate pairs.	*/
+                if (uc >= 0xD800 && uc <= 0xDBFF) /* UTF16 surrogate pairs.	*/
                 {
                     if (ptr[1] != '\\' || ptr[2] != 'u')
                         break; /* missing second-half of surrogate.	*/
@@ -375,9 +367,7 @@
     unsigned char token;
 
     for (ptr = str; *ptr; ptr++)
-        flag |= ((*ptr > 0 && *ptr < 32) || (*ptr == '\"') || (*ptr == '\\'))
-                    ? 1
-                    : 0;
+        flag |= ((*ptr > 0 && *ptr < 32) || (*ptr == '\"') || (*ptr == '\\')) ? 1 : 0;
     if (!flag) {
         len = ptr - str;
         if (p)
@@ -461,9 +451,7 @@
     return out;
 }
 /* Invote print_string_ptr (which is useful) on an item. */
-static char *print_string(cJSON *item, printbuffer *p) {
-    return print_string_ptr(item->valuestring, p);
-}
+static char *print_string(cJSON *item, printbuffer *p) { return print_string_ptr(item->valuestring, p); }
 
 /* Predeclare these prototypes. */
 static const char *parse_value(cJSON *item, const char *value);
@@ -481,8 +469,7 @@
 }
 
 /* Parse an object - create a new root, and populate. */
-cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end,
-                           int require_null_terminated) {
+cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end, int require_null_terminated) {
     const char *end = 0;
     cJSON *c = cJSON_New_Item();
     ep = 0;
@@ -510,9 +497,7 @@
     return c;
 }
 /* Default options for cJSON_Parse */
-cJSON *cJSON_Parse(const char *value) {
-    return cJSON_ParseWithOpts(value, 0, 0);
-}
+cJSON *cJSON_Parse(const char *value) { return cJSON_ParseWithOpts(value, 0, 0); }
 
 /* Render a cJSON item/entity/structure to text. */
 char *cJSON_Print(cJSON *item) { return print_value(item, 0, 1, 0); }
@@ -641,9 +626,8 @@
 
     item->child = child = cJSON_New_Item();
     if (!item->child)
-        return 0; /* memory fail */
-    value = skip(
-        parse_value(child, skip(value))); /* skip any spacing, get the value. */
+        return 0;                                  /* memory fail */
+    value = skip(parse_value(child, skip(value))); /* skip any spacing, get the value. */
     if (!value)
         return 0;
 
@@ -800,9 +784,8 @@
     if (*value != ':') {
         ep = value;
         return 0;
-    } /* fail! */
-    value = skip(parse_value(
-        child, skip(value + 1))); /* skip any spacing, get the value. */
+    }                                                  /* fail! */
+    value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */
     if (!value)
         return 0;
 
@@ -821,9 +804,8 @@
         if (*value != ':') {
             ep = value;
             return 0;
-        } /* fail! */
-        value = skip(parse_value(
-            child, skip(value + 1))); /* skip any spacing, get the value. */
+        }                                                  /* fail! */
+        value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */
         if (!value)
             return 0;
     }
@@ -1076,11 +1058,8 @@
     item->type |= cJSON_StringIsConst;
     cJSON_AddItemToArray(object, item);
 }
-void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) {
-    cJSON_AddItemToArray(array, create_reference(item));
-}
-void cJSON_AddItemReferenceToObject(cJSON *object, const char *string,
-                                    cJSON *item) {
+void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) { cJSON_AddItemToArray(array, create_reference(item)); }
+void cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) {
     cJSON_AddItemToObject(object, string, create_reference(item));
 }
 
@@ -1099,9 +1078,7 @@
     c->prev = c->next = 0;
     return c;
 }
-void cJSON_DeleteItemFromArray(cJSON *array, int which) {
-    cJSON_Delete(cJSON_DetachItemFromArray(array, which));
-}
+void cJSON_DeleteItemFromArray(cJSON *array, int which) { cJSON_Delete(cJSON_DetachItemFromArray(array, which)); }
 cJSON *cJSON_DetachItemFromObject(cJSON *object, const char *string) {
     int i = 0;
     cJSON *c = object->child;
@@ -1111,9 +1088,7 @@
         return cJSON_DetachItemFromArray(object, i);
     return 0;
 }
-void cJSON_DeleteItemFromObject(cJSON *object, const char *string) {
-    cJSON_Delete(cJSON_DetachItemFromObject(object, string));
-}
+void cJSON_DeleteItemFromObject(cJSON *object, const char *string) { cJSON_Delete(cJSON_DetachItemFromObject(object, string)); }
 
 /* Replace array/object items with new ones. */
 void cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) {
@@ -1149,8 +1124,7 @@
     c->next = c->prev = 0;
     cJSON_Delete(c);
 }
-void cJSON_ReplaceItemInObject(cJSON *object, const char *string,
-                               cJSON *newitem) {
+void cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) {
     int i = 0;
     cJSON *c = object->child;
     while (c && strcmp(c->string, string))
@@ -1281,9 +1255,7 @@
     if (!newitem)
         return 0;
     /* Copy over all vars */
-    newitem->type = item->type & (~cJSON_IsReference),
-    newitem->valueint = item->valueint,
-    newitem->valuedouble = item->valuedouble;
+    newitem->type = item->type & (~cJSON_IsReference), newitem->valueint = item->valueint, newitem->valuedouble = item->valuedouble;
     if (item->valuestring) {
         newitem->valuestring = cJSON_strdup(item->valuestring);
         if (!newitem->valuestring) {
@@ -1304,9 +1276,7 @@
     /* Walk the ->next chain for the child. */
     cptr = item->child;
     while (cptr) {
-        newchild = cJSON_Duplicate(
-            cptr,
-            1); /* Duplicate (with recurse) each item in the ->next chain */
+        newchild = cJSON_Duplicate(cptr, 1); /* Duplicate (with recurse) each item in the ->next chain */
         if (!newchild) {
             cJSON_Delete(newitem);
             return 0;
diff --git a/loader/cJSON.h b/loader/cJSON.h
index cab3051..f0059ab 100644
--- a/loader/cJSON.h
+++ b/loader/cJSON.h
@@ -47,9 +47,9 @@
     struct cJSON *next, *prev; /* next/prev allow you to walk array/object
                                   chains. Alternatively, use
                                   GetArraySize/GetArrayItem/GetObjectItem */
-    struct cJSON *child; /* An array or object item will have a child pointer
-                            pointing to a chain of the items in the
-                            array/object. */
+    struct cJSON *child;       /* An array or object item will have a child pointer
+                                  pointing to a chain of the items in the
+                                  array/object. */
 
     int type; /* The type of the item, as above. */
 
@@ -118,19 +118,16 @@
 
 /* Append item to the specified array/object. */
 extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);
-extern void cJSON_AddItemToObject(cJSON *object, const char *string,
-                                  cJSON *item);
-extern void cJSON_AddItemToObjectCS(
-    cJSON *object, const char *string,
-    cJSON *item); /* Use this when string is definitely const (i.e. a literal,
-                     or as good as), and will definitely survive the cJSON
-                     object */
+extern void cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+extern void cJSON_AddItemToObjectCS(cJSON *object, const char *string,
+                                    cJSON *item); /* Use this when string is definitely const (i.e. a literal,
+                                                     or as good as), and will definitely survive the cJSON
+                                                     object */
 /* Append reference to item to the specified array/object. Use this when you
  * want to add an existing cJSON to a new cJSON, but don't want to corrupt your
  * existing cJSON. */
 extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
-extern void cJSON_AddItemReferenceToObject(cJSON *object, const char *string,
-                                           cJSON *item);
+extern void cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
 
 /* Remove/Detatch items from Arrays/Objects. */
 extern cJSON *cJSON_DetachItemFromArray(cJSON *array, int which);
@@ -139,12 +136,9 @@
 extern void cJSON_DeleteItemFromObject(cJSON *object, const char *string);
 
 /* Update array items. */
-extern void cJSON_InsertItemInArray(
-    cJSON *array, int which,
-    cJSON *newitem); /* Shifts pre-existing items to the right. */
+extern void cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
 extern void cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
-extern void cJSON_ReplaceItemInObject(cJSON *object, const char *string,
-                                      cJSON *newitem);
+extern void cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem);
 
 /* Duplicate a cJSON item */
 extern cJSON *cJSON_Duplicate(cJSON *item, int recurse);
@@ -156,32 +150,22 @@
 
 /* ParseWithOpts allows you to require (and check) that the JSON is null
  * terminated, and to retrieve the pointer to the final byte parsed. */
-extern cJSON *cJSON_ParseWithOpts(const char *value,
-                                  const char **return_parse_end,
-                                  int require_null_terminated);
+extern cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end, int require_null_terminated);
 
 extern void cJSON_Minify(char *json);
 
 /* Macros for creating things quickly. */
-#define cJSON_AddNullToObject(object, name)                                    \
-    cJSON_AddItemToObject(object, name, cJSON_CreateNull())
-#define cJSON_AddTrueToObject(object, name)                                    \
-    cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
-#define cJSON_AddFalseToObject(object, name)                                   \
-    cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
-#define cJSON_AddBoolToObject(object, name, b)                                 \
-    cJSON_AddItemToObject(object, name, cJSON_CreateBool(b))
-#define cJSON_AddNumberToObject(object, name, n)                               \
-    cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
-#define cJSON_AddStringToObject(object, name, s)                               \
-    cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
+#define cJSON_AddNullToObject(object, name) cJSON_AddItemToObject(object, name, cJSON_CreateNull())
+#define cJSON_AddTrueToObject(object, name) cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
+#define cJSON_AddFalseToObject(object, name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
+#define cJSON_AddBoolToObject(object, name, b) cJSON_AddItemToObject(object, name, cJSON_CreateBool(b))
+#define cJSON_AddNumberToObject(object, name, n) cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
+#define cJSON_AddStringToObject(object, name, s) cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
 
 /* When assigning an integer value, it needs to be propagated to valuedouble
  * too. */
-#define cJSON_SetIntValue(object, val)                                         \
-    ((object) ? (object)->valueint = (object)->valuedouble = (val) : (val))
-#define cJSON_SetNumberValue(object, val)                                      \
-    ((object) ? (object)->valueint = (object)->valuedouble = (val) : (val))
+#define cJSON_SetIntValue(object, val) ((object) ? (object)->valueint = (object)->valuedouble = (val) : (val))
+#define cJSON_SetNumberValue(object, val) ((object) ? (object)->valueint = (object)->valuedouble = (val) : (val))
 
 #ifdef __cplusplus
 }
diff --git a/loader/debug_report.c b/loader/debug_report.c
index bf9ff41..84b8549 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -37,50 +37,38 @@
 typedef void(VKAPI_PTR *PFN_stringCallback)(char *message);
 
 static const VkExtensionProperties debug_report_extension_info = {
-    .extensionName = VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
-    .specVersion = VK_EXT_DEBUG_REPORT_SPEC_VERSION,
+    .extensionName = VK_EXT_DEBUG_REPORT_EXTENSION_NAME, .specVersion = VK_EXT_DEBUG_REPORT_SPEC_VERSION,
 };
 
-void debug_report_add_instance_extensions(
-    const struct loader_instance *inst,
-    struct loader_extension_list *ext_list) {
+void debug_report_add_instance_extensions(const struct loader_instance *inst, struct loader_extension_list *ext_list) {
     loader_add_to_ext_list(inst, ext_list, 1, &debug_report_extension_info);
 }
 
-void debug_report_create_instance(struct loader_instance *ptr_instance,
-                                  const VkInstanceCreateInfo *pCreateInfo) {
+void debug_report_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) {
     ptr_instance->enabled_known_extensions.ext_debug_report = 0;
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) {
             ptr_instance->enabled_known_extensions.ext_debug_report = 1;
             return;
         }
     }
 }
 
-VkResult
-util_CreateDebugReportCallback(struct loader_instance *inst,
-                               VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                               const VkAllocationCallbacks *pAllocator,
-                               VkDebugReportCallbackEXT callback) {
+VkResult util_CreateDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                        const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT callback) {
     VkLayerDbgFunctionNode *pNewDbgFuncNode = NULL;
 
 #if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
     {
 #else
     if (pAllocator != NULL) {
-        pNewDbgFuncNode =
-            (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(
-                pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode),
-                sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+        pNewDbgFuncNode = (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode),
+                                                                              sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     } else {
 #endif
-        pNewDbgFuncNode =
-            (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(
-                inst, sizeof(VkLayerDbgFunctionNode),
-                VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+        pNewDbgFuncNode = (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(inst, sizeof(VkLayerDbgFunctionNode),
+                                                                               VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     }
     if (!pNewDbgFuncNode) {
         return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -97,32 +85,24 @@
     return VK_SUCCESS;
 }
 
-static VKAPI_ATTR VkResult VKAPI_CALL debug_report_CreateDebugReportCallbackEXT(
-    VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator,
-    VkDebugReportCallbackEXT *pCallback) {
+static VKAPI_ATTR VkResult VKAPI_CALL
+debug_report_CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                          const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) {
     struct loader_instance *inst = loader_get_instance(instance);
     loader_platform_thread_lock_mutex(&loader_lock);
-    VkResult result = inst->disp->layer_inst_disp.CreateDebugReportCallbackEXT(
-        instance, pCreateInfo, pAllocator, pCallback);
+    VkResult result = inst->disp->layer_inst_disp.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
     loader_platform_thread_unlock_mutex(&loader_lock);
     return result;
 }
 
 // Utility function to handle reporting
-VkBool32 util_DebugReportMessage(const struct loader_instance *inst,
-                                 VkFlags msgFlags,
-                                 VkDebugReportObjectTypeEXT objectType,
-                                 uint64_t srcObject, size_t location,
-                                 int32_t msgCode, const char *pLayerPrefix,
-                                 const char *pMsg) {
+VkBool32 util_DebugReportMessage(const struct loader_instance *inst, VkFlags msgFlags, VkDebugReportObjectTypeEXT objectType,
+                                 uint64_t srcObject, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
     VkBool32 bail = false;
     VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead;
     while (pTrav) {
         if (pTrav->msgFlags & msgFlags) {
-            if (pTrav->pfnMsgCallback(msgFlags, objectType, srcObject, location,
-                                      msgCode, pLayerPrefix, pMsg,
-                                      pTrav->pUserData)) {
+            if (pTrav->pfnMsgCallback(msgFlags, objectType, srcObject, location, msgCode, pLayerPrefix, pMsg, pTrav->pUserData)) {
                 bail = true;
             }
         }
@@ -132,8 +112,7 @@
     return bail;
 }
 
-void util_DestroyDebugReportCallback(struct loader_instance *inst,
-                                     VkDebugReportCallbackEXT callback,
+void util_DestroyDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackEXT callback,
                                      const VkAllocationCallbacks *pAllocator) {
     VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead;
     VkLayerDbgFunctionNode *pPrev = pTrav;
@@ -164,10 +143,8 @@
 // then allocates array that can hold that many structs, as well as that many
 // VkDebugReportCallbackEXT handles.  It then copies each
 // VkDebugReportCallbackCreateInfoEXT, and initializes each handle.
-VkResult util_CopyDebugReportCreateInfos(
-    const void *pChain, const VkAllocationCallbacks *pAllocator,
-    uint32_t *num_callbacks, VkDebugReportCallbackCreateInfoEXT **infos,
-    VkDebugReportCallbackEXT **callbacks) {
+VkResult util_CopyDebugReportCreateInfos(const void *pChain, const VkAllocationCallbacks *pAllocator, uint32_t *num_callbacks,
+                                         VkDebugReportCallbackCreateInfoEXT **infos, VkDebugReportCallbackEXT **callbacks) {
     uint32_t n = *num_callbacks = 0;
     VkDebugReportCallbackCreateInfoEXT *pInfos = NULL;
     VkDebugReportCallbackEXT *pCallbacks = NULL;
@@ -178,8 +155,7 @@
     const void *pNext = pChain;
     while (pNext) {
         // 1st, count the number VkDebugReportCallbackCreateInfoEXT:
-        if (((VkDebugReportCallbackCreateInfoEXT *)pNext)->sType ==
-            VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) {
+        if (((VkDebugReportCallbackCreateInfoEXT *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) {
             n++;
         }
         pNext = (void *)((VkDebugReportCallbackCreateInfoEXT *)pNext)->pNext;
@@ -193,15 +169,12 @@
     {
 #else
     if (pAllocator != NULL) {
-        pInfos = *infos =
-            ((VkDebugReportCallbackCreateInfoEXT *)pAllocator->pfnAllocation(
-                pAllocator->pUserData,
-                n * sizeof(VkDebugReportCallbackCreateInfoEXT), sizeof(void *),
-                VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
+        pInfos = *infos = ((VkDebugReportCallbackCreateInfoEXT *)pAllocator->pfnAllocation(
+            pAllocator->pUserData, n * sizeof(VkDebugReportCallbackCreateInfoEXT), sizeof(void *),
+            VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
     } else {
 #endif
-        pInfos = *infos = ((VkDebugReportCallbackCreateInfoEXT *)malloc(
-            n * sizeof(VkDebugReportCallbackCreateInfoEXT)));
+        pInfos = *infos = ((VkDebugReportCallbackCreateInfoEXT *)malloc(n * sizeof(VkDebugReportCallbackCreateInfoEXT)));
     }
     if (!pInfos) {
         return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -211,18 +184,15 @@
     {
 #else
     if (pAllocator != NULL) {
-        pCallbacks = *callbacks =
-            ((VkDebugReportCallbackEXT *)pAllocator->pfnAllocation(
-                pAllocator->pUserData, n * sizeof(VkDebugReportCallbackEXT),
-                sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
+        pCallbacks = *callbacks = ((VkDebugReportCallbackEXT *)pAllocator->pfnAllocation(
+            pAllocator->pUserData, n * sizeof(VkDebugReportCallbackEXT), sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
         if (!pCallbacks) {
             pAllocator->pfnFree(pAllocator->pUserData, pInfos);
             return VK_ERROR_OUT_OF_HOST_MEMORY;
         }
     } else {
 #endif
-        pCallbacks = *callbacks = ((VkDebugReportCallbackEXT *)malloc(
-            n * sizeof(VkDebugReportCallbackEXT)));
+        pCallbacks = *callbacks = ((VkDebugReportCallbackEXT *)malloc(n * sizeof(VkDebugReportCallbackEXT)));
         if (!pCallbacks) {
             free(pInfos);
             return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -233,8 +203,7 @@
     // use the address of the copied VkDebugReportCallbackCreateInfoEXT):
     pNext = pChain;
     while (pNext) {
-        if (((VkInstanceCreateInfo *)pNext)->sType ==
-            VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) {
+        if (((VkInstanceCreateInfo *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) {
             memcpy(pInfos, pNext, sizeof(VkDebugReportCallbackCreateInfoEXT));
             *pCallbacks++ = (VkDebugReportCallbackEXT)(uintptr_t)pInfos++;
         }
@@ -245,15 +214,14 @@
     return VK_SUCCESS;
 }
 
-void util_FreeDebugReportCreateInfos(const VkAllocationCallbacks *pAllocator,
-                                     VkDebugReportCallbackCreateInfoEXT *infos,
+void util_FreeDebugReportCreateInfos(const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackCreateInfoEXT *infos,
                                      VkDebugReportCallbackEXT *callbacks) {
 #if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-                                         {
+    {
 #else
     if (pAllocator != NULL) {
-         pAllocator->pfnFree(pAllocator->pUserData, infos);
-         pAllocator->pfnFree(pAllocator->pUserData, callbacks);
+        pAllocator->pfnFree(pAllocator->pUserData, infos);
+        pAllocator->pfnFree(pAllocator->pUserData, callbacks);
     } else {
 #endif
         free(infos);
@@ -261,14 +229,12 @@
     }
 }
 
-VkResult util_CreateDebugReportCallbacks(
-    struct loader_instance *inst, const VkAllocationCallbacks *pAllocator,
-    uint32_t num_callbacks, VkDebugReportCallbackCreateInfoEXT *infos,
-    VkDebugReportCallbackEXT *callbacks) {
+VkResult util_CreateDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator,
+                                         uint32_t num_callbacks, VkDebugReportCallbackCreateInfoEXT *infos,
+                                         VkDebugReportCallbackEXT *callbacks) {
     VkResult rtn = VK_SUCCESS;
     for (uint32_t i = 0; i < num_callbacks; i++) {
-        rtn = util_CreateDebugReportCallback(inst, &infos[i], pAllocator,
-                                             callbacks[i]);
+        rtn = util_CreateDebugReportCallback(inst, &infos[i], pAllocator, callbacks[i]);
         if (rtn != VK_SUCCESS) {
             for (uint32_t j = 0; j < i; j++) {
                 util_DestroyDebugReportCallback(inst, callbacks[j], pAllocator);
@@ -279,39 +245,32 @@
     return rtn;
 }
 
-void util_DestroyDebugReportCallbacks(struct loader_instance *inst,
-                                      const VkAllocationCallbacks *pAllocator,
-                                      uint32_t num_callbacks,
+void util_DestroyDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, uint32_t num_callbacks,
                                       VkDebugReportCallbackEXT *callbacks) {
     for (uint32_t i = 0; i < num_callbacks; i++) {
         util_DestroyDebugReportCallback(inst, callbacks[i], pAllocator);
     }
 }
 
-static VKAPI_ATTR void VKAPI_CALL
-debug_report_DestroyDebugReportCallbackEXT(
-    VkInstance instance, VkDebugReportCallbackEXT callback,
-    const VkAllocationCallbacks *pAllocator) {
+static VKAPI_ATTR void VKAPI_CALL debug_report_DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
+                                                                             const VkAllocationCallbacks *pAllocator) {
     struct loader_instance *inst = loader_get_instance(instance);
     loader_platform_thread_lock_mutex(&loader_lock);
 
-    inst->disp->layer_inst_disp.DestroyDebugReportCallbackEXT(
-        instance, callback, pAllocator);
+    inst->disp->layer_inst_disp.DestroyDebugReportCallbackEXT(instance, callback, pAllocator);
 
     util_DestroyDebugReportCallback(inst, callback, pAllocator);
 
     loader_platform_thread_unlock_mutex(&loader_lock);
 }
 
-static VKAPI_ATTR void VKAPI_CALL debug_report_DebugReportMessageEXT(
-    VkInstance instance, VkDebugReportFlagsEXT flags,
-    VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
-    int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
+static VKAPI_ATTR void VKAPI_CALL debug_report_DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+                                                                     VkDebugReportObjectTypeEXT objType, uint64_t object,
+                                                                     size_t location, int32_t msgCode, const char *pLayerPrefix,
+                                                                     const char *pMsg) {
     struct loader_instance *inst = loader_get_instance(instance);
 
-    inst->disp->layer_inst_disp.DebugReportMessageEXT(
-        instance, flags, objType, object, location, msgCode, pLayerPrefix,
-        pMsg);
+    inst->disp->layer_inst_disp.DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
 }
 
 /*
@@ -319,10 +278,10 @@
  * for CreateDebugReportCallback
  */
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugReportCallback(
-    VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator,
-    VkDebugReportCallbackEXT *pCallback) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugReportCallback(VkInstance instance,
+                                                                    const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                                                    const VkAllocationCallbacks *pAllocator,
+                                                                    VkDebugReportCallbackEXT *pCallback) {
     VkDebugReportCallbackEXT *icd_info = NULL;
     const struct loader_icd_term *icd_term;
     struct loader_instance *inst = (struct loader_instance *)instance;
@@ -334,18 +293,15 @@
     {
 #else
     if (pAllocator != NULL) {
-        icd_info = ((VkDebugReportCallbackEXT *)pAllocator->pfnAllocation(
-            pAllocator->pUserData,
-            inst->total_icd_count * sizeof(VkDebugReportCallbackEXT),
-            sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
+        icd_info = ((VkDebugReportCallbackEXT *)pAllocator->pfnAllocation(pAllocator->pUserData,
+                                                                          inst->total_icd_count * sizeof(VkDebugReportCallbackEXT),
+                                                                          sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
         if (icd_info) {
-            memset(icd_info, 0,
-                   inst->total_icd_count * sizeof(VkDebugReportCallbackEXT));
+            memset(icd_info, 0, inst->total_icd_count * sizeof(VkDebugReportCallbackEXT));
         }
     } else {
 #endif
-        icd_info =
-            calloc(sizeof(VkDebugReportCallbackEXT), inst->total_icd_count);
+        icd_info = calloc(sizeof(VkDebugReportCallbackEXT), inst->total_icd_count);
     }
     if (!icd_info) {
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -358,9 +314,7 @@
             continue;
         }
 
-        res = icd_term->CreateDebugReportCallbackEXT(icd_term->instance,
-                                                     pCreateInfo, pAllocator,
-                                                     &icd_info[storage_idx]);
+        res = icd_term->CreateDebugReportCallbackEXT(icd_term->instance, pCreateInfo, pAllocator, &icd_info[storage_idx]);
 
         if (res != VK_SUCCESS) {
             goto out;
@@ -368,23 +322,19 @@
         storage_idx++;
     }
 
-    // Setup the debug report callback in the terminator since a layer may want
-    // to grab the information itself (RenderDoc) and then return back to the
-    // user callback a sub-set of the messages.
+// Setup the debug report callback in the terminator since a layer may want
+// to grab the information itself (RenderDoc) and then return back to the
+// user callback a sub-set of the messages.
 #if (DEBUG_DISABLE_APP_ALLOCATORS == 0)
     if (pAllocator != NULL) {
-        pNewDbgFuncNode =
-            (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(
-                pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode),
-                sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+        pNewDbgFuncNode = (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode),
+                                                                              sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     } else {
 #else
     {
 #endif
-        pNewDbgFuncNode =
-            (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(
-                inst, sizeof(VkLayerDbgFunctionNode),
-                VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+        pNewDbgFuncNode = (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(inst, sizeof(VkLayerDbgFunctionNode),
+                                                                               VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     }
     if (!pNewDbgFuncNode) {
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -412,8 +362,7 @@
             }
 
             if (icd_info && icd_info[storage_idx]) {
-                icd_term->DestroyDebugReportCallbackEXT(
-                    icd_term->instance, icd_info[storage_idx], pAllocator);
+                icd_term->DestroyDebugReportCallbackEXT(icd_term->instance, icd_info[storage_idx], pAllocator);
             }
             storage_idx++;
         }
@@ -446,9 +395,8 @@
  * This is the instance chain terminator function
  * for DestroyDebugReportCallback
  */
-VKAPI_ATTR void VKAPI_CALL terminator_DestroyDebugReportCallback(
-    VkInstance instance, VkDebugReportCallbackEXT callback,
-    const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL terminator_DestroyDebugReportCallback(VkInstance instance, VkDebugReportCallbackEXT callback,
+                                                                 const VkAllocationCallbacks *pAllocator) {
     uint32_t storage_idx;
     VkDebugReportCallbackEXT *icd_info;
     const struct loader_icd_term *icd_term;
@@ -462,8 +410,7 @@
         }
 
         if (icd_info[storage_idx]) {
-            icd_term->DestroyDebugReportCallbackEXT(
-                icd_term->instance, icd_info[storage_idx], pAllocator);
+            icd_term->DestroyDebugReportCallbackEXT(icd_term->instance, icd_info[storage_idx], pAllocator);
         }
         storage_idx++;
     }
@@ -483,10 +430,9 @@
  * This is the instance chain terminator function
  * for DebugReportMessage
  */
-VKAPI_ATTR void VKAPI_CALL terminator_DebugReportMessage(
-    VkInstance instance, VkDebugReportFlagsEXT flags,
-    VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
-    int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
+VKAPI_ATTR void VKAPI_CALL terminator_DebugReportMessage(VkInstance instance, VkDebugReportFlagsEXT flags,
+                                                         VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
+                                                         int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
     const struct loader_icd_term *icd_term;
 
     struct loader_instance *inst = (struct loader_instance *)instance;
@@ -494,9 +440,7 @@
     loader_platform_thread_lock_mutex(&loader_lock);
     for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
         if (icd_term->DebugReportMessageEXT != NULL) {
-            icd_term->DebugReportMessageEXT(icd_term->instance, flags, objType,
-                                            object, location, msgCode,
-                                            pLayerPrefix, pMsg);
+            icd_term->DebugReportMessageEXT(icd_term->instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
         }
     }
 
@@ -506,34 +450,28 @@
      * point.
      */
 
-    util_DebugReportMessage(inst, flags, objType, object, location, msgCode,
-                            pLayerPrefix, pMsg);
+    util_DebugReportMessage(inst, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
 
     loader_platform_thread_unlock_mutex(&loader_lock);
 }
 
-bool debug_report_instance_gpa(struct loader_instance *ptr_instance,
-                               const char *name, void **addr) {
+bool debug_report_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) {
     // debug_report is currently advertised to be supported by the loader,
     // so always return the entry points if name matches and it's enabled
     *addr = NULL;
 
     if (!strcmp("vkCreateDebugReportCallbackEXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.ext_debug_report == 1)
-                    ? (void *)debug_report_CreateDebugReportCallbackEXT
-                    : NULL;
+        *addr = (ptr_instance->enabled_known_extensions.ext_debug_report == 1) ? (void *)debug_report_CreateDebugReportCallbackEXT
+                                                                               : NULL;
         return true;
     }
     if (!strcmp("vkDestroyDebugReportCallbackEXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.ext_debug_report == 1)
-                    ? (void *)debug_report_DestroyDebugReportCallbackEXT
-                    : NULL;
+        *addr = (ptr_instance->enabled_known_extensions.ext_debug_report == 1) ? (void *)debug_report_DestroyDebugReportCallbackEXT
+                                                                               : NULL;
         return true;
     }
     if (!strcmp("vkDebugReportMessageEXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.ext_debug_report == 1)
-                    ? (void *)debug_report_DebugReportMessageEXT
-                    : NULL;
+        *addr = (ptr_instance->enabled_known_extensions.ext_debug_report == 1) ? (void *)debug_report_DebugReportMessageEXT : NULL;
         return true;
     }
     return false;
diff --git a/loader/debug_report.h b/loader/debug_report.h
index 7a659d0..425811f 100644
--- a/loader/debug_report.h
+++ b/loader/debug_report.h
@@ -100,61 +100,40 @@
  * Any reports generated after this will only have MsgCallbackObject2 available.
  */
 
-void debug_report_add_instance_extensions(
-    const struct loader_instance *inst, struct loader_extension_list *ext_list);
+void debug_report_add_instance_extensions(const struct loader_instance *inst, struct loader_extension_list *ext_list);
 
-void debug_report_create_instance(struct loader_instance *ptr_instance,
-                                  const VkInstanceCreateInfo *pCreateInfo);
+void debug_report_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo);
 
-bool debug_report_instance_gpa(struct loader_instance *ptr_instance,
-                               const char *name, void **addr);
+bool debug_report_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr);
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugReportCallback(
-    VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator,
-    VkDebugReportCallbackEXT *pCallback);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugReportCallback(VkInstance instance,
+                                                                    const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                                                    const VkAllocationCallbacks *pAllocator,
+                                                                    VkDebugReportCallbackEXT *pCallback);
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_DestroyDebugReportCallback(VkInstance instance,
-                                      VkDebugReportCallbackEXT callback,
-                                      const VkAllocationCallbacks *pAllocator);
+VKAPI_ATTR void VKAPI_CALL terminator_DestroyDebugReportCallback(VkInstance instance, VkDebugReportCallbackEXT callback,
+                                                                 const VkAllocationCallbacks *pAllocator);
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_DebugReportMessage(VkInstance instance, VkDebugReportFlagsEXT flags,
-                              VkDebugReportObjectTypeEXT objType,
-                              uint64_t object, size_t location, int32_t msgCode,
-                              const char *pLayerPrefix, const char *pMsg);
+VKAPI_ATTR void VKAPI_CALL terminator_DebugReportMessage(VkInstance instance, VkDebugReportFlagsEXT flags,
+                                                         VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
+                                                         int32_t msgCode, const char *pLayerPrefix, const char *pMsg);
 
-VkResult
-util_CreateDebugReportCallback(struct loader_instance *inst,
-                               VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                               const VkAllocationCallbacks *pAllocator,
-                               VkDebugReportCallbackEXT callback);
+VkResult util_CreateDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+                                        const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT callback);
 
-void util_DestroyDebugReportCallback(struct loader_instance *inst,
-                                     VkDebugReportCallbackEXT callback,
+void util_DestroyDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackEXT callback,
                                      const VkAllocationCallbacks *pAllocator);
 
-VkResult util_CopyDebugReportCreateInfos(
-    const void *pChain, const VkAllocationCallbacks *pAllocator,
-    uint32_t *num_callbacks, VkDebugReportCallbackCreateInfoEXT **infos,
-    VkDebugReportCallbackEXT **callbacks);
-void util_FreeDebugReportCreateInfos(const VkAllocationCallbacks *pAllocator,
-                                     VkDebugReportCallbackCreateInfoEXT *infos,
+VkResult util_CopyDebugReportCreateInfos(const void *pChain, const VkAllocationCallbacks *pAllocator, uint32_t *num_callbacks,
+                                         VkDebugReportCallbackCreateInfoEXT **infos, VkDebugReportCallbackEXT **callbacks);
+void util_FreeDebugReportCreateInfos(const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackCreateInfoEXT *infos,
                                      VkDebugReportCallbackEXT *callbacks);
-VkResult util_CreateDebugReportCallbacks(
-    struct loader_instance *inst, const VkAllocationCallbacks *pAllocator,
-    uint32_t num_callbacks, VkDebugReportCallbackCreateInfoEXT *infos,
-    VkDebugReportCallbackEXT *callbacks);
+VkResult util_CreateDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator,
+                                         uint32_t num_callbacks, VkDebugReportCallbackCreateInfoEXT *infos,
+                                         VkDebugReportCallbackEXT *callbacks);
 
-void util_DestroyDebugReportCallbacks(struct loader_instance *inst,
-                                      const VkAllocationCallbacks *pAllocator,
-                                      uint32_t num_callbacks,
+void util_DestroyDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, uint32_t num_callbacks,
                                       VkDebugReportCallbackEXT *callbacks);
 
-VkBool32 util_DebugReportMessage(const struct loader_instance *inst,
-                                 VkFlags msgFlags,
-                                 VkDebugReportObjectTypeEXT objectType,
-                                 uint64_t srcObject, size_t location,
-                                 int32_t msgCode, const char *pLayerPrefix,
-                                 const char *pMsg);
+VkBool32 util_DebugReportMessage(const struct loader_instance *inst, VkFlags msgFlags, VkDebugReportObjectTypeEXT objectType,
+                                 uint64_t srcObject, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg);
diff --git a/loader/dirent_on_windows.c b/loader/dirent_on_windows.c
index 6f78cf9..16318cc 100644
--- a/loader/dirent_on_windows.c
+++ b/loader/dirent_on_windows.c
@@ -37,12 +37,10 @@
             strchr("/\\", name[base_length - 1]) ? "*" : "/*";
 
         if ((dir = (DIR *)loader_instance_tls_heap_alloc(sizeof *dir)) != 0 &&
-            (dir->name = (char *)loader_instance_tls_heap_alloc(
-                 base_length + strlen(all) + 1)) != 0) {
+            (dir->name = (char *)loader_instance_tls_heap_alloc(base_length + strlen(all) + 1)) != 0) {
             strcat(strcpy(dir->name, name), all);
 
-            if ((dir->handle =
-                     (handle_type)_findfirst(dir->name, &dir->info)) != -1) {
+            if ((dir->handle = (handle_type)_findfirst(dir->name, &dir->info)) != -1) {
                 dir->result.d_name = 0;
             } else /* rollback */
             {
diff --git a/loader/extensions.c b/loader/extensions.c
index 221924a..0b5c000 100644
--- a/loader/extensions.c
+++ b/loader/extensions.c
@@ -31,19 +31,17 @@
 
 // Definitions for the VK_KHR_get_physical_device_properties2 extension
 
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
-    VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures) {
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+                                                           VkPhysicalDeviceFeatures2KHR *pFeatures) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
     disp->GetPhysicalDeviceFeatures2KHR(unwrapped_phys_dev, pFeatures);
 }
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2KHR(
-    VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+                                                                    VkPhysicalDeviceFeatures2KHR *pFeatures) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->GetPhysicalDeviceFeatures2KHR) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
@@ -53,173 +51,134 @@
     icd_term->GetPhysicalDeviceFeatures2KHR(phys_dev_term->phys_dev, pFeatures);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
-                                  VkPhysicalDeviceProperties2KHR *pProperties) {
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                             VkPhysicalDeviceProperties2KHR *pProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
     disp->GetPhysicalDeviceProperties2KHR(unwrapped_phys_dev, pProperties);
 }
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceProperties2KHR *pProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                      VkPhysicalDeviceProperties2KHR *pProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->GetPhysicalDeviceProperties2KHR) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "ICD associated with VkPhysicalDevice does not support "
                    "vkGetPhysicalDeviceProperties2KHR");
     }
-    icd_term->GetPhysicalDeviceProperties2KHR(phys_dev_term->phys_dev,
-                                              pProperties);
+    icd_term->GetPhysicalDeviceProperties2KHR(phys_dev_term->phys_dev, pProperties);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, VkFormat format,
-    VkFormatProperties2KHR *pFormatProperties) {
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                   VkFormatProperties2KHR *pFormatProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceFormatProperties2KHR(unwrapped_phys_dev, format,
-                                                pFormatProperties);
+    disp->GetPhysicalDeviceFormatProperties2KHR(unwrapped_phys_dev, format, pFormatProperties);
 }
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, VkFormat format,
-    VkFormatProperties2KHR *pFormatProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                            VkFormatProperties2KHR *pFormatProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->GetPhysicalDeviceFormatProperties2KHR) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "ICD associated with VkPhysicalDevice does not support "
                    "vkGetPhysicalDeviceFormatProperties2KHR");
     }
-    icd_term->GetPhysicalDeviceFormatProperties2KHR(phys_dev_term->phys_dev,
-                                                    format, pFormatProperties);
+    icd_term->GetPhysicalDeviceFormatProperties2KHR(phys_dev_term->phys_dev, format, pFormatProperties);
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
     VkImageFormatProperties2KHR *pImageFormatProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetPhysicalDeviceImageFormatProperties2KHR(
-        unwrapped_phys_dev, pImageFormatInfo, pImageFormatProperties);
+    return disp->GetPhysicalDeviceImageFormatProperties2KHR(unwrapped_phys_dev, pImageFormatInfo, pImageFormatProperties);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
     VkImageFormatProperties2KHR *pImageFormatProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->GetPhysicalDeviceImageFormatProperties2KHR) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "ICD associated with VkPhysicalDevice does not support "
                    "vkGetPhysicalDeviceImageFormatProperties2KHR");
     }
-    return icd_term->GetPhysicalDeviceImageFormatProperties2KHR(
-        phys_dev_term->phys_dev, pImageFormatInfo, pImageFormatProperties);
+    return icd_term->GetPhysicalDeviceImageFormatProperties2KHR(phys_dev_term->phys_dev, pImageFormatInfo, pImageFormatProperties);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
-    VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                        uint32_t *pQueueFamilyPropertyCount,
+                                                                        VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceQueueFamilyProperties2KHR(
-        unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+    disp->GetPhysicalDeviceQueueFamilyProperties2KHR(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceQueueFamilyProperties2KHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
-    VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties2KHR(
+    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->GetPhysicalDeviceQueueFamilyProperties2KHR) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "ICD associated with VkPhysicalDevice does not support "
                    "vkGetPhysicalDeviceQueueFamilyProperties2KHR");
     }
-    icd_term->GetPhysicalDeviceQueueFamilyProperties2KHR(
-        phys_dev_term->phys_dev, pQueueFamilyPropertyCount,
-        pQueueFamilyProperties);
+    icd_term->GetPhysicalDeviceQueueFamilyProperties2KHR(phys_dev_term->phys_dev, pQueueFamilyPropertyCount,
+                                                         pQueueFamilyProperties);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) {
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                   VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceMemoryProperties2KHR(unwrapped_phys_dev,
-                                                pMemoryProperties);
+    disp->GetPhysicalDeviceMemoryProperties2KHR(unwrapped_phys_dev, pMemoryProperties);
 }
 VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->GetPhysicalDeviceMemoryProperties2KHR) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "ICD associated with VkPhysicalDevice does not support "
                    "vkGetPhysicalDeviceMemoryProperties2KHR");
     }
-    icd_term->GetPhysicalDeviceMemoryProperties2KHR(phys_dev_term->phys_dev,
-                                                    pMemoryProperties);
+    icd_term->GetPhysicalDeviceMemoryProperties2KHR(phys_dev_term->phys_dev, pMemoryProperties);
 }
 
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo,
-    uint32_t *pPropertyCount, VkSparseImageFormatProperties2KHR *pProperties) {
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount,
+    VkSparseImageFormatProperties2KHR *pProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceSparseImageFormatProperties2KHR(
-        unwrapped_phys_dev, pFormatInfo, pPropertyCount, pProperties);
+    disp->GetPhysicalDeviceSparseImageFormatProperties2KHR(unwrapped_phys_dev, pFormatInfo, pPropertyCount, pProperties);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo,
-    uint32_t *pPropertyCount, VkSparseImageFormatProperties2KHR *pProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount,
+    VkSparseImageFormatProperties2KHR *pProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->GetPhysicalDeviceSparseImageFormatProperties2KHR) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "ICD associated with VkPhysicalDevice does not support "
                    "vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
     }
-    icd_term->GetPhysicalDeviceSparseImageFormatProperties2KHR(
-        phys_dev_term->phys_dev, pFormatInfo, pPropertyCount, pProperties);
+    icd_term->GetPhysicalDeviceSparseImageFormatProperties2KHR(phys_dev_term->phys_dev, pFormatInfo, pPropertyCount, pProperties);
 }
 
 // Definitions for the VK_KHR_maintenance1 extension
 
-VKAPI_ATTR void VKAPI_CALL
-vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
-                     VkCommandPoolTrimFlagsKHR flags) {
+VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(device);
     disp->TrimCommandPoolKHR(device, commandPool, flags);
 }
@@ -227,99 +186,78 @@
 // Definitions for the VK_EXT_acquire_xlib_display extension
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
-    VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) {
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
     return disp->AcquireXlibDisplayEXT(unwrapped_phys_dev, dpy, display);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(
-    VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy,
+                                                                VkDisplayKHR display) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->AcquireXlibDisplayEXT) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "ICD associated with VkPhysicalDevice does not support "
                    "vkAcquireXlibDisplayEXT");
     }
-    return icd_term->AcquireXlibDisplayEXT(phys_dev_term->phys_dev, dpy,
-                                           display);
+    return icd_term->AcquireXlibDisplayEXT(phys_dev_term->phys_dev, dpy, display);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy,
-                           RROutput rrOutput, VkDisplayKHR *pDisplay) {
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput,
+                                                          VkDisplayKHR *pDisplay) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetRandROutputDisplayEXT(unwrapped_phys_dev, dpy, rrOutput,
-                                          pDisplay);
+    return disp->GetRandROutputDisplayEXT(unwrapped_phys_dev, dpy, rrOutput, pDisplay);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(
-    VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput,
-    VkDisplayKHR *pDisplay) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput,
+                                                                   VkDisplayKHR *pDisplay) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->GetRandROutputDisplayEXT) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "ICD associated with VkPhysicalDevice does not support "
                    "vkGetRandROutputDisplayEXT");
     }
-    return icd_term->GetRandROutputDisplayEXT(phys_dev_term->phys_dev, dpy,
-                                              rrOutput, pDisplay);
+    return icd_term->GetRandROutputDisplayEXT(phys_dev_term->phys_dev, dpy, rrOutput, pDisplay);
 }
 #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
 
 // Definitions for the VK_EXT_debug_marker extension commands which
 // need to have a terminator function
 
-VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
-    VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) {
+VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(device);
     // If this is a physical device, we have to replace it with the proper one
     // for the next call.
-    if (pTagInfo->objectType ==
-        VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
-        struct loader_physical_device_tramp *phys_dev_tramp =
-            (struct loader_physical_device_tramp *)(uintptr_t)pTagInfo->object;
+    if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
+        struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)pTagInfo->object;
         pTagInfo->object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev;
     }
     return disp->DebugMarkerSetObjectTagEXT(device, pTagInfo);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectTagEXT(
-    VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) {
     uint32_t icd_index = 0;
     struct loader_device *dev;
-    struct loader_icd_term *icd_term =
-        loader_get_icd_and_device(device, &dev, &icd_index);
+    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
     if (NULL != icd_term && NULL != icd_term->DebugMarkerSetObjectTagEXT) {
         // If this is a physical device, we have to replace it with the proper
         // one for the next call.
-        if (pTagInfo->objectType ==
-            VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
-            struct loader_physical_device_term *phys_dev_term =
-                (struct loader_physical_device_term *)(uintptr_t)
-                    pTagInfo->object;
+        if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
+            struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)pTagInfo->object;
             pTagInfo->object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev;
 
             // If this is a KHR_surface, and the ICD has created its own, we
             // have to replace it with the proper one for the next call.
-        } else if (pTagInfo->objectType ==
-                   VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) {
+        } else if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) {
             if (NULL != icd_term && NULL != icd_term->CreateSwapchainKHR) {
-                VkIcdSurface *icd_surface =
-                    (VkIcdSurface *)(uintptr_t)pTagInfo->object;
+                VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pTagInfo->object;
                 if (NULL != icd_surface->real_icd_surfaces) {
-                    pTagInfo->object =
-                        (uint64_t)icd_surface->real_icd_surfaces[icd_index];
+                    pTagInfo->object = (uint64_t)icd_surface->real_icd_surfaces[icd_index];
                 }
             }
         }
@@ -329,47 +267,35 @@
     }
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
-    VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
+VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(device);
     // If this is a physical device, we have to replace it with the proper one
     // for the next call.
-    if (pNameInfo->objectType ==
-        VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
-        struct loader_physical_device_tramp *phys_dev_tramp =
-            (struct loader_physical_device_tramp *)(uintptr_t)pNameInfo->object;
+    if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
+        struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)pNameInfo->object;
         pNameInfo->object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev;
     }
     return disp->DebugMarkerSetObjectNameEXT(device, pNameInfo);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectNameEXT(
-    VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
     uint32_t icd_index = 0;
     struct loader_device *dev;
-    struct loader_icd_term *icd_term =
-        loader_get_icd_and_device(device, &dev, &icd_index);
+    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
     if (NULL != icd_term && NULL != icd_term->DebugMarkerSetObjectNameEXT) {
         // If this is a physical device, we have to replace it with the proper
         // one for the next call.
-        if (pNameInfo->objectType ==
-            VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
-            struct loader_physical_device_term *phys_dev_term =
-                (struct loader_physical_device_term *)(uintptr_t)
-                    pNameInfo->object;
+        if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
+            struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)pNameInfo->object;
             pNameInfo->object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev;
 
             // If this is a KHR_surface, and the ICD has created its own, we
             // have to replace it with the proper one for the next call.
-        } else if (pNameInfo->objectType ==
-                   VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) {
+        } else if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) {
             if (NULL != icd_term && NULL != icd_term->CreateSwapchainKHR) {
-                VkIcdSurface *icd_surface =
-                    (VkIcdSurface *)(uintptr_t)pNameInfo->object;
+                VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pNameInfo->object;
                 if (NULL != icd_surface->real_icd_surfaces) {
-                    pNameInfo->object =
-                        (uint64_t)(
-                            uintptr_t)icd_surface->real_icd_surfaces[icd_index];
+                    pNameInfo->object = (uint64_t)(uintptr_t)icd_surface->real_icd_surfaces[icd_index];
                 }
             }
         }
@@ -381,19 +307,15 @@
 
 // Definitions for the VK_EXT_direct_mode_display extension
 
-VKAPI_ATTR VkResult VKAPI_CALL
-vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
+VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
     return disp->ReleaseDisplayEXT(unwrapped_phys_dev, display);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(
-    VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->ReleaseDisplayEXT) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
@@ -405,28 +327,21 @@
 
 // Definitions for the VK_EXT_display_surface_counter extension
 
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-    VkSurfaceCapabilities2EXT *pSurfaceCapabilities) {
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                          VkSurfaceCapabilities2EXT *pSurfaceCapabilities) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetPhysicalDeviceSurfaceCapabilities2EXT(
-        unwrapped_phys_dev, surface, pSurfaceCapabilities);
+    return disp->GetPhysicalDeviceSurfaceCapabilities2EXT(unwrapped_phys_dev, surface, pSurfaceCapabilities);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceSurfaceCapabilities2EXT(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-    VkSurfaceCapabilities2EXT *pSurfaceCapabilities) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2EXT(
+    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL != icd_term) {
         if (NULL == icd_term->GetPhysicalDeviceSurfaceCapabilities2EXT) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                       0,
+            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                        "ICD associated with VkPhysicalDevice does not support "
                        "vkGetPhysicalDeviceSurfaceCapabilities2EXT");
         }
@@ -435,63 +350,48 @@
         if (NULL != icd_surface->real_icd_surfaces) {
             if (NULL != (void *)icd_surface->real_icd_surfaces[icd_index]) {
                 return icd_term->GetPhysicalDeviceSurfaceCapabilities2EXT(
-                    phys_dev_term->phys_dev,
-                    icd_surface->real_icd_surfaces[icd_index],
-                    pSurfaceCapabilities);
+                    phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[icd_index], pSurfaceCapabilities);
             }
         }
     }
-    return icd_term->GetPhysicalDeviceSurfaceCapabilities2EXT(
-        phys_dev_term->phys_dev, surface, pSurfaceCapabilities);
+    return icd_term->GetPhysicalDeviceSurfaceCapabilities2EXT(phys_dev_term->phys_dev, surface, pSurfaceCapabilities);
 }
 
 // Definitions for the VK_AMD_draw_indirect_count extension
 
-VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
-    VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-    VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
-    uint32_t stride) {
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                     VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                     uint32_t stride) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer,
-                                  countBufferOffset, maxDrawCount, stride);
+    disp->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
-    VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-    VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
-    uint32_t stride) {
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                            VkBuffer countBuffer, VkDeviceSize countBufferOffset,
+                                                            uint32_t maxDrawCount, uint32_t stride) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset,
-                                         countBuffer, countBufferOffset,
-                                         maxDrawCount, stride);
+    disp->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
 // Definitions for the VK_NV_external_memory_capabilities extension
 
-VKAPI_ATTR VkResult VKAPI_CALL
-vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
-    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage,
+    VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType,
     VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
 
-    return disp->GetPhysicalDeviceExternalImageFormatPropertiesNV(
-        unwrapped_phys_dev, format, type, tiling, usage, flags,
-        externalHandleType, pExternalImageFormatProperties);
+    return disp->GetPhysicalDeviceExternalImageFormatPropertiesNV(unwrapped_phys_dev, format, type, tiling, usage, flags,
+                                                                  externalHandleType, pExternalImageFormatProperties);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
-    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage,
+    VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType,
     VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
 
     if (!icd_term->GetPhysicalDeviceExternalImageFormatPropertiesNV) {
@@ -507,23 +407,20 @@
         pExternalImageFormatProperties->exportFromImportedHandleTypes = 0;
         pExternalImageFormatProperties->compatibleHandleTypes = 0;
 
-        return icd_term->GetPhysicalDeviceImageFormatProperties(
-            phys_dev_term->phys_dev, format, type, tiling, usage, flags,
-            &pExternalImageFormatProperties->imageFormatProperties);
+        return icd_term->GetPhysicalDeviceImageFormatProperties(phys_dev_term->phys_dev, format, type, tiling, usage, flags,
+                                                                &pExternalImageFormatProperties->imageFormatProperties);
     }
 
-    return icd_term->GetPhysicalDeviceExternalImageFormatPropertiesNV(
-        phys_dev_term->phys_dev, format, type, tiling, usage, flags,
-        externalHandleType, pExternalImageFormatProperties);
+    return icd_term->GetPhysicalDeviceExternalImageFormatPropertiesNV(phys_dev_term->phys_dev, format, type, tiling, usage, flags,
+                                                                      externalHandleType, pExternalImageFormatProperties);
 }
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
 // Definitions for the VK_NV_external_memory_win32 extension
 
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
-    VkDevice device, VkDeviceMemory memory,
-    VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle) {
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory,
+                                                        VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(device);
     return disp->GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
 }
@@ -532,153 +429,125 @@
 
 // Definitions for the VK_NVX_device_generated_commands
 
-VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
-    VkCommandBuffer commandBuffer,
-    const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo) {
+VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(VkCommandBuffer commandBuffer,
+                                                   const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
     disp->CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
-    VkCommandBuffer commandBuffer,
-    const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo) {
+VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer,
+                                                           const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
     disp->CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
-    VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator,
-    VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout) {
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(VkDevice device,
+                                                                 const VkIndirectCommandsLayoutCreateInfoNVX *pCreateInfo,
+                                                                 const VkAllocationCallbacks *pAllocator,
+                                                                 VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->CreateIndirectCommandsLayoutNVX(
-        device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+    return disp->CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
-    VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout,
-    const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+                                                              const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout,
-                                           pAllocator);
+    disp->DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
-    VkDevice device, const VkObjectTableCreateInfoNVX *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable) {
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX *pCreateInfo,
+                                                      const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->CreateObjectTableNVX(device, pCreateInfo, pAllocator,
-                                      pObjectTable);
+    return disp->CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-vkDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable,
-                        const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable,
+                                                   const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(device);
     disp->DestroyObjectTableNVX(device, objectTable, pAllocator);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
-    VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount,
-    const VkObjectTableEntryNVX *const *ppObjectTableEntries,
-    const uint32_t *pObjectIndices) {
+VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount,
+                                                    const VkObjectTableEntryNVX *const *ppObjectTableEntries,
+                                                    const uint32_t *pObjectIndices) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->RegisterObjectsNVX(device, objectTable, objectCount,
-                                    ppObjectTableEntries, pObjectIndices);
+    return disp->RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
-    VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount,
-    const VkObjectEntryTypeNVX *pObjectEntryTypes,
-    const uint32_t *pObjectIndices) {
+VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount,
+                                                      const VkObjectEntryTypeNVX *pObjectEntryTypes,
+                                                      const uint32_t *pObjectIndices) {
     const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->UnregisterObjectsNVX(device, objectTable, objectCount,
-                                      pObjectEntryTypes, pObjectIndices);
+    return disp->UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
 }
 
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
-    VkPhysicalDevice physicalDevice,
-    VkDeviceGeneratedCommandsFeaturesNVX *pFeatures,
-    VkDeviceGeneratedCommandsLimitsNVX *pLimits) {
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice,
+                                                                             VkDeviceGeneratedCommandsFeaturesNVX *pFeatures,
+                                                                             VkDeviceGeneratedCommandsLimitsNVX *pLimits) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(unwrapped_phys_dev,
-                                                          pFeatures, pLimits);
+    disp->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(unwrapped_phys_dev, pFeatures, pLimits);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
-    VkPhysicalDevice physicalDevice,
-    VkDeviceGeneratedCommandsFeaturesNVX *pFeatures,
-    VkDeviceGeneratedCommandsLimitsNVX *pLimits) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, VkDeviceGeneratedCommandsLimitsNVX *pLimits) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->GetPhysicalDeviceGeneratedCommandsPropertiesNVX) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "ICD associated with VkPhysicalDevice does not support "
                    "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
     } else {
-        icd_term->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
-            phys_dev_term->phys_dev, pFeatures, pLimits);
+        icd_term->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(phys_dev_term->phys_dev, pFeatures, pLimits);
     }
 }
 
 // GPA helpers for extensions
 
-bool extension_instance_gpa(struct loader_instance *ptr_instance,
-                            const char *name, void **addr) {
+bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) {
     *addr = NULL;
 
     // Functions for the VK_KHR_get_physical_device_properties2 extension
 
     if (!strcmp("vkGetPhysicalDeviceFeatures2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions
-                     .khr_get_physical_device_properties2 == 1)
+        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
                     ? (void *)vkGetPhysicalDeviceFeatures2KHR
                     : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions
-                     .khr_get_physical_device_properties2 == 1)
+        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
                     ? (void *)vkGetPhysicalDeviceProperties2KHR
                     : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceFormatProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions
-                     .khr_get_physical_device_properties2 == 1)
+        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
                     ? (void *)vkGetPhysicalDeviceFormatProperties2KHR
                     : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceImageFormatProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions
-                     .khr_get_physical_device_properties2 == 1)
+        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
                     ? (void *)vkGetPhysicalDeviceImageFormatProperties2KHR
                     : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceQueueFamilyProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions
-                     .khr_get_physical_device_properties2 == 1)
+        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
                     ? (void *)vkGetPhysicalDeviceQueueFamilyProperties2KHR
                     : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceMemoryProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions
-                     .khr_get_physical_device_properties2 == 1)
+        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
                     ? (void *)vkGetPhysicalDeviceMemoryProperties2KHR
                     : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceSparseImageFormatProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions
-                     .khr_get_physical_device_properties2 == 1)
+        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
                     ? (void *)vkGetPhysicalDeviceSparseImageFormatProperties2KHR
                     : NULL;
         return true;
@@ -695,20 +564,12 @@
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     if (!strcmp("vkAcquireXlibDisplayEXT", name)) {
-        *addr =
-            (ptr_instance->enabled_known_extensions.ext_acquire_xlib_display ==
-             1)
-                ? (void *)vkAcquireXlibDisplayEXT
-                : NULL;
+        *addr = (ptr_instance->enabled_known_extensions.ext_acquire_xlib_display == 1) ? (void *)vkAcquireXlibDisplayEXT : NULL;
         return true;
     }
 
     if (!strcmp("vkGetRandROutputDisplayEXT", name)) {
-        *addr =
-            (ptr_instance->enabled_known_extensions.ext_acquire_xlib_display ==
-             1)
-                ? (void *)vkGetRandROutputDisplayEXT
-                : NULL;
+        *addr = (ptr_instance->enabled_known_extensions.ext_acquire_xlib_display == 1) ? (void *)vkGetRandROutputDisplayEXT : NULL;
         return true;
     }
 
@@ -730,19 +591,14 @@
     // Functions for the VK_EXT_direct_mode_display extension
 
     if (!strcmp("vkReleaseDisplayEXT", name)) {
-        *addr =
-            (ptr_instance->enabled_known_extensions.ext_direct_mode_display ==
-             1)
-                ? (void *)vkReleaseDisplayEXT
-                : NULL;
+        *addr = (ptr_instance->enabled_known_extensions.ext_direct_mode_display == 1) ? (void *)vkReleaseDisplayEXT : NULL;
         return true;
     }
 
     // Functions for the VK_EXT_display_surface_counter extension
 
     if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilities2EXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions
-                     .ext_display_surface_counter == 1)
+        *addr = (ptr_instance->enabled_known_extensions.ext_display_surface_counter == 1)
                     ? (void *)vkGetPhysicalDeviceSurfaceCapabilities2EXT
                     : NULL;
         return true;
@@ -761,8 +617,7 @@
     // Functions for the VK_NV_external_memory_capabilities extension
 
     if (!strcmp("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", name)) {
-        *addr = (ptr_instance->enabled_known_extensions
-                     .nv_external_memory_capabilities == 1)
+        *addr = (ptr_instance->enabled_known_extensions.nv_external_memory_capabilities == 1)
                     ? (void *)vkGetPhysicalDeviceExternalImageFormatPropertiesNV
                     : NULL;
         return true;
@@ -820,31 +675,20 @@
     return false;
 }
 
-void extensions_create_instance(struct loader_instance *ptr_instance,
-                                const VkInstanceCreateInfo *pCreateInfo) {
+void extensions_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) {
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        if (0 ==
-            strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions
-                .khr_get_physical_device_properties2 = 1;
+        if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+            ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 = 1;
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                               VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME)) {
+        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME)) {
             ptr_instance->enabled_known_extensions.ext_acquire_xlib_display = 1;
 #endif
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                               VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)) {
+        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)) {
             ptr_instance->enabled_known_extensions.ext_direct_mode_display = 1;
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                               VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.ext_display_surface_counter =
-                1;
-        } else if (0 ==
-                   strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                          VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions
-                .nv_external_memory_capabilities = 1;
+        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) {
+            ptr_instance->enabled_known_extensions.ext_display_surface_counter = 1;
+        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) {
+            ptr_instance->enabled_known_extensions.nv_external_memory_capabilities = 1;
         }
     }
 }
diff --git a/loader/extensions.h b/loader/extensions.h
index b94aaf9..5736f3b 100644
--- a/loader/extensions.h
+++ b/loader/extensions.h
@@ -22,96 +22,75 @@
 #include "vk_loader_platform.h"
 #include "loader.h"
 
-bool extension_instance_gpa(struct loader_instance *ptr_instance,
-                            const char *name, void **addr);
+bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr);
 
-void extensions_create_instance(struct loader_instance *ptr_instance,
-                                const VkInstanceCreateInfo *pCreateInfo);
+void extensions_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo);
 
 // Instance extension terminators for the VK_KHR_get_physical_device_properties2
 // extension
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2KHR(
-    VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+                                                                    VkPhysicalDeviceFeatures2KHR *pFeatures);
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceProperties2KHR *pProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                      VkPhysicalDeviceProperties2KHR *pProperties);
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, VkFormat format,
-    VkFormatProperties2KHR *pFormatProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                            VkFormatProperties2KHR *pFormatProperties);
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
     VkImageFormatProperties2KHR *pImageFormatProperties);
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceQueueFamilyProperties2KHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
-    VkQueueFamilyProperties2KHR *pQueueFamilyProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties2KHR(
+    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties);
 
 VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties);
+    VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties);
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice,
-    const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo,
-    uint32_t *pPropertyCount, VkSparseImageFormatProperties2KHR *pProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount,
+    VkSparseImageFormatProperties2KHR *pProperties);
 
 // Instance extension terminators for the VK_EXT_acquire_xlib_display
 // extension
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(
-    VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy,
+                                                                VkDisplayKHR display);
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(
-    VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput,
-    VkDisplayKHR *pDisplay);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput,
+                                                                   VkDisplayKHR *pDisplay);
 #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
 
 // Instance extension terminators for the VK_EXT_direct_mode_display
 // extension
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(
-    VkPhysicalDevice physicalDevice, VkDisplayKHR display);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
 
 // Instance extension terminators for the VK_EXT_display_surface_counter
 // extension
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceSurfaceCapabilities2EXT(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-    VkSurfaceCapabilities2EXT *pSurfaceCapabilities);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,
+                                                                                   VkSurfaceKHR surface,
+                                                                                   VkSurfaceCapabilities2EXT *pSurfaceCapabilities);
 
 // Device extension terminators for the VK_NV_external_memory_capabilities
 // extension
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectTagEXT(
-    VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo);
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectNameEXT(
-    VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo);
 
 // Instance extension terminators for the VK_NV_external_memory_capabilities
 // extension
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
-    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage,
+    VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType,
     VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties);
 
 // Instance extension terminators for the VK_NVX_device_generated_commands
 // extension
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
-    VkPhysicalDevice physicalDevice,
-    VkDeviceGeneratedCommandsFeaturesNVX *pFeatures,
-    VkDeviceGeneratedCommandsLimitsNVX *pLimits);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, VkDeviceGeneratedCommandsLimitsNVX *pLimits);
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index c7e7ba2..e3e41ba 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -24,8 +24,7 @@
 #include "wsi.h"
 #include "extensions.h"
 
-static inline void *trampolineGetProcAddr(struct loader_instance *inst,
-                                          const char *funcName) {
+static inline void *trampolineGetProcAddr(struct loader_instance *inst, const char *funcName) {
     // Don't include or check global functions
     if (!strcmp(funcName, "vkGetInstanceProcAddr"))
         return (PFN_vkVoidFunction)vkGetInstanceProcAddr;
@@ -40,8 +39,7 @@
     if (!strcmp(funcName, "vkGetPhysicalDeviceImageFormatProperties"))
         return (PFN_vkVoidFunction)vkGetPhysicalDeviceImageFormatProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceSparseImageFormatProperties"))
-        return (
-            PFN_vkVoidFunction)vkGetPhysicalDeviceSparseImageFormatProperties;
+        return (PFN_vkVoidFunction)vkGetPhysicalDeviceSparseImageFormatProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceProperties"))
         return (PFN_vkVoidFunction)vkGetPhysicalDeviceProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceQueueFamilyProperties"))
diff --git a/loader/loader.c b/loader/loader.c
index 24758f4..b002d43 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -93,63 +93,45 @@
     .DestroyInstance = terminator_DestroyInstance,
     .EnumeratePhysicalDevices = terminator_EnumeratePhysicalDevices,
     .GetPhysicalDeviceFeatures = terminator_GetPhysicalDeviceFeatures,
-    .GetPhysicalDeviceFormatProperties =
-        terminator_GetPhysicalDeviceFormatProperties,
-    .GetPhysicalDeviceImageFormatProperties =
-        terminator_GetPhysicalDeviceImageFormatProperties,
+    .GetPhysicalDeviceFormatProperties = terminator_GetPhysicalDeviceFormatProperties,
+    .GetPhysicalDeviceImageFormatProperties = terminator_GetPhysicalDeviceImageFormatProperties,
     .GetPhysicalDeviceProperties = terminator_GetPhysicalDeviceProperties,
-    .GetPhysicalDeviceQueueFamilyProperties =
-        terminator_GetPhysicalDeviceQueueFamilyProperties,
-    .GetPhysicalDeviceMemoryProperties =
-        terminator_GetPhysicalDeviceMemoryProperties,
-    .EnumerateDeviceExtensionProperties =
-        terminator_EnumerateDeviceExtensionProperties,
+    .GetPhysicalDeviceQueueFamilyProperties = terminator_GetPhysicalDeviceQueueFamilyProperties,
+    .GetPhysicalDeviceMemoryProperties = terminator_GetPhysicalDeviceMemoryProperties,
+    .EnumerateDeviceExtensionProperties = terminator_EnumerateDeviceExtensionProperties,
     .EnumerateDeviceLayerProperties = terminator_EnumerateDeviceLayerProperties,
-    .GetPhysicalDeviceSparseImageFormatProperties =
-        terminator_GetPhysicalDeviceSparseImageFormatProperties,
+    .GetPhysicalDeviceSparseImageFormatProperties = terminator_GetPhysicalDeviceSparseImageFormatProperties,
     .DestroySurfaceKHR = terminator_DestroySurfaceKHR,
-    .GetPhysicalDeviceSurfaceSupportKHR =
-        terminator_GetPhysicalDeviceSurfaceSupportKHR,
-    .GetPhysicalDeviceSurfaceCapabilitiesKHR =
-        terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR,
-    .GetPhysicalDeviceSurfaceFormatsKHR =
-        terminator_GetPhysicalDeviceSurfaceFormatsKHR,
-    .GetPhysicalDeviceSurfacePresentModesKHR =
-        terminator_GetPhysicalDeviceSurfacePresentModesKHR,
+    .GetPhysicalDeviceSurfaceSupportKHR = terminator_GetPhysicalDeviceSurfaceSupportKHR,
+    .GetPhysicalDeviceSurfaceCapabilitiesKHR = terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR,
+    .GetPhysicalDeviceSurfaceFormatsKHR = terminator_GetPhysicalDeviceSurfaceFormatsKHR,
+    .GetPhysicalDeviceSurfacePresentModesKHR = terminator_GetPhysicalDeviceSurfacePresentModesKHR,
 #ifdef VK_USE_PLATFORM_MIR_KHR
     .CreateMirSurfaceKHR = terminator_CreateMirSurfaceKHR,
-    .GetPhysicalDeviceMirPresentationSupportKHR =
-        terminator_GetPhysicalDeviceMirPresentationSupportKHR,
+    .GetPhysicalDeviceMirPresentationSupportKHR = terminator_GetPhysicalDeviceMirPresentationSupportKHR,
 #endif
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
     .CreateWaylandSurfaceKHR = terminator_CreateWaylandSurfaceKHR,
-    .GetPhysicalDeviceWaylandPresentationSupportKHR =
-        terminator_GetPhysicalDeviceWaylandPresentationSupportKHR,
+    .GetPhysicalDeviceWaylandPresentationSupportKHR = terminator_GetPhysicalDeviceWaylandPresentationSupportKHR,
 #endif
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     .CreateWin32SurfaceKHR = terminator_CreateWin32SurfaceKHR,
-    .GetPhysicalDeviceWin32PresentationSupportKHR =
-        terminator_GetPhysicalDeviceWin32PresentationSupportKHR,
+    .GetPhysicalDeviceWin32PresentationSupportKHR = terminator_GetPhysicalDeviceWin32PresentationSupportKHR,
 #endif
 #ifdef VK_USE_PLATFORM_XCB_KHR
     .CreateXcbSurfaceKHR = terminator_CreateXcbSurfaceKHR,
-    .GetPhysicalDeviceXcbPresentationSupportKHR =
-        terminator_GetPhysicalDeviceXcbPresentationSupportKHR,
+    .GetPhysicalDeviceXcbPresentationSupportKHR = terminator_GetPhysicalDeviceXcbPresentationSupportKHR,
 #endif
 #ifdef VK_USE_PLATFORM_XLIB_KHR
     .CreateXlibSurfaceKHR = terminator_CreateXlibSurfaceKHR,
-    .GetPhysicalDeviceXlibPresentationSupportKHR =
-        terminator_GetPhysicalDeviceXlibPresentationSupportKHR,
+    .GetPhysicalDeviceXlibPresentationSupportKHR = terminator_GetPhysicalDeviceXlibPresentationSupportKHR,
 #endif
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
     .CreateAndroidSurfaceKHR = terminator_CreateAndroidSurfaceKHR,
 #endif
-    .GetPhysicalDeviceDisplayPropertiesKHR =
-        terminator_GetPhysicalDeviceDisplayPropertiesKHR,
-    .GetPhysicalDeviceDisplayPlanePropertiesKHR =
-        terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR,
-    .GetDisplayPlaneSupportedDisplaysKHR =
-        terminator_GetDisplayPlaneSupportedDisplaysKHR,
+    .GetPhysicalDeviceDisplayPropertiesKHR = terminator_GetPhysicalDeviceDisplayPropertiesKHR,
+    .GetPhysicalDeviceDisplayPlanePropertiesKHR = terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR,
+    .GetDisplayPlaneSupportedDisplaysKHR = terminator_GetDisplayPlaneSupportedDisplaysKHR,
     .GetDisplayModePropertiesKHR = terminator_GetDisplayModePropertiesKHR,
     .CreateDisplayModeKHR = terminator_CreateDisplayModeKHR,
     .GetDisplayPlaneCapabilitiesKHR = terminator_GetDisplayPlaneCapabilitiesKHR,
@@ -157,18 +139,12 @@
 
     // KHR_get_physical_device_properties2
     .GetPhysicalDeviceFeatures2KHR = terminator_GetPhysicalDeviceFeatures2KHR,
-    .GetPhysicalDeviceProperties2KHR =
-        terminator_GetPhysicalDeviceProperties2KHR,
-    .GetPhysicalDeviceFormatProperties2KHR =
-        terminator_GetPhysicalDeviceFormatProperties2KHR,
-    .GetPhysicalDeviceImageFormatProperties2KHR =
-        terminator_GetPhysicalDeviceImageFormatProperties2KHR,
-    .GetPhysicalDeviceQueueFamilyProperties2KHR =
-        terminator_GetPhysicalDeviceQueueFamilyProperties2KHR,
-    .GetPhysicalDeviceMemoryProperties2KHR =
-        terminator_GetPhysicalDeviceMemoryProperties2KHR,
-    .GetPhysicalDeviceSparseImageFormatProperties2KHR =
-        terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR,
+    .GetPhysicalDeviceProperties2KHR = terminator_GetPhysicalDeviceProperties2KHR,
+    .GetPhysicalDeviceFormatProperties2KHR = terminator_GetPhysicalDeviceFormatProperties2KHR,
+    .GetPhysicalDeviceImageFormatProperties2KHR = terminator_GetPhysicalDeviceImageFormatProperties2KHR,
+    .GetPhysicalDeviceQueueFamilyProperties2KHR = terminator_GetPhysicalDeviceQueueFamilyProperties2KHR,
+    .GetPhysicalDeviceMemoryProperties2KHR = terminator_GetPhysicalDeviceMemoryProperties2KHR,
+    .GetPhysicalDeviceSparseImageFormatProperties2KHR = terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR,
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     // EXT_acquire_xlib_display
@@ -185,60 +161,54 @@
     .ReleaseDisplayEXT = terminator_ReleaseDisplayEXT,
 
     // EXT_display_surface_counter
-    .GetPhysicalDeviceSurfaceCapabilities2EXT =
-        terminator_GetPhysicalDeviceSurfaceCapabilities2EXT,
+    .GetPhysicalDeviceSurfaceCapabilities2EXT = terminator_GetPhysicalDeviceSurfaceCapabilities2EXT,
 
     // NV_external_memory_capabilities
-    .GetPhysicalDeviceExternalImageFormatPropertiesNV =
-        terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV,
+    .GetPhysicalDeviceExternalImageFormatPropertiesNV = terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV,
 
     // NVX_device_generated_commands
-    .GetPhysicalDeviceGeneratedCommandsPropertiesNVX =
-        terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX,
+    .GetPhysicalDeviceGeneratedCommandsPropertiesNVX = terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX,
 };
 
 // A null-terminated list of all of the instance extensions supported by the
 // loader
-static const char *const LOADER_INSTANCE_EXTENSIONS[] = {
-    VK_KHR_SURFACE_EXTENSION_NAME,
-    VK_KHR_DISPLAY_EXTENSION_NAME,
+static const char *const LOADER_INSTANCE_EXTENSIONS[] = {VK_KHR_SURFACE_EXTENSION_NAME,
+                                                         VK_KHR_DISPLAY_EXTENSION_NAME,
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-    VK_KHR_XLIB_SURFACE_EXTENSION_NAME,
+                                                         VK_KHR_XLIB_SURFACE_EXTENSION_NAME,
 #endif
 #ifdef VK_USE_PLATFORM_XCB_KHR
-    VK_KHR_XCB_SURFACE_EXTENSION_NAME,
+                                                         VK_KHR_XCB_SURFACE_EXTENSION_NAME,
 #endif
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
+                                                         VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
 #endif
 #ifdef VK_USE_PLATFORM_MIR_KHR
-    VK_KHR_MIR_SURFACE_EXTENSION_NAME,
+                                                         VK_KHR_MIR_SURFACE_EXTENSION_NAME,
 #endif
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-    VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
+                                                         VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
 #endif
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-    VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
+                                                         VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
 #endif
-    VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
+                                                         VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME,
+                                                         VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME,
 #endif
-    VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
-    VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME,
-    VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME,
-    VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME,
+                                                         VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
+                                                         VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME,
+                                                         VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME,
+                                                         VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME,
 #ifdef VK_USE_PLATFORM_VI_NN
-    VK_NN_VI_SURFACE_EXTENSION_NAME,
+                                                         VK_NN_VI_SURFACE_EXTENSION_NAME,
 #endif
-    VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
-    NULL};
+                                                         VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
+                                                         NULL};
 
 LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_init);
 
-void *loader_instance_heap_alloc(const struct loader_instance *instance,
-                                 size_t size,
-                                 VkSystemAllocationScope alloc_scope) {
+void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope alloc_scope) {
     void *pMemory = NULL;
 #if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
     {
@@ -247,9 +217,7 @@
         /* These are internal structures, so it's best to align everything to
          * the largest unit size which is the size of a uint64_t.
         */
-        pMemory = instance->alloc_callbacks.pfnAllocation(
-            instance->alloc_callbacks.pUserData, size, sizeof(uint64_t),
-            alloc_scope);
+        pMemory = instance->alloc_callbacks.pfnAllocation(instance->alloc_callbacks.pUserData, size, sizeof(uint64_t), alloc_scope);
     } else {
 #endif
         pMemory = malloc(size);
@@ -257,15 +225,13 @@
     return pMemory;
 }
 
-void loader_instance_heap_free(const struct loader_instance *instance,
-                               void *pMemory) {
+void loader_instance_heap_free(const struct loader_instance *instance, void *pMemory) {
     if (pMemory != NULL) {
 #if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
         {
 #else
         if (instance && instance->alloc_callbacks.pfnFree) {
-            instance->alloc_callbacks.pfnFree(
-                instance->alloc_callbacks.pUserData, pMemory);
+            instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMemory);
         } else {
 #endif
             free(pMemory);
@@ -273,8 +239,7 @@
     }
 }
 
-void *loader_instance_heap_realloc(const struct loader_instance *instance,
-                                   void *pMemory, size_t orig_size, size_t size,
+void *loader_instance_heap_realloc(const struct loader_instance *instance, void *pMemory, size_t orig_size, size_t size,
                                    VkSystemAllocationScope alloc_scope) {
     void *pNewMem = NULL;
     if (pMemory == NULL || orig_size == 0) {
@@ -287,9 +252,8 @@
         /* These are internal structures, so it's best to align everything to
          * the largest unit size which is the size of a uint64_t.
          */
-        pNewMem = instance->alloc_callbacks.pfnReallocation(
-            instance->alloc_callbacks.pUserData, pMemory, size,
-            sizeof(uint64_t), alloc_scope);
+        pNewMem = instance->alloc_callbacks.pfnReallocation(instance->alloc_callbacks.pUserData, pMemory, size, sizeof(uint64_t),
+                                                            alloc_scope);
 #endif
     } else {
         pNewMem = realloc(pMemory, size);
@@ -298,16 +262,12 @@
 }
 
 void *loader_instance_tls_heap_alloc(size_t size) {
-    return loader_instance_heap_alloc(tls_instance, size,
-                                      VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
+    return loader_instance_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
 }
 
-void loader_instance_tls_heap_free(void *pMemory) {
-    loader_instance_heap_free(tls_instance, pMemory);
-}
+void loader_instance_tls_heap_free(void *pMemory) { loader_instance_heap_free(tls_instance, pMemory); }
 
-void *loader_device_heap_alloc(const struct loader_device *device, size_t size,
-                               VkSystemAllocationScope alloc_scope) {
+void *loader_device_heap_alloc(const struct loader_device *device, size_t size, VkSystemAllocationScope alloc_scope) {
     void *pMemory = NULL;
 #if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
     {
@@ -316,9 +276,7 @@
         /* These are internal structures, so it's best to align everything to
          * the largest unit size which is the size of a uint64_t.
         */
-        pMemory = device->alloc_callbacks.pfnAllocation(
-            device->alloc_callbacks.pUserData, size, sizeof(uint64_t),
-            alloc_scope);
+        pMemory = device->alloc_callbacks.pfnAllocation(device->alloc_callbacks.pUserData, size, sizeof(uint64_t), alloc_scope);
     } else {
 #endif
         pMemory = malloc(size);
@@ -326,15 +284,13 @@
     return pMemory;
 }
 
-void loader_device_heap_free(const struct loader_device *device,
-                             void *pMemory) {
+void loader_device_heap_free(const struct loader_device *device, void *pMemory) {
     if (pMemory != NULL) {
 #if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
         {
 #else
         if (device && device->alloc_callbacks.pfnFree) {
-            device->alloc_callbacks.pfnFree(device->alloc_callbacks.pUserData,
-                                            pMemory);
+            device->alloc_callbacks.pfnFree(device->alloc_callbacks.pUserData, pMemory);
         } else {
 #endif
             free(pMemory);
@@ -342,8 +298,7 @@
     }
 }
 
-void *loader_device_heap_realloc(const struct loader_device *device,
-                                 void *pMemory, size_t orig_size, size_t size,
+void *loader_device_heap_realloc(const struct loader_device *device, void *pMemory, size_t orig_size, size_t size,
                                  VkSystemAllocationScope alloc_scope) {
     void *pNewMem = NULL;
     if (pMemory == NULL || orig_size == 0) {
@@ -356,9 +311,8 @@
         /* These are internal structures, so it's best to align everything to
          * the largest unit size which is the size of a uint64_t.
         */
-        pNewMem = device->alloc_callbacks.pfnReallocation(
-            device->alloc_callbacks.pUserData, pMemory, size, sizeof(uint64_t),
-            alloc_scope);
+        pNewMem = device->alloc_callbacks.pfnReallocation(device->alloc_callbacks.pUserData, pMemory, size, sizeof(uint64_t),
+                                                          alloc_scope);
 #endif
     } else {
         pNewMem = realloc(pMemory, size);
@@ -369,15 +323,13 @@
 // Environment variables
 #if defined(__linux__)
 
-static inline char *loader_getenv(const char *name,
-                                  const struct loader_instance *inst) {
+static inline char *loader_getenv(const char *name, const struct loader_instance *inst) {
     // No allocation of memory necessary for Linux, but we should at least touch
     // the inst pointer to get rid of compiler warnings.
     (void)inst;
     return getenv(name);
 }
-static inline void loader_free_getenv(char *val,
-                                      const struct loader_instance *inst) {
+static inline void loader_free_getenv(char *val, const struct loader_instance *inst) {
     // No freeing of memory necessary for Linux, but we should at least touch
     // the val and inst pointers to get rid of compiler warnings.
     (void)val;
@@ -386,8 +338,7 @@
 
 #elif defined(WIN32)
 
-static inline char *loader_getenv(const char *name,
-                                  const struct loader_instance *inst) {
+static inline char *loader_getenv(const char *name, const struct loader_instance *inst) {
     char *retVal;
     DWORD valSize;
 
@@ -400,9 +351,8 @@
 
     // Allocate the space necessary for the registry entry
     if (NULL != inst && NULL != inst->alloc_callbacks.pfnAllocation) {
-        retVal = (char *)inst->alloc_callbacks.pfnAllocation(
-            inst->alloc_callbacks.pUserData, valSize, sizeof(char *),
-            VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
+        retVal = (char *)inst->alloc_callbacks.pfnAllocation(inst->alloc_callbacks.pUserData, valSize, sizeof(char *),
+                                                             VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
     } else {
         retVal = (char *)malloc(valSize);
     }
@@ -414,8 +364,7 @@
     return retVal;
 }
 
-static inline void loader_free_getenv(char *val,
-                                      const struct loader_instance *inst) {
+static inline void loader_free_getenv(char *val, const struct loader_instance *inst) {
     if (NULL != inst && NULL != inst->alloc_callbacks.pfnFree) {
         inst->alloc_callbacks.pfnFree(inst->alloc_callbacks.pUserData, val);
     } else {
@@ -425,15 +374,13 @@
 
 #else
 
-static inline char *loader_getenv(const char *name,
-                                  const struct loader_instance *inst) {
+static inline char *loader_getenv(const char *name, const struct loader_instance *inst) {
     // stub func
     (void)inst;
     (void)name;
     return NULL;
 }
-static inline void loader_free_getenv(char *val,
-                                      const struct loader_instance *inst) {
+static inline void loader_free_getenv(char *val, const struct loader_instance *inst) {
     // stub func
     (void)val;
     (void)inst;
@@ -441,8 +388,7 @@
 
 #endif
 
-void loader_log(const struct loader_instance *inst, VkFlags msg_type,
-                int32_t msg_code, const char *format, ...) {
+void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t msg_code, const char *format, ...) {
     char msg[512];
     char cmd_line_msg[512];
     uint16_t cmd_line_size = sizeof(cmd_line_msg);
@@ -457,9 +403,8 @@
     va_end(ap);
 
     if (inst) {
-        util_DebugReportMessage(
-            inst, msg_type, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
-            (uint64_t)(uintptr_t)inst, 0, msg_code, "loader", msg);
+        util_DebugReportMessage(inst, msg_type, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, (uint64_t)(uintptr_t)inst, 0, msg_code,
+                                "loader", msg);
     }
 
     if (!(msg_type & g_loader_log_msgs)) {
@@ -519,25 +464,21 @@
     fputc('\n', stderr);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL vkSetInstanceDispatch(VkInstance instance,
-                                                     void *object) {
+VKAPI_ATTR VkResult VKAPI_CALL vkSetInstanceDispatch(VkInstance instance, void *object) {
 
     struct loader_instance *inst = loader_get_instance(instance);
     if (!inst) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkSetInstanceDispatch: Can not retrieve Instance "
-                   "dispatch table.");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkSetInstanceDispatch: Can not retrieve Instance "
+                                                           "dispatch table.");
         return VK_ERROR_INITIALIZATION_FAILED;
     }
     loader_set_dispatch(object, inst->disp);
     return VK_SUCCESS;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL vkSetDeviceDispatch(VkDevice device,
-                                                   void *object) {
+VKAPI_ATTR VkResult VKAPI_CALL vkSetDeviceDispatch(VkDevice device, void *object) {
     struct loader_device *dev;
-    struct loader_icd_term *icd_term =
-        loader_get_icd_and_device(device, &dev, NULL);
+    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, NULL);
 
     if (NULL == icd_term) {
         return VK_ERROR_INITIALIZATION_FAILED;
@@ -562,8 +503,7 @@
 //
 // *reg_data contains a string list of filenames as pointer.
 // When done using the returned string list, the caller should free the pointer.
-VkResult loaderGetRegistryFiles(const struct loader_instance *inst,
-    char *location, char **reg_data) {
+VkResult loaderGetRegistryFiles(const struct loader_instance *inst, char *location, char **reg_data) {
     LONG rtn_value;
     HKEY hive, key;
     DWORD access_flags;
@@ -594,32 +534,25 @@
             continue;
         }
 
-        while ((rtn_value = RegEnumValue(key, idx++, name, &name_size, NULL,
-                                         NULL, (LPBYTE)&value, &value_size)) ==
-               ERROR_SUCCESS) {
+        while ((rtn_value = RegEnumValue(key, idx++, name, &name_size, NULL, NULL, (LPBYTE)&value, &value_size)) == ERROR_SUCCESS) {
             if (value_size == sizeof(value) && value == 0) {
                 if (NULL == *reg_data) {
-                    *reg_data = loader_instance_heap_alloc(
-                        inst, total_size, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+                    *reg_data = loader_instance_heap_alloc(inst, total_size, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
                     if (NULL == *reg_data) {
-                        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                            "loaderGetRegistryFiles: Failed to allocate "
-                            "space for registry data for key %s",
-                            name);
+                        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loaderGetRegistryFiles: Failed to allocate "
+                                                                           "space for registry data for key %s",
+                                   name);
                         result = VK_ERROR_OUT_OF_HOST_MEMORY;
                         goto out;
                     }
                     *reg_data[0] = '\0';
                 } else if (strlen(*reg_data) + name_size + 1 > total_size) {
-                    *reg_data = loader_instance_heap_realloc(
-                        inst, *reg_data, total_size, total_size * 2,
-                        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+                    *reg_data = loader_instance_heap_realloc(inst, *reg_data, total_size, total_size * 2,
+                                                             VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
                     if (NULL == *reg_data) {
-                        loader_log(
-                            inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                            "loaderGetRegistryFiles: Failed to reallocate "
-                            "space for registry value of size %d for key %s",
-                            total_size * 2, name);
+                        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loaderGetRegistryFiles: Failed to reallocate "
+                                                                           "space for registry value of size %d for key %s",
+                                   total_size * 2, name);
                         result = VK_ERROR_OUT_OF_HOST_MEMORY;
                         goto out;
                     }
@@ -628,8 +561,7 @@
                 if (strlen(*reg_data) == 0) {
                     (void)snprintf(*reg_data, name_size + 1, "%s", name);
                 } else {
-                    (void)snprintf(*reg_data + strlen(*reg_data), name_size + 2,
-                                   "%c%s", PATH_SEPARATOR, name);
+                    (void)snprintf(*reg_data + strlen(*reg_data), name_size + 2, "%c%s", PATH_SEPARATOR, name);
                 }
                 found = true;
             }
@@ -675,8 +607,7 @@
             // This path element is not the first non-empty element; prepend
             // a directory separator if space allows
             if (dest && required_len + 1 < len) {
-                (void)snprintf(dest + required_len, len - required_len, "%c",
-                               DIRECTORY_SYMBOL);
+                (void)snprintf(dest + required_len, len - required_len, "%c", DIRECTORY_SYMBOL);
             }
             required_len++;
         }
@@ -725,8 +656,7 @@
     return VK_MAKE_VERSION(major, minor, patch);
 }
 
-bool compare_vk_extension_properties(const VkExtensionProperties *op1,
-                                     const VkExtensionProperties *op2) {
+bool compare_vk_extension_properties(const VkExtensionProperties *op1, const VkExtensionProperties *op2) {
     return strcmp(op1->extensionName, op2->extensionName) == 0 ? true : false;
 }
 
@@ -734,8 +664,7 @@
  * Search the given ext_array for an extension
  * matching the given vk_ext_prop
  */
-bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop,
-                                     const uint32_t count,
+bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop, const uint32_t count,
                                      const VkExtensionProperties *ext_array) {
     for (uint32_t i = 0; i < count; i++) {
         if (compare_vk_extension_properties(vk_ext_prop, &ext_array[i]))
@@ -748,8 +677,7 @@
  * Search the given ext_list for an extension
  * matching the given vk_ext_prop
  */
-bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop,
-                               const struct loader_extension_list *ext_list) {
+bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop, const struct loader_extension_list *ext_list) {
     for (uint32_t i = 0; i < ext_list->count; i++) {
         if (compare_vk_extension_properties(&ext_list->list[i], vk_ext_prop))
             return true;
@@ -760,9 +688,7 @@
 /**
  * Search the given ext_list for a device extension matching the given ext_prop
  */
-bool has_vk_dev_ext_property(
-    const VkExtensionProperties *ext_prop,
-    const struct loader_device_extension_list *ext_list) {
+bool has_vk_dev_ext_property(const VkExtensionProperties *ext_prop, const struct loader_device_extension_list *ext_list) {
     for (uint32_t i = 0; i < ext_list->count; i++) {
         if (compare_vk_extension_properties(&ext_list->list[i].props, ext_prop))
             return true;
@@ -773,9 +699,7 @@
 /*
  * Search the given layer list for a layer matching the given layer name
  */
-static struct loader_layer_properties *
-loader_get_layer_property(const char *name,
-                          const struct loader_layer_list *layer_list) {
+static struct loader_layer_properties *loader_get_layer_property(const char *name, const struct loader_layer_list *layer_list) {
     for (uint32_t i = 0; i < layer_list->count; i++) {
         const VkLayerProperties *item = &layer_list->list[i].info;
         if (strcmp(name, item->layerName) == 0)
@@ -787,34 +711,27 @@
 /**
  * Get the next unused layer property in the list. Init the property to zero.
  */
-static struct loader_layer_properties *
-loader_get_next_layer_property(const struct loader_instance *inst,
-                               struct loader_layer_list *layer_list) {
+static struct loader_layer_properties *loader_get_next_layer_property(const struct loader_instance *inst,
+                                                                      struct loader_layer_list *layer_list) {
     if (layer_list->capacity == 0) {
-        layer_list->list = loader_instance_heap_alloc(
-            inst, sizeof(struct loader_layer_properties) * 64,
-            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        layer_list->list =
+            loader_instance_heap_alloc(inst, sizeof(struct loader_layer_properties) * 64, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (layer_list->list == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_get_next_layer_property: Out of memory can "
-                       "not add any layer properties to list");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_next_layer_property: Out of memory can "
+                                                               "not add any layer properties to list");
             return NULL;
         }
-        memset(layer_list->list, 0,
-               sizeof(struct loader_layer_properties) * 64);
+        memset(layer_list->list, 0, sizeof(struct loader_layer_properties) * 64);
         layer_list->capacity = sizeof(struct loader_layer_properties) * 64;
     }
 
     // ensure enough room to add an entry
-    if ((layer_list->count + 1) * sizeof(struct loader_layer_properties) >
-        layer_list->capacity) {
-        layer_list->list = loader_instance_heap_realloc(
-            inst, layer_list->list, layer_list->capacity,
-            layer_list->capacity * 2, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    if ((layer_list->count + 1) * sizeof(struct loader_layer_properties) > layer_list->capacity) {
+        layer_list->list = loader_instance_heap_realloc(inst, layer_list->list, layer_list->capacity, layer_list->capacity * 2,
+                                                        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (layer_list->list == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_get_next_layer_property: realloc failed for "
-                       "layer list");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_next_layer_property: realloc failed for "
+                                                               "layer list");
             return NULL;
         }
         layer_list->capacity *= 2;
@@ -827,28 +744,22 @@
 /**
  * Remove all layer properties entrys from the list
  */
-void loader_delete_layer_properties(const struct loader_instance *inst,
-                                    struct loader_layer_list *layer_list) {
+void loader_delete_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_list) {
     uint32_t i, j;
     struct loader_device_extension_list *dev_ext_list;
     if (!layer_list)
         return;
 
     for (i = 0; i < layer_list->count; i++) {
-        loader_destroy_generic_list(
-            inst, (struct loader_generic_list *)&layer_list->list[i]
-                      .instance_extension_list);
+        loader_destroy_generic_list(inst, (struct loader_generic_list *)&layer_list->list[i].instance_extension_list);
         dev_ext_list = &layer_list->list[i].device_extension_list;
-        if (dev_ext_list->capacity > 0 && NULL != dev_ext_list->list &&
-            dev_ext_list->list->entrypoint_count > 0) {
+        if (dev_ext_list->capacity > 0 && NULL != dev_ext_list->list && dev_ext_list->list->entrypoint_count > 0) {
             for (j = 0; j < dev_ext_list->list->entrypoint_count; j++) {
-                loader_instance_heap_free(inst,
-                                          dev_ext_list->list->entrypoints[j]);
+                loader_instance_heap_free(inst, dev_ext_list->list->entrypoints[j]);
             }
             loader_instance_heap_free(inst, dev_ext_list->list->entrypoints);
         }
-        loader_destroy_generic_list(inst,
-                                    (struct loader_generic_list *)dev_ext_list);
+        loader_destroy_generic_list(inst, (struct loader_generic_list *)dev_ext_list);
     }
     layer_list->count = 0;
 
@@ -858,10 +769,9 @@
     }
 }
 
-static VkResult loader_add_instance_extensions(
-    const struct loader_instance *inst,
-    const PFN_vkEnumerateInstanceExtensionProperties fp_get_props,
-    const char *lib_name, struct loader_extension_list *ext_list) {
+static VkResult loader_add_instance_extensions(const struct loader_instance *inst,
+                                               const PFN_vkEnumerateInstanceExtensionProperties fp_get_props, const char *lib_name,
+                                               struct loader_extension_list *ext_list) {
     uint32_t i, count = 0;
     VkExtensionProperties *ext_props;
     VkResult res = VK_SUCCESS;
@@ -873,9 +783,8 @@
 
     res = fp_get_props(NULL, &count, NULL);
     if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_add_instance_extensions: Error getting Instance "
-                   "extension count from %s",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_instance_extensions: Error getting Instance "
+                                                           "extension count from %s",
                    lib_name);
         goto out;
     }
@@ -893,9 +802,8 @@
 
     res = fp_get_props(NULL, &count, ext_props);
     if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_add_instance_extensions: Error getting Instance "
-                   "extensions from %s",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_instance_extensions: Error getting Instance "
+                                                           "extensions from %s",
                    lib_name);
         goto out;
     }
@@ -903,22 +811,17 @@
     for (i = 0; i < count; i++) {
         char spec_version[64];
 
-        bool ext_unsupported =
-            wsi_unsupported_instance_extension(&ext_props[i]);
+        bool ext_unsupported = wsi_unsupported_instance_extension(&ext_props[i]);
         if (!ext_unsupported) {
-            (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d",
-                           VK_MAJOR(ext_props[i].specVersion),
-                           VK_MINOR(ext_props[i].specVersion),
-                           VK_PATCH(ext_props[i].specVersion));
-            loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                       "Instance Extension: %s (%s) version %s",
-                       ext_props[i].extensionName, lib_name, spec_version);
+            (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_MAJOR(ext_props[i].specVersion),
+                           VK_MINOR(ext_props[i].specVersion), VK_PATCH(ext_props[i].specVersion));
+            loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Instance Extension: %s (%s) version %s", ext_props[i].extensionName,
+                       lib_name, spec_version);
 
             res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
             if (res != VK_SUCCESS) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_add_instance_extensions: Failed to add %s "
-                           "to Instance extension list",
+                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_instance_extensions: Failed to add %s "
+                                                                   "to Instance extension list",
                            lib_name);
                 goto out;
             }
@@ -933,16 +836,13 @@
  * Initialize ext_list with the physical device extensions.
  * The extension properties are passed as inputs in count and ext_props.
  */
-static VkResult
-loader_init_device_extensions(const struct loader_instance *inst,
-                              struct loader_physical_device_term *phys_dev_term,
-                              uint32_t count, VkExtensionProperties *ext_props,
-                              struct loader_extension_list *ext_list) {
+static VkResult loader_init_device_extensions(const struct loader_instance *inst, struct loader_physical_device_term *phys_dev_term,
+                                              uint32_t count, VkExtensionProperties *ext_props,
+                                              struct loader_extension_list *ext_list) {
     VkResult res;
     uint32_t i;
 
-    res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list,
-                                   sizeof(VkExtensionProperties));
+    res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(VkExtensionProperties));
     if (VK_SUCCESS != res) {
         return res;
     }
@@ -950,14 +850,10 @@
     for (i = 0; i < count; i++) {
         char spec_version[64];
 
-        (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d",
-                       VK_MAJOR(ext_props[i].specVersion),
-                       VK_MINOR(ext_props[i].specVersion),
-                       VK_PATCH(ext_props[i].specVersion));
-        loader_log(
-            inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-            "Device Extension: %s (%s) version %s", ext_props[i].extensionName,
-            phys_dev_term->this_icd_term->scanned_icd->lib_name, spec_version);
+        (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_MAJOR(ext_props[i].specVersion),
+                       VK_MINOR(ext_props[i].specVersion), VK_PATCH(ext_props[i].specVersion));
+        loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Device Extension: %s (%s) version %s", ext_props[i].extensionName,
+                   phys_dev_term->this_icd_term->scanned_icd->lib_name, spec_version);
         res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
         if (res != VK_SUCCESS)
             return res;
@@ -967,49 +863,40 @@
 }
 
 VkResult loader_add_device_extensions(const struct loader_instance *inst,
-                                      PFN_vkEnumerateDeviceExtensionProperties
-                                          fpEnumerateDeviceExtensionProperties,
-                                      VkPhysicalDevice physical_device,
-                                      const char *lib_name,
+                                      PFN_vkEnumerateDeviceExtensionProperties fpEnumerateDeviceExtensionProperties,
+                                      VkPhysicalDevice physical_device, const char *lib_name,
                                       struct loader_extension_list *ext_list) {
     uint32_t i, count;
     VkResult res;
     VkExtensionProperties *ext_props;
 
-    res = fpEnumerateDeviceExtensionProperties(physical_device, NULL, &count,
-                                               NULL);
+    res = fpEnumerateDeviceExtensionProperties(physical_device, NULL, &count, NULL);
     if (res == VK_SUCCESS && count > 0) {
         ext_props = loader_stack_alloc(count * sizeof(VkExtensionProperties));
         if (!ext_props) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_device_extensions: Failed to allocate space"
-                       " for device extension properties.");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_device_extensions: Failed to allocate space"
+                                                               " for device extension properties.");
             return VK_ERROR_OUT_OF_HOST_MEMORY;
         }
-        res = fpEnumerateDeviceExtensionProperties(physical_device, NULL,
-                                                   &count, ext_props);
+        res = fpEnumerateDeviceExtensionProperties(physical_device, NULL, &count, ext_props);
         if (res != VK_SUCCESS) {
             return res;
         }
         for (i = 0; i < count; i++) {
             char spec_version[64];
 
-            (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d",
-                           VK_MAJOR(ext_props[i].specVersion),
-                           VK_MINOR(ext_props[i].specVersion),
-                           VK_PATCH(ext_props[i].specVersion));
-            loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                       "Device Extension: %s (%s) version %s",
-                       ext_props[i].extensionName, lib_name, spec_version);
+            (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_MAJOR(ext_props[i].specVersion),
+                           VK_MINOR(ext_props[i].specVersion), VK_PATCH(ext_props[i].specVersion));
+            loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Device Extension: %s (%s) version %s", ext_props[i].extensionName,
+                       lib_name, spec_version);
             res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
             if (res != VK_SUCCESS) {
                 return res;
             }
         }
     } else {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_add_device_extensions: Error getting physical "
-                   "device extension info count from library %s",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_device_extensions: Error getting physical "
+                                                           "device extension info count from library %s",
                    lib_name);
         return res;
     }
@@ -1017,18 +904,14 @@
     return VK_SUCCESS;
 }
 
-VkResult loader_init_generic_list(const struct loader_instance *inst,
-                                  struct loader_generic_list *list_info,
-                                  size_t element_size) {
+VkResult loader_init_generic_list(const struct loader_instance *inst, struct loader_generic_list *list_info, size_t element_size) {
     size_t capacity = 32 * element_size;
     list_info->count = 0;
     list_info->capacity = 0;
-    list_info->list = loader_instance_heap_alloc(
-        inst, capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    list_info->list = loader_instance_heap_alloc(inst, capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (list_info->list == NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_init_generic_list: Failed to allocate space "
-                   "for generic list");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_init_generic_list: Failed to allocate space "
+                                                           "for generic list");
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
     memset(list_info->list, 0, capacity);
@@ -1036,8 +919,7 @@
     return VK_SUCCESS;
 }
 
-void loader_destroy_generic_list(const struct loader_instance *inst,
-                                 struct loader_generic_list *list) {
+void loader_destroy_generic_list(const struct loader_instance *inst, struct loader_generic_list *list) {
     loader_instance_heap_free(inst, list->list);
     list->count = 0;
     list->capacity = 0;
@@ -1049,17 +931,13 @@
  * Return
  *  Vk_SUCCESS on success
  */
-VkResult loader_add_to_ext_list(const struct loader_instance *inst,
-                                struct loader_extension_list *ext_list,
-                                uint32_t prop_list_count,
-                                const VkExtensionProperties *props) {
+VkResult loader_add_to_ext_list(const struct loader_instance *inst, struct loader_extension_list *ext_list,
+                                uint32_t prop_list_count, const VkExtensionProperties *props) {
     uint32_t i;
     const VkExtensionProperties *cur_ext;
 
     if (ext_list->list == NULL || ext_list->capacity == 0) {
-        VkResult res = loader_init_generic_list(
-            inst, (struct loader_generic_list *)ext_list,
-            sizeof(VkExtensionProperties));
+        VkResult res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(VkExtensionProperties));
         if (VK_SUCCESS != res) {
             return res;
         }
@@ -1075,17 +953,14 @@
 
         // add to list at end
         // check for enough capacity
-        if (ext_list->count * sizeof(VkExtensionProperties) >=
-            ext_list->capacity) {
+        if (ext_list->count * sizeof(VkExtensionProperties) >= ext_list->capacity) {
 
-            ext_list->list = loader_instance_heap_realloc(
-                inst, ext_list->list, ext_list->capacity,
-                ext_list->capacity * 2, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+            ext_list->list = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2,
+                                                          VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
 
             if (ext_list->list == NULL) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_add_to_ext_list: Failed to reallocate "
-                           "space for extension list");
+                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_to_ext_list: Failed to reallocate "
+                                                                   "space for extension list");
                 return VK_ERROR_OUT_OF_HOST_MEMORY;
             }
 
@@ -1093,8 +968,7 @@
             ext_list->capacity *= 2;
         }
 
-        memcpy(&ext_list->list[ext_list->count], cur_ext,
-               sizeof(VkExtensionProperties));
+        memcpy(&ext_list->list[ext_list->count], cur_ext, sizeof(VkExtensionProperties));
         ext_list->count++;
     }
     return VK_SUCCESS;
@@ -1106,16 +980,11 @@
  * Return
  *  Vk_SUCCESS on success
  */
-VkResult
-loader_add_to_dev_ext_list(const struct loader_instance *inst,
-                           struct loader_device_extension_list *ext_list,
-                           const VkExtensionProperties *props,
-                           uint32_t entry_count, char **entrys) {
+VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst, struct loader_device_extension_list *ext_list,
+                                    const VkExtensionProperties *props, uint32_t entry_count, char **entrys) {
     uint32_t idx;
     if (ext_list->list == NULL || ext_list->capacity == 0) {
-        VkResult res = loader_init_generic_list(
-            inst, (struct loader_generic_list *)ext_list,
-            sizeof(struct loader_dev_ext_props));
+        VkResult res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(struct loader_dev_ext_props));
         if (VK_SUCCESS != res) {
             return res;
         }
@@ -1131,14 +1000,12 @@
     // check for enough capacity
     if (idx * sizeof(struct loader_dev_ext_props) >= ext_list->capacity) {
 
-        ext_list->list = loader_instance_heap_realloc(
-            inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2,
-            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        ext_list->list = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2,
+                                                      VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
 
         if (ext_list->list == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_to_dev_ext_list: Failed to reallocate "
-                       "space for device extension list");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_to_dev_ext_list: Failed to reallocate "
+                                                               "space for device extension list");
             return VK_ERROR_OUT_OF_HOST_MEMORY;
         }
 
@@ -1146,34 +1013,29 @@
         ext_list->capacity *= 2;
     }
 
-    memcpy(&ext_list->list[idx].props, props,
-           sizeof(struct loader_dev_ext_props));
+    memcpy(&ext_list->list[idx].props, props, sizeof(struct loader_dev_ext_props));
     ext_list->list[idx].entrypoint_count = entry_count;
     ext_list->list[idx].entrypoints =
-        loader_instance_heap_alloc(inst, sizeof(char *) * entry_count,
-                                   VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        loader_instance_heap_alloc(inst, sizeof(char *) * entry_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (ext_list->list[idx].entrypoints == NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_add_to_dev_ext_list: Failed to allocate space "
-                   "for device extension entrypoint list in list %d",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_to_dev_ext_list: Failed to allocate space "
+                                                           "for device extension entrypoint list in list %d",
                    idx);
         ext_list->list[idx].entrypoint_count = 0;
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
     for (uint32_t i = 0; i < entry_count; i++) {
-        ext_list->list[idx].entrypoints[i] = loader_instance_heap_alloc(
-            inst, strlen(entrys[i]) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        ext_list->list[idx].entrypoints[i] =
+            loader_instance_heap_alloc(inst, strlen(entrys[i]) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (ext_list->list[idx].entrypoints[i] == NULL) {
             for (uint32_t j = 0; j < i; j++) {
-                loader_instance_heap_free(inst,
-                                          ext_list->list[idx].entrypoints[j]);
+                loader_instance_heap_free(inst, ext_list->list[idx].entrypoints[j]);
             }
             loader_instance_heap_free(inst, ext_list->list[idx].entrypoints);
             ext_list->list[idx].entrypoint_count = 0;
             ext_list->list[idx].entrypoints = NULL;
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_to_dev_ext_list: Failed to allocate space "
-                       "for device extension entrypoint %d name",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_to_dev_ext_list: Failed to allocate space "
+                                                               "for device extension entrypoint %d name",
                        i);
             return VK_ERROR_OUT_OF_HOST_MEMORY;
         }
@@ -1189,11 +1051,9 @@
  * Add these to the output layer_list.  Don't add duplicates to the output
  * layer_list.
  */
-static VkResult
-loader_add_layer_names_to_list(const struct loader_instance *inst,
-                               struct loader_layer_list *output_list,
-                               uint32_t name_count, const char *const *names,
-                               const struct loader_layer_list *search_list) {
+static VkResult loader_add_layer_names_to_list(const struct loader_instance *inst, struct loader_layer_list *output_list,
+                                               uint32_t name_count, const char *const *names,
+                                               const struct loader_layer_list *search_list) {
     struct loader_layer_properties *layer_prop;
     VkResult err = VK_SUCCESS;
 
@@ -1201,9 +1061,8 @@
         const char *search_target = names[i];
         layer_prop = loader_get_layer_property(search_target, search_list);
         if (!layer_prop) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_layer_names_to_list: Unable to find layer"
-                       " %s",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_layer_names_to_list: Unable to find layer"
+                                                               " %s",
                        search_target);
             err = VK_ERROR_LAYER_NOT_PRESENT;
             continue;
@@ -1218,11 +1077,9 @@
 /*
  * Manage lists of VkLayerProperties
  */
-static bool loader_init_layer_list(const struct loader_instance *inst,
-                                   struct loader_layer_list *list) {
+static bool loader_init_layer_list(const struct loader_instance *inst, struct loader_layer_list *list) {
     list->capacity = 32 * sizeof(struct loader_layer_properties);
-    list->list = loader_instance_heap_alloc(
-        inst, list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    list->list = loader_instance_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (list->list == NULL) {
         return false;
     }
@@ -1231,8 +1088,7 @@
     return true;
 }
 
-void loader_destroy_layer_list(const struct loader_instance *inst,
-                               struct loader_device *device,
+void loader_destroy_layer_list(const struct loader_instance *inst, struct loader_device *device,
                                struct loader_layer_list *layer_list) {
     if (device) {
         loader_device_heap_free(device, layer_list->list);
@@ -1247,8 +1103,7 @@
  * Search the given layer list for a list
  * matching the given VkLayerProperties
  */
-bool has_vk_layer_property(const VkLayerProperties *vk_layer_prop,
-                           const struct loader_layer_list *list) {
+bool has_vk_layer_property(const VkLayerProperties *vk_layer_prop, const struct loader_layer_list *list) {
     for (uint32_t i = 0; i < list->count; i++) {
         if (strcmp(vk_layer_prop->layerName, list->list[i].info.layerName) == 0)
             return true;
@@ -1272,9 +1127,7 @@
  * Append non-duplicate layer properties defined in prop_list
  * to the given layer_info list
  */
-VkResult loader_add_to_layer_list(const struct loader_instance *inst,
-                                  struct loader_layer_list *list,
-                                  uint32_t prop_list_count,
+VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loader_layer_list *list, uint32_t prop_list_count,
                                   const struct loader_layer_properties *props) {
     uint32_t i;
     struct loader_layer_properties *layer;
@@ -1296,24 +1149,20 @@
 
         // add to list at end
         // check for enough capacity
-        if (list->count * sizeof(struct loader_layer_properties) >=
-            list->capacity) {
+        if (list->count * sizeof(struct loader_layer_properties) >= list->capacity) {
 
-            list->list = loader_instance_heap_realloc(
-                inst, list->list, list->capacity, list->capacity * 2,
-                VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+            list->list = loader_instance_heap_realloc(inst, list->list, list->capacity, list->capacity * 2,
+                                                      VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
             if (NULL == list->list) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_add_to_layer_list: Realloc failed for "
-                           "when attempting to add new layer");
+                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_to_layer_list: Realloc failed for "
+                                                                   "when attempting to add new layer");
                 return VK_ERROR_OUT_OF_HOST_MEMORY;
             }
             // double capacity
             list->capacity *= 2;
         }
 
-        memcpy(&list->list[list->count], layer,
-               sizeof(struct loader_layer_properties));
+        memcpy(&list->list[list->count], layer, sizeof(struct loader_layer_properties));
         list->count++;
     }
 
@@ -1327,33 +1176,26 @@
  * Do not add if found loader_layer_properties is already
  * on the found_list.
  */
-void loader_find_layer_name_add_list(
-    const struct loader_instance *inst, const char *name,
-    const enum layer_type type, const struct loader_layer_list *search_list,
-    struct loader_layer_list *found_list) {
+void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type type,
+                                     const struct loader_layer_list *search_list, struct loader_layer_list *found_list) {
     bool found = false;
     for (uint32_t i = 0; i < search_list->count; i++) {
         struct loader_layer_properties *layer_prop = &search_list->list[i];
-        if (0 == strcmp(layer_prop->info.layerName, name) &&
-            (layer_prop->type & type)) {
+        if (0 == strcmp(layer_prop->info.layerName, name) && (layer_prop->type & type)) {
             /* Found a layer with the same name, add to found_list */
-            if (VK_SUCCESS ==
-                loader_add_to_layer_list(inst, found_list, 1, layer_prop)) {
+            if (VK_SUCCESS == loader_add_to_layer_list(inst, found_list, 1, layer_prop)) {
                 found = true;
             }
         }
     }
     if (!found) {
-        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                   "loader_find_layer_name_add_list: Failed to find layer name "
-                   "%s to activate",
+        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_find_layer_name_add_list: Failed to find layer name "
+                                                             "%s to activate",
                    name);
     }
 }
 
-static VkExtensionProperties *
-get_extension_property(const char *name,
-                       const struct loader_extension_list *list) {
+static VkExtensionProperties *get_extension_property(const char *name, const struct loader_extension_list *list) {
     for (uint32_t i = 0; i < list->count; i++) {
         if (strcmp(name, list->list[i].extensionName) == 0)
             return &list->list[i];
@@ -1361,9 +1203,7 @@
     return NULL;
 }
 
-static VkExtensionProperties *
-get_dev_extension_property(const char *name,
-                           const struct loader_device_extension_list *list) {
+static VkExtensionProperties *get_dev_extension_property(const char *name, const struct loader_device_extension_list *list) {
     for (uint32_t i = 0; i < list->count; i++) {
         if (strcmp(name, list->list[i].props.extensionName) == 0)
             return &list->list[i].props;
@@ -1391,38 +1231,29 @@
  * linked directly with the loader.
  */
 
-VkResult loader_get_icd_loader_instance_extensions(
-    const struct loader_instance *inst,
-    struct loader_icd_tramp_list *icd_tramp_list,
-    struct loader_extension_list *inst_exts) {
+VkResult loader_get_icd_loader_instance_extensions(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list,
+                                                   struct loader_extension_list *inst_exts) {
     struct loader_extension_list icd_exts;
     VkResult res = VK_SUCCESS;
 
-    loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-               "Build ICD instance extension list");
+    loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Build ICD instance extension list");
 
     // traverse scanned icd list adding non-duplicate extensions to the list
     for (uint32_t i = 0; i < icd_tramp_list->count; i++) {
-        res = loader_init_generic_list(inst,
-                                       (struct loader_generic_list *)&icd_exts,
-                                       sizeof(VkExtensionProperties));
+        res = loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
         if (VK_SUCCESS != res) {
             goto out;
         }
-        res = loader_add_instance_extensions(
-            inst, icd_tramp_list->scanned_list[i]
-                      .EnumerateInstanceExtensionProperties,
-            icd_tramp_list->scanned_list[i].lib_name, &icd_exts);
+        res = loader_add_instance_extensions(inst, icd_tramp_list->scanned_list[i].EnumerateInstanceExtensionProperties,
+                                             icd_tramp_list->scanned_list[i].lib_name, &icd_exts);
         if (VK_SUCCESS == res) {
             // Remove any extensions not recognized by the loader
             for (int32_t j = 0; j < (int32_t)icd_exts.count; j++) {
 
                 // See if the extension is in the list of supported extensions
                 bool found = false;
-                for (uint32_t k = 0; LOADER_INSTANCE_EXTENSIONS[k] != NULL;
-                     k++) {
-                    if (strcmp(icd_exts.list[j].extensionName,
-                               LOADER_INSTANCE_EXTENSIONS[k]) == 0) {
+                for (uint32_t k = 0; LOADER_INSTANCE_EXTENSIONS[k] != NULL; k++) {
+                    if (strcmp(icd_exts.list[j].extensionName, LOADER_INSTANCE_EXTENSIONS[k]) == 0) {
                         found = true;
                         break;
                     }
@@ -1438,17 +1269,14 @@
                 }
             }
 
-            res = loader_add_to_ext_list(inst, inst_exts, icd_exts.count,
-                                         icd_exts.list);
+            res = loader_add_to_ext_list(inst, inst_exts, icd_exts.count, icd_exts.list);
         }
-        loader_destroy_generic_list(inst,
-                                    (struct loader_generic_list *)&icd_exts);
+        loader_destroy_generic_list(inst, (struct loader_generic_list *)&icd_exts);
         if (VK_SUCCESS != res) {
             goto out;
         }
     };
 
-
     // Traverse loader's extensions, adding non-duplicate extensions to the list
     debug_report_add_instance_extensions(inst, inst_exts);
 
@@ -1456,23 +1284,15 @@
     return res;
 }
 
-struct loader_icd_term *
-loader_get_icd_and_device(const VkDevice device,
-                          struct loader_device **found_dev,
-                          uint32_t *icd_index) {
+struct loader_icd_term *loader_get_icd_and_device(const VkDevice device, struct loader_device **found_dev, uint32_t *icd_index) {
     *found_dev = NULL;
     uint32_t index = 0;
-    for (struct loader_instance *inst = loader.instances; inst;
-         inst = inst->next) {
-        for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term;
-             icd_term = icd_term->next) {
-            for (struct loader_device *dev = icd_term->logical_device_list; dev;
-                 dev = dev->next)
+    for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) {
+        for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
+            for (struct loader_device *dev = icd_term->logical_device_list; dev; dev = dev->next)
                 // Value comparison of device prevents object wrapping by layers
-                if (loader_get_dispatch(dev->icd_device) ==
-                        loader_get_dispatch(device) ||
-                    loader_get_dispatch(dev->chain_device) ==
-                        loader_get_dispatch(device)) {
+                if (loader_get_dispatch(dev->icd_device) == loader_get_dispatch(device) ||
+                    loader_get_dispatch(dev->chain_device) == loader_get_dispatch(device)) {
                     *found_dev = dev;
                     if (NULL != icd_index) {
                         *icd_index = index;
@@ -1485,8 +1305,7 @@
     return NULL;
 }
 
-void loader_destroy_logical_device(const struct loader_instance *inst,
-                                   struct loader_device *dev,
+void loader_destroy_logical_device(const struct loader_instance *inst, struct loader_device *dev,
                                    const VkAllocationCallbacks *pAllocator) {
     if (pAllocator) {
         dev->alloc_callbacks = *pAllocator;
@@ -1497,26 +1316,22 @@
     loader_device_heap_free(dev, dev);
 }
 
-struct loader_device *
-loader_create_logical_device(const struct loader_instance *inst,
-                             const VkAllocationCallbacks *pAllocator) {
+struct loader_device *loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator) {
     struct loader_device *new_dev;
 #if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
     {
 #else
     if (pAllocator) {
-        new_dev = (struct loader_device *)pAllocator->pfnAllocation(
-            pAllocator->pUserData, sizeof(struct loader_device), sizeof(int *),
-            VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+        new_dev = (struct loader_device *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(struct loader_device),
+                                                                    sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
     } else {
 #endif
         new_dev = (struct loader_device *)malloc(sizeof(struct loader_device));
     }
 
     if (!new_dev) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_create_logical_device: Failed to alloc struct "
-                   "loader_device");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_create_logical_device: Failed to alloc struct "
+                                                           "loader_device");
         return NULL;
     }
 
@@ -1528,17 +1343,13 @@
     return new_dev;
 }
 
-void loader_add_logical_device(const struct loader_instance *inst,
-                               struct loader_icd_term *icd_term,
-                               struct loader_device *dev) {
+void loader_add_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term, struct loader_device *dev) {
     dev->next = icd_term->logical_device_list;
     icd_term->logical_device_list = dev;
 }
 
-void loader_remove_logical_device(const struct loader_instance *inst,
-                                  struct loader_icd_term *icd_term,
-                                  struct loader_device *found_dev,
-                                  const VkAllocationCallbacks *pAllocator) {
+void loader_remove_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term,
+                                  struct loader_device *found_dev, const VkAllocationCallbacks *pAllocator) {
     struct loader_device *dev, *prev_dev;
 
     if (!icd_term || !found_dev)
@@ -1558,8 +1369,7 @@
     loader_destroy_logical_device(inst, found_dev, pAllocator);
 }
 
-static void loader_icd_destroy(struct loader_instance *ptr_inst,
-                               struct loader_icd_term *icd_term,
+static void loader_icd_destroy(struct loader_instance *ptr_inst, struct loader_icd_term *icd_term,
                                const VkAllocationCallbacks *pAllocator) {
     ptr_inst->total_icd_count--;
     for (struct loader_device *dev = icd_term->logical_device_list; dev;) {
@@ -1571,12 +1381,10 @@
     loader_instance_heap_free(ptr_inst, icd_term);
 }
 
-static struct loader_icd_term *
-loader_icd_create(const struct loader_instance *inst) {
+static struct loader_icd_term *loader_icd_create(const struct loader_instance *inst) {
     struct loader_icd_term *icd_term;
 
-    icd_term = loader_instance_heap_alloc(inst, sizeof(struct loader_icd_term),
-                                          VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    icd_term = loader_instance_heap_alloc(inst, sizeof(struct loader_icd_term), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (!icd_term) {
         return NULL;
     }
@@ -1586,9 +1394,7 @@
     return icd_term;
 }
 
-static struct loader_icd_term *
-loader_icd_add(struct loader_instance *ptr_inst,
-               const struct loader_scanned_icd *scanned_icd) {
+static struct loader_icd_term *loader_icd_add(struct loader_instance *ptr_inst, const struct loader_scanned_icd *scanned_icd) {
     struct loader_icd_term *icd_term;
 
     icd_term = loader_icd_create(ptr_inst);
@@ -1615,9 +1421,7 @@
  * @return  bool indicating true if the selected interface version is supported
  *          by the loader, false indicates the version is not supported
  */
-bool loader_get_icd_interface_version(
-    PFN_vkNegotiateLoaderICDInterfaceVersion fp_negotiate_icd_version,
-    uint32_t *pVersion) {
+bool loader_get_icd_interface_version(PFN_vkNegotiateLoaderICDInterfaceVersion fp_negotiate_icd_version, uint32_t *pVersion) {
 
     if (fp_negotiate_icd_version == NULL) {
         // ICD does not support the negotiation API, it supports version 0 or 1
@@ -1646,14 +1450,12 @@
     return true;
 }
 
-void loader_scanned_icd_clear(const struct loader_instance *inst,
-                              struct loader_icd_tramp_list *icd_tramp_list) {
+void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) {
     if (icd_tramp_list->capacity == 0)
         return;
     for (uint32_t i = 0; i < icd_tramp_list->count; i++) {
         loader_platform_close_library(icd_tramp_list->scanned_list[i].handle);
-        loader_instance_heap_free(inst,
-                                  icd_tramp_list->scanned_list[i].lib_name);
+        loader_instance_heap_free(inst, icd_tramp_list->scanned_list[i].lib_name);
     }
     loader_instance_heap_free(inst, icd_tramp_list->scanned_list);
     icd_tramp_list->capacity = 0;
@@ -1661,28 +1463,21 @@
     icd_tramp_list->scanned_list = NULL;
 }
 
-static VkResult
-loader_scanned_icd_init(const struct loader_instance *inst,
-                        struct loader_icd_tramp_list *icd_tramp_list) {
+static VkResult loader_scanned_icd_init(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) {
     VkResult err = VK_SUCCESS;
     loader_scanned_icd_clear(inst, icd_tramp_list);
     icd_tramp_list->capacity = 8 * sizeof(struct loader_scanned_icd);
-    icd_tramp_list->scanned_list = loader_instance_heap_alloc(
-        inst, icd_tramp_list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    icd_tramp_list->scanned_list = loader_instance_heap_alloc(inst, icd_tramp_list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (NULL == icd_tramp_list->scanned_list) {
-        loader_log(
-            inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "loader_scanned_icd_init: Realloc failed for layer list when "
-            "attempting to add new layer");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_init: Realloc failed for layer list when "
+                                                           "attempting to add new layer");
         err = VK_ERROR_OUT_OF_HOST_MEMORY;
     }
     return err;
 }
 
-static VkResult
-loader_scanned_icd_add(const struct loader_instance *inst,
-                       struct loader_icd_tramp_list *icd_tramp_list,
-                       const char *filename, uint32_t api_version) {
+static VkResult loader_scanned_icd_add(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list,
+                                       const char *filename, uint32_t api_version) {
     loader_platform_dl_handle handle;
     PFN_vkCreateInstance fp_create_inst;
     PFN_vkEnumerateInstanceExtensionProperties fp_get_inst_ext_props;
@@ -1697,62 +1492,50 @@
      * function leaves libraries open and the scanned_icd_clear closes them */
     handle = loader_platform_open_library(filename);
     if (NULL == handle) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   loader_platform_open_library_error(filename));
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, loader_platform_open_library_error(filename));
         goto out;
     }
 
     // Get and settle on an ICD interface version
-    fp_negotiate_icd_version = loader_platform_get_proc_address(
-        handle, "vk_icdNegotiateLoaderICDInterfaceVersion");
+    fp_negotiate_icd_version = loader_platform_get_proc_address(handle, "vk_icdNegotiateLoaderICDInterfaceVersion");
 
-    if (!loader_get_icd_interface_version(fp_negotiate_icd_version,
-                                          &interface_vers)) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_scanned_icd_add: ICD %s doesn't support interface"
-                   " version compatible with loader, skip this ICD.",
+    if (!loader_get_icd_interface_version(fp_negotiate_icd_version, &interface_vers)) {
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_add: ICD %s doesn't support interface"
+                                                           " version compatible with loader, skip this ICD.",
                    filename);
         goto out;
     }
 
-    fp_get_proc_addr =
-        loader_platform_get_proc_address(handle, "vk_icdGetInstanceProcAddr");
+    fp_get_proc_addr = loader_platform_get_proc_address(handle, "vk_icdGetInstanceProcAddr");
     if (NULL == fp_get_proc_addr) {
         assert(interface_vers == 0);
         // Use deprecated interface from version 0
-        fp_get_proc_addr =
-            loader_platform_get_proc_address(handle, "vkGetInstanceProcAddr");
+        fp_get_proc_addr = loader_platform_get_proc_address(handle, "vkGetInstanceProcAddr");
         if (NULL == fp_get_proc_addr) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Attempt to retreive either "
-                       "\'vkGetInstanceProcAddr\' or "
-                       "\'vk_icdGetInstanceProcAddr\' from ICD %s failed.",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_add: Attempt to retreive either "
+                                                               "\'vkGetInstanceProcAddr\' or "
+                                                               "\'vk_icdGetInstanceProcAddr\' from ICD %s failed.",
                        filename);
             goto out;
         } else {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Using deprecated ICD "
-                       "interface of \'vkGetInstanceProcAddr\' instead of "
-                       "\'vk_icdGetInstanceProcAddr\' for ICD %s",
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_scanned_icd_add: Using deprecated ICD "
+                                                                 "interface of \'vkGetInstanceProcAddr\' instead of "
+                                                                 "\'vk_icdGetInstanceProcAddr\' for ICD %s",
                        filename);
         }
-        fp_create_inst =
-            loader_platform_get_proc_address(handle, "vkCreateInstance");
+        fp_create_inst = loader_platform_get_proc_address(handle, "vkCreateInstance");
         if (NULL == fp_create_inst) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add:  Failed querying "
-                       "\'vkCreateInstance\' via dlsym/loadlibrary for "
-                       "ICD %s",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_add:  Failed querying "
+                                                               "\'vkCreateInstance\' via dlsym/loadlibrary for "
+                                                               "ICD %s",
                        filename);
             goto out;
         }
-        fp_get_inst_ext_props = loader_platform_get_proc_address(
-            handle, "vkEnumerateInstanceExtensionProperties");
+        fp_get_inst_ext_props = loader_platform_get_proc_address(handle, "vkEnumerateInstanceExtensionProperties");
         if (NULL == fp_get_inst_ext_props) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Could not get \'vkEnumerate"
-                       "InstanceExtensionProperties\' via dlsym/loadlibrary "
-                       "for ICD %s",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_add: Could not get \'vkEnumerate"
+                                                               "InstanceExtensionProperties\' via dlsym/loadlibrary "
+                                                               "for ICD %s",
                        filename);
             goto out;
         }
@@ -1762,43 +1545,36 @@
             interface_vers = 1;
         }
 
-        fp_create_inst =
-            (PFN_vkCreateInstance)fp_get_proc_addr(NULL, "vkCreateInstance");
+        fp_create_inst = (PFN_vkCreateInstance)fp_get_proc_addr(NULL, "vkCreateInstance");
         if (NULL == fp_create_inst) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Could not get "
-                       "\'vkCreateInstance\' via \'vk_icdGetInstanceProcAddr\'"
-                       " for ICD %s",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_add: Could not get "
+                                                               "\'vkCreateInstance\' via \'vk_icdGetInstanceProcAddr\'"
+                                                               " for ICD %s",
                        filename);
             goto out;
         }
         fp_get_inst_ext_props =
-            (PFN_vkEnumerateInstanceExtensionProperties)fp_get_proc_addr(
-                NULL, "vkEnumerateInstanceExtensionProperties");
+            (PFN_vkEnumerateInstanceExtensionProperties)fp_get_proc_addr(NULL, "vkEnumerateInstanceExtensionProperties");
         if (NULL == fp_get_inst_ext_props) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Could not get \'vkEnumerate"
-                       "InstanceExtensionProperties\' via "
-                       "\'vk_icdGetInstanceProcAddr\' for ICD %s",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_add: Could not get \'vkEnumerate"
+                                                               "InstanceExtensionProperties\' via "
+                                                               "\'vk_icdGetInstanceProcAddr\' for ICD %s",
                        filename);
             goto out;
         }
-        fp_get_phys_dev_proc_addr =
-            loader_platform_get_proc_address(handle, "vk_icdGetPhysicalDeviceProcAddr");
+        fp_get_phys_dev_proc_addr = loader_platform_get_proc_address(handle, "vk_icdGetPhysicalDeviceProcAddr");
     }
 
     // check for enough capacity
-    if ((icd_tramp_list->count * sizeof(struct loader_scanned_icd)) >=
-        icd_tramp_list->capacity) {
+    if ((icd_tramp_list->count * sizeof(struct loader_scanned_icd)) >= icd_tramp_list->capacity) {
 
-        icd_tramp_list->scanned_list = loader_instance_heap_realloc(
-            inst, icd_tramp_list->scanned_list, icd_tramp_list->capacity,
-            icd_tramp_list->capacity * 2, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        icd_tramp_list->scanned_list =
+            loader_instance_heap_realloc(inst, icd_tramp_list->scanned_list, icd_tramp_list->capacity, icd_tramp_list->capacity * 2,
+                                         VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (NULL == icd_tramp_list->scanned_list) {
             res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Realloc failed on icd library"
-                       " list for ICD %s",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_add: Realloc failed on icd library"
+                                                               " list for ICD %s",
                        filename);
             goto out;
         }
@@ -1811,17 +1587,13 @@
     new_scanned_icd->api_version = api_version;
     new_scanned_icd->GetInstanceProcAddr = fp_get_proc_addr;
     new_scanned_icd->GetPhysicalDeviceProcAddr = fp_get_phys_dev_proc_addr;
-    new_scanned_icd->EnumerateInstanceExtensionProperties =
-        fp_get_inst_ext_props;
+    new_scanned_icd->EnumerateInstanceExtensionProperties = fp_get_inst_ext_props;
     new_scanned_icd->CreateInstance = fp_create_inst;
     new_scanned_icd->interface_version = interface_vers;
 
-    new_scanned_icd->lib_name = (char *)loader_instance_heap_alloc(
-        inst, strlen(filename) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    new_scanned_icd->lib_name = (char *)loader_instance_heap_alloc(inst, strlen(filename) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (NULL == new_scanned_icd->lib_name) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_scanned_icd_add: Out of memory can't add ICD %s",
-                   filename);
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_add: Out of memory can't add ICD %s", filename);
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     }
@@ -1833,20 +1605,17 @@
     return res;
 }
 
-static bool loader_icd_init_entrys(struct loader_icd_term *icd_term,
-                                   VkInstance inst,
-                                   const PFN_vkGetInstanceProcAddr fp_gipa) {
+static bool loader_icd_init_entrys(struct loader_icd_term *icd_term, VkInstance inst, const PFN_vkGetInstanceProcAddr fp_gipa) {
 /* initialize entrypoint function pointers */
 
-#define LOOKUP_GIPA(func, required)                                            \
-    do {                                                                       \
-        icd_term->func = (PFN_vk##func)fp_gipa(inst, "vk" #func);              \
-        if (!icd_term->func && required) {                                     \
-            loader_log((struct loader_instance *)inst,                         \
-                       VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,                     \
-                       loader_platform_get_proc_address_error("vk" #func));    \
-            return false;                                                      \
-        }                                                                      \
+#define LOOKUP_GIPA(func, required)                                                                                                \
+    do {                                                                                                                           \
+        icd_term->func = (PFN_vk##func)fp_gipa(inst, "vk" #func);                                                                  \
+        if (!icd_term->func && required) {                                                                                         \
+            loader_log((struct loader_instance *)inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,                                         \
+                       loader_platform_get_proc_address_error("vk" #func));                                                        \
+            return false;                                                                                                          \
+        }                                                                                                                          \
     } while (0)
 
     LOOKUP_GIPA(GetDeviceProcAddr, true);
@@ -1966,8 +1735,7 @@
                 g_loader_log_msgs |= VK_DEBUG_REPORT_INFORMATION_BIT_EXT;
             } else if (strncmp(env, "perf", len) == 0) {
                 g_loader_debug |= LOADER_PERF_BIT;
-                g_loader_log_msgs |=
-                    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
+                g_loader_log_msgs |= VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
             } else if (strncmp(env, "error", len) == 0) {
                 g_loader_debug |= LOADER_ERROR_BIT;
                 g_loader_log_msgs |= VK_DEBUG_REPORT_ERROR_BIT_EXT;
@@ -1996,8 +1764,7 @@
 
     // initial cJSON to use alloc callbacks
     cJSON_Hooks alloc_fns = {
-        .malloc_fn = loader_instance_tls_heap_alloc,
-        .free_fn = loader_instance_tls_heap_free,
+        .malloc_fn = loader_instance_tls_heap_alloc, .free_fn = loader_instance_tls_heap_free,
     };
     cJSON_InitHooks(&alloc_fns);
 }
@@ -2041,8 +1808,7 @@
  * \returns
  * A string in out_fullpath of the full absolute path
  */
-static void loader_expand_path(const char *path, const char *rel_base,
-                               size_t out_size, char *out_fullpath) {
+static void loader_expand_path(const char *path, const char *rel_base, size_t out_size, char *out_fullpath) {
     if (loader_platform_is_path_absolute(path)) {
         // do not prepend a base to an absolute path
         rel_base = "";
@@ -2059,8 +1825,7 @@
  * \returns
  * A string in out_fullpath of either the full path or file.
  */
-static void loader_get_fullpath(const char *file, const char *dirs,
-                                size_t out_size, char *out_fullpath) {
+static void loader_get_fullpath(const char *file, const char *dirs, size_t out_size, char *out_fullpath) {
     if (!loader_platform_is_path(file) && *dirs) {
         char *dirs_copy, *dir, *next_dir;
 
@@ -2068,10 +1833,8 @@
         strcpy(dirs_copy, dirs);
 
         // find if file exists after prepending paths in given list
-        for (dir = dirs_copy; *dir && (next_dir = loader_get_next_path(dir));
-             dir = next_dir) {
-            loader_platform_combine_path(out_fullpath, out_size, dir, file,
-                                         NULL);
+        for (dir = dirs_copy; *dir && (next_dir = loader_get_next_path(dir)); dir = next_dir) {
+            loader_platform_combine_path(out_fullpath, out_size, dir, file, NULL);
             if (loader_platform_file_exists(out_fullpath)) {
                 return;
             }
@@ -2088,16 +1851,14 @@
  * A pointer to a cJSON object representing the JSON parse tree.
  * This returned buffer should be freed by caller.
  */
-static VkResult loader_get_json(const struct loader_instance *inst,
-                                const char *filename, cJSON **json) {
+static VkResult loader_get_json(const struct loader_instance *inst, const char *filename, cJSON **json) {
     FILE *file = NULL;
     char *json_buf;
     size_t len;
     VkResult res = VK_SUCCESS;
 
     if (NULL == json) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_get_json: Received invalid JSON file");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Received invalid JSON file");
         res = VK_ERROR_INITIALIZATION_FAILED;
         goto out;
     }
@@ -2106,8 +1867,7 @@
 
     file = fopen(filename, "rb");
     if (!file) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_get_json: Failed to open JSON file %s", filename);
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Failed to open JSON file %s", filename);
         res = VK_ERROR_INITIALIZATION_FAILED;
         goto out;
     }
@@ -2116,16 +1876,14 @@
     fseek(file, 0, SEEK_SET);
     json_buf = (char *)loader_stack_alloc(len + 1);
     if (json_buf == NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_get_json: Failed to allocate space for "
-                   "JSON file %s buffer of length %d",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Failed to allocate space for "
+                                                           "JSON file %s buffer of length %d",
                    filename, len);
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     }
     if (fread(json_buf, sizeof(char), len, file) != len) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_get_json: Failed to read JSON file %s.", filename);
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Failed to read JSON file %s.", filename);
         res = VK_ERROR_INITIALIZATION_FAILED;
         goto out;
     }
@@ -2134,10 +1892,9 @@
     // parse text from file
     *json = cJSON_Parse(json_buf);
     if (*json == NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_get_json: Failed to parse JSON file %s, "
-                   "this is usually because something ran out of "
-                   "memory.",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Failed to parse JSON file %s, "
+                                                           "this is usually because something ran out of "
+                                                           "memory.",
                    filename);
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
@@ -2154,86 +1911,62 @@
 /**
  * Do a deep copy of the loader_layer_properties structure.
  */
-VkResult loader_copy_layer_properties(const struct loader_instance *inst,
-                                      struct loader_layer_properties *dst,
+VkResult loader_copy_layer_properties(const struct loader_instance *inst, struct loader_layer_properties *dst,
                                       struct loader_layer_properties *src) {
     uint32_t cnt, i;
     memcpy(dst, src, sizeof(*src));
     dst->instance_extension_list.list = loader_instance_heap_alloc(
-        inst,
-        sizeof(VkExtensionProperties) * src->instance_extension_list.count,
-        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        inst, sizeof(VkExtensionProperties) * src->instance_extension_list.count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (NULL == dst->instance_extension_list.list) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_copy_layer_properties: Failed to allocate space "
-                   "for instance extension list of size %d.",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_copy_layer_properties: Failed to allocate space "
+                                                           "for instance extension list of size %d.",
                    src->instance_extension_list.count);
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
-    dst->instance_extension_list.capacity =
-        sizeof(VkExtensionProperties) * src->instance_extension_list.count;
-    memcpy(dst->instance_extension_list.list, src->instance_extension_list.list,
-           dst->instance_extension_list.capacity);
+    dst->instance_extension_list.capacity = sizeof(VkExtensionProperties) * src->instance_extension_list.count;
+    memcpy(dst->instance_extension_list.list, src->instance_extension_list.list, dst->instance_extension_list.capacity);
     dst->device_extension_list.list = loader_instance_heap_alloc(
-        inst,
-        sizeof(struct loader_dev_ext_props) * src->device_extension_list.count,
-        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        inst, sizeof(struct loader_dev_ext_props) * src->device_extension_list.count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (NULL == dst->device_extension_list.list) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_copy_layer_properties: Failed to allocate space "
-                   "for device extension list of size %d.",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_copy_layer_properties: Failed to allocate space "
+                                                           "for device extension list of size %d.",
                    src->device_extension_list.count);
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
-    memset(dst->device_extension_list.list, 0,
-           sizeof(struct loader_dev_ext_props) *
-               src->device_extension_list.count);
+    memset(dst->device_extension_list.list, 0, sizeof(struct loader_dev_ext_props) * src->device_extension_list.count);
 
-    dst->device_extension_list.capacity =
-        sizeof(struct loader_dev_ext_props) * src->device_extension_list.count;
-    memcpy(dst->device_extension_list.list, src->device_extension_list.list,
-           dst->device_extension_list.capacity);
-    if (src->device_extension_list.count > 0 &&
-        src->device_extension_list.list->entrypoint_count > 0) {
+    dst->device_extension_list.capacity = sizeof(struct loader_dev_ext_props) * src->device_extension_list.count;
+    memcpy(dst->device_extension_list.list, src->device_extension_list.list, dst->device_extension_list.capacity);
+    if (src->device_extension_list.count > 0 && src->device_extension_list.list->entrypoint_count > 0) {
         cnt = src->device_extension_list.list->entrypoint_count;
         dst->device_extension_list.list->entrypoints =
-            loader_instance_heap_alloc(inst, sizeof(char *) * cnt,
-                                       VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+            loader_instance_heap_alloc(inst, sizeof(char *) * cnt, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (NULL == dst->device_extension_list.list->entrypoints) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_copy_layer_properties: Failed to allocate space "
-                       "for device extension entrypoint list of size %d.",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_copy_layer_properties: Failed to allocate space "
+                                                               "for device extension entrypoint list of size %d.",
                        cnt);
             return VK_ERROR_OUT_OF_HOST_MEMORY;
         }
-        memset(dst->device_extension_list.list->entrypoints, 0,
-               sizeof(char *) * cnt);
+        memset(dst->device_extension_list.list->entrypoints, 0, sizeof(char *) * cnt);
 
         for (i = 0; i < cnt; i++) {
-            dst->device_extension_list.list->entrypoints[i] =
-                loader_instance_heap_alloc(
-                    inst,
-                    strlen(src->device_extension_list.list->entrypoints[i]) + 1,
-                    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+            dst->device_extension_list.list->entrypoints[i] = loader_instance_heap_alloc(
+                inst, strlen(src->device_extension_list.list->entrypoints[i]) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
             if (NULL == dst->device_extension_list.list->entrypoints[i]) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_copy_layer_properties: Failed to "
-                           "allocate space for device extension entrypoint "
-                           "%d name of length",
+                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_copy_layer_properties: Failed to "
+                                                                   "allocate space for device extension entrypoint "
+                                                                   "%d name of length",
                            i);
                 return VK_ERROR_OUT_OF_HOST_MEMORY;
             }
-            strcpy(dst->device_extension_list.list->entrypoints[i],
-                   src->device_extension_list.list->entrypoints[i]);
+            strcpy(dst->device_extension_list.list->entrypoints[i], src->device_extension_list.list->entrypoints[i]);
         }
     }
 
     return VK_SUCCESS;
 }
 
-static bool
-loader_find_layer_name_list(const char *name,
-                            const struct loader_layer_list *layer_list) {
+static bool loader_find_layer_name_list(const char *name, const struct loader_layer_list *layer_list) {
     if (!layer_list)
         return false;
     for (uint32_t j = 0; j < layer_list->count; j++)
@@ -2242,8 +1975,7 @@
     return false;
 }
 
-static bool loader_find_layer_name(const char *name, uint32_t layer_count,
-                                   const char **layer_list) {
+static bool loader_find_layer_name(const char *name, uint32_t layer_count, const char **layer_list) {
     if (!layer_list)
         return false;
     for (uint32_t j = 0; j < layer_count; j++)
@@ -2252,9 +1984,7 @@
     return false;
 }
 
-bool loader_find_layer_name_array(
-    const char *name, uint32_t layer_count,
-    const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]) {
+bool loader_find_layer_name_array(const char *name, uint32_t layer_count, const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]) {
     if (!layer_list)
         return false;
     for (uint32_t j = 0; j < layer_count; j++)
@@ -2275,31 +2005,25 @@
  * @param layer_count
  * @param ppp_layer_names
  */
-VkResult loader_expand_layer_names(
-    struct loader_instance *inst, const char *key_name, uint32_t expand_count,
-    const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE],
-    uint32_t *layer_count, char const *const **ppp_layer_names) {
+VkResult loader_expand_layer_names(struct loader_instance *inst, const char *key_name, uint32_t expand_count,
+                                   const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE], uint32_t *layer_count,
+                                   char const *const **ppp_layer_names) {
 
     char const *const *pp_src_layers = *ppp_layer_names;
 
-    if (!loader_find_layer_name(key_name, *layer_count,
-                                (char const **)pp_src_layers)) {
+    if (!loader_find_layer_name(key_name, *layer_count, (char const **)pp_src_layers)) {
         inst->activated_layers_are_std_val = false;
         return VK_SUCCESS; // didn't find the key_name in the list.
     }
 
-    loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-               "Found meta layer %s, replacing with actual layer group",
-               key_name);
+    loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Found meta layer %s, replacing with actual layer group", key_name);
 
     inst->activated_layers_are_std_val = true;
-    char const **pp_dst_layers = loader_instance_heap_alloc(
-        inst, (expand_count + *layer_count - 1) * sizeof(char const *),
-        VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
+    char const **pp_dst_layers = loader_instance_heap_alloc(inst, (expand_count + *layer_count - 1) * sizeof(char const *),
+                                                            VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
     if (NULL == pp_dst_layers) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_expand_layer_names:: Failed to allocate space for "
-                   "std_validation layer names in pp_dst_layers.");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_expand_layer_names:: Failed to allocate space for "
+                                                           "std_validation layer names in pp_dst_layers.");
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
 
@@ -2307,16 +2031,14 @@
     // expand_names.
     uint32_t src_index, dst_index = 0;
     for (src_index = 0; src_index < *layer_count; src_index++) {
-        if (loader_find_layer_name_array(pp_src_layers[src_index], expand_count,
-                                         expand_names)) {
+        if (loader_find_layer_name_array(pp_src_layers[src_index], expand_count, expand_names)) {
             continue;
         }
 
         if (!strcmp(pp_src_layers[src_index], key_name)) {
             // insert all expand_names in place of key_name
             uint32_t expand_index;
-            for (expand_index = 0; expand_index < expand_count;
-                 expand_index++) {
+            for (expand_index = 0; expand_index < expand_count; expand_index++) {
                 pp_dst_layers[dst_index++] = expand_names[expand_index];
             }
             continue;
@@ -2331,8 +2053,7 @@
     return VK_SUCCESS;
 }
 
-void loader_delete_shadow_inst_layer_names(const struct loader_instance *inst,
-                                           const VkInstanceCreateInfo *orig,
+void loader_delete_shadow_inst_layer_names(const struct loader_instance *inst, const VkInstanceCreateInfo *orig,
                                            VkInstanceCreateInfo *ours) {
     /* Free the layer names array iff we had to reallocate it */
     if (orig->ppEnabledLayerNames != ours->ppEnabledLayerNames) {
@@ -2343,11 +2064,9 @@
 void loader_init_std_validation_props(struct loader_layer_properties *props) {
     memset(props, 0, sizeof(struct loader_layer_properties));
     props->type = VK_LAYER_TYPE_META_EXPLICT;
-    strncpy(props->info.description, "LunarG Standard Validation Layer",
-            sizeof(props->info.description));
+    strncpy(props->info.description, "LunarG Standard Validation Layer", sizeof(props->info.description));
     props->info.implementationVersion = 1;
-    strncpy(props->info.layerName, std_validation_str,
-            sizeof(props->info.layerName));
+    strncpy(props->info.layerName, std_validation_str, sizeof(props->info.layerName));
     // TODO what about specVersion? for now insert loader's built version
     props->info.specVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION);
 }
@@ -2362,10 +2081,9 @@
  * @param layer_names  array of required layer names
  * @param layer_instance_list
  */
-static void loader_add_layer_property_meta(
-    const struct loader_instance *inst, uint32_t layer_count,
-    const char layer_names[][VK_MAX_EXTENSION_NAME_SIZE],
-    struct loader_layer_list *layer_instance_list) {
+static void loader_add_layer_property_meta(const struct loader_instance *inst, uint32_t layer_count,
+                                           const char layer_names[][VK_MAX_EXTENSION_NAME_SIZE],
+                                           struct loader_layer_list *layer_instance_list) {
     uint32_t i;
     bool found;
     struct loader_layer_list *layer_list;
@@ -2406,12 +2124,9 @@
     uint16_t patch;
 } layer_json_version;
 
-static void
-loader_read_json_layer(const struct loader_instance *inst,
-                       struct loader_layer_list *layer_instance_list,
-                       cJSON *layer_node, layer_json_version version,
-                       cJSON *item, cJSON *disable_environment,
-                       bool is_implicit, char *filename) {
+static void loader_read_json_layer(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list,
+                                   cJSON *layer_node, layer_json_version version, cJSON *item, cJSON *disable_environment,
+                                   bool is_implicit, char *filename) {
     char *temp;
     char *name, *type, *library_path, *api_version;
     char *implementation_version, *description;
@@ -2429,42 +2144,39 @@
  * (required for implicit layers) “disable_environment”
  */
 
-#define GET_JSON_OBJECT(node, var)                                             \
-    {                                                                          \
-        var = cJSON_GetObjectItem(node, #var);                                 \
-        if (var == NULL) {                                                     \
-            layer_node = layer_node->next;                                     \
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,               \
-                       "Didn't find required layer object %s in manifest "     \
-                       "JSON file, skipping this layer",                       \
-                       #var);                                                  \
-            return;                                                            \
-        }                                                                      \
+#define GET_JSON_OBJECT(node, var)                                                                                                 \
+    {                                                                                                                              \
+        var = cJSON_GetObjectItem(node, #var);                                                                                     \
+        if (var == NULL) {                                                                                                         \
+            layer_node = layer_node->next;                                                                                         \
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Didn't find required layer object %s in manifest "               \
+                                                                 "JSON file, skipping this layer",                                 \
+                       #var);                                                                                                      \
+            return;                                                                                                                \
+        }                                                                                                                          \
     }
-#define GET_JSON_ITEM(node, var)                                               \
-    {                                                                          \
-        item = cJSON_GetObjectItem(node, #var);                                \
-        if (item == NULL) {                                                    \
-            layer_node = layer_node->next;                                     \
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,               \
-                       "Didn't find required layer value %s in manifest JSON " \
-                       "file, skipping this layer",                            \
-                       #var);                                                  \
-            return;                                                            \
-        }                                                                      \
-        temp = cJSON_Print(item);                                              \
-        if (temp == NULL) {                                                    \
-            layer_node = layer_node->next;                                     \
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,               \
-                       "Problem accessing layer value %s in manifest JSON "    \
-                       "file, skipping this layer",                            \
-                       #var);                                                  \
-            return;                                                            \
-        }                                                                      \
-        temp[strlen(temp) - 1] = '\0';                                         \
-        var = loader_stack_alloc(strlen(temp) + 1);                            \
-        strcpy(var, &temp[1]);                                                 \
-        cJSON_Free(temp);                                                      \
+#define GET_JSON_ITEM(node, var)                                                                                                   \
+    {                                                                                                                              \
+        item = cJSON_GetObjectItem(node, #var);                                                                                    \
+        if (item == NULL) {                                                                                                        \
+            layer_node = layer_node->next;                                                                                         \
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Didn't find required layer value %s in manifest JSON "           \
+                                                                 "file, skipping this layer",                                      \
+                       #var);                                                                                                      \
+            return;                                                                                                                \
+        }                                                                                                                          \
+        temp = cJSON_Print(item);                                                                                                  \
+        if (temp == NULL) {                                                                                                        \
+            layer_node = layer_node->next;                                                                                         \
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Problem accessing layer value %s in manifest JSON "              \
+                                                                 "file, skipping this layer",                                      \
+                       #var);                                                                                                      \
+            return;                                                                                                                \
+        }                                                                                                                          \
+        temp[strlen(temp) - 1] = '\0';                                                                                             \
+        var = loader_stack_alloc(strlen(temp) + 1);                                                                                \
+        strcpy(var, &temp[1]);                                                                                                     \
+        cJSON_Free(temp);                                                                                                          \
     }
     GET_JSON_ITEM(layer_node, name)
     GET_JSON_ITEM(layer_node, type)
@@ -2481,8 +2193,7 @@
     // Add list entry
     struct loader_layer_properties *props = NULL;
     if (!strcmp(type, "DEVICE")) {
-        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                   "Device layers are deprecated skipping this layer");
+        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Device layers are deprecated skipping this layer");
         layer_node = layer_node->next;
         return;
     }
@@ -2498,8 +2209,7 @@
             // Error already triggered in loader_get_next_layer_property.
             return;
         }
-        props->type = (is_implicit) ? VK_LAYER_TYPE_INSTANCE_IMPLICIT
-                                    : VK_LAYER_TYPE_INSTANCE_EXPLICIT;
+        props->type = (is_implicit) ? VK_LAYER_TYPE_INSTANCE_IMPLICIT : VK_LAYER_TYPE_INSTANCE_EXPLICIT;
     }
 
     if (props == NULL) {
@@ -2520,32 +2230,23 @@
         loader_expand_path(library_path, rel_base, MAX_STRING_SIZE, fullpath);
     } else {
         // A filename which is assumed in a system directory
-        loader_get_fullpath(library_path, DEFAULT_VK_LAYERS_PATH,
-                            MAX_STRING_SIZE, fullpath);
+        loader_get_fullpath(library_path, DEFAULT_VK_LAYERS_PATH, MAX_STRING_SIZE, fullpath);
     }
     props->info.specVersion = loader_make_version(api_version);
     props->info.implementationVersion = atoi(implementation_version);
-    strncpy((char *)props->info.description, description,
-            sizeof(props->info.description));
+    strncpy((char *)props->info.description, description, sizeof(props->info.description));
     props->info.description[sizeof(props->info.description) - 1] = '\0';
     if (is_implicit) {
         if (!disable_environment || !disable_environment->child) {
-            loader_log(
-                inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                "Didn't find required layer child value disable_environment"
-                "in manifest JSON file, skipping this layer");
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Didn't find required layer child value disable_environment"
+                                                                 "in manifest JSON file, skipping this layer");
             layer_node = layer_node->next;
             return;
         }
-        strncpy(props->disable_env_var.name, disable_environment->child->string,
-                sizeof(props->disable_env_var.name));
-        props->disable_env_var.name[sizeof(props->disable_env_var.name) - 1] =
-            '\0';
-        strncpy(props->disable_env_var.value,
-                disable_environment->child->valuestring,
-                sizeof(props->disable_env_var.value));
-        props->disable_env_var.value[sizeof(props->disable_env_var.value) - 1] =
-            '\0';
+        strncpy(props->disable_env_var.name, disable_environment->child->string, sizeof(props->disable_env_var.name));
+        props->disable_env_var.name[sizeof(props->disable_env_var.name) - 1] = '\0';
+        strncpy(props->disable_env_var.value, disable_environment->child->valuestring, sizeof(props->disable_env_var.value));
+        props->disable_env_var.value[sizeof(props->disable_env_var.value) - 1] = '\0';
     }
 
 /**
@@ -2555,24 +2256,23 @@
 * device_extensions
 * enable_environment (implicit layers only)
 */
-#define GET_JSON_OBJECT(node, var)                                             \
+#define GET_JSON_OBJECT(node, var)                                                                                                 \
     { var = cJSON_GetObjectItem(node, #var); }
-#define GET_JSON_ITEM(node, var)                                               \
-    {                                                                          \
-        item = cJSON_GetObjectItem(node, #var);                                \
-        if (item != NULL) {                                                    \
-            temp = cJSON_Print(item);                                          \
-            if (temp != NULL) {                                                \
-                temp[strlen(temp) - 1] = '\0';                                 \
-                var = loader_stack_alloc(strlen(temp) + 1);                    \
-                strcpy(var, &temp[1]);                                         \
-                cJSON_Free(temp);                                              \
-            }                                                                  \
-        }                                                                      \
+#define GET_JSON_ITEM(node, var)                                                                                                   \
+    {                                                                                                                              \
+        item = cJSON_GetObjectItem(node, #var);                                                                                    \
+        if (item != NULL) {                                                                                                        \
+            temp = cJSON_Print(item);                                                                                              \
+            if (temp != NULL) {                                                                                                    \
+                temp[strlen(temp) - 1] = '\0';                                                                                     \
+                var = loader_stack_alloc(strlen(temp) + 1);                                                                        \
+                strcpy(var, &temp[1]);                                                                                             \
+                cJSON_Free(temp);                                                                                                  \
+            }                                                                                                                      \
+        }                                                                                                                          \
     }
 
-    cJSON *instance_extensions, *device_extensions, *functions,
-        *enable_environment;
+    cJSON *instance_extensions, *device_extensions, *functions, *enable_environment;
     cJSON *entrypoints = NULL;
     char *vkGetInstanceProcAddr = NULL;
     char *vkGetDeviceProcAddr = NULL;
@@ -2591,41 +2291,35 @@
         if (version.major > 1 || version.minor >= 1) {
             GET_JSON_ITEM(functions, vkNegotiateLoaderLayerInterfaceVersion)
             if (vkNegotiateLoaderLayerInterfaceVersion != NULL)
-                strncpy(props->functions.str_negotiate_interface,
-                        vkNegotiateLoaderLayerInterfaceVersion,
+                strncpy(props->functions.str_negotiate_interface, vkNegotiateLoaderLayerInterfaceVersion,
                         sizeof(props->functions.str_negotiate_interface));
-            props->functions.str_negotiate_interface
-                [sizeof(props->functions.str_negotiate_interface) - 1] = '\0';
+            props->functions.str_negotiate_interface[sizeof(props->functions.str_negotiate_interface) - 1] = '\0';
         } else {
             props->functions.str_negotiate_interface[0] = '\0';
         }
         GET_JSON_ITEM(functions, vkGetInstanceProcAddr)
         GET_JSON_ITEM(functions, vkGetDeviceProcAddr)
         if (vkGetInstanceProcAddr != NULL) {
-            strncpy(props->functions.str_gipa, vkGetInstanceProcAddr,
-                    sizeof(props->functions.str_gipa));
+            strncpy(props->functions.str_gipa, vkGetInstanceProcAddr, sizeof(props->functions.str_gipa));
             if (version.major > 1 || version.minor >= 1) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "Indicating layer-specific vkGetInstanceProcAddr "
-                           "function is deprecated starting with JSON file "
-                           "version 1.1.0.  Instead, use the new "
-                           "vkNegotiateLayerInterfaceVersion function to "
-                           "return the GetInstanceProcAddr function for this"
-                           "layer");
+                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Indicating layer-specific vkGetInstanceProcAddr "
+                                                                     "function is deprecated starting with JSON file "
+                                                                     "version 1.1.0.  Instead, use the new "
+                                                                     "vkNegotiateLayerInterfaceVersion function to "
+                                                                     "return the GetInstanceProcAddr function for this"
+                                                                     "layer");
             }
         }
         props->functions.str_gipa[sizeof(props->functions.str_gipa) - 1] = '\0';
         if (vkGetDeviceProcAddr != NULL) {
-            strncpy(props->functions.str_gdpa, vkGetDeviceProcAddr,
-                    sizeof(props->functions.str_gdpa));
+            strncpy(props->functions.str_gdpa, vkGetDeviceProcAddr, sizeof(props->functions.str_gdpa));
             if (version.major > 1 || version.minor >= 1) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "Indicating layer-specific vkGetDeviceProcAddr "
-                           "function is deprecated starting with JSON file "
-                           "version 1.1.0.  Instead, use the new "
-                           "vkNegotiateLayerInterfaceVersion function to "
-                           "return the GetDeviceProcAddr function for this"
-                           "layer");
+                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Indicating layer-specific vkGetDeviceProcAddr "
+                                                                     "function is deprecated starting with JSON file "
+                                                                     "version 1.1.0.  Instead, use the new "
+                                                                     "vkNegotiateLayerInterfaceVersion function to "
+                                                                     "return the GetDeviceProcAddr function for this"
+                                                                     "layer");
             }
         }
         props->functions.str_gdpa[sizeof(props->functions.str_gdpa) - 1] = '\0';
@@ -2643,10 +2337,8 @@
             ext_item = cJSON_GetArrayItem(instance_extensions, i);
             GET_JSON_ITEM(ext_item, name)
             if (name != NULL) {
-                strncpy(ext_prop.extensionName, name,
-                        sizeof(ext_prop.extensionName));
-                ext_prop.extensionName[sizeof(ext_prop.extensionName) - 1] =
-                    '\0';
+                strncpy(ext_prop.extensionName, name, sizeof(ext_prop.extensionName));
+                ext_prop.extensionName[sizeof(ext_prop.extensionName) - 1] = '\0';
             }
             GET_JSON_ITEM(ext_item, spec_version)
             if (NULL != spec_version) {
@@ -2654,11 +2346,9 @@
             } else {
                 ext_prop.specVersion = 0;
             }
-            bool ext_unsupported =
-                wsi_unsupported_instance_extension(&ext_prop);
+            bool ext_unsupported = wsi_unsupported_instance_extension(&ext_prop);
             if (!ext_unsupported) {
-                loader_add_to_ext_list(inst, &props->instance_extension_list, 1,
-                                       &ext_prop);
+                loader_add_to_ext_list(inst, &props->instance_extension_list, 1, &ext_prop);
             }
         }
     }
@@ -2677,10 +2367,8 @@
             GET_JSON_ITEM(ext_item, name)
             GET_JSON_ITEM(ext_item, spec_version)
             if (name != NULL) {
-                strncpy(ext_prop.extensionName, name,
-                        sizeof(ext_prop.extensionName));
-                ext_prop.extensionName[sizeof(ext_prop.extensionName) - 1] =
-                    '\0';
+                strncpy(ext_prop.extensionName, name, sizeof(ext_prop.extensionName));
+                ext_prop.extensionName[sizeof(ext_prop.extensionName) - 1] = '\0';
             }
             if (NULL != spec_version) {
                 ext_prop.specVersion = atoi(spec_version);
@@ -2691,14 +2379,12 @@
             GET_JSON_OBJECT(ext_item, entrypoints)
             int entry_count;
             if (entrypoints == NULL) {
-                loader_add_to_dev_ext_list(inst, &props->device_extension_list,
-                                           &ext_prop, 0, NULL);
+                loader_add_to_dev_ext_list(inst, &props->device_extension_list, &ext_prop, 0, NULL);
                 continue;
             }
             entry_count = cJSON_GetArraySize(entrypoints);
             if (entry_count) {
-                entry_array =
-                    (char **)loader_stack_alloc(sizeof(char *) * entry_count);
+                entry_array = (char **)loader_stack_alloc(sizeof(char *) * entry_count);
             }
             for (j = 0; j < entry_count; j++) {
                 ext_item = cJSON_GetArrayItem(entrypoints, j);
@@ -2714,8 +2400,7 @@
                     cJSON_Free(temp);
                 }
             }
-            loader_add_to_dev_ext_list(inst, &props->device_extension_list,
-                                       &ext_prop, entry_count, entry_array);
+            loader_add_to_dev_ext_list(inst, &props->device_extension_list, &ext_prop, entry_count, entry_array);
         }
     }
     if (is_implicit) {
@@ -2723,16 +2408,10 @@
 
         // enable_environment is optional
         if (enable_environment) {
-            strncpy(props->enable_env_var.name,
-                    enable_environment->child->string,
-                    sizeof(props->enable_env_var.name));
-            props->enable_env_var.name[sizeof(props->enable_env_var.name) - 1] =
-                '\0';
-            strncpy(props->enable_env_var.value,
-                    enable_environment->child->valuestring,
-                    sizeof(props->enable_env_var.value));
-            props->enable_env_var
-                .value[sizeof(props->enable_env_var.value) - 1] = '\0';
+            strncpy(props->enable_env_var.name, enable_environment->child->string, sizeof(props->enable_env_var.name));
+            props->enable_env_var.name[sizeof(props->enable_env_var.name) - 1] = '\0';
+            strncpy(props->enable_env_var.value, enable_environment->child->valuestring, sizeof(props->enable_env_var.value));
+            props->enable_env_var.value[sizeof(props->enable_env_var.value) - 1] = '\0';
         }
     }
 #undef GET_JSON_ITEM
@@ -2767,10 +2446,8 @@
  * If the json input object does not have all the required fields no entry
  * is added to the list.
  */
-static void
-loader_add_layer_properties(const struct loader_instance *inst,
-                            struct loader_layer_list *layer_instance_list,
-                            cJSON *json, bool is_implicit, char *filename) {
+static void loader_add_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list,
+                                        cJSON *json, bool is_implicit, char *filename) {
     // The following Fields in layer manifest file that are required:
     //   - “file_format_version”
     //   - If more than one "layer" object are used, then the "layers" array is
@@ -2788,8 +2465,7 @@
     if (NULL == file_vers) {
         return;
     }
-    loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-               "Found manifest file %s, version %s", filename, file_vers);
+    loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Found manifest file %s, version %s", filename, file_vers);
     // Get the major/minor/and patch as integers for easier comparison
     vers_tok = strtok(file_vers, ".\"\n\r");
     if (NULL != vers_tok) {
@@ -2805,11 +2481,9 @@
     }
 
     if (!is_valid_layer_json_version(&json_version)) {
-        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                   "loader_add_layer_properties: %s invalid layer "
-                   " manifest file version %d.%d.%d.  May cause errors.",
-                   filename, json_version.major, json_version.minor,
-                   json_version.patch);
+        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_add_layer_properties: %s invalid layer "
+                                                             " manifest file version %d.%d.%d.  May cause errors.",
+                   filename, json_version.major, json_version.minor, json_version.patch);
     }
     cJSON_Free(file_vers);
 
@@ -2818,33 +2492,29 @@
     if (layers_node != NULL) {
         int numItems = cJSON_GetArraySize(layers_node);
         if (!layer_json_supports_layers_tag(&json_version)) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_add_layer_properties: \'layers\' tag not "
-                       "supported until file version 1.0.1, but %s is "
-                       "reporting version %s",
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_add_layer_properties: \'layers\' tag not "
+                                                                 "supported until file version 1.0.1, but %s is "
+                                                                 "reporting version %s",
                        filename, file_vers);
         }
         for (int curLayer = 0; curLayer < numItems; curLayer++) {
             layer_node = cJSON_GetArrayItem(layers_node, curLayer);
             if (layer_node == NULL) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "loader_add_layer_properties: Can not find "
-                           "\'layers\' array element %d object in manifest "
-                           "JSON file %s.  Skipping this file",
+                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_add_layer_properties: Can not find "
+                                                                     "\'layers\' array element %d object in manifest "
+                                                                     "JSON file %s.  Skipping this file",
                            curLayer, filename);
                 return;
             }
-            loader_read_json_layer(inst, layer_instance_list, layer_node,
-                                   json_version, item, disable_environment,
-                                   is_implicit, filename);
+            loader_read_json_layer(inst, layer_instance_list, layer_node, json_version, item, disable_environment, is_implicit,
+                                   filename);
         }
     } else {
         // Otherwise, try to read in individual layers
         layer_node = cJSON_GetObjectItem(json, "layer");
         if (layer_node == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_add_layer_properties: Can not find \'layer\' "
-                       "object in manifest JSON file %s.  Skipping this file.",
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_add_layer_properties: Can not find \'layer\' "
+                                                                 "object in manifest JSON file %s.  Skipping this file.",
                        filename);
             return;
         }
@@ -2861,16 +2531,14 @@
         // versions newer than 1.0.0.  Having multiple objects with the same
         // name at the same level is actually a JSON standard violation.
         if (layer_count > 1 && layer_json_supports_layers_tag(&json_version)) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_layer_properties: Multiple \'layer\' nodes"
-                       " are deprecated starting in file version \"1.0.1\".  "
-                       "Please use \'layers\' : [] array instead in %s.",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_layer_properties: Multiple \'layer\' nodes"
+                                                               " are deprecated starting in file version \"1.0.1\".  "
+                                                               "Please use \'layers\' : [] array instead in %s.",
                        filename);
         } else {
             do {
-                loader_read_json_layer(inst, layer_instance_list, layer_node,
-                                       json_version, item, disable_environment,
-                                       is_implicit, filename);
+                loader_read_json_layer(inst, layer_instance_list, layer_node, json_version, item, disable_environment, is_implicit,
+                                       filename);
                 layer_node = layer_node->next;
             } while (layer_node != NULL);
         }
@@ -2905,12 +2573,9 @@
  * Linux ICD  | dirs     | files
  * Linux Layer| dirs     | dirs
  */
-static VkResult
-loader_get_manifest_files(const struct loader_instance *inst,
-                          const char *env_override, const char *source_override,
-                          bool is_layer, bool warn_if_not_present,
-                          const char *location, const char *home_location,
-                          struct loader_manifest_files *out_files) {
+static VkResult loader_get_manifest_files(const struct loader_instance *inst, const char *env_override, const char *source_override,
+                                          bool is_layer, bool warn_if_not_present, const char *location, const char *home_location,
+                                          struct loader_manifest_files *out_files) {
     const char * override = NULL;
     char *override_getenv = NULL;
     char *loc, *orig_loc = NULL;
@@ -2946,9 +2611,8 @@
     home_location = NULL;
     if (location == NULL) {
 #endif
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_get_manifest_files: Can not get manifest files with "
-                   "NULL location, env_override=%s",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_manifest_files: Can not get manifest files with "
+                                                           "NULL location, env_override=%s",
                    (env_override != NULL) ? env_override : "");
         res = VK_ERROR_INITIALIZATION_FAILED;
         goto out;
@@ -2964,9 +2628,8 @@
     if (override == NULL) {
         loc = loader_stack_alloc(strlen(location) + 1);
         if (loc == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_get_manifest_files: Failed to allocate "
-                       "%d bytes for manifest file location.",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_manifest_files: Failed to allocate "
+                                                               "%d bytes for manifest file location.",
                        strlen(location));
             res = VK_ERROR_OUT_OF_HOST_MEMORY;
             goto out;
@@ -2976,12 +2639,10 @@
         VkResult reg_result = loaderGetRegistryFiles(inst, loc, &reg);
         if (VK_SUCCESS != reg_result || NULL == reg) {
             if (!is_layer) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_get_manifest_files: Registry lookup failed "
-                           "to get ICD manifest files.  Possibly missing Vulkan"
-                           " driver?");
-                if (VK_SUCCESS == reg_result ||
-                    VK_ERROR_OUT_OF_HOST_MEMORY == reg_result) {
+                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_manifest_files: Registry lookup failed "
+                                                                   "to get ICD manifest files.  Possibly missing Vulkan"
+                                                                   " driver?");
+                if (VK_SUCCESS == reg_result || VK_ERROR_OUT_OF_HOST_MEMORY == reg_result) {
                     res = reg_result;
                 } else {
                     res = VK_ERROR_INCOMPATIBLE_DRIVER;
@@ -2989,10 +2650,8 @@
             } else {
                 if (warn_if_not_present) {
                     // This is only a warning for layers
-                    loader_log(
-                        inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                        "loader_get_manifest_files: Registry lookup failed "
-                        "to get layer manifest files.");
+                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_get_manifest_files: Registry lookup failed "
+                                                                         "to get layer manifest files.");
                 }
                 if (reg_result == VK_ERROR_OUT_OF_HOST_MEMORY) {
                     res = reg_result;
@@ -3009,11 +2668,9 @@
     } else {
         loc = loader_stack_alloc(strlen(override) + 1);
         if (loc == NULL) {
-            loader_log(
-                inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "loader_get_manifest_files: Failed to allocate space for "
-                "override environment variable of length %d",
-                strlen(override) + 1);
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_manifest_files: Failed to allocate space for "
+                                                               "override environment variable of length %d",
+                       strlen(override) + 1);
             res = VK_ERROR_OUT_OF_HOST_MEMORY;
             goto out;
         }
@@ -3021,8 +2678,7 @@
     }
 
     // Print out the paths being searched if debugging is enabled
-    loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-               "Searching the following paths for manifest files: %s\n", loc);
+    loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching the following paths for manifest files: %s\n", loc);
 
     file = loc;
     while (*file) {
@@ -3047,9 +2703,8 @@
             // make a copy of location so it isn't modified
             dir = loader_stack_alloc(strlen(loc) + 1);
             if (dir == NULL) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_get_manifest_files: Failed to allocate "
-                           "space for relative location path length %d",
+                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_manifest_files: Failed to allocate "
+                                                                   "space for relative location path length %d",
                            strlen(loc) + 1);
                 goto out;
             }
@@ -3066,32 +2721,25 @@
             const char *suf = name + nlen - 5;
             if ((nlen > 5) && !strncmp(suf, ".json", 5)) {
                 if (out_files->count == 0) {
-                    out_files->filename_list = loader_instance_heap_alloc(
-                        inst, alloced_count * sizeof(char *),
-                        VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
+                    out_files->filename_list =
+                        loader_instance_heap_alloc(inst, alloced_count * sizeof(char *), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
                 } else if (out_files->count == alloced_count) {
-                    out_files->filename_list = loader_instance_heap_realloc(
-                        inst, out_files->filename_list,
-                        alloced_count * sizeof(char *),
-                        alloced_count * sizeof(char *) * 2,
-                        VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
+                    out_files->filename_list =
+                        loader_instance_heap_realloc(inst, out_files->filename_list, alloced_count * sizeof(char *),
+                                                     alloced_count * sizeof(char *) * 2, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
                     alloced_count *= 2;
                 }
                 if (out_files->filename_list == NULL) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "loader_get_manifest_files: Failed to allocate "
-                               "space for manifest file name list");
+                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_manifest_files: Failed to allocate "
+                                                                       "space for manifest file name list");
                     res = VK_ERROR_OUT_OF_HOST_MEMORY;
                     goto out;
                 }
                 out_files->filename_list[out_files->count] =
-                    loader_instance_heap_alloc(
-                        inst, strlen(name) + 1,
-                        VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
+                    loader_instance_heap_alloc(inst, strlen(name) + 1, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
                 if (out_files->filename_list[out_files->count] == NULL) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "loader_get_manifest_files: Failed to allocate "
-                               "space for manifest file %d list",
+                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_manifest_files: Failed to allocate "
+                                                                       "space for manifest file %d list",
                                out_files->count);
                     res = VK_ERROR_OUT_OF_HOST_MEMORY;
                     goto out;
@@ -3099,10 +2747,8 @@
                 strcpy(out_files->filename_list[out_files->count], name);
                 out_files->count++;
             } else if (!list_is_dirs) {
-                loader_log(
-                    inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                    "Skipping manifest file %s, file name must end in .json",
-                    name);
+                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Skipping manifest file %s, file name must end in .json",
+                           name);
             }
             if (list_is_dirs) {
                 dent = readdir(sysdir);
@@ -3122,18 +2768,15 @@
         }
         file = next_file;
 #if !defined(_WIN32)
-        if (home_location != NULL &&
-            (next_file == NULL || *next_file == '\0') && override == NULL) {
+        if (home_location != NULL && (next_file == NULL || *next_file == '\0') && override == NULL) {
             char *xdgdatahome = secure_getenv("XDG_DATA_HOME");
             size_t len;
             if (xdgdatahome != NULL) {
 
-                char *home_loc = loader_stack_alloc(strlen(xdgdatahome) + 2 +
-                                                    strlen(home_location));
+                char *home_loc = loader_stack_alloc(strlen(xdgdatahome) + 2 + strlen(home_location));
                 if (home_loc == NULL) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "loader_get_manifest_files: Failed to allocate "
-                               "space for manifest file XDG Home location");
+                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_manifest_files: Failed to allocate "
+                                                                       "space for manifest file XDG Home location");
                     res = VK_ERROR_OUT_OF_HOST_MEMORY;
                     goto out;
                 }
@@ -3149,23 +2792,18 @@
                 next_file = loader_get_next_path(file);
                 home_location = NULL;
 
-                loader_log(
-                    inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                    "Searching the following path for manifest files: %s\n",
-                    home_loc);
+                loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching the following path for manifest files: %s\n",
+                           home_loc);
                 list_is_dirs = true;
 
             } else {
 
                 char *home = secure_getenv("HOME");
                 if (home != NULL) {
-                    char *home_loc = loader_stack_alloc(strlen(home) + 16 +
-                                                        strlen(home_location));
+                    char *home_loc = loader_stack_alloc(strlen(home) + 16 + strlen(home_location));
                     if (home_loc == NULL) {
-                        loader_log(
-                            inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                            "loader_get_manifest_files: Failed to allocate "
-                            "space for manifest file Home location");
+                        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_manifest_files: Failed to allocate "
+                                                                           "space for manifest file Home location");
                         res = VK_ERROR_OUT_OF_HOST_MEMORY;
                         goto out;
                     }
@@ -3188,10 +2826,8 @@
                     next_file = loader_get_next_path(file);
                     home_location = NULL;
 
-                    loader_log(
-                        inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                        "Searching the following path for manifest files: %s\n",
-                        home_loc);
+                    loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching the following path for manifest files: %s\n",
+                               home_loc);
                     list_is_dirs = true;
                 } else {
                     // without knowing HOME, we just.. give up
@@ -3240,8 +2876,7 @@
  * Vulkan result
  * (on result == VK_SUCCESS) a list of icds that were discovered
  */
-VkResult loader_icd_scan(const struct loader_instance *inst,
-                         struct loader_icd_tramp_list *icd_tramp_list) {
+VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) {
     char *file_str;
     uint16_t file_major_vers = 0;
     uint16_t file_minor_vers = 0;
@@ -3261,9 +2896,8 @@
     }
 
     // Get a list of manifest files for ICDs
-    res = loader_get_manifest_files(inst, "VK_ICD_FILENAMES", NULL, false, true,
-                                    DEFAULT_VK_DRIVERS_INFO,
-                                    HOME_VK_DRIVERS_INFO, &manifest_files);
+    res = loader_get_manifest_files(inst, "VK_ICD_FILENAMES", NULL, false, true, DEFAULT_VK_DRIVERS_INFO, HOME_VK_DRIVERS_INFO,
+                                    &manifest_files);
     if (VK_SUCCESS != res || manifest_files.count == 0) {
         goto out;
     }
@@ -3288,9 +2922,8 @@
             if (num_good_icds == 0) {
                 res = VK_ERROR_INITIALIZATION_FAILED;
             }
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_icd_scan: ICD JSON %s does not have a"
-                       " \'file_format_version\' field. Skipping ICD JSON.",
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_icd_scan: ICD JSON %s does not have a"
+                                                                 " \'file_format_version\' field. Skipping ICD JSON.",
                        file_str);
             cJSON_Delete(json);
             json = NULL;
@@ -3303,17 +2936,14 @@
             if (num_good_icds == 0) {
                 res = VK_ERROR_OUT_OF_HOST_MEMORY;
             }
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_icd_scan: Failed retrieving ICD JSON %s"
-                       " \'file_format_version\' field.  Skipping ICD JSON",
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_icd_scan: Failed retrieving ICD JSON %s"
+                                                                 " \'file_format_version\' field.  Skipping ICD JSON",
                        file_str);
             cJSON_Delete(json);
             json = NULL;
             continue;
         }
-        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "Found ICD manifest file %s, version %s", file_str,
-                   file_vers);
+        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Found ICD manifest file %s, version %s", file_str, file_vers);
         // Get the major/minor/and patch as integers for easier comparison
         vers_tok = strtok(file_vers, ".\"\n\r");
         if (NULL != vers_tok) {
@@ -3328,9 +2958,8 @@
             }
         }
         if (file_major_vers != 1 || file_minor_vers != 0 || file_patch_vers > 1)
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_icd_scan: Unexpected manifest file version "
-                       "(expected 1.0.0 or 1.0.1), may cause errors");
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_icd_scan: Unexpected manifest file version "
+                                                                 "(expected 1.0.0 or 1.0.1), may cause errors");
         cJSON_Free(file_vers);
         itemICD = cJSON_GetObjectItem(json, "ICD");
         if (itemICD != NULL) {
@@ -3341,9 +2970,8 @@
                     if (num_good_icds == 0) {
                         res = VK_ERROR_OUT_OF_HOST_MEMORY;
                     }
-                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "loader_icd_scan: Failed retrieving ICD JSON %s"
-                               " \'library_path\' field.  Skipping ICD JSON.",
+                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_icd_scan: Failed retrieving ICD JSON %s"
+                                                                         " \'library_path\' field.  Skipping ICD JSON.",
                                file_str);
                     cJSON_Free(temp);
                     cJSON_Delete(json);
@@ -3354,10 +2982,9 @@
                 temp[strlen(temp) - 1] = '\0';
                 char *library_path = loader_stack_alloc(strlen(temp) + 1);
                 if (NULL == library_path) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "loader_icd_scan: Failed to allocate space for "
-                               "ICD JSON %s \'library_path\' value.  Skipping "
-                               "ICD JSON.",
+                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_icd_scan: Failed to allocate space for "
+                                                                       "ICD JSON %s \'library_path\' value.  Skipping "
+                                                                       "ICD JSON.",
                                file_str);
                     res = VK_ERROR_OUT_OF_HOST_MEMORY;
                     cJSON_Free(temp);
@@ -3368,9 +2995,8 @@
                 strcpy(library_path, &temp[1]);
                 cJSON_Free(temp);
                 if (strlen(library_path) == 0) {
-                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "loader_icd_scan: ICD JSON %s \'library_path\'"
-                               " field is empty.  Skipping ICD JSON.",
+                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_icd_scan: ICD JSON %s \'library_path\'"
+                                                                         " field is empty.  Skipping ICD JSON.",
                                file_str);
                     cJSON_Delete(json);
                     json = NULL;
@@ -3378,22 +3004,18 @@
                 }
                 char fullpath[MAX_STRING_SIZE];
                 // Print out the paths being searched if debugging is enabled
-                loader_log(
-                    inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                    "Searching for ICD drivers named %s, using default dir %s",
-                    library_path, DEFAULT_VK_DRIVERS_PATH);
+                loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching for ICD drivers named %s, using default dir %s",
+                           library_path, DEFAULT_VK_DRIVERS_PATH);
                 if (loader_platform_is_path(library_path)) {
                     // a relative or absolute path
                     char *name_copy = loader_stack_alloc(strlen(file_str) + 1);
                     char *rel_base;
                     strcpy(name_copy, file_str);
                     rel_base = loader_platform_dirname(name_copy);
-                    loader_expand_path(library_path, rel_base, sizeof(fullpath),
-                                       fullpath);
+                    loader_expand_path(library_path, rel_base, sizeof(fullpath), fullpath);
                 } else {
                     // a filename which is assumed in a system directory
-                    loader_get_fullpath(library_path, DEFAULT_VK_DRIVERS_PATH,
-                                        sizeof(fullpath), fullpath);
+                    loader_get_fullpath(library_path, DEFAULT_VK_DRIVERS_PATH, sizeof(fullpath), fullpath);
                 }
 
                 uint32_t vers = 0;
@@ -3401,11 +3023,9 @@
                 if (item != NULL) {
                     temp = cJSON_Print(item);
                     if (NULL == temp) {
-                        loader_log(
-                            inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                            "loader_icd_scan: Failed retrieving ICD JSON %s"
-                            " \'api_version\' field.  Skipping ICD JSON.",
-                            file_str);
+                        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_icd_scan: Failed retrieving ICD JSON %s"
+                                                                             " \'api_version\' field.  Skipping ICD JSON.",
+                                   file_str);
 
                         // Only reason the print can fail is if there was an
                         // allocation issue
@@ -3421,34 +3041,28 @@
                     vers = loader_make_version(temp);
                     cJSON_Free(temp);
                 } else {
-                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "loader_icd_scan: ICD JSON %s does not have an"
-                               " \'api_version\' field.",
+                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_icd_scan: ICD JSON %s does not have an"
+                                                                         " \'api_version\' field.",
                                file_str);
                 }
 
-                res = loader_scanned_icd_add(inst, icd_tramp_list, fullpath,
-                                             vers);
+                res = loader_scanned_icd_add(inst, icd_tramp_list, fullpath, vers);
                 if (VK_SUCCESS != res) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "loader_icd_scan: Failed to add ICD JSON %s. "
-                               " Skipping ICD JSON.",
+                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_icd_scan: Failed to add ICD JSON %s. "
+                                                                       " Skipping ICD JSON.",
                                fullpath);
                     continue;
                 }
                 num_good_icds++;
             } else {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "loader_icd_scan: Failed to find \'library_path\' "
-                           "object in ICD JSON file %s.  Skipping ICD JSON.",
+                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_icd_scan: Failed to find \'library_path\' "
+                                                                     "object in ICD JSON file %s.  Skipping ICD JSON.",
                            file_str);
             }
         } else {
-            loader_log(
-                inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                "loader_icd_scan: Can not find \'ICD\' object in ICD JSON "
-                "file %s.  Skipping ICD JSON",
-                file_str);
+            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_icd_scan: Can not find \'ICD\' object in ICD JSON "
+                                                                 "file %s.  Skipping ICD JSON",
+                       file_str);
         }
 
         cJSON_Delete(json);
@@ -3463,8 +3077,7 @@
     if (NULL != manifest_files.filename_list) {
         for (uint32_t i = 0; i < manifest_files.count; i++) {
             if (NULL != manifest_files.filename_list[i]) {
-                loader_instance_heap_free(inst,
-                                          manifest_files.filename_list[i]);
+                loader_instance_heap_free(inst, manifest_files.filename_list[i]);
             }
         }
         loader_instance_heap_free(inst, manifest_files.filename_list);
@@ -3475,11 +3088,9 @@
     return res;
 }
 
-void loader_layer_scan(const struct loader_instance *inst,
-                       struct loader_layer_list *instance_layers) {
+void loader_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers) {
     char *file_str;
-    struct loader_manifest_files
-        manifest_files[2]; // [0] = explicit, [1] = implicit
+    struct loader_manifest_files manifest_files[2]; // [0] = explicit, [1] = implicit
     cJSON *json;
     uint32_t implicit;
     bool lockedMutex = false;
@@ -3487,19 +3098,15 @@
     memset(manifest_files, 0, sizeof(struct loader_manifest_files) * 2);
 
     // Get a list of manifest files for explicit layers
-    if (VK_SUCCESS !=
-        loader_get_manifest_files(inst, LAYERS_PATH_ENV, LAYERS_SOURCE_PATH,
-                                  true, true, DEFAULT_VK_ELAYERS_INFO,
-                                  HOME_VK_ELAYERS_INFO, &manifest_files[0])) {
+    if (VK_SUCCESS != loader_get_manifest_files(inst, LAYERS_PATH_ENV, LAYERS_SOURCE_PATH, true, true, DEFAULT_VK_ELAYERS_INFO,
+                                                HOME_VK_ELAYERS_INFO, &manifest_files[0])) {
         goto out;
     }
 
     // Get a list of manifest files for any implicit layers
     // Pass NULL for environment variable override - implicit layers are not
     // overridden by LAYERS_PATH_ENV
-    if (VK_SUCCESS != loader_get_manifest_files(inst, NULL, NULL, true, false,
-                                                DEFAULT_VK_ILAYERS_INFO,
-                                                HOME_VK_ILAYERS_INFO,
+    if (VK_SUCCESS != loader_get_manifest_files(inst, NULL, NULL, true, false, DEFAULT_VK_ILAYERS_INFO, HOME_VK_ILAYERS_INFO,
                                                 &manifest_files[1])) {
         goto out;
     }
@@ -3528,16 +3135,14 @@
                 continue;
             }
 
-            loader_add_layer_properties(inst, instance_layers, json,
-                                        (implicit == 1), file_str);
+            loader_add_layer_properties(inst, instance_layers, json, (implicit == 1), file_str);
             cJSON_Delete(json);
         }
     }
 
     // add a meta layer for validation if the validation layers are all present
-    loader_add_layer_property_meta(inst, sizeof(std_validation_names) /
-                                             sizeof(std_validation_names[0]),
-                                   std_validation_names, instance_layers);
+    loader_add_layer_property_meta(inst, sizeof(std_validation_names) / sizeof(std_validation_names[0]), std_validation_names,
+                                   instance_layers);
 
 out:
 
@@ -3545,12 +3150,10 @@
         if (NULL != manifest_files[manFile].filename_list) {
             for (uint32_t i = 0; i < manifest_files[manFile].count; i++) {
                 if (NULL != manifest_files[manFile].filename_list[i]) {
-                    loader_instance_heap_free(
-                        inst, manifest_files[manFile].filename_list[i]);
+                    loader_instance_heap_free(inst, manifest_files[manFile].filename_list[i]);
                 }
             }
-            loader_instance_heap_free(inst,
-                                      manifest_files[manFile].filename_list);
+            loader_instance_heap_free(inst, manifest_files[manFile].filename_list);
         }
     }
     if (lockedMutex) {
@@ -3558,8 +3161,7 @@
     }
 }
 
-void loader_implicit_layer_scan(const struct loader_instance *inst,
-                                struct loader_layer_list *instance_layers) {
+void loader_implicit_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers) {
     char *file_str;
     struct loader_manifest_files manifest_files;
     cJSON *json;
@@ -3567,9 +3169,8 @@
 
     // Pass NULL for environment variable override - implicit layers are not
     // overridden by LAYERS_PATH_ENV
-    VkResult res = loader_get_manifest_files(
-        inst, NULL, NULL, true, false, DEFAULT_VK_ILAYERS_INFO,
-        HOME_VK_ILAYERS_INFO, &manifest_files);
+    VkResult res =
+        loader_get_manifest_files(inst, NULL, NULL, true, false, DEFAULT_VK_ILAYERS_INFO, HOME_VK_ILAYERS_INFO, &manifest_files);
     if (VK_SUCCESS != res || manifest_files.count == 0) {
         return;
     }
@@ -3593,8 +3194,7 @@
             continue;
         }
 
-        loader_add_layer_properties(inst, instance_layers, json, true,
-                                    file_str);
+        loader_add_layer_properties(inst, instance_layers, json, true, file_str);
 
         loader_instance_heap_free(inst, file_str);
         cJSON_Delete(json);
@@ -3602,29 +3202,25 @@
     loader_instance_heap_free(inst, manifest_files.filename_list);
 
     // add a meta layer for validation if the validation layers are all present
-    loader_add_layer_property_meta(inst, sizeof(std_validation_names) /
-                                             sizeof(std_validation_names[0]),
-                                   std_validation_names, instance_layers);
+    loader_add_layer_property_meta(inst, sizeof(std_validation_names) / sizeof(std_validation_names[0]), std_validation_names,
+                                   instance_layers);
 
     loader_platform_thread_unlock_mutex(&loader_json_lock);
 }
 
-static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
-loader_gpdpa_instance_internal(VkInstance inst, const char *pName) {
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpdpa_instance_internal(VkInstance inst, const char *pName) {
     // inst is not wrapped
     if (inst == VK_NULL_HANDLE) {
         return NULL;
     }
-    VkLayerInstanceDispatchTable *disp_table =
-        *(VkLayerInstanceDispatchTable **)inst;
+    VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst;
     void *addr;
 
     if (disp_table == NULL)
         return NULL;
 
     bool found_name;
-    addr =
-        loader_lookup_instance_dispatch_table(disp_table, pName, &found_name);
+    addr = loader_lookup_instance_dispatch_table(disp_table, pName, &found_name);
     if (found_name) {
         return addr;
     }
@@ -3633,47 +3229,39 @@
         return addr;
 
     // Don't call down the chain, this would be an infinite loop
-    loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-               "loader_gpdpa_instance_internal() unrecognized name %s", pName);
+    loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_gpdpa_instance_internal() unrecognized name %s", pName);
     return NULL;
 }
 
-static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
-loader_gpdpa_instance_terminator(VkInstance inst, const char *pName) {
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpdpa_instance_terminator(VkInstance inst, const char *pName) {
     // inst is not wrapped
     if (inst == VK_NULL_HANDLE) {
         return NULL;
     }
-    VkLayerInstanceDispatchTable *disp_table =
-        *(VkLayerInstanceDispatchTable **)inst;
+    VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst;
     void *addr;
 
     if (disp_table == NULL)
         return NULL;
 
     bool found_name;
-    addr =
-        loader_lookup_instance_dispatch_table(disp_table, pName, &found_name);
+    addr = loader_lookup_instance_dispatch_table(disp_table, pName, &found_name);
     if (found_name) {
         return addr;
     }
 
     // Get the terminator, but don't perform checking since it should already
     // have been setup if we get here.
-    if (loader_phys_dev_ext_gpa(loader_get_instance(inst), pName, false, NULL,
-                                &addr)) {
+    if (loader_phys_dev_ext_gpa(loader_get_instance(inst), pName, false, NULL, &addr)) {
         return addr;
     }
 
     // Don't call down the chain, this would be an infinite loop
-    loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-               "loader_gpdpa_instance_terminator() unrecognized name %s",
-               pName);
+    loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_gpdpa_instance_terminator() unrecognized name %s", pName);
     return NULL;
 }
 
-static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
-loader_gpa_instance_internal(VkInstance inst, const char *pName) {
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpa_instance_internal(VkInstance inst, const char *pName) {
     if (!strcmp(pName, "vkGetInstanceProcAddr")) {
         return (PFN_vkVoidFunction)loader_gpa_instance_internal;
     }
@@ -3691,31 +3279,26 @@
     if (inst == VK_NULL_HANDLE) {
         return NULL;
     }
-    VkLayerInstanceDispatchTable *disp_table =
-        *(VkLayerInstanceDispatchTable **)inst;
+    VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst;
     void *addr;
 
     if (disp_table == NULL)
         return NULL;
 
     bool found_name;
-    addr =
-        loader_lookup_instance_dispatch_table(disp_table, pName, &found_name);
+    addr = loader_lookup_instance_dispatch_table(disp_table, pName, &found_name);
     if (found_name) {
         return addr;
     }
 
     // Don't call down the chain, this would be an infinite loop
-    loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-               "loader_gpa_instance_internal() unrecognized name %s", pName);
+    loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_gpa_instance_internal() unrecognized name %s", pName);
     return NULL;
 }
 
-VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
-loader_gpa_device_internal(VkDevice device, const char *pName) {
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpa_device_internal(VkDevice device, const char *pName) {
     struct loader_device *dev;
-    struct loader_icd_term *icd_term =
-        loader_get_icd_and_device(device, &dev, NULL);
+    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, NULL);
 
     // NOTE: Device Funcs needing Trampoline/Terminator.
     // Overrides for device functions needing a trampoline and
@@ -3749,30 +3332,22 @@
  * GDPA.
  * If GDPA returns NULL then don't initialize the dispatch table entry.
  */
-static void loader_init_dispatch_dev_ext_entry(struct loader_instance *inst,
-                                               struct loader_device *dev,
-                                               uint32_t idx,
+static void loader_init_dispatch_dev_ext_entry(struct loader_instance *inst, struct loader_device *dev, uint32_t idx,
                                                const char *funcName)
 
 {
     void *gdpa_value;
     if (dev != NULL) {
-        gdpa_value = dev->loader_dispatch.core_dispatch.GetDeviceProcAddr(
-            dev->chain_device, funcName);
+        gdpa_value = dev->loader_dispatch.core_dispatch.GetDeviceProcAddr(dev->chain_device, funcName);
         if (gdpa_value != NULL)
-            dev->loader_dispatch.ext_dispatch.dev_ext[idx] =
-                (PFN_vkDevExt)gdpa_value;
+            dev->loader_dispatch.ext_dispatch.dev_ext[idx] = (PFN_vkDevExt)gdpa_value;
     } else {
-        for (struct loader_icd_term *icd_term = inst->icd_terms;
-             icd_term != NULL; icd_term = icd_term->next) {
+        for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL; icd_term = icd_term->next) {
             struct loader_device *ldev = icd_term->logical_device_list;
             while (ldev) {
-                gdpa_value =
-                    ldev->loader_dispatch.core_dispatch.GetDeviceProcAddr(
-                        ldev->chain_device, funcName);
+                gdpa_value = ldev->loader_dispatch.core_dispatch.GetDeviceProcAddr(ldev->chain_device, funcName);
                 if (gdpa_value != NULL)
-                    ldev->loader_dispatch.ext_dispatch.dev_ext[idx] =
-                        (PFN_vkDevExt)gdpa_value;
+                    ldev->loader_dispatch.ext_dispatch.dev_ext[idx] = (PFN_vkDevExt)gdpa_value;
                 ldev = ldev->next;
             }
         }
@@ -3784,22 +3359,18 @@
  * for dev  for each of those extension entrypoints found in hash table.
 
  */
-void loader_init_dispatch_dev_ext(struct loader_instance *inst,
-                                  struct loader_device *dev) {
+void loader_init_dispatch_dev_ext(struct loader_instance *inst, struct loader_device *dev) {
     for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) {
         if (inst->dev_ext_disp_hash[i].func_name != NULL)
-            loader_init_dispatch_dev_ext_entry(inst, dev, i,
-                                               inst->dev_ext_disp_hash[i].func_name);
+            loader_init_dispatch_dev_ext_entry(inst, dev, i, inst->dev_ext_disp_hash[i].func_name);
     }
 }
 
-static bool loader_check_icds_for_dev_ext_address(struct loader_instance *inst,
-                                                  const char *funcName) {
+static bool loader_check_icds_for_dev_ext_address(struct loader_instance *inst, const char *funcName) {
     struct loader_icd_term *icd_term;
     icd_term = inst->icd_terms;
     while (NULL != icd_term) {
-        if (icd_term->scanned_icd->GetInstanceProcAddr(icd_term->instance,
-                                                       funcName))
+        if (icd_term->scanned_icd->GetInstanceProcAddr(icd_term->instance, funcName))
             // this icd supports funcName
             return true;
         icd_term = icd_term->next;
@@ -3808,20 +3379,15 @@
     return false;
 }
 
-static bool loader_check_layer_list_for_dev_ext_address(
-    const struct loader_layer_list *const layers, const char *funcName) {
+static bool loader_check_layer_list_for_dev_ext_address(const struct loader_layer_list *const layers, const char *funcName) {
     // Iterate over the layers.
     for (uint32_t layer = 0; layer < layers->count; ++layer) {
         // Iterate over the extensions.
-        const struct loader_device_extension_list *const extensions =
-            &(layers->list[layer].device_extension_list);
-        for (uint32_t extension = 0; extension < extensions->count;
-             ++extension) {
+        const struct loader_device_extension_list *const extensions = &(layers->list[layer].device_extension_list);
+        for (uint32_t extension = 0; extension < extensions->count; ++extension) {
             // Iterate over the entry points.
-            const struct loader_dev_ext_props *const property =
-                &(extensions->list[extension]);
-            for (uint32_t entry = 0; entry < property->entrypoint_count;
-                 ++entry) {
+            const struct loader_dev_ext_props *const property = &(extensions->list[extension]);
+            for (uint32_t entry = 0; entry < property->entrypoint_count; ++entry) {
                 if (strcmp(property->entrypoints[entry], funcName) == 0) {
                     return true;
                 }
@@ -3840,8 +3406,7 @@
     memset(inst->dev_ext_disp_hash, 0, sizeof(inst->dev_ext_disp_hash));
 }
 
-static bool loader_add_dev_ext_table(struct loader_instance *inst,
-                                     uint32_t *ptr_idx, const char *funcName) {
+static bool loader_add_dev_ext_table(struct loader_instance *inst, uint32_t *ptr_idx, const char *funcName) {
     uint32_t i;
     uint32_t idx = *ptr_idx;
     struct loader_dispatch_hash_list *list = &inst->dev_ext_disp_hash[idx].list;
@@ -3850,42 +3415,33 @@
         // no entry here at this idx, so use it
         assert(list->capacity == 0);
         inst->dev_ext_disp_hash[idx].func_name =
-            (char *)loader_instance_heap_alloc(
-                inst, strlen(funcName) + 1,
-                VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+            (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (inst->dev_ext_disp_hash[idx].func_name == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_dev_ext_table: Failed to allocate memory "
-                       "for func_name %s",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_dev_ext_table: Failed to allocate memory "
+                                                               "for func_name %s",
                        funcName);
             return false;
         }
-        strncpy(inst->dev_ext_disp_hash[idx].func_name, funcName,
-                strlen(funcName) + 1);
+        strncpy(inst->dev_ext_disp_hash[idx].func_name, funcName, strlen(funcName) + 1);
         return true;
     }
 
     // check for enough capacity
     if (list->capacity == 0) {
-        list->index =
-            loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)),
-                                       VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        list->index = loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (list->index == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_dev_ext_table: Failed to allocate memory "
-                       "for list index",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_dev_ext_table: Failed to allocate memory "
+                                                               "for list index",
                        funcName);
             return false;
         }
         list->capacity = 8 * sizeof(*(list->index));
     } else if (list->capacity < (list->count + 1) * sizeof(*(list->index))) {
-        list->index = loader_instance_heap_realloc(
-            inst, list->index, list->capacity, list->capacity * 2,
-            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        list->index = loader_instance_heap_realloc(inst, list->index, list->capacity, list->capacity * 2,
+                                                   VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (list->index == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_dev_ext_table: Failed to reallocate memory "
-                       "for list index",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_dev_ext_table: Failed to reallocate memory "
+                                                               "for list index",
                        funcName);
             return false;
         }
@@ -3898,19 +3454,14 @@
         if (!inst->dev_ext_disp_hash[i].func_name) {
             assert(inst->dev_ext_disp_hash[i].list.capacity == 0);
             inst->dev_ext_disp_hash[i].func_name =
-                (char *)loader_instance_heap_alloc(
-                    inst, strlen(funcName) + 1,
-                    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+                (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
             if (inst->dev_ext_disp_hash[i].func_name == NULL) {
-                loader_log(
-                    inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                    "loader_add_dev_ext_table: Failed to allocate memory "
-                    "for func_name %s",
-                    funcName);
+                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_dev_ext_table: Failed to allocate memory "
+                                                                   "for func_name %s",
+                           funcName);
                 return false;
             }
-            strncpy(inst->dev_ext_disp_hash[i].func_name, funcName,
-                    strlen(funcName) + 1);
+            strncpy(inst->dev_ext_disp_hash[i].func_name, funcName, strlen(funcName) + 1);
             list->index[list->count] = i;
             list->count++;
             *ptr_idx = i;
@@ -3919,19 +3470,15 @@
         i = (i + 1) % MAX_NUM_UNKNOWN_EXTS;
     } while (i != idx);
 
-    loader_log(
-        inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-        "loader_add_dev_ext_table:  Could not insert into hash table; is "
-        "it full?");
+    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_dev_ext_table:  Could not insert into hash table; is "
+                                                       "it full?");
 
     return false;
 }
 
-static bool loader_name_in_dev_ext_table(struct loader_instance *inst,
-                                         uint32_t *idx, const char *funcName) {
+static bool loader_name_in_dev_ext_table(struct loader_instance *inst, uint32_t *idx, const char *funcName) {
     uint32_t alt_idx;
-    if (inst->dev_ext_disp_hash[*idx].func_name &&
-        !strcmp(inst->dev_ext_disp_hash[*idx].func_name, funcName))
+    if (inst->dev_ext_disp_hash[*idx].func_name && !strcmp(inst->dev_ext_disp_hash[*idx].func_name, funcName))
         return true;
 
     // funcName wasn't at the primary spot in the hash table
@@ -3992,16 +3539,12 @@
     return NULL;
 }
 
-static bool
-loader_check_icds_for_phys_dev_ext_address(struct loader_instance *inst,
-                                           const char *funcName) {
+static bool loader_check_icds_for_phys_dev_ext_address(struct loader_instance *inst, const char *funcName) {
     struct loader_icd_term *icd_term;
     icd_term = inst->icd_terms;
     while (NULL != icd_term) {
-        if (icd_term->scanned_icd->interface_version >=
-            MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION &&
-            icd_term->scanned_icd->GetPhysicalDeviceProcAddr(icd_term->instance,
-                                                             funcName))
+        if (icd_term->scanned_icd->interface_version >= MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION &&
+            icd_term->scanned_icd->GetPhysicalDeviceProcAddr(icd_term->instance, funcName))
             // this icd supports funcName
             return true;
         icd_term = icd_term->next;
@@ -4010,21 +3553,15 @@
     return false;
 }
 
-static bool
-loader_check_layer_list_for_phys_dev_ext_address(struct loader_instance *inst,
-                                                 const char *funcName) {
-    struct loader_layer_properties *layer_prop_list =
-        inst->activated_layer_list.list;
+static bool loader_check_layer_list_for_phys_dev_ext_address(struct loader_instance *inst, const char *funcName) {
+    struct loader_layer_properties *layer_prop_list = inst->activated_layer_list.list;
     for (uint32_t layer = 0; layer < inst->activated_layer_list.count; ++layer) {
         // If this layer supports the vk_layerGetPhysicalDeviceProcAddr, then call
         // it and see if it returns a valid pointer for this function name.
         if (layer_prop_list[layer].interface_version > 1) {
-            const struct loader_layer_functions *const functions =
-                &(layer_prop_list[layer].functions);
+            const struct loader_layer_functions *const functions = &(layer_prop_list[layer].functions);
             if (NULL != functions->get_physical_device_proc_addr &&
-                NULL !=
-                    functions->get_physical_device_proc_addr((VkInstance)inst,
-                                                             funcName)) {
+                NULL != functions->get_physical_device_proc_addr((VkInstance)inst, funcName)) {
                 return true;
             }
         }
@@ -4033,65 +3570,46 @@
     return false;
 }
 
-
 static void loader_free_phys_dev_ext_table(struct loader_instance *inst) {
     for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) {
-        loader_instance_heap_free(inst,
-                                  inst->phys_dev_ext_disp_hash[i].func_name);
-        loader_instance_heap_free(inst,
-                                  inst->phys_dev_ext_disp_hash[i].list.index);
+        loader_instance_heap_free(inst, inst->phys_dev_ext_disp_hash[i].func_name);
+        loader_instance_heap_free(inst, inst->phys_dev_ext_disp_hash[i].list.index);
     }
-    memset(inst->phys_dev_ext_disp_hash, 0,
-           sizeof(inst->phys_dev_ext_disp_hash));
+    memset(inst->phys_dev_ext_disp_hash, 0, sizeof(inst->phys_dev_ext_disp_hash));
 }
 
-static bool loader_add_phys_dev_ext_table(struct loader_instance *inst,
-                                          uint32_t *ptr_idx,
-                                          const char *funcName) {
+static bool loader_add_phys_dev_ext_table(struct loader_instance *inst, uint32_t *ptr_idx, const char *funcName) {
     uint32_t i;
     uint32_t idx = *ptr_idx;
-    struct loader_dispatch_hash_list *list =
-        &inst->phys_dev_ext_disp_hash[idx].list;
+    struct loader_dispatch_hash_list *list = &inst->phys_dev_ext_disp_hash[idx].list;
 
     if (!inst->phys_dev_ext_disp_hash[idx].func_name) {
         // no entry here at this idx, so use it
         assert(list->capacity == 0);
         inst->phys_dev_ext_disp_hash[idx].func_name =
-            (char *)loader_instance_heap_alloc(
-                inst, strlen(funcName) + 1,
-                VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+            (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (inst->phys_dev_ext_disp_hash[idx].func_name == NULL) {
-            loader_log(
-                inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "loader_add_phys_dev_ext_table() can't allocate memory for "
-                "func_name");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_phys_dev_ext_table() can't allocate memory for "
+                                                               "func_name");
             return false;
         }
-        strncpy(inst->phys_dev_ext_disp_hash[idx].func_name, funcName,
-                strlen(funcName) + 1);
+        strncpy(inst->phys_dev_ext_disp_hash[idx].func_name, funcName, strlen(funcName) + 1);
         return true;
     }
 
     // check for enough capacity
     if (list->capacity == 0) {
-        list->index =
-            loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)),
-                                       VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        list->index = loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (list->index == NULL) {
-            loader_log(
-                inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "loader_add_phys_dev_ext_table() can't allocate list memory");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_phys_dev_ext_table() can't allocate list memory");
             return false;
         }
         list->capacity = 8 * sizeof(*(list->index));
     } else if (list->capacity < (list->count + 1) * sizeof(*(list->index))) {
-        list->index = loader_instance_heap_realloc(
-            inst, list->index, list->capacity, list->capacity * 2,
-            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        list->index = loader_instance_heap_realloc(inst, list->index, list->capacity, list->capacity * 2,
+                                                   VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (list->index == NULL) {
-            loader_log(
-                inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "loader_add_phys_dev_ext_table() can't reallocate list memory");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_phys_dev_ext_table() can't reallocate list memory");
             return false;
         }
         list->capacity *= 2;
@@ -4103,17 +3621,13 @@
         if (!inst->phys_dev_ext_disp_hash[i].func_name) {
             assert(inst->phys_dev_ext_disp_hash[i].list.capacity == 0);
             inst->phys_dev_ext_disp_hash[i].func_name =
-                (char *)loader_instance_heap_alloc(
-                    inst, strlen(funcName) + 1,
-                    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+                (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
             if (inst->phys_dev_ext_disp_hash[i].func_name == NULL) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_add_dev_ext_table() can't rallocate "
-                           "func_name memory");
+                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_dev_ext_table() can't rallocate "
+                                                                   "func_name memory");
                 return false;
             }
-            strncpy(inst->phys_dev_ext_disp_hash[i].func_name, funcName,
-                    strlen(funcName) + 1);
+            strncpy(inst->phys_dev_ext_disp_hash[i].func_name, funcName, strlen(funcName) + 1);
             list->index[list->count] = i;
             list->count++;
             *ptr_idx = i;
@@ -4122,24 +3636,19 @@
         i = (i + 1) % MAX_NUM_UNKNOWN_EXTS;
     } while (i != idx);
 
-    loader_log(
-        inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-        "loader_add_phys_dev_ext_table() couldn't insert into hash table; is "
-        "it full?");
+    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_phys_dev_ext_table() couldn't insert into hash table; is "
+                                                       "it full?");
     return false;
 }
 
-static bool loader_name_in_phys_dev_ext_table(struct loader_instance* inst,
-    uint32_t *idx, const char *funcName) {
+static bool loader_name_in_phys_dev_ext_table(struct loader_instance *inst, uint32_t *idx, const char *funcName) {
     uint32_t alt_idx;
-    if (inst->phys_dev_ext_disp_hash[*idx].func_name &&
-        !strcmp(inst->phys_dev_ext_disp_hash[*idx].func_name, funcName))
+    if (inst->phys_dev_ext_disp_hash[*idx].func_name && !strcmp(inst->phys_dev_ext_disp_hash[*idx].func_name, funcName))
         return true;
 
     // funcName wasn't at the primary spot in the hash table
     // search the list of secondary locations (shallow search, not deep search)
-    for (uint32_t i = 0; i < inst->phys_dev_ext_disp_hash[*idx].list.count;
-         i++) {
+    for (uint32_t i = 0; i < inst->phys_dev_ext_disp_hash[*idx].list.count; i++) {
         alt_idx = inst->phys_dev_ext_disp_hash[*idx].list.index[i];
         if (!strcmp(inst->phys_dev_ext_disp_hash[*idx].func_name, funcName)) {
             *idx = alt_idx;
@@ -4166,8 +3675,7 @@
 // addresses are returned.
 // Null is returned if the hash table is full or if no discovered layer or
 // ICD returns a non-NULL GetProcAddr for it.
-bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName,
-                             bool perform_checking, void **tramp_addr,
+bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName, bool perform_checking, void **tramp_addr,
                              void **term_addr) {
     uint32_t idx;
     uint32_t seed = 0;
@@ -4188,15 +3696,13 @@
     if (!loader_check_icds_for_phys_dev_ext_address(inst, funcName)) {
         // If we're not checking layers, or we are and it's not in a layer, just
         // return
-        if (!perform_checking ||
-            !loader_check_layer_list_for_phys_dev_ext_address(inst, funcName)) {
+        if (!perform_checking || !loader_check_layer_list_for_phys_dev_ext_address(inst, funcName)) {
             goto out;
         }
     }
 
     idx = murmurhash(funcName, strlen(funcName), seed) % MAX_NUM_UNKNOWN_EXTS;
-    if (perform_checking &&
-        !loader_name_in_phys_dev_ext_table(inst, &idx, funcName)) {
+    if (perform_checking && !loader_name_in_phys_dev_ext_table(inst, &idx, funcName)) {
         uint32_t i;
         bool added = false;
 
@@ -4209,19 +3715,15 @@
         // Setup the ICD function pointers
         struct loader_icd_term *icd_term = inst->icd_terms;
         while (NULL != icd_term) {
-            if (MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION <=
-                    icd_term->scanned_icd->interface_version &&
+            if (MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION <= icd_term->scanned_icd->interface_version &&
                 NULL != icd_term->scanned_icd->GetPhysicalDeviceProcAddr) {
                 icd_term->phys_dev_ext[idx] =
-                    (PFN_PhysDevExt)
-                        icd_term->scanned_icd->GetPhysicalDeviceProcAddr(
-                            icd_term->instance, funcName);
+                    (PFN_PhysDevExt)icd_term->scanned_icd->GetPhysicalDeviceProcAddr(icd_term->instance, funcName);
 
                 // Make sure we set the instance dispatch to point to the
                 // loader's terminator now since we can at least handle it
                 // in one ICD.
-                inst->disp->phys_dev_ext[idx] =
-                    loader_get_phys_dev_ext_termin(idx);
+                inst->disp->phys_dev_ext[idx] = loader_get_phys_dev_ext_termin(idx);
             } else {
                 icd_term->phys_dev_ext[idx] = NULL;
             }
@@ -4232,14 +3734,10 @@
         // Now, search for the first layer attached and query using it to get
         // the first entry point.
         for (i = 0; i < inst->activated_layer_list.count; i++) {
-            struct loader_layer_properties *layer_prop =
-                &inst->activated_layer_list.list[i];
-            if (layer_prop->interface_version > 1 &&
-                NULL != layer_prop->functions.get_physical_device_proc_addr) {
+            struct loader_layer_properties *layer_prop = &inst->activated_layer_list.list[i];
+            if (layer_prop->interface_version > 1 && NULL != layer_prop->functions.get_physical_device_proc_addr) {
                 inst->disp->phys_dev_ext[idx] =
-                    (PFN_PhysDevExt)
-                        layer_prop->functions.get_physical_device_proc_addr(
-                            (VkInstance)inst, funcName);
+                    (PFN_PhysDevExt)layer_prop->functions.get_physical_device_proc_addr((VkInstance)inst, funcName);
                 if (NULL != inst->disp->phys_dev_ext[idx]) {
                     break;
                 }
@@ -4269,8 +3767,7 @@
     const VkLayerInstanceDispatchTable *disp;
     struct loader_instance *ptr_instance = NULL;
     disp = loader_get_instance_layer_dispatch(instance);
-    for (struct loader_instance *inst = loader.instances; inst;
-         inst = inst->next) {
+    for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) {
         if (&inst->disp->layer_inst_disp == disp) {
             ptr_instance = inst;
             break;
@@ -4279,37 +3776,28 @@
     return ptr_instance;
 }
 
-static loader_platform_dl_handle
-loader_open_layer_lib(const struct loader_instance *inst,
-                      const char *chain_type,
-                      struct loader_layer_properties *prop) {
+static loader_platform_dl_handle loader_open_layer_lib(const struct loader_instance *inst, const char *chain_type,
+                                                       struct loader_layer_properties *prop) {
 
-    if ((prop->lib_handle = loader_platform_open_library(prop->lib_name)) ==
-        NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_open_layer_lib: Failed to open library %s",
-                   prop->lib_name);
+    if ((prop->lib_handle = loader_platform_open_library(prop->lib_name)) == NULL) {
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_open_layer_lib: Failed to open library %s", prop->lib_name);
     } else {
-        loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                   "Loading layer library %s", prop->lib_name);
+        loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Loading layer library %s", prop->lib_name);
     }
 
     return prop->lib_handle;
 }
 
-static void loader_close_layer_lib(const struct loader_instance *inst,
-                                   struct loader_layer_properties *prop) {
+static void loader_close_layer_lib(const struct loader_instance *inst, struct loader_layer_properties *prop) {
 
     if (prop->lib_handle) {
         loader_platform_close_library(prop->lib_handle);
-        loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                   "Unloading layer library %s", prop->lib_name);
+        loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Unloading layer library %s", prop->lib_name);
         prop->lib_handle = NULL;
     }
 }
 
-void loader_deactivate_layers(const struct loader_instance *instance,
-                              struct loader_device *device,
+void loader_deactivate_layers(const struct loader_instance *instance, struct loader_device *device,
                               struct loader_layer_list *list) {
     /* delete instance list of enabled layers and close any layer libraries */
     for (uint32_t i = 0; i < list->count; i++) {
@@ -4324,11 +3812,8 @@
  * Go through the search_list and find any layers which match type. If layer
  * type match is found in then add it to ext_list.
  */
-static void
-loader_add_layer_implicit(const struct loader_instance *inst,
-                          const enum layer_type type,
-                          struct loader_layer_list *list,
-                          const struct loader_layer_list *search_list) {
+static void loader_add_layer_implicit(const struct loader_instance *inst, const enum layer_type type,
+                                      struct loader_layer_list *list, const struct loader_layer_list *search_list) {
     bool enable;
     char *env_value;
     uint32_t i;
@@ -4372,11 +3857,8 @@
  * is found in search_list then add it to layer_list.  But only add it to
  * layer_list if type matches.
  */
-static void loader_add_layer_env(struct loader_instance *inst,
-                                 const enum layer_type type,
-                                 const char *env_name,
-                                 struct loader_layer_list *layer_list,
-                                 const struct loader_layer_list *search_list) {
+static void loader_add_layer_env(struct loader_instance *inst, const enum layer_type type, const char *env_name,
+                                 struct loader_layer_list *layer_list, const struct loader_layer_list *search_list) {
     char *layerEnv;
     char *next, *name;
 
@@ -4399,20 +3881,15 @@
                don't attempt to remove duplicate layers already added by app or
                env var
              */
-            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                       "Expanding meta layer %s found in environment variable",
+            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Expanding meta layer %s found in environment variable",
                        std_validation_str);
             if (type == VK_LAYER_TYPE_INSTANCE_EXPLICIT)
                 inst->activated_layers_are_std_val = true;
-            for (uint32_t i = 0; i < sizeof(std_validation_names) /
-                                         sizeof(std_validation_names[0]);
-                 i++) {
-                loader_find_layer_name_add_list(inst, std_validation_names[i],
-                                                type, search_list, layer_list);
+            for (uint32_t i = 0; i < sizeof(std_validation_names) / sizeof(std_validation_names[0]); i++) {
+                loader_find_layer_name_add_list(inst, std_validation_names[i], type, search_list, layer_list);
             }
         } else {
-            loader_find_layer_name_add_list(inst, name, type, search_list,
-                                            layer_list);
+            loader_find_layer_name_add_list(inst, name, type, search_list, layer_list);
         }
         name = next;
     }
@@ -4420,42 +3897,34 @@
     return;
 }
 
-VkResult
-loader_enable_instance_layers(struct loader_instance *inst,
-                              const VkInstanceCreateInfo *pCreateInfo,
-                              const struct loader_layer_list *instance_layers) {
+VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo,
+                                       const struct loader_layer_list *instance_layers) {
     VkResult err;
 
     assert(inst && "Cannot have null instance");
 
     if (!loader_init_layer_list(inst, &inst->activated_layer_list)) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_enable_instance_layers: Failed to initialize"
-                   " the layer list");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_enable_instance_layers: Failed to initialize"
+                                                           " the layer list");
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
 
     /* Add any implicit layers first */
-    loader_add_layer_implicit(inst, VK_LAYER_TYPE_INSTANCE_IMPLICIT,
-                              &inst->activated_layer_list, instance_layers);
+    loader_add_layer_implicit(inst, VK_LAYER_TYPE_INSTANCE_IMPLICIT, &inst->activated_layer_list, instance_layers);
 
     /* Add any layers specified via environment variable next */
-    loader_add_layer_env(inst, VK_LAYER_TYPE_INSTANCE_EXPLICIT,
-                         "VK_INSTANCE_LAYERS", &inst->activated_layer_list,
-                         instance_layers);
+    loader_add_layer_env(inst, VK_LAYER_TYPE_INSTANCE_EXPLICIT, "VK_INSTANCE_LAYERS", &inst->activated_layer_list, instance_layers);
 
     /* Add layers specified by the application */
-    err = loader_add_layer_names_to_list(
-        inst, &inst->activated_layer_list, pCreateInfo->enabledLayerCount,
-        pCreateInfo->ppEnabledLayerNames, instance_layers);
+    err = loader_add_layer_names_to_list(inst, &inst->activated_layer_list, pCreateInfo->enabledLayerCount,
+                                         pCreateInfo->ppEnabledLayerNames, instance_layers);
 
     return err;
 }
 
 // Determine the layer interface version to use.
-bool loader_get_layer_interface_version(
-    PFN_vkNegotiateLoaderLayerInterfaceVersion fp_negotiate_layer_version,
-    VkNegotiateLayerInterface *interface_struct) {
+bool loader_get_layer_interface_version(PFN_vkNegotiateLoaderLayerInterfaceVersion fp_negotiate_layer_version,
+                                        VkNegotiateLayerInterface *interface_struct) {
 
     memset(interface_struct, 0, sizeof(VkNegotiateLayerInterface));
 
@@ -4465,8 +3934,7 @@
     if (fp_negotiate_layer_version != NULL) {
         // Layer supports the negotiation API, so call it with the loader's
         // latest version supported
-        interface_struct->loaderLayerInterfaceVersion =
-            CURRENT_LOADER_LAYER_INTERFACE_VERSION;
+        interface_struct->loaderLayerInterfaceVersion = CURRENT_LOADER_LAYER_INTERFACE_VERSION;
         VkResult result = fp_negotiate_layer_version(interface_struct);
 
         if (result != VK_SUCCESS) {
@@ -4476,8 +3944,7 @@
         }
     }
 
-    if (interface_struct->loaderLayerInterfaceVersion <
-        MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION) {
+    if (interface_struct->loaderLayerInterfaceVersion < MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION) {
         // Loader no longer supports the layer's latest interface version so
         // fail loading the layer
         return false;
@@ -4504,10 +3971,8 @@
  * that will call CreateInstance on all available ICD's and
  * cache those VkInstance objects for future use.
  */
-VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo,
-                                      const VkAllocationCallbacks *pAllocator,
-                                      struct loader_instance *inst,
-                                      VkInstance *created_instance) {
+VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
+                                      struct loader_instance *inst, VkInstance *created_instance) {
     uint32_t activated_layers = 0;
     VkLayerInstanceCreateInfo chain_info;
     VkLayerInstanceLink *layer_instance_link_info = NULL;
@@ -4529,19 +3994,16 @@
         chain_info.function = VK_LAYER_LINK_INFO;
         loader_create_info.pNext = &chain_info;
 
-        layer_instance_link_info = loader_stack_alloc(
-            sizeof(VkLayerInstanceLink) * inst->activated_layer_list.count);
+        layer_instance_link_info = loader_stack_alloc(sizeof(VkLayerInstanceLink) * inst->activated_layer_list.count);
         if (!layer_instance_link_info) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_create_instance_chain: Failed to alloc Instance"
-                       " objects for layer");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_create_instance_chain: Failed to alloc Instance"
+                                                               " objects for layer");
             return VK_ERROR_OUT_OF_HOST_MEMORY;
         }
 
         // Create instance chain of enabled layers
         for (int32_t i = inst->activated_layer_list.count - 1; i >= 0; i--) {
-            struct loader_layer_properties *layer_prop =
-                &inst->activated_layer_list.list[i];
+            struct loader_layer_properties *layer_prop = &inst->activated_layer_list.list[i];
             loader_platform_dl_handle lib_handle;
 
             lib_handle = loader_open_layer_lib(inst, "instance", layer_prop);
@@ -4550,22 +4012,14 @@
             }
 
             if (NULL == layer_prop->functions.negotiate_layer_interface) {
-                PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_interface =
-                    NULL;
+                PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_interface = NULL;
                 bool functions_in_interface = false;
-                if (strlen(layer_prop->functions.str_negotiate_interface) ==
-                        0) {
-                    negotiate_interface =
-                        (PFN_vkNegotiateLoaderLayerInterfaceVersion)
-                            loader_platform_get_proc_address(
-                                lib_handle,
-                                "vkNegotiateLoaderLayerInterfaceVersion");
+                if (strlen(layer_prop->functions.str_negotiate_interface) == 0) {
+                    negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address(
+                        lib_handle, "vkNegotiateLoaderLayerInterfaceVersion");
                 } else {
-                    negotiate_interface =
-                        (PFN_vkNegotiateLoaderLayerInterfaceVersion)
-                            loader_platform_get_proc_address(
-                                lib_handle,
-                                layer_prop->functions.str_negotiate_interface);
+                    negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address(
+                        lib_handle, layer_prop->functions.str_negotiate_interface);
                 }
 
                 // If we can negotiate an interface version, then we can also
@@ -4573,18 +4027,15 @@
                 // that first, and see if we can get all the function pointers
                 // necessary from that one call.
                 if (NULL != negotiate_interface) {
-                    layer_prop->functions.negotiate_layer_interface =
-                        negotiate_interface;
+                    layer_prop->functions.negotiate_layer_interface = negotiate_interface;
 
                     VkNegotiateLayerInterface interface_struct;
 
-                    if (loader_get_layer_interface_version(negotiate_interface,
-                                                           &interface_struct)) {
+                    if (loader_get_layer_interface_version(negotiate_interface, &interface_struct)) {
 
                         // Go ahead and set the properites version to the
                         // correct value.
-                        layer_prop->interface_version =
-                            interface_struct.loaderLayerInterfaceVersion;
+                        layer_prop->interface_version = interface_struct.loaderLayerInterfaceVersion;
 
                         // If the interface is 2 or newer, we have access to the
                         // new GetPhysicalDeviceProcAddr function, so grab it,
@@ -4592,8 +4043,7 @@
                         // structure.
                         if (interface_struct.loaderLayerInterfaceVersion > 1) {
                             cur_gipa = interface_struct.pfnGetInstanceProcAddr;
-                            cur_gpdpa =
-                                interface_struct.pfnGetPhysicalDeviceProcAddr;
+                            cur_gpdpa = interface_struct.pfnGetPhysicalDeviceProcAddr;
                             if (cur_gipa != NULL) {
                                 // We've set the functions, so make sure we
                                 // don't do the unnecessary calls later.
@@ -4604,26 +4054,20 @@
                 }
 
                 if (!functions_in_interface) {
-                    if ((cur_gipa =
-                             layer_prop->functions.get_instance_proc_addr) ==
-                        NULL) {
+                    if ((cur_gipa = layer_prop->functions.get_instance_proc_addr) == NULL) {
                         if (strlen(layer_prop->functions.str_gipa) == 0) {
-                            cur_gipa = (PFN_vkGetInstanceProcAddr)
-                                loader_platform_get_proc_address(
-                                    lib_handle, "vkGetInstanceProcAddr");
-                            layer_prop->functions.get_instance_proc_addr =
-                                cur_gipa;
+                            cur_gipa =
+                                (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle, "vkGetInstanceProcAddr");
+                            layer_prop->functions.get_instance_proc_addr = cur_gipa;
                         } else {
-                            cur_gipa = (PFN_vkGetInstanceProcAddr)
-                                loader_platform_get_proc_address(
-                                    lib_handle, layer_prop->functions.str_gipa);
+                            cur_gipa = (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle,
+                                                                                                   layer_prop->functions.str_gipa);
                         }
 
                         if (NULL == cur_gipa) {
-                            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                                       "loader_create_instance_chain: Failed to"
-                                       " find \'vkGetInstanceProcAddr\' in "
-                                       "layer %s",
+                            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_create_instance_chain: Failed to"
+                                                                               " find \'vkGetInstanceProcAddr\' in "
+                                                                               "layer %s",
                                        layer_prop->lib_name);
                             continue;
                         }
@@ -4631,31 +4075,25 @@
                 }
             }
 
-            layer_instance_link_info[activated_layers].pNext =
-                chain_info.u.pLayerInfo;
-            layer_instance_link_info[activated_layers]
-                .pfnNextGetInstanceProcAddr = next_gipa;
-            layer_instance_link_info[activated_layers]
-                .pfnNextGetPhysicalDeviceProcAddr = next_gpdpa;
+            layer_instance_link_info[activated_layers].pNext = chain_info.u.pLayerInfo;
+            layer_instance_link_info[activated_layers].pfnNextGetInstanceProcAddr = next_gipa;
+            layer_instance_link_info[activated_layers].pfnNextGetPhysicalDeviceProcAddr = next_gpdpa;
             next_gipa = cur_gipa;
             if (layer_prop->interface_version > 1 && cur_gpdpa != NULL) {
                 layer_prop->functions.get_physical_device_proc_addr = cur_gpdpa;
                 next_gpdpa = cur_gpdpa;
             }
 
-            chain_info.u.pLayerInfo =
-                &layer_instance_link_info[activated_layers];
+            chain_info.u.pLayerInfo = &layer_instance_link_info[activated_layers];
 
-            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                       "Insert instance layer %s (%s)",
-                       layer_prop->info.layerName, layer_prop->lib_name);
+            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Insert instance layer %s (%s)", layer_prop->info.layerName,
+                       layer_prop->lib_name);
 
             activated_layers++;
         }
     }
 
-    PFN_vkCreateInstance fpCreateInstance =
-        (PFN_vkCreateInstance)next_gipa(*created_instance, "vkCreateInstance");
+    PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)next_gipa(*created_instance, "vkCreateInstance");
     if (fpCreateInstance) {
         VkLayerInstanceCreateInfo create_info_disp;
 
@@ -4666,39 +4104,31 @@
 
         create_info_disp.pNext = loader_create_info.pNext;
         loader_create_info.pNext = &create_info_disp;
-        res =
-            fpCreateInstance(&loader_create_info, pAllocator, created_instance);
+        res = fpCreateInstance(&loader_create_info, pAllocator, created_instance);
     } else {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_create_instance_chain: Failed to find "
-                   "\'vkCreateInstance\'");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_create_instance_chain: Failed to find "
+                                                           "\'vkCreateInstance\'");
         // Couldn't find CreateInstance function!
         res = VK_ERROR_INITIALIZATION_FAILED;
     }
 
     if (res == VK_SUCCESS) {
-        loader_init_instance_core_dispatch_table(&inst->disp->layer_inst_disp,
-                                                 next_gipa, *created_instance);
+        loader_init_instance_core_dispatch_table(&inst->disp->layer_inst_disp, next_gipa, *created_instance);
         inst->instance = *created_instance;
     }
 
     return res;
 }
 
-void loader_activate_instance_layer_extensions(struct loader_instance *inst,
-                                               VkInstance created_inst) {
+void loader_activate_instance_layer_extensions(struct loader_instance *inst, VkInstance created_inst) {
 
-    loader_init_instance_extension_dispatch_table(
-        &inst->disp->layer_inst_disp,
-        inst->disp->layer_inst_disp.GetInstanceProcAddr, created_inst);
+    loader_init_instance_extension_dispatch_table(&inst->disp->layer_inst_disp, inst->disp->layer_inst_disp.GetInstanceProcAddr,
+                                                  created_inst);
 }
 
-VkResult
-loader_create_device_chain(const struct loader_physical_device_tramp *pd,
-                           const VkDeviceCreateInfo *pCreateInfo,
-                           const VkAllocationCallbacks *pAllocator,
-                           const struct loader_instance *inst,
-                           struct loader_device *dev) {
+VkResult loader_create_device_chain(const struct loader_physical_device_tramp *pd, const VkDeviceCreateInfo *pCreateInfo,
+                                    const VkAllocationCallbacks *pAllocator, const struct loader_instance *inst,
+                                    struct loader_device *dev) {
     uint32_t activated_layers = 0;
     VkLayerDeviceLink *layer_device_link_info;
     VkLayerDeviceCreateInfo chain_info;
@@ -4710,12 +4140,10 @@
 
     memcpy(&loader_create_info, pCreateInfo, sizeof(VkDeviceCreateInfo));
 
-    layer_device_link_info = loader_stack_alloc(
-        sizeof(VkLayerDeviceLink) * dev->activated_layer_list.count);
+    layer_device_link_info = loader_stack_alloc(sizeof(VkLayerDeviceLink) * dev->activated_layer_list.count);
     if (!layer_device_link_info) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_create_device_chain: Failed to alloc Device objects"
-                   " for layer.  Skipping Layer.");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_create_device_chain: Failed to alloc Device objects"
+                                                           " for layer.  Skipping Layer.");
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
 
@@ -4728,8 +4156,7 @@
 
         // Create instance chain of enabled layers
         for (int32_t i = dev->activated_layer_list.count - 1; i >= 0; i--) {
-            struct loader_layer_properties *layer_prop =
-                &dev->activated_layer_list.list[i];
+            struct loader_layer_properties *layer_prop = &dev->activated_layer_list.list[i];
             loader_platform_dl_handle lib_handle;
             bool functions_in_interface = false;
 
@@ -4743,36 +4170,25 @@
             // that first, and see if we can get all the function pointers
             // necessary from that one call.
             if (NULL == layer_prop->functions.negotiate_layer_interface) {
-                PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_interface =
-                    NULL;
-                if (strlen(layer_prop->functions.str_negotiate_interface) ==
-                        0) {
-                    negotiate_interface =
-                        (PFN_vkNegotiateLoaderLayerInterfaceVersion)
-                            loader_platform_get_proc_address(
-                                lib_handle,
-                                "vkNegotiateLoaderLayerInterfaceVersion");
+                PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_interface = NULL;
+                if (strlen(layer_prop->functions.str_negotiate_interface) == 0) {
+                    negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address(
+                        lib_handle, "vkNegotiateLoaderLayerInterfaceVersion");
                 } else {
-                    negotiate_interface =
-                        (PFN_vkNegotiateLoaderLayerInterfaceVersion)
-                            loader_platform_get_proc_address(
-                                lib_handle,
-                                layer_prop->functions.str_negotiate_interface);
+                    negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address(
+                        lib_handle, layer_prop->functions.str_negotiate_interface);
                 }
 
                 if (NULL != negotiate_interface) {
-                    layer_prop->functions.negotiate_layer_interface =
-                        negotiate_interface;
+                    layer_prop->functions.negotiate_layer_interface = negotiate_interface;
 
                     VkNegotiateLayerInterface interface_struct;
 
-                    if (loader_get_layer_interface_version(negotiate_interface,
-                        &interface_struct)) {
+                    if (loader_get_layer_interface_version(negotiate_interface, &interface_struct)) {
 
                         // Go ahead and set the properites version to the
                         // correct value.
-                        layer_prop->interface_version =
-                            interface_struct.loaderLayerInterfaceVersion;
+                        layer_prop->interface_version = interface_struct.loaderLayerInterfaceVersion;
 
                         // If the interface is 2 or newer, we have access to the
                         // new GetPhysicalDeviceProcAddr function, so grab it,
@@ -4791,66 +4207,51 @@
             }
 
             if (!functions_in_interface) {
-                if ((fpGIPA = layer_prop->functions.get_instance_proc_addr) ==
-                    NULL) {
+                if ((fpGIPA = layer_prop->functions.get_instance_proc_addr) == NULL) {
                     if (strlen(layer_prop->functions.str_gipa) == 0) {
-                        fpGIPA = (PFN_vkGetInstanceProcAddr)
-                            loader_platform_get_proc_address(
-                                lib_handle, "vkGetInstanceProcAddr");
+                        fpGIPA = (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle, "vkGetInstanceProcAddr");
                         layer_prop->functions.get_instance_proc_addr = fpGIPA;
                     } else
-                        fpGIPA = (PFN_vkGetInstanceProcAddr)
-                        loader_platform_get_proc_address(
-                            lib_handle, layer_prop->functions.str_gipa);
+                        fpGIPA =
+                            (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle, layer_prop->functions.str_gipa);
                     if (!fpGIPA) {
-                        loader_log(
-                            inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                            "loader_create_device_chain: Failed to find "
-                            "\'vkGetInstanceProcAddr\' in layer %s.  Skipping"
-                            " layer.",
-                            layer_prop->lib_name);
+                        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_create_device_chain: Failed to find "
+                                                                           "\'vkGetInstanceProcAddr\' in layer %s.  Skipping"
+                                                                           " layer.",
+                                   layer_prop->lib_name);
                         continue;
                     }
                 }
                 if ((fpGDPA = layer_prop->functions.get_device_proc_addr) == NULL) {
                     if (strlen(layer_prop->functions.str_gdpa) == 0) {
-                        fpGDPA = (PFN_vkGetDeviceProcAddr)
-                            loader_platform_get_proc_address(lib_handle,
-                                "vkGetDeviceProcAddr");
+                        fpGDPA = (PFN_vkGetDeviceProcAddr)loader_platform_get_proc_address(lib_handle, "vkGetDeviceProcAddr");
                         layer_prop->functions.get_device_proc_addr = fpGDPA;
                     } else
-                        fpGDPA = (PFN_vkGetDeviceProcAddr)
-                        loader_platform_get_proc_address(
-                            lib_handle, layer_prop->functions.str_gdpa);
+                        fpGDPA =
+                            (PFN_vkGetDeviceProcAddr)loader_platform_get_proc_address(lib_handle, layer_prop->functions.str_gdpa);
                     if (!fpGDPA) {
-                        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                            "Failed to find vkGetDeviceProcAddr in layer %s",
-                            layer_prop->lib_name);
+                        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Failed to find vkGetDeviceProcAddr in layer %s",
+                                   layer_prop->lib_name);
                         continue;
                     }
                 }
             }
-            layer_device_link_info[activated_layers].pNext =
-                chain_info.u.pLayerInfo;
-            layer_device_link_info[activated_layers]
-                .pfnNextGetInstanceProcAddr = nextGIPA;
-            layer_device_link_info[activated_layers].pfnNextGetDeviceProcAddr =
-                nextGDPA;
+            layer_device_link_info[activated_layers].pNext = chain_info.u.pLayerInfo;
+            layer_device_link_info[activated_layers].pfnNextGetInstanceProcAddr = nextGIPA;
+            layer_device_link_info[activated_layers].pfnNextGetDeviceProcAddr = nextGDPA;
             chain_info.u.pLayerInfo = &layer_device_link_info[activated_layers];
             nextGIPA = fpGIPA;
             nextGDPA = fpGDPA;
 
-            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                       "Insert device layer %s (%s)",
-                       layer_prop->info.layerName, layer_prop->lib_name);
+            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Insert device layer %s (%s)", layer_prop->info.layerName,
+                       layer_prop->lib_name);
 
             activated_layers++;
         }
     }
 
     VkDevice created_device = (VkDevice)dev;
-    PFN_vkCreateDevice fpCreateDevice =
-        (PFN_vkCreateDevice)nextGIPA(inst->instance, "vkCreateDevice");
+    PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)nextGIPA(inst->instance, "vkCreateDevice");
     if (fpCreateDevice) {
         VkLayerDeviceCreateInfo create_info_disp;
 
@@ -4861,49 +4262,40 @@
 
         create_info_disp.pNext = loader_create_info.pNext;
         loader_create_info.pNext = &create_info_disp;
-        res = fpCreateDevice(pd->phys_dev, &loader_create_info, pAllocator,
-                             &created_device);
+        res = fpCreateDevice(pd->phys_dev, &loader_create_info, pAllocator, &created_device);
         if (res != VK_SUCCESS) {
             return res;
         }
         dev->chain_device = created_device;
     } else {
-        loader_log(
-            inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "loader_create_device_chain: Failed to find \'vkCreateDevice\' "
-            "in layer %s");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_create_device_chain: Failed to find \'vkCreateDevice\' "
+                                                           "in layer %s");
         // Couldn't find CreateDevice function!
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
     // Initialize device dispatch table
-    loader_init_device_dispatch_table(&dev->loader_dispatch, nextGDPA,
-                                      dev->chain_device);
+    loader_init_device_dispatch_table(&dev->loader_dispatch, nextGDPA, dev->chain_device);
 
     return res;
 }
 
-VkResult loader_validate_layers(const struct loader_instance *inst,
-                                const uint32_t layer_count,
-                                const char *const *ppEnabledLayerNames,
-                                const struct loader_layer_list *list) {
+VkResult loader_validate_layers(const struct loader_instance *inst, const uint32_t layer_count,
+                                const char *const *ppEnabledLayerNames, const struct loader_layer_list *list) {
     struct loader_layer_properties *prop;
 
     for (uint32_t i = 0; i < layer_count; i++) {
-        VkStringErrorFlags result =
-            vk_string_validate(MaxLoaderStringLength, ppEnabledLayerNames[i]);
+        VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, ppEnabledLayerNames[i]);
         if (result != VK_STRING_ERROR_NONE) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_layers: Device ppEnabledLayerNames "
-                       "contains string that is too long or is badly formed");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_validate_layers: Device ppEnabledLayerNames "
+                                                               "contains string that is too long or is badly formed");
             return VK_ERROR_LAYER_NOT_PRESENT;
         }
 
         prop = loader_get_layer_property(ppEnabledLayerNames[i], list);
         if (!prop) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_layers: Layer %d does not exist in "
-                       "the list of available layers",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_validate_layers: Layer %d does not exist in "
+                                                               "the list of available layers",
                        i);
             return VK_ERROR_LAYER_NOT_PRESENT;
         }
@@ -4911,31 +4303,26 @@
     return VK_SUCCESS;
 }
 
-VkResult loader_validate_instance_extensions(
-    const struct loader_instance *inst,
-    const struct loader_extension_list *icd_exts,
-    const struct loader_layer_list *instance_layers,
-    const VkInstanceCreateInfo *pCreateInfo) {
+VkResult loader_validate_instance_extensions(const struct loader_instance *inst, const struct loader_extension_list *icd_exts,
+                                             const struct loader_layer_list *instance_layers,
+                                             const VkInstanceCreateInfo *pCreateInfo) {
 
     VkExtensionProperties *extension_prop;
     struct loader_layer_properties *layer_prop;
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        VkStringErrorFlags result = vk_string_validate(
-            MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]);
+        VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]);
         if (result != VK_STRING_ERROR_NONE) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_instance_extensions: Instance "
-                       "ppEnabledExtensionNames contains "
-                       "string that is too long or is badly formed");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_validate_instance_extensions: Instance "
+                                                               "ppEnabledExtensionNames contains "
+                                                               "string that is too long or is badly formed");
             return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
 
         // See if the extension is in the list of supported extensions
         bool found = false;
         for (uint32_t j = 0; LOADER_INSTANCE_EXTENSIONS[j] != NULL; j++) {
-            if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                       LOADER_INSTANCE_EXTENSIONS[j]) == 0) {
+            if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], LOADER_INSTANCE_EXTENSIONS[j]) == 0) {
                 found = true;
                 break;
             }
@@ -4943,15 +4330,13 @@
 
         // If it isn't in the list, return an error
         if (!found) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_instance_extensions: Extension %d "
-                       "not found in list of available extensions.",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_validate_instance_extensions: Extension %d "
+                                                               "not found in list of available extensions.",
                        i);
             return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
 
-        extension_prop = get_extension_property(
-            pCreateInfo->ppEnabledExtensionNames[i], icd_exts);
+        extension_prop = get_extension_property(pCreateInfo->ppEnabledExtensionNames[i], icd_exts);
 
         if (extension_prop) {
             continue;
@@ -4961,8 +4346,7 @@
 
         /* Not in global list, search layer extension lists */
         for (uint32_t j = 0; j < pCreateInfo->enabledLayerCount; j++) {
-            layer_prop = loader_get_layer_property(
-                pCreateInfo->ppEnabledLayerNames[j], instance_layers);
+            layer_prop = loader_get_layer_property(pCreateInfo->ppEnabledLayerNames[j], instance_layers);
             if (!layer_prop) {
                 /* Should NOT get here, loader_validate_layers
                  * should have already filtered this case out.
@@ -4970,9 +4354,7 @@
                 continue;
             }
 
-            extension_prop =
-                get_extension_property(pCreateInfo->ppEnabledExtensionNames[i],
-                                       &layer_prop->instance_extension_list);
+            extension_prop = get_extension_property(pCreateInfo->ppEnabledExtensionNames[i], &layer_prop->instance_extension_list);
             if (extension_prop) {
                 /* Found the extension in one of the layers enabled by the app.
                  */
@@ -4982,9 +4364,8 @@
 
         if (!extension_prop) {
             // Didn't find extension name in any of the global layers, error out
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_instance_extensions: Extension %d "
-                       "not found in enabled layer list extensions.",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_validate_instance_extensions: Extension %d "
+                                                               "not found in enabled layer list extensions.",
                        i);
             return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
@@ -4992,23 +4373,19 @@
     return VK_SUCCESS;
 }
 
-VkResult loader_validate_device_extensions(
-    struct loader_physical_device_tramp *phys_dev,
-    const struct loader_layer_list *activated_device_layers,
-    const struct loader_extension_list *icd_exts,
-    const VkDeviceCreateInfo *pCreateInfo) {
+VkResult loader_validate_device_extensions(struct loader_physical_device_tramp *phys_dev,
+                                           const struct loader_layer_list *activated_device_layers,
+                                           const struct loader_extension_list *icd_exts, const VkDeviceCreateInfo *pCreateInfo) {
     VkExtensionProperties *extension_prop;
     struct loader_layer_properties *layer_prop;
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
 
-        VkStringErrorFlags result = vk_string_validate(
-            MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]);
+        VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]);
         if (result != VK_STRING_ERROR_NONE) {
-            loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                       0, "loader_validate_device_extensions: Device "
-                          "ppEnabledExtensionNames contains "
-                          "string that is too long or is badly formed");
+            loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_validate_device_extensions: Device "
+                                                                                  "ppEnabledExtensionNames contains "
+                                                                                  "string that is too long or is badly formed");
             return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
 
@@ -5023,8 +4400,7 @@
         for (uint32_t j = 0; j < activated_device_layers->count; j++) {
             layer_prop = &activated_device_layers->list[j];
 
-            extension_prop = get_dev_extension_property(
-                extension_name, &layer_prop->device_extension_list);
+            extension_prop = get_dev_extension_property(extension_name, &layer_prop->device_extension_list);
             if (extension_prop) {
                 // Found the extension in one of the layers enabled by the app.
                 break;
@@ -5033,9 +4409,8 @@
 
         if (!extension_prop) {
             // Didn't find extension name in any of the device layers, error out
-            loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                       0, "loader_validate_device_extensions: Extension %d "
-                          "not found in enabled layer list extensions.",
+            loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_validate_device_extensions: Extension %d "
+                                                                                  "not found in enabled layer list extensions.",
                        i);
             return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
@@ -5045,9 +4420,8 @@
 
 // Terminator functions for the Instance chain
 // All named terminator_<Vulakn API name>
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateInstance(
-    const VkInstanceCreateInfo *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
+                                                         const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
     struct loader_icd_term *icd_term;
     VkExtensionProperties *prop;
     char **filtered_extension_names = NULL;
@@ -5065,27 +4439,21 @@
     //       No ICD will advertise support for layers. An ICD library could
     //       support a layer, but it would be independent of the actual ICD,
     //       just in the same library.
-    filtered_extension_names =
-        loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *));
+    filtered_extension_names = loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *));
     if (!filtered_extension_names) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "terminator_CreateInstance: Failed create extension name "
-                   "array for %d extensions",
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "terminator_CreateInstance: Failed create extension name "
+                                                                   "array for %d extensions",
                    pCreateInfo->enabledExtensionCount);
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     }
-    icd_create_info.ppEnabledExtensionNames =
-        (const char *const *)filtered_extension_names;
+    icd_create_info.ppEnabledExtensionNames = (const char *const *)filtered_extension_names;
 
     for (uint32_t i = 0; i < ptr_instance->icd_tramp_list.count; i++) {
-        icd_term = loader_icd_add(
-            ptr_instance, &ptr_instance->icd_tramp_list.scanned_list[i]);
+        icd_term = loader_icd_add(ptr_instance, &ptr_instance->icd_tramp_list.scanned_list[i]);
         if (NULL == icd_term) {
-            loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                       0,
-                       "terminator_CreateInstance: Failed to add ICD %d to ICD "
-                       "trampoline list.",
+            loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "terminator_CreateInstance: Failed to add ICD %d to ICD "
+                                                                       "trampoline list.",
                        i);
             res = VK_ERROR_OUT_OF_HOST_MEMORY;
             goto out;
@@ -5094,13 +4462,10 @@
         icd_create_info.enabledExtensionCount = 0;
         struct loader_extension_list icd_exts;
 
-        loader_log(ptr_instance, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                   "Build ICD instance extension list");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Build ICD instance extension list");
         // traverse scanned icd list adding non-duplicate extensions to the
         // list
-        res = loader_init_generic_list(ptr_instance,
-                                       (struct loader_generic_list *)&icd_exts,
-                                       sizeof(VkExtensionProperties));
+        res = loader_init_generic_list(ptr_instance, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
         if (VK_ERROR_OUT_OF_HOST_MEMORY == res) {
             // If out of memory, bail immediately.
             goto out;
@@ -5113,13 +4478,10 @@
             continue;
         }
 
-        res = loader_add_instance_extensions(
-            ptr_instance,
-            icd_term->scanned_icd->EnumerateInstanceExtensionProperties,
-            icd_term->scanned_icd->lib_name, &icd_exts);
+        res = loader_add_instance_extensions(ptr_instance, icd_term->scanned_icd->EnumerateInstanceExtensionProperties,
+                                             icd_term->scanned_icd->lib_name, &icd_exts);
         if (VK_SUCCESS != res) {
-            loader_destroy_generic_list(
-                ptr_instance, (struct loader_generic_list *)&icd_exts);
+            loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&icd_exts);
             if (VK_ERROR_OUT_OF_HOST_MEMORY == res) {
                 // If out of memory, bail immediately.
                 goto out;
@@ -5134,30 +4496,24 @@
         }
 
         for (uint32_t j = 0; j < pCreateInfo->enabledExtensionCount; j++) {
-            prop = get_extension_property(
-                pCreateInfo->ppEnabledExtensionNames[j], &icd_exts);
+            prop = get_extension_property(pCreateInfo->ppEnabledExtensionNames[j], &icd_exts);
             if (prop) {
-                filtered_extension_names[icd_create_info
-                                             .enabledExtensionCount] =
-                    (char *)pCreateInfo->ppEnabledExtensionNames[j];
+                filtered_extension_names[icd_create_info.enabledExtensionCount] = (char *)pCreateInfo->ppEnabledExtensionNames[j];
                 icd_create_info.enabledExtensionCount++;
             }
         }
 
-        loader_destroy_generic_list(ptr_instance,
-                                    (struct loader_generic_list *)&icd_exts);
+        loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&icd_exts);
 
         VkResult icd_result =
-            ptr_instance->icd_tramp_list.scanned_list[i].CreateInstance(
-                &icd_create_info, pAllocator, &(icd_term->instance));
+            ptr_instance->icd_tramp_list.scanned_list[i].CreateInstance(&icd_create_info, pAllocator, &(icd_term->instance));
         if (VK_ERROR_OUT_OF_HOST_MEMORY == icd_result) {
             // If out of memory, bail immediately.
             res = VK_ERROR_OUT_OF_HOST_MEMORY;
             goto out;
         } else if (VK_SUCCESS != icd_result) {
-            loader_log(ptr_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "terminator_CreateInstance: Failed to CreateInstance in "
-                       "ICD %d.  Skipping ICD.",
+            loader_log(ptr_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "terminator_CreateInstance: Failed to CreateInstance in "
+                                                                         "ICD %d.  Skipping ICD.",
                        i);
             ptr_instance->icd_terms = icd_term->next;
             icd_term->next = NULL;
@@ -5166,12 +4522,10 @@
         }
 
         if (!loader_icd_init_entrys(icd_term, icd_term->instance,
-                                    ptr_instance->icd_tramp_list.scanned_list[i]
-                                        .GetInstanceProcAddr)) {
-            loader_log(
-                ptr_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                "terminator_CreateInstance: Failed to CreateInstance and find "
-                "entrypoints with ICD.  Skipping ICD.");
+                                    ptr_instance->icd_tramp_list.scanned_list[i].GetInstanceProcAddr)) {
+            loader_log(ptr_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
+                       "terminator_CreateInstance: Failed to CreateInstance and find "
+                       "entrypoints with ICD.  Skipping ICD.");
             continue;
         }
 
@@ -5182,8 +4536,7 @@
     // If no ICDs were added to instance list and res is unchanged
     // from it's initial value, the loader was unable to find
     // a suitable ICD.
-    if (VK_SUCCESS == res &&
-        (ptr_instance->icd_terms == NULL || !one_icd_successful)) {
+    if (VK_SUCCESS == res && (ptr_instance->icd_terms == NULL || !one_icd_successful)) {
         res = VK_ERROR_INCOMPATIBLE_DRIVER;
     }
 
@@ -5203,8 +4556,7 @@
     return res;
 }
 
-VKAPI_ATTR void VKAPI_CALL terminator_DestroyInstance(
-    VkInstance instance, const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL terminator_DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
     struct loader_instance *ptr_instance = loader_instance(instance);
     if (NULL == ptr_instance) {
         return;
@@ -5239,15 +4591,12 @@
         icd_terms = next_icd_term;
     }
 
-    loader_delete_layer_properties(ptr_instance,
-                                   &ptr_instance->instance_layer_list);
+    loader_delete_layer_properties(ptr_instance, &ptr_instance->instance_layer_list);
     loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_tramp_list);
-    loader_destroy_generic_list(
-        ptr_instance, (struct loader_generic_list *)&ptr_instance->ext_list);
+    loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&ptr_instance->ext_list);
     if (NULL != ptr_instance->phys_devs_term) {
         for (uint32_t i = 0; i < ptr_instance->phys_dev_count_term; i++) {
-            loader_instance_heap_free(ptr_instance,
-                                      ptr_instance->phys_devs_term[i]);
+            loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_term[i]);
         }
         loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_term);
     }
@@ -5255,9 +4604,8 @@
     loader_free_phys_dev_ext_table(ptr_instance);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDevice(
-    VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
+                                                       const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
     VkResult res = VK_SUCCESS;
     struct loader_physical_device_term *phys_dev_term;
     phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
@@ -5288,8 +4636,7 @@
     //       support a layer, but it would be independent of the actual ICD,
     //       just in the same library.
     char **filtered_extension_names = NULL;
-    filtered_extension_names =
-        loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *));
+    filtered_extension_names = loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *));
     if (NULL == filtered_extension_names) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "terminator_CreateDevice: Failed to create extension name "
@@ -5302,42 +4649,34 @@
     localCreateInfo.ppEnabledLayerNames = NULL;
 
     localCreateInfo.enabledExtensionCount = 0;
-    localCreateInfo.ppEnabledExtensionNames =
-        (const char *const *)filtered_extension_names;
+    localCreateInfo.ppEnabledExtensionNames = (const char *const *)filtered_extension_names;
 
     // Get the physical device (ICD) extensions
-    res = loader_init_generic_list(icd_term->this_instance,
-                                   (struct loader_generic_list *)&icd_exts,
-                                   sizeof(VkExtensionProperties));
+    res = loader_init_generic_list(icd_term->this_instance, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
     if (VK_SUCCESS != res) {
         goto out;
     }
 
-    res = loader_add_device_extensions(
-        icd_term->this_instance, icd_term->EnumerateDeviceExtensionProperties,
-        phys_dev_term->phys_dev, icd_term->scanned_icd->lib_name, &icd_exts);
+    res = loader_add_device_extensions(icd_term->this_instance, icd_term->EnumerateDeviceExtensionProperties,
+                                       phys_dev_term->phys_dev, icd_term->scanned_icd->lib_name, &icd_exts);
     if (res != VK_SUCCESS) {
         goto out;
     }
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
         const char *extension_name = pCreateInfo->ppEnabledExtensionNames[i];
-        VkExtensionProperties *prop =
-            get_extension_property(extension_name, &icd_exts);
+        VkExtensionProperties *prop = get_extension_property(extension_name, &icd_exts);
         if (prop) {
-            filtered_extension_names[localCreateInfo.enabledExtensionCount] =
-                (char *)extension_name;
+            filtered_extension_names[localCreateInfo.enabledExtensionCount] = (char *)extension_name;
             localCreateInfo.enabledExtensionCount++;
         } else {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT,
-                       0, "vkCreateDevice extension %s not available for "
-                          "devices associated with ICD %s",
+            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "vkCreateDevice extension %s not available for "
+                                                                                    "devices associated with ICD %s",
                        extension_name, icd_term->scanned_icd->lib_name);
         }
     }
 
-    res = fpCreateDevice(phys_dev_term->phys_dev, &localCreateInfo, pAllocator,
-                         &dev->icd_device);
+    res = fpCreateDevice(phys_dev_term->phys_dev, &localCreateInfo, pAllocator, &dev->icd_device);
     if (res != VK_SUCCESS) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
                    "terminator_CreateDevice: Failed in ICD %s vkCreateDevice"
@@ -5354,8 +4693,7 @@
 
 out:
     if (NULL != icd_exts.list) {
-        loader_destroy_generic_list(icd_term->this_instance,
-                                    (struct loader_generic_list *)&icd_exts);
+        loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&icd_exts);
     }
 
     return res;
@@ -5377,44 +4715,34 @@
 
     // Create an array for the new physical devices, which will be stored
     // in the instance for the trampoline code.
-    new_phys_devs =
-        (struct loader_physical_device_tramp **)loader_instance_heap_alloc(
-            inst,
-            total_count * sizeof(struct loader_physical_device_tramp *),
-            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    new_phys_devs = (struct loader_physical_device_tramp **)loader_instance_heap_alloc(
+        inst, total_count * sizeof(struct loader_physical_device_tramp *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (NULL == new_phys_devs) {
-        loader_log(
-            inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "setupLoaderTrampPhysDevs:  Failed to allocate new physical device"
-            " array of size %d",
-            total_count);
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "setupLoaderTrampPhysDevs:  Failed to allocate new physical device"
+                                                           " array of size %d",
+                   total_count);
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     }
-    memset(new_phys_devs, 0,
-        total_count * sizeof(struct loader_physical_device_tramp *));
+    memset(new_phys_devs, 0, total_count * sizeof(struct loader_physical_device_tramp *));
 
     // Create a temporary array (on the stack) to keep track of the
     // returned VkPhysicalDevice values.
-    local_phys_devs =
-        loader_stack_alloc(sizeof(VkPhysicalDevice) * total_count);
+    local_phys_devs = loader_stack_alloc(sizeof(VkPhysicalDevice) * total_count);
     if (NULL == local_phys_devs) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTrampPhysDevs:  Failed to allocate local "
-                   "physical device array of size %d",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "setupLoaderTrampPhysDevs:  Failed to allocate local "
+                                                           "physical device array of size %d",
                    total_count);
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     }
     memset(local_phys_devs, 0, sizeof(VkPhysicalDevice) * total_count);
 
-    res = inst->disp->layer_inst_disp.EnumeratePhysicalDevices(
-        instance, &total_count, local_phys_devs);
+    res = inst->disp->layer_inst_disp.EnumeratePhysicalDevices(instance, &total_count, local_phys_devs);
     if (VK_SUCCESS != res) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTrampPhysDevs:  Failed during dispatch call "
-                   "of \'vkEnumeratePhysicalDevices\' to lower layers or "
-                   "loader.");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "setupLoaderTrampPhysDevs:  Failed during dispatch call "
+                                                           "of \'vkEnumeratePhysicalDevices\' to lower layers or "
+                                                           "loader.");
         goto out;
     }
 
@@ -5422,11 +4750,8 @@
     for (uint32_t new_idx = 0; new_idx < total_count; new_idx++) {
 
         // Check if this physical device is already in the old buffer
-        for (uint32_t old_idx = 0;
-            old_idx < inst->phys_dev_count_tramp;
-            old_idx++) {
-            if (local_phys_devs[new_idx] ==
-                inst->phys_devs_tramp[old_idx]->phys_dev) {
+        for (uint32_t old_idx = 0; old_idx < inst->phys_dev_count_tramp; old_idx++) {
+            if (local_phys_devs[new_idx] == inst->phys_devs_tramp[old_idx]->phys_dev) {
                 new_phys_devs[new_idx] = inst->phys_devs_tramp[old_idx];
                 break;
             }
@@ -5434,14 +4759,11 @@
 
         // If this physical device isn't in the old buffer, create it
         if (NULL == new_phys_devs[new_idx]) {
-            new_phys_devs[new_idx] = (struct loader_physical_device_tramp *)
-                loader_instance_heap_alloc(
-                    inst, sizeof(struct loader_physical_device_tramp),
-                    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+            new_phys_devs[new_idx] = (struct loader_physical_device_tramp *)loader_instance_heap_alloc(
+                inst, sizeof(struct loader_physical_device_tramp), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
             if (NULL == new_phys_devs[new_idx]) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTrampPhysDevs:  Failed to allocate "
-                           "physical device trampoline object %d",
+                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "setupLoaderTrampPhysDevs:  Failed to allocate "
+                                                                   "physical device trampoline object %d",
                            new_idx);
                 total_count = new_idx;
                 res = VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -5478,8 +4800,7 @@
                     }
                 }
                 if (!found) {
-                    loader_instance_heap_free(inst,
-                        inst->phys_devs_tramp[i]);
+                    loader_instance_heap_free(inst, inst->phys_devs_tramp[i]);
                 }
             }
             loader_instance_heap_free(inst, inst->phys_devs_tramp);
@@ -5504,49 +4825,42 @@
 
     // Allocate something to store the physical device characteristics
     // that we read from each ICD.
-    icd_phys_dev_array = (struct loader_phys_dev_per_icd *)loader_stack_alloc(
-        sizeof(struct loader_phys_dev_per_icd) * inst->total_icd_count);
+    icd_phys_dev_array =
+        (struct loader_phys_dev_per_icd *)loader_stack_alloc(sizeof(struct loader_phys_dev_per_icd) * inst->total_icd_count);
     if (NULL == icd_phys_dev_array) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTermPhysDevs:  Failed to allocate temporary "
-                   "ICD Physical device info array of size %d",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "setupLoaderTermPhysDevs:  Failed to allocate temporary "
+                                                           "ICD Physical device info array of size %d",
                    inst->total_gpu_count);
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     }
-    memset(icd_phys_dev_array, 0,
-           sizeof(struct loader_phys_dev_per_icd) * inst->total_icd_count);
+    memset(icd_phys_dev_array, 0, sizeof(struct loader_phys_dev_per_icd) * inst->total_icd_count);
     icd_term = inst->icd_terms;
 
     // For each ICD, query the number of physical devices, and then get an
     // internal value for those physical devices.
     while (NULL != icd_term) {
-        res = icd_term->EnumeratePhysicalDevices(
-            icd_term->instance, &icd_phys_dev_array[i].count, NULL);
+        res = icd_term->EnumeratePhysicalDevices(icd_term->instance, &icd_phys_dev_array[i].count, NULL);
         if (VK_SUCCESS != res) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "setupLoaderTermPhysDevs:  Call to "
-                       "ICD %d's \'vkEnumeratePhysicalDevices\' failed with"
-                       " error 0x%08x",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "setupLoaderTermPhysDevs:  Call to "
+                                                               "ICD %d's \'vkEnumeratePhysicalDevices\' failed with"
+                                                               " error 0x%08x",
                        i, res);
             goto out;
         }
 
         icd_phys_dev_array[i].phys_devs =
-            (VkPhysicalDevice *)loader_stack_alloc(icd_phys_dev_array[i].count *
-                                                   sizeof(VkPhysicalDevice));
+            (VkPhysicalDevice *)loader_stack_alloc(icd_phys_dev_array[i].count * sizeof(VkPhysicalDevice));
         if (NULL == icd_phys_dev_array[i].phys_devs) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "setupLoaderTermPhysDevs:  Failed to allocate temporary "
-                       "ICD Physical device array for ICD %d of size %d",
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "setupLoaderTermPhysDevs:  Failed to allocate temporary "
+                                                               "ICD Physical device array for ICD %d of size %d",
                        i, inst->total_gpu_count);
             res = VK_ERROR_OUT_OF_HOST_MEMORY;
             goto out;
         }
 
-        res = icd_term->EnumeratePhysicalDevices(
-            icd_term->instance, &(icd_phys_dev_array[i].count),
-            icd_phys_dev_array[i].phys_devs);
+        res =
+            icd_term->EnumeratePhysicalDevices(icd_term->instance, &(icd_phys_dev_array[i].count), icd_phys_dev_array[i].phys_devs);
         if (VK_SUCCESS != res) {
             goto out;
         }
@@ -5558,41 +4872,32 @@
     }
 
     if (0 == inst->total_gpu_count) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTermPhysDevs:  Failed to detect any valid"
-                   " GPUs in the current config");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "setupLoaderTermPhysDevs:  Failed to detect any valid"
+                                                           " GPUs in the current config");
         res = VK_ERROR_INITIALIZATION_FAILED;
         goto out;
     }
 
-    new_phys_devs = loader_instance_heap_alloc(
-        inst,
-        sizeof(struct loader_physical_device_term *) * inst->total_gpu_count,
-        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    new_phys_devs = loader_instance_heap_alloc(inst, sizeof(struct loader_physical_device_term *) * inst->total_gpu_count,
+                                               VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (NULL == new_phys_devs) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTermPhysDevs:  Failed to allocate new physical"
-                   " device array of size %d",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "setupLoaderTermPhysDevs:  Failed to allocate new physical"
+                                                           " device array of size %d",
                    inst->total_gpu_count);
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     }
-    memset(new_phys_devs, 0, sizeof(struct loader_physical_device_term *) *
-        inst->total_gpu_count);
+    memset(new_phys_devs, 0, sizeof(struct loader_physical_device_term *) * inst->total_gpu_count);
 
     // Copy or create everything to fill the new array of physical devices
     uint32_t idx = 0;
     for (uint32_t icd_idx = 0; icd_idx < inst->total_icd_count; icd_idx++) {
-        for (uint32_t pd_idx = 0; pd_idx < icd_phys_dev_array[icd_idx].count;
-            pd_idx++) {
+        for (uint32_t pd_idx = 0; pd_idx < icd_phys_dev_array[icd_idx].count; pd_idx++) {
 
             // Check if this physical device is already in the old buffer
             if (NULL != inst->phys_devs_term) {
-                for (uint32_t old_idx = 0;
-                    old_idx < inst->phys_dev_count_term;
-                    old_idx++) {
-                    if (icd_phys_dev_array[icd_idx].phys_devs[pd_idx] ==
-                        inst->phys_devs_term[old_idx]->phys_dev) {
+                for (uint32_t old_idx = 0; old_idx < inst->phys_dev_count_term; old_idx++) {
+                    if (icd_phys_dev_array[icd_idx].phys_devs[pd_idx] == inst->phys_devs_term[old_idx]->phys_dev) {
                         new_phys_devs[idx] = inst->phys_devs_term[old_idx];
                         break;
                     }
@@ -5601,13 +4906,11 @@
             // If this physical device isn't in the old buffer, then we
             // need to create it.
             if (NULL == new_phys_devs[idx]) {
-                new_phys_devs[idx] = loader_instance_heap_alloc(
-                    inst, sizeof(struct loader_physical_device_term),
-                    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+                new_phys_devs[idx] = loader_instance_heap_alloc(inst, sizeof(struct loader_physical_device_term),
+                                                                VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
                 if (NULL == new_phys_devs[idx]) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "setupLoaderTermPhysDevs:  Failed to allocate "
-                               "physical device terminator object %d",
+                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "setupLoaderTermPhysDevs:  Failed to allocate "
+                                                                       "physical device terminator object %d",
                                idx);
                     inst->total_gpu_count = idx;
                     res = VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -5615,11 +4918,9 @@
                 }
 
                 loader_set_dispatch((void *)new_phys_devs[idx], inst->disp);
-                new_phys_devs[idx]->this_icd_term =
-                    icd_phys_dev_array[icd_idx].this_icd_term;
+                new_phys_devs[idx]->this_icd_term = icd_phys_dev_array[icd_idx].this_icd_term;
                 new_phys_devs[idx]->icd_index = (uint8_t)(icd_idx);
-                new_phys_devs[idx]->phys_dev =
-                    icd_phys_dev_array[icd_idx].phys_devs[pd_idx];
+                new_phys_devs[idx]->phys_dev = icd_phys_dev_array[icd_idx].phys_devs[pd_idx];
             }
             idx++;
         }
@@ -5642,21 +4943,16 @@
         // physical devices.  Everything else will have been copied over
         // to the new array.
         if (NULL != inst->phys_devs_term) {
-            for (uint32_t cur_pd = 0; cur_pd < inst->phys_dev_count_term;
-                cur_pd++) {
+            for (uint32_t cur_pd = 0; cur_pd < inst->phys_dev_count_term; cur_pd++) {
                 bool found = false;
-                for (uint32_t new_pd_idx = 0;
-                    new_pd_idx < inst->total_gpu_count;
-                    new_pd_idx++) {
-                    if (inst->phys_devs_term[cur_pd] ==
-                        new_phys_devs[new_pd_idx]) {
+                for (uint32_t new_pd_idx = 0; new_pd_idx < inst->total_gpu_count; new_pd_idx++) {
+                    if (inst->phys_devs_term[cur_pd] == new_phys_devs[new_pd_idx]) {
                         found = true;
                         break;
                     }
                 }
                 if (!found) {
-                    loader_instance_heap_free(inst,
-                        inst->phys_devs_term[cur_pd]);
+                    loader_instance_heap_free(inst, inst->phys_devs_term[cur_pd]);
                 }
             }
             loader_instance_heap_free(inst, inst->phys_devs_term);
@@ -5670,9 +4966,8 @@
     return res;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDevices(
-    VkInstance instance, uint32_t *pPhysicalDeviceCount,
-    VkPhysicalDevice *pPhysicalDevices) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
+                                                                   VkPhysicalDevice *pPhysicalDevices) {
     struct loader_instance *inst = (struct loader_instance *)instance;
     VkResult res = VK_SUCCESS;
 
@@ -5704,70 +4999,57 @@
     return res;
 }
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties(
-    VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+                                                                  VkPhysicalDeviceProperties *pProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL != icd_term->GetPhysicalDeviceProperties) {
-        icd_term->GetPhysicalDeviceProperties(phys_dev_term->phys_dev,
-                                              pProperties);
+        icd_term->GetPhysicalDeviceProperties(phys_dev_term->phys_dev, pProperties);
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties(
-    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
-    VkQueueFamilyProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
+                                                                             uint32_t *pQueueFamilyPropertyCount,
+                                                                             VkQueueFamilyProperties *pProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL != icd_term->GetPhysicalDeviceQueueFamilyProperties) {
-        icd_term->GetPhysicalDeviceQueueFamilyProperties(
-            phys_dev_term->phys_dev, pQueueFamilyPropertyCount, pProperties);
+        icd_term->GetPhysicalDeviceQueueFamilyProperties(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, pProperties);
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceMemoryProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
+                                                                        VkPhysicalDeviceMemoryProperties *pProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL != icd_term->GetPhysicalDeviceMemoryProperties) {
-        icd_term->GetPhysicalDeviceMemoryProperties(phys_dev_term->phys_dev,
-                                                    pProperties);
+        icd_term->GetPhysicalDeviceMemoryProperties(phys_dev_term->phys_dev, pProperties);
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures(
-    VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+                                                                VkPhysicalDeviceFeatures *pFeatures) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL != icd_term->GetPhysicalDeviceFeatures) {
         icd_term->GetPhysicalDeviceFeatures(phys_dev_term->phys_dev, pFeatures);
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties(
-    VkPhysicalDevice physicalDevice, VkFormat format,
-    VkFormatProperties *pFormatInfo) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                        VkFormatProperties *pFormatInfo) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL != icd_term->GetPhysicalDeviceFormatProperties) {
-        icd_term->GetPhysicalDeviceFormatProperties(phys_dev_term->phys_dev,
-                                                    format, pFormatInfo);
+        icd_term->GetPhysicalDeviceFormatProperties(phys_dev_term->phys_dev, format, pFormatInfo);
     }
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceImageFormatProperties(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
-    VkImageFormatProperties *pImageFormatProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                                 VkImageType type, VkImageTiling tiling,
+                                                                                 VkImageUsageFlags usage, VkImageCreateFlags flags,
+                                                                                 VkImageFormatProperties *pImageFormatProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL == icd_term->GetPhysicalDeviceImageFormatProperties) {
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
@@ -5775,30 +5057,26 @@
                    "terminator.  This means a layer improperly continued.");
         return VK_ERROR_INITIALIZATION_FAILED;
     }
-    return icd_term->GetPhysicalDeviceImageFormatProperties(
-        phys_dev_term->phys_dev, format, type, tiling, usage, flags,
-        pImageFormatProperties);
+    return icd_term->GetPhysicalDeviceImageFormatProperties(phys_dev_term->phys_dev, format, type, tiling, usage, flags,
+                                                            pImageFormatProperties);
 }
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceSparseImageFormatProperties(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkSampleCountFlagBits samples, VkImageUsageFlags usage,
-    VkImageTiling tiling, uint32_t *pNumProperties,
-    VkSparseImageFormatProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                                   VkImageType type, VkSampleCountFlagBits samples,
+                                                                                   VkImageUsageFlags usage, VkImageTiling tiling,
+                                                                                   uint32_t *pNumProperties,
+                                                                                   VkSparseImageFormatProperties *pProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
     if (NULL != icd_term->GetPhysicalDeviceSparseImageFormatProperties) {
-        icd_term->GetPhysicalDeviceSparseImageFormatProperties(
-            phys_dev_term->phys_dev, format, type, samples, usage, tiling,
-            pNumProperties, pProperties);
+        icd_term->GetPhysicalDeviceSparseImageFormatProperties(phys_dev_term->phys_dev, format, type, samples, usage, tiling,
+                                                               pNumProperties, pProperties);
     }
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(
-    VkPhysicalDevice physicalDevice, const char *pLayerName,
-    uint32_t *pPropertyCount, VkExtensionProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
+                                                                             const char *pLayerName, uint32_t *pPropertyCount,
+                                                                             VkExtensionProperties *pProperties) {
     struct loader_physical_device_term *phys_dev_term;
 
     struct loader_layer_list implicit_layer_list = {0};
@@ -5818,30 +5096,25 @@
     VkResult res;
 
     /* get device extensions */
-    res = icd_term->EnumerateDeviceExtensionProperties(
-        phys_dev_term->phys_dev, NULL, &icd_ext_count, pProperties);
+    res = icd_term->EnumerateDeviceExtensionProperties(phys_dev_term->phys_dev, NULL, &icd_ext_count, pProperties);
     if (res != VK_SUCCESS) {
         goto out;
     }
 
-    if (!loader_init_layer_list(icd_term->this_instance,
-                                &implicit_layer_list)) {
+    if (!loader_init_layer_list(icd_term->this_instance, &implicit_layer_list)) {
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     }
 
-    loader_add_layer_implicit(
-        icd_term->this_instance, VK_LAYER_TYPE_INSTANCE_IMPLICIT,
-        &implicit_layer_list, &icd_term->this_instance->instance_layer_list);
+    loader_add_layer_implicit(icd_term->this_instance, VK_LAYER_TYPE_INSTANCE_IMPLICIT, &implicit_layer_list,
+                              &icd_term->this_instance->instance_layer_list);
     /* we need to determine which implicit layers are active,
      * and then add their extensions. This can't be cached as
      * it depends on results of environment variables (which can change).
      */
     if (pProperties != NULL) {
         /* initialize dev_extension list within the physicalDevice object */
-        res = loader_init_device_extensions(icd_term->this_instance,
-                                            phys_dev_term, icd_ext_count,
-                                            pProperties, &icd_exts);
+        res = loader_init_device_extensions(icd_term->this_instance, phys_dev_term, icd_ext_count, pProperties, &icd_exts);
         if (res != VK_SUCCESS) {
             goto out;
         }
@@ -5851,26 +5124,18 @@
          * it depends on results of environment variables (which can
          * change).
          */
-        res = loader_add_to_ext_list(icd_term->this_instance, &all_exts,
-                                     icd_exts.count, icd_exts.list);
+        res = loader_add_to_ext_list(icd_term->this_instance, &all_exts, icd_exts.count, icd_exts.list);
         if (res != VK_SUCCESS) {
             goto out;
         }
 
-        loader_add_layer_implicit(
-            icd_term->this_instance, VK_LAYER_TYPE_INSTANCE_IMPLICIT,
-            &implicit_layer_list,
-            &icd_term->this_instance->instance_layer_list);
+        loader_add_layer_implicit(icd_term->this_instance, VK_LAYER_TYPE_INSTANCE_IMPLICIT, &implicit_layer_list,
+                                  &icd_term->this_instance->instance_layer_list);
 
         for (uint32_t i = 0; i < implicit_layer_list.count; i++) {
-            for (uint32_t j = 0;
-                 j < implicit_layer_list.list[i].device_extension_list.count;
-                 j++) {
-                res = loader_add_to_ext_list(icd_term->this_instance, &all_exts,
-                                             1,
-                                             &implicit_layer_list.list[i]
-                                                  .device_extension_list.list[j]
-                                                  .props);
+            for (uint32_t j = 0; j < implicit_layer_list.list[i].device_extension_list.count; j++) {
+                res = loader_add_to_ext_list(icd_term->this_instance, &all_exts, 1,
+                                             &implicit_layer_list.list[i].device_extension_list.list[j].props);
                 if (res != VK_SUCCESS) {
                     goto out;
                 }
@@ -5896,8 +5161,7 @@
         *pPropertyCount = icd_ext_count;
 
         for (uint32_t i = 0; i < implicit_layer_list.count; i++) {
-            *pPropertyCount +=
-                implicit_layer_list.list[i].device_extension_list.count;
+            *pPropertyCount += implicit_layer_list.list[i].device_extension_list.count;
         }
         res = VK_SUCCESS;
     }
@@ -5905,31 +5169,24 @@
 out:
 
     if (NULL != implicit_layer_list.list) {
-        loader_destroy_generic_list(
-            icd_term->this_instance,
-            (struct loader_generic_list *)&implicit_layer_list);
+        loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&implicit_layer_list);
     }
     if (NULL != all_exts.list) {
-        loader_destroy_generic_list(icd_term->this_instance,
-                                    (struct loader_generic_list *)&all_exts);
+        loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&all_exts);
     }
     if (NULL != icd_exts.list) {
-        loader_destroy_generic_list(icd_term->this_instance,
-                                    (struct loader_generic_list *)&icd_exts);
+        loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&icd_exts);
     }
 
     return res;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceLayerProperties(
-    VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-    VkLayerProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
+                                                                         VkLayerProperties *pProperties) {
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-               "Encountered the vkEnumerateDeviceLayerProperties "
-               "terminator.  This means a layer improperly continued.");
+    loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "Encountered the vkEnumerateDeviceLayerProperties "
+                                                                          "terminator.  This means a layer improperly continued.");
     // Should never get here this call isn't dispatched down the chain
     return VK_ERROR_INITIALIZATION_FAILED;
 }
diff --git a/loader/loader.h b/loader/loader.h
index 019125f..e355b55 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -58,7 +58,6 @@
 #define MAX_NUM_UNKNOWN_EXTS 250
 #endif
 
-
 enum layer_type {
     VK_LAYER_TYPE_INSTANCE_EXPLICIT = 0x1,
     VK_LAYER_TYPE_INSTANCE_IMPLICIT = 0x2,
@@ -83,14 +82,13 @@
 static const char UTF8_DATA_BYTE_MASK = 0xC0;
 
 static const char std_validation_names[7][VK_MAX_EXTENSION_NAME_SIZE] = {
-    "VK_LAYER_GOOGLE_threading",       "VK_LAYER_LUNARG_parameter_validation",
-    "VK_LAYER_LUNARG_object_tracker",  "VK_LAYER_LUNARG_image",
-    "VK_LAYER_LUNARG_core_validation", "VK_LAYER_LUNARG_swapchain",
-     "VK_LAYER_GOOGLE_unique_objects"};
+    "VK_LAYER_GOOGLE_threading",     "VK_LAYER_LUNARG_parameter_validation", "VK_LAYER_LUNARG_object_tracker",
+    "VK_LAYER_LUNARG_image",         "VK_LAYER_LUNARG_core_validation",      "VK_LAYER_LUNARG_swapchain",
+    "VK_LAYER_GOOGLE_unique_objects"};
 
 struct VkStructureHeader {
     VkStructureType sType;
-    const void* pNext;
+    const void *pNext;
 };
 
 // form of all dynamic lists/arrays
@@ -159,7 +157,6 @@
     uint32_t *index; // index into the dev_ext dispatch table
 };
 
-
 // loader_dispatch_hash_entry and loader_dev_ext_dispatch_table.dev_ext have
 // one to one correspondence; one loader_dispatch_hash_entry for one dev_ext
 // dispatch entry.
@@ -183,7 +180,7 @@
 struct loader_device {
     struct loader_dev_dispatch_table loader_dispatch;
     VkDevice chain_device; // device object from the dispatch chain
-    VkDevice icd_device; // device object from the icd
+    VkDevice icd_device;   // device object from the icd
     struct loader_physical_device_term *phys_dev_term;
 
     struct loader_layer_list activated_layer_list;
@@ -205,54 +202,41 @@
     PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
     PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
     PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
-    PFN_vkGetPhysicalDeviceImageFormatProperties
-        GetPhysicalDeviceImageFormatProperties;
+    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
     PFN_vkCreateDevice CreateDevice;
     PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties
-        GetPhysicalDeviceQueueFamilyProperties;
+    PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
     PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
     PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties
-        GetPhysicalDeviceSparseImageFormatProperties;
+    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
     // WSI extensions
     PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
-    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
-        GetPhysicalDeviceSurfaceCapabilitiesKHR;
+    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
     PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
-    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR
-        GetPhysicalDeviceSurfacePresentModesKHR;
+    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     PFN_vkCreateWin32SurfaceKHR CreateWin32SurfaceKHR;
-    PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR
-        GetPhysicalDeviceWin32PresentationSupportKHR;
+    PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR GetPhysicalDeviceWin32PresentationSupportKHR;
 #endif
 #ifdef VK_USE_PLATFORM_MIR_KHR
     PFN_vkCreateMirSurfaceKHR CreateMirSurfaceKHR;
-    PFN_vkGetPhysicalDeviceMirPresentationSupportKHR
-        GetPhysicalDeviceMirPresentationSupportKHR;
+    PFN_vkGetPhysicalDeviceMirPresentationSupportKHR GetPhysicalDeviceMirPresentationSupportKHR;
 #endif
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
     PFN_vkCreateWaylandSurfaceKHR CreateWaylandSurfaceKHR;
-    PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR
-        GetPhysicalDeviceWaylandPresentationSupportKHR;
+    PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR GetPhysicalDeviceWaylandPresentationSupportKHR;
 #endif
 #ifdef VK_USE_PLATFORM_XCB_KHR
     PFN_vkCreateXcbSurfaceKHR CreateXcbSurfaceKHR;
-    PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR
-        GetPhysicalDeviceXcbPresentationSupportKHR;
+    PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR GetPhysicalDeviceXcbPresentationSupportKHR;
 #endif
 #ifdef VK_USE_PLATFORM_XLIB_KHR
     PFN_vkCreateXlibSurfaceKHR CreateXlibSurfaceKHR;
-    PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR
-        GetPhysicalDeviceXlibPresentationSupportKHR;
+    PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR GetPhysicalDeviceXlibPresentationSupportKHR;
 #endif
-    PFN_vkGetPhysicalDeviceDisplayPropertiesKHR
-        GetPhysicalDeviceDisplayPropertiesKHR;
-    PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR
-        GetPhysicalDeviceDisplayPlanePropertiesKHR;
-    PFN_vkGetDisplayPlaneSupportedDisplaysKHR
-        GetDisplayPlaneSupportedDisplaysKHR;
+    PFN_vkGetPhysicalDeviceDisplayPropertiesKHR GetPhysicalDeviceDisplayPropertiesKHR;
+    PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR GetPhysicalDeviceDisplayPlanePropertiesKHR;
+    PFN_vkGetDisplayPlaneSupportedDisplaysKHR GetDisplayPlaneSupportedDisplaysKHR;
     PFN_vkGetDisplayModePropertiesKHR GetDisplayModePropertiesKHR;
     PFN_vkCreateDisplayModeKHR CreateDisplayModeKHR;
     PFN_vkGetDisplayPlaneCapabilitiesKHR GetDisplayPlaneCapabilitiesKHR;
@@ -264,16 +248,11 @@
     // KHR_get_physical_device_properties2
     PFN_vkGetPhysicalDeviceFeatures2KHR GetPhysicalDeviceFeatures2KHR;
     PFN_vkGetPhysicalDeviceProperties2KHR GetPhysicalDeviceProperties2KHR;
-    PFN_vkGetPhysicalDeviceFormatProperties2KHR
-        GetPhysicalDeviceFormatProperties2KHR;
-    PFN_vkGetPhysicalDeviceImageFormatProperties2KHR
-        GetPhysicalDeviceImageFormatProperties2KHR;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR
-        GetPhysicalDeviceQueueFamilyProperties2KHR;
-    PFN_vkGetPhysicalDeviceMemoryProperties2KHR
-        GetPhysicalDeviceMemoryProperties2KHR;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR
-        GetPhysicalDeviceSparseImageFormatProperties2KHR;
+    PFN_vkGetPhysicalDeviceFormatProperties2KHR GetPhysicalDeviceFormatProperties2KHR;
+    PFN_vkGetPhysicalDeviceImageFormatProperties2KHR GetPhysicalDeviceImageFormatProperties2KHR;
+    PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR GetPhysicalDeviceQueueFamilyProperties2KHR;
+    PFN_vkGetPhysicalDeviceMemoryProperties2KHR GetPhysicalDeviceMemoryProperties2KHR;
+    PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR GetPhysicalDeviceSparseImageFormatProperties2KHR;
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     // EXT_acquire_xlib_display
@@ -294,20 +273,17 @@
     PFN_vkReleaseDisplayEXT ReleaseDisplayEXT;
 
     // EXT_display_surface_counter
-    PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT
-        GetPhysicalDeviceSurfaceCapabilities2EXT;
+    PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT GetPhysicalDeviceSurfaceCapabilities2EXT;
 
     // NV_external_memory_capabilities
-    PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV
-        GetPhysicalDeviceExternalImageFormatPropertiesNV;
+    PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV GetPhysicalDeviceExternalImageFormatPropertiesNV;
 
     // NVX_device_generated_commands
-    PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX
-        GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+    PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
 
     struct loader_icd_term *next;
 
-    PFN_PhysDevExt  phys_dev_ext[MAX_NUM_UNKNOWN_EXTS];
+    PFN_PhysDevExt phys_dev_ext[MAX_NUM_UNKNOWN_EXTS];
 };
 
 // per ICD library structure
@@ -333,7 +309,7 @@
     VkLayerInstanceDispatchTable layer_inst_disp; // must be first entry in structure
 
     // Physical device functions unknown to the loader
-    PFN_PhysDevExt  phys_dev_ext[MAX_NUM_UNKNOWN_EXTS];
+    PFN_PhysDevExt phys_dev_ext[MAX_NUM_UNKNOWN_EXTS];
 };
 
 // per instance structure
@@ -434,49 +410,36 @@
     PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
     PFN_GetPhysicalDeviceProcAddr GetPhysicalDeviceProcAddr;
     PFN_vkCreateInstance CreateInstance;
-    PFN_vkEnumerateInstanceExtensionProperties
-        EnumerateInstanceExtensionProperties;
+    PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
 };
 
-static inline struct loader_instance *loader_instance(VkInstance instance) {
-    return (struct loader_instance *)instance;
-}
+static inline struct loader_instance *loader_instance(VkInstance instance) { return (struct loader_instance *)instance; }
 
-static inline VkPhysicalDevice
-loader_unwrap_physical_device(VkPhysicalDevice physicalDevice) {
-    struct loader_physical_device_tramp *phys_dev =
-        (struct loader_physical_device_tramp *)physicalDevice;
+static inline VkPhysicalDevice loader_unwrap_physical_device(VkPhysicalDevice physicalDevice) {
+    struct loader_physical_device_tramp *phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
     return phys_dev->phys_dev;
 }
 
-static inline void loader_set_dispatch(void *obj, const void *data) {
-    *((const void **)obj) = data;
-}
+static inline void loader_set_dispatch(void *obj, const void *data) { *((const void **)obj) = data; }
 
-static inline VkLayerDispatchTable *loader_get_dispatch(const void *obj) {
-    return *((VkLayerDispatchTable **)obj);
-}
+static inline VkLayerDispatchTable *loader_get_dispatch(const void *obj) { return *((VkLayerDispatchTable **)obj); }
 
-static inline struct loader_dev_dispatch_table *
-loader_get_dev_dispatch(const void *obj) {
+static inline struct loader_dev_dispatch_table *loader_get_dev_dispatch(const void *obj) {
     return *((struct loader_dev_dispatch_table **)obj);
 }
 
-static inline VkLayerInstanceDispatchTable *
-loader_get_instance_layer_dispatch(const void *obj) {
+static inline VkLayerInstanceDispatchTable *loader_get_instance_layer_dispatch(const void *obj) {
     return *((VkLayerInstanceDispatchTable **)obj);
 }
 
-static inline struct loader_instance_dispatch_table *
-loader_get_instance_dispatch(const void *obj) {
+static inline struct loader_instance_dispatch_table *loader_get_instance_dispatch(const void *obj) {
     return *((struct loader_instance_dispatch_table **)obj);
 }
 
 static inline void loader_init_dispatch(void *obj, const void *data) {
 #ifdef DEBUG
-    assert(valid_loader_magic_value(obj) &&
-           "Incompatible ICD, first dword must be initialized to "
-           "ICD_LOADER_MAGIC. See loader/README.md for details.");
+    assert(valid_loader_magic_value(obj) && "Incompatible ICD, first dword must be initialized to "
+                                            "ICD_LOADER_MAGIC. See loader/README.md for details.");
 #endif
 
     loader_set_dispatch(obj, data);
@@ -497,241 +460,154 @@
 };
 
 /* helper function definitions */
-void *loader_instance_heap_alloc(const struct loader_instance *instance,
-                                 size_t size,
-                                 VkSystemAllocationScope allocationScope);
-void loader_instance_heap_free(const struct loader_instance *instance,
-                               void *pMemory);
-void *loader_instance_heap_realloc(const struct loader_instance *instance,
-                                   void *pMemory, size_t orig_size, size_t size,
+void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope allocationScope);
+void loader_instance_heap_free(const struct loader_instance *instance, void *pMemory);
+void *loader_instance_heap_realloc(const struct loader_instance *instance, void *pMemory, size_t orig_size, size_t size,
                                    VkSystemAllocationScope alloc_scope);
 void *loader_instance_tls_heap_alloc(size_t size);
 void loader_instance_tls_heap_free(void *pMemory);
-void *loader_device_heap_alloc(const struct loader_device *device, size_t size,
-                               VkSystemAllocationScope allocationScope);
+void *loader_device_heap_alloc(const struct loader_device *device, size_t size, VkSystemAllocationScope allocationScope);
 void loader_device_heap_free(const struct loader_device *device, void *pMemory);
-void *loader_device_heap_realloc(const struct loader_device *device,
-                                 void *pMemory, size_t orig_size, size_t size,
+void *loader_device_heap_realloc(const struct loader_device *device, void *pMemory, size_t orig_size, size_t size,
                                  VkSystemAllocationScope alloc_scope);
 
-void loader_log(const struct loader_instance *inst, VkFlags msg_type,
-                int32_t msg_code, const char *format, ...);
+void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t msg_code, const char *format, ...);
 
-bool compare_vk_extension_properties(const VkExtensionProperties *op1,
-                                     const VkExtensionProperties *op2);
+bool compare_vk_extension_properties(const VkExtensionProperties *op1, const VkExtensionProperties *op2);
 
-VkResult loader_validate_layers(const struct loader_instance *inst,
-                                const uint32_t layer_count,
-                                const char *const *ppEnabledLayerNames,
-                                const struct loader_layer_list *list);
+VkResult loader_validate_layers(const struct loader_instance *inst, const uint32_t layer_count,
+                                const char *const *ppEnabledLayerNames, const struct loader_layer_list *list);
 
-VkResult loader_validate_instance_extensions(
-    const struct loader_instance *inst,
-    const struct loader_extension_list *icd_exts,
-    const struct loader_layer_list *instance_layer,
-    const VkInstanceCreateInfo *pCreateInfo);
+VkResult loader_validate_instance_extensions(const struct loader_instance *inst, const struct loader_extension_list *icd_exts,
+                                             const struct loader_layer_list *instance_layer,
+                                             const VkInstanceCreateInfo *pCreateInfo);
 
 void loader_initialize(void);
-VkResult loader_copy_layer_properties(const struct loader_instance *inst,
-                                      struct loader_layer_properties *dst,
+VkResult loader_copy_layer_properties(const struct loader_instance *inst, struct loader_layer_properties *dst,
                                       struct loader_layer_properties *src);
-bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop,
-                                     const uint32_t count,
+bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop, const uint32_t count,
                                      const VkExtensionProperties *ext_array);
-bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop,
-                               const struct loader_extension_list *ext_list);
+bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop, const struct loader_extension_list *ext_list);
 
-VkResult loader_add_to_ext_list(const struct loader_instance *inst,
-                                struct loader_extension_list *ext_list,
-                                uint32_t prop_list_count,
-                                const VkExtensionProperties *props);
-VkResult
-loader_add_to_dev_ext_list(const struct loader_instance *inst,
-                           struct loader_device_extension_list *ext_list,
-                           const VkExtensionProperties *props,
-                           uint32_t entry_count, char **entrys);
+VkResult loader_add_to_ext_list(const struct loader_instance *inst, struct loader_extension_list *ext_list,
+                                uint32_t prop_list_count, const VkExtensionProperties *props);
+VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst, struct loader_device_extension_list *ext_list,
+                                    const VkExtensionProperties *props, uint32_t entry_count, char **entrys);
 VkResult loader_add_device_extensions(const struct loader_instance *inst,
-                                      PFN_vkEnumerateDeviceExtensionProperties
-                                          fpEnumerateDeviceExtensionProperties,
-                                      VkPhysicalDevice physical_device,
-                                      const char *lib_name,
+                                      PFN_vkEnumerateDeviceExtensionProperties fpEnumerateDeviceExtensionProperties,
+                                      VkPhysicalDevice physical_device, const char *lib_name,
                                       struct loader_extension_list *ext_list);
-VkResult loader_init_generic_list(const struct loader_instance *inst,
-                                  struct loader_generic_list *list_info,
-                                  size_t element_size);
-void loader_destroy_generic_list(const struct loader_instance *inst,
-                                 struct loader_generic_list *list);
-void loader_destroy_layer_list(const struct loader_instance *inst,
-                               struct loader_device *device,
+VkResult loader_init_generic_list(const struct loader_instance *inst, struct loader_generic_list *list_info, size_t element_size);
+void loader_destroy_generic_list(const struct loader_instance *inst, struct loader_generic_list *list);
+void loader_destroy_layer_list(const struct loader_instance *inst, struct loader_device *device,
                                struct loader_layer_list *layer_list);
-void loader_delete_layer_properties(const struct loader_instance *inst,
-                                    struct loader_layer_list *layer_list);
-bool loader_find_layer_name_array(
-    const char *name, uint32_t layer_count,
-    const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]);
-VkResult loader_expand_layer_names(
-    struct loader_instance *inst, const char *key_name, uint32_t expand_count,
-    const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE],
-    uint32_t *layer_count, char const *const **ppp_layer_names);
+void loader_delete_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_list);
+bool loader_find_layer_name_array(const char *name, uint32_t layer_count, const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]);
+VkResult loader_expand_layer_names(struct loader_instance *inst, const char *key_name, uint32_t expand_count,
+                                   const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE], uint32_t *layer_count,
+                                   char const *const **ppp_layer_names);
 void loader_init_std_validation_props(struct loader_layer_properties *props);
-void loader_delete_shadow_dev_layer_names(const struct loader_instance *inst,
-                                          const VkDeviceCreateInfo *orig,
+void loader_delete_shadow_dev_layer_names(const struct loader_instance *inst, const VkDeviceCreateInfo *orig,
                                           VkDeviceCreateInfo *ours);
-void loader_delete_shadow_inst_layer_names(const struct loader_instance *inst,
-                                           const VkInstanceCreateInfo *orig,
+void loader_delete_shadow_inst_layer_names(const struct loader_instance *inst, const VkInstanceCreateInfo *orig,
                                            VkInstanceCreateInfo *ours);
-VkResult loader_add_to_layer_list(const struct loader_instance *inst,
-                                  struct loader_layer_list *list,
-                                  uint32_t prop_list_count,
+VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loader_layer_list *list, uint32_t prop_list_count,
                                   const struct loader_layer_properties *props);
-void loader_find_layer_name_add_list(
-    const struct loader_instance *inst, const char *name,
-    const enum layer_type type, const struct loader_layer_list *search_list,
-    struct loader_layer_list *found_list);
-void loader_scanned_icd_clear(const struct loader_instance *inst,
-                              struct loader_icd_tramp_list *icd_tramp_list);
-VkResult loader_icd_scan(const struct loader_instance *inst,
-                         struct loader_icd_tramp_list *icd_tramp_list);
-void loader_layer_scan(const struct loader_instance *inst,
-                       struct loader_layer_list *instance_layers);
-void loader_implicit_layer_scan(const struct loader_instance *inst,
-                                struct loader_layer_list *instance_layers);
-VkResult loader_get_icd_loader_instance_extensions(
-    const struct loader_instance *inst,
-    struct loader_icd_tramp_list *icd_tramp_list,
-    struct loader_extension_list *inst_exts);
-struct loader_icd_term *
-loader_get_icd_and_device(const VkDevice device,
-                          struct loader_device **found_dev,
-                          uint32_t *icd_index);
-void loader_init_dispatch_dev_ext(struct loader_instance *inst,
-                                  struct loader_device *dev);
+void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type type,
+                                     const struct loader_layer_list *search_list, struct loader_layer_list *found_list);
+void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list);
+VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list);
+void loader_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers);
+void loader_implicit_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers);
+VkResult loader_get_icd_loader_instance_extensions(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list,
+                                                   struct loader_extension_list *inst_exts);
+struct loader_icd_term *loader_get_icd_and_device(const VkDevice device, struct loader_device **found_dev, uint32_t *icd_index);
+void loader_init_dispatch_dev_ext(struct loader_instance *inst, struct loader_device *dev);
 void *loader_dev_ext_gpa(struct loader_instance *inst, const char *funcName);
 void *loader_get_dev_ext_trampoline(uint32_t index);
-bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName,
-                             bool perform_checking, void **tramp_addr, void **term_addr);
+bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName, bool perform_checking, void **tramp_addr,
+                             void **term_addr);
 void *loader_get_phys_dev_ext_tramp(uint32_t index);
 void *loader_get_phys_dev_ext_termin(uint32_t index);
 struct loader_instance *loader_get_instance(const VkInstance instance);
-void loader_deactivate_layers(const struct loader_instance *instance,
-                              struct loader_device *device,
-                              struct loader_layer_list *list);
-struct loader_device *
-loader_create_logical_device(const struct loader_instance *inst,
-                             const VkAllocationCallbacks *pAllocator);
-void loader_add_logical_device(const struct loader_instance *inst,
-                               struct loader_icd_term *icd_term,
+void loader_deactivate_layers(const struct loader_instance *instance, struct loader_device *device, struct loader_layer_list *list);
+struct loader_device *loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator);
+void loader_add_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term,
                                struct loader_device *found_dev);
-void loader_remove_logical_device(const struct loader_instance *inst,
-                                  struct loader_icd_term *icd_term,
-                                  struct loader_device *found_dev,
-                                  const VkAllocationCallbacks *pAllocator);
+void loader_remove_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term,
+                                  struct loader_device *found_dev, const VkAllocationCallbacks *pAllocator);
 // NOTE: Outside of loader, this entry-point is only proivided for error
 // cleanup.
-void loader_destroy_logical_device(const struct loader_instance *inst,
-                                   struct loader_device *dev,
+void loader_destroy_logical_device(const struct loader_instance *inst, struct loader_device *dev,
                                    const VkAllocationCallbacks *pAllocator);
 
-VkResult
-loader_enable_instance_layers(struct loader_instance *inst,
-                              const VkInstanceCreateInfo *pCreateInfo,
-                              const struct loader_layer_list *instance_layers);
+VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo,
+                                       const struct loader_layer_list *instance_layers);
 void loader_deactivate_instance_layers(struct loader_instance *instance);
 
-VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo,
-                                      const VkAllocationCallbacks *pAllocator,
-                                      struct loader_instance *inst,
-                                      VkInstance *created_instance);
+VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
+                                      struct loader_instance *inst, VkInstance *created_instance);
 
-void loader_activate_instance_layer_extensions(struct loader_instance *inst,
-                                               VkInstance created_inst);
-VkResult
-loader_enable_device_layers(const struct loader_instance *inst,
-                            struct loader_layer_list *activated_layer_list,
-                            const VkDeviceCreateInfo *pCreateInfo,
-                            const struct loader_layer_list *device_layers);
+void loader_activate_instance_layer_extensions(struct loader_instance *inst, VkInstance created_inst);
+VkResult loader_enable_device_layers(const struct loader_instance *inst, struct loader_layer_list *activated_layer_list,
+                                     const VkDeviceCreateInfo *pCreateInfo, const struct loader_layer_list *device_layers);
 
-VkResult
-loader_create_device_chain(const struct loader_physical_device_tramp *pd,
-                           const VkDeviceCreateInfo *pCreateInfo,
-                           const VkAllocationCallbacks *pAllocator,
-                           const struct loader_instance *inst,
-                           struct loader_device *dev);
+VkResult loader_create_device_chain(const struct loader_physical_device_tramp *pd, const VkDeviceCreateInfo *pCreateInfo,
+                                    const VkAllocationCallbacks *pAllocator, const struct loader_instance *inst,
+                                    struct loader_device *dev);
 
-VkResult loader_validate_device_extensions(
-    struct loader_physical_device_tramp *phys_dev,
-    const struct loader_layer_list *activated_device_layers,
-    const struct loader_extension_list *icd_exts,
-    const VkDeviceCreateInfo *pCreateInfo);
+VkResult loader_validate_device_extensions(struct loader_physical_device_tramp *phys_dev,
+                                           const struct loader_layer_list *activated_device_layers,
+                                           const struct loader_extension_list *icd_exts, const VkDeviceCreateInfo *pCreateInfo);
 
 VkResult setupLoaderTrampPhysDevs(VkInstance instance);
 VkResult setupLoaderTermPhysDevs(struct loader_instance *inst);
 
 /* instance layer chain termination entrypoint definitions */
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
-                          const VkAllocationCallbacks *pAllocator,
-                          VkInstance *pInstance);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
+                                                         const VkAllocationCallbacks *pAllocator, VkInstance *pInstance);
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_DestroyInstance(VkInstance instance,
-                           const VkAllocationCallbacks *pAllocator);
+VKAPI_ATTR void VKAPI_CALL terminator_DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator);
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_EnumeratePhysicalDevices(VkInstance instance,
-                                    uint32_t *pPhysicalDeviceCount,
-                                    VkPhysicalDevice *pPhysicalDevices);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
+                                                                   VkPhysicalDevice *pPhysicalDevices);
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
-                                     VkPhysicalDeviceFeatures *pFeatures);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+                                                                VkPhysicalDeviceFeatures *pFeatures);
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
-                                             VkFormat format,
-                                             VkFormatProperties *pFormatInfo);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                        VkFormatProperties *pFormatInfo);
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceImageFormatProperties(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
-    VkImageFormatProperties *pImageFormatProperties);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                                 VkImageType type, VkImageTiling tiling,
+                                                                                 VkImageUsageFlags usage, VkImageCreateFlags flags,
+                                                                                 VkImageFormatProperties *pImageFormatProperties);
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceSparseImageFormatProperties(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkSampleCountFlagBits samples, VkImageUsageFlags usage,
-    VkImageTiling tiling, uint32_t *pNumProperties,
-    VkSparseImageFormatProperties *pProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                                   VkImageType type, VkSampleCountFlagBits samples,
+                                                                                   VkImageUsageFlags usage, VkImageTiling tiling,
+                                                                                   uint32_t *pNumProperties,
+                                                                                   VkSparseImageFormatProperties *pProperties);
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
-                                       VkPhysicalDeviceProperties *pProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+                                                                  VkPhysicalDeviceProperties *pProperties);
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(
-    VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pCount,
-    VkExtensionProperties *pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
+                                                                             const char *pLayerName, uint32_t *pCount,
+                                                                             VkExtensionProperties *pProperties);
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
-                                          uint32_t *pCount,
-                                          VkLayerProperties *pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
+                                                                         VkLayerProperties *pProperties);
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties(
-    VkPhysicalDevice physicalDevice, uint32_t *pCount,
-    VkQueueFamilyProperties *pProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
+                                                                             VkQueueFamilyProperties *pProperties);
 
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceMemoryProperties *pProperties);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
+                                                                        VkPhysicalDeviceMemoryProperties *pProperties);
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_CreateDevice(VkPhysicalDevice gpu,
-                        const VkDeviceCreateInfo *pCreateInfo,
-                        const VkAllocationCallbacks *pAllocator,
-                        VkDevice *pDevice);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
+                                                       const VkAllocationCallbacks *pAllocator, VkDevice *pDevice);
 
-VkStringErrorFlags vk_string_validate(const int max_length,
-                                      const char *char_array);
+VkStringErrorFlags vk_string_validate(const int max_length, const char *char_array);
 
 #endif /* LOADER_H */
diff --git a/loader/phys_dev_ext.c b/loader/phys_dev_ext.c
index 27a09ef..cf2ada5 100644
--- a/loader/phys_dev_ext.c
+++ b/loader/phys_dev_ext.c
@@ -34,30 +34,24 @@
 #endif
 
 // Trampoline function macro for unknown physical device extension command.
-#define PhysDevExtTramp(num)                                                   \
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp##num(                             \
-        VkPhysicalDevice physical_device) {                                    \
-        const struct loader_instance_dispatch_table *disp;                     \
-        disp = loader_get_instance_dispatch(physical_device);                  \
-        disp->phys_dev_ext[num](                                               \
-            loader_unwrap_physical_device(physical_device));                   \
+#define PhysDevExtTramp(num)                                                                                                       \
+    VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp##num(VkPhysicalDevice physical_device) {                                          \
+        const struct loader_instance_dispatch_table *disp;                                                                         \
+        disp = loader_get_instance_dispatch(physical_device);                                                                      \
+        disp->phys_dev_ext[num](loader_unwrap_physical_device(physical_device));                                                   \
     }
 
 // Terminator function macro for unknown physical device extension command.
-#define PhysDevExtTermin(num)                                                  \
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin##num(                            \
-        VkPhysicalDevice physical_device) {                                    \
-        struct loader_physical_device_term *phys_dev_term =                    \
-            (struct loader_physical_device_term *)physical_device;             \
-        struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;       \
-        struct loader_instance *inst =                                         \
-            (struct loader_instance *)icd_term->this_instance;                 \
-        if (NULL == icd_term->phys_dev_ext[num]) {                             \
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,                 \
-                       "Extension %s not supported for this physical device",  \
-                       inst->phys_dev_ext_disp_hash[num].func_name);           \
-        }                                                                      \
-        icd_term->phys_dev_ext[num](phys_dev_term->phys_dev);                  \
+#define PhysDevExtTermin(num)                                                                                                      \
+    VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin##num(VkPhysicalDevice physical_device) {                                         \
+        struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physical_device;                 \
+        struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;                                                           \
+        struct loader_instance *inst = (struct loader_instance *)icd_term->this_instance;                                          \
+        if (NULL == icd_term->phys_dev_ext[num]) {                                                                                 \
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "Extension %s not supported for this physical device",              \
+                       inst->phys_dev_ext_disp_hash[num].func_name);                                                               \
+        }                                                                                                                          \
+        icd_term->phys_dev_ext[num](phys_dev_term->phys_dev);                                                                      \
     }
 
 // Disable clang-format for lists of macros
diff --git a/loader/table_ops.h b/loader/table_ops.h
index b3b9079..15a7e99 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -32,8 +32,7 @@
 static VkResult VKAPI_CALL vkDevExtError(VkDevice dev) {
     struct loader_device *found_dev;
     // The device going in is a trampoline device
-    struct loader_icd_term *icd_term =
-        loader_get_icd_and_device(dev, &found_dev, NULL);
+    struct loader_icd_term *icd_term = loader_get_icd_and_device(dev, &found_dev, NULL);
 
     if (icd_term)
         loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
@@ -42,15 +41,13 @@
     return VK_ERROR_EXTENSION_NOT_PRESENT;
 }
 
-static inline void
-loader_init_device_dispatch_table(struct loader_dev_dispatch_table *dev_table,
-                                  PFN_vkGetDeviceProcAddr gpa, VkDevice dev) {
+static inline void loader_init_device_dispatch_table(struct loader_dev_dispatch_table *dev_table, PFN_vkGetDeviceProcAddr gpa,
+                                                     VkDevice dev) {
     VkLayerDispatchTable *table = &dev_table->core_dispatch;
     for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++)
         dev_table->ext_dispatch.dev_ext[i] = (PFN_vkDevExt)vkDevExtError;
 
-    table->GetDeviceProcAddr =
-        (PFN_vkGetDeviceProcAddr)gpa(dev, "vkGetDeviceProcAddr");
+    table->GetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)gpa(dev, "vkGetDeviceProcAddr");
     table->DestroyDevice = (PFN_vkDestroyDevice)gpa(dev, "vkDestroyDevice");
     table->GetDeviceQueue = (PFN_vkGetDeviceQueue)gpa(dev, "vkGetDeviceQueue");
     table->QueueSubmit = (PFN_vkQueueSubmit)gpa(dev, "vkQueueSubmit");
@@ -60,284 +57,170 @@
     table->FreeMemory = (PFN_vkFreeMemory)gpa(dev, "vkFreeMemory");
     table->MapMemory = (PFN_vkMapMemory)gpa(dev, "vkMapMemory");
     table->UnmapMemory = (PFN_vkUnmapMemory)gpa(dev, "vkUnmapMemory");
-    table->FlushMappedMemoryRanges =
-        (PFN_vkFlushMappedMemoryRanges)gpa(dev, "vkFlushMappedMemoryRanges");
-    table->InvalidateMappedMemoryRanges =
-        (PFN_vkInvalidateMappedMemoryRanges)gpa(
-            dev, "vkInvalidateMappedMemoryRanges");
-    table->GetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment)gpa(
-        dev, "vkGetDeviceMemoryCommitment");
+    table->FlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)gpa(dev, "vkFlushMappedMemoryRanges");
+    table->InvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)gpa(dev, "vkInvalidateMappedMemoryRanges");
+    table->GetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment)gpa(dev, "vkGetDeviceMemoryCommitment");
     table->GetImageSparseMemoryRequirements =
-        (PFN_vkGetImageSparseMemoryRequirements)gpa(
-            dev, "vkGetImageSparseMemoryRequirements");
-    table->GetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)gpa(
-        dev, "vkGetBufferMemoryRequirements");
-    table->GetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)gpa(
-        dev, "vkGetImageMemoryRequirements");
-    table->BindBufferMemory =
-        (PFN_vkBindBufferMemory)gpa(dev, "vkBindBufferMemory");
-    table->BindImageMemory =
-        (PFN_vkBindImageMemory)gpa(dev, "vkBindImageMemory");
-    table->QueueBindSparse =
-        (PFN_vkQueueBindSparse)gpa(dev, "vkQueueBindSparse");
+        (PFN_vkGetImageSparseMemoryRequirements)gpa(dev, "vkGetImageSparseMemoryRequirements");
+    table->GetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)gpa(dev, "vkGetBufferMemoryRequirements");
+    table->GetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)gpa(dev, "vkGetImageMemoryRequirements");
+    table->BindBufferMemory = (PFN_vkBindBufferMemory)gpa(dev, "vkBindBufferMemory");
+    table->BindImageMemory = (PFN_vkBindImageMemory)gpa(dev, "vkBindImageMemory");
+    table->QueueBindSparse = (PFN_vkQueueBindSparse)gpa(dev, "vkQueueBindSparse");
     table->CreateFence = (PFN_vkCreateFence)gpa(dev, "vkCreateFence");
     table->DestroyFence = (PFN_vkDestroyFence)gpa(dev, "vkDestroyFence");
     table->ResetFences = (PFN_vkResetFences)gpa(dev, "vkResetFences");
     table->GetFenceStatus = (PFN_vkGetFenceStatus)gpa(dev, "vkGetFenceStatus");
     table->WaitForFences = (PFN_vkWaitForFences)gpa(dev, "vkWaitForFences");
-    table->CreateSemaphore =
-        (PFN_vkCreateSemaphore)gpa(dev, "vkCreateSemaphore");
-    table->DestroySemaphore =
-        (PFN_vkDestroySemaphore)gpa(dev, "vkDestroySemaphore");
+    table->CreateSemaphore = (PFN_vkCreateSemaphore)gpa(dev, "vkCreateSemaphore");
+    table->DestroySemaphore = (PFN_vkDestroySemaphore)gpa(dev, "vkDestroySemaphore");
     table->CreateEvent = (PFN_vkCreateEvent)gpa(dev, "vkCreateEvent");
     table->DestroyEvent = (PFN_vkDestroyEvent)gpa(dev, "vkDestroyEvent");
     table->GetEventStatus = (PFN_vkGetEventStatus)gpa(dev, "vkGetEventStatus");
     table->SetEvent = (PFN_vkSetEvent)gpa(dev, "vkSetEvent");
     table->ResetEvent = (PFN_vkResetEvent)gpa(dev, "vkResetEvent");
-    table->CreateQueryPool =
-        (PFN_vkCreateQueryPool)gpa(dev, "vkCreateQueryPool");
-    table->DestroyQueryPool =
-        (PFN_vkDestroyQueryPool)gpa(dev, "vkDestroyQueryPool");
-    table->GetQueryPoolResults =
-        (PFN_vkGetQueryPoolResults)gpa(dev, "vkGetQueryPoolResults");
+    table->CreateQueryPool = (PFN_vkCreateQueryPool)gpa(dev, "vkCreateQueryPool");
+    table->DestroyQueryPool = (PFN_vkDestroyQueryPool)gpa(dev, "vkDestroyQueryPool");
+    table->GetQueryPoolResults = (PFN_vkGetQueryPoolResults)gpa(dev, "vkGetQueryPoolResults");
     table->CreateBuffer = (PFN_vkCreateBuffer)gpa(dev, "vkCreateBuffer");
     table->DestroyBuffer = (PFN_vkDestroyBuffer)gpa(dev, "vkDestroyBuffer");
-    table->CreateBufferView =
-        (PFN_vkCreateBufferView)gpa(dev, "vkCreateBufferView");
-    table->DestroyBufferView =
-        (PFN_vkDestroyBufferView)gpa(dev, "vkDestroyBufferView");
+    table->CreateBufferView = (PFN_vkCreateBufferView)gpa(dev, "vkCreateBufferView");
+    table->DestroyBufferView = (PFN_vkDestroyBufferView)gpa(dev, "vkDestroyBufferView");
     table->CreateImage = (PFN_vkCreateImage)gpa(dev, "vkCreateImage");
     table->DestroyImage = (PFN_vkDestroyImage)gpa(dev, "vkDestroyImage");
-    table->GetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout)gpa(
-        dev, "vkGetImageSubresourceLayout");
-    table->CreateImageView =
-        (PFN_vkCreateImageView)gpa(dev, "vkCreateImageView");
-    table->DestroyImageView =
-        (PFN_vkDestroyImageView)gpa(dev, "vkDestroyImageView");
-    table->CreateShaderModule =
-        (PFN_vkCreateShaderModule)gpa(dev, "vkCreateShaderModule");
-    table->DestroyShaderModule =
-        (PFN_vkDestroyShaderModule)gpa(dev, "vkDestroyShaderModule");
-    table->CreatePipelineCache =
-        (PFN_vkCreatePipelineCache)gpa(dev, "vkCreatePipelineCache");
-    table->DestroyPipelineCache =
-        (PFN_vkDestroyPipelineCache)gpa(dev, "vkDestroyPipelineCache");
-    table->GetPipelineCacheData =
-        (PFN_vkGetPipelineCacheData)gpa(dev, "vkGetPipelineCacheData");
-    table->MergePipelineCaches =
-        (PFN_vkMergePipelineCaches)gpa(dev, "vkMergePipelineCaches");
-    table->CreateGraphicsPipelines =
-        (PFN_vkCreateGraphicsPipelines)gpa(dev, "vkCreateGraphicsPipelines");
-    table->CreateComputePipelines =
-        (PFN_vkCreateComputePipelines)gpa(dev, "vkCreateComputePipelines");
-    table->DestroyPipeline =
-        (PFN_vkDestroyPipeline)gpa(dev, "vkDestroyPipeline");
-    table->CreatePipelineLayout =
-        (PFN_vkCreatePipelineLayout)gpa(dev, "vkCreatePipelineLayout");
-    table->DestroyPipelineLayout =
-        (PFN_vkDestroyPipelineLayout)gpa(dev, "vkDestroyPipelineLayout");
+    table->GetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout)gpa(dev, "vkGetImageSubresourceLayout");
+    table->CreateImageView = (PFN_vkCreateImageView)gpa(dev, "vkCreateImageView");
+    table->DestroyImageView = (PFN_vkDestroyImageView)gpa(dev, "vkDestroyImageView");
+    table->CreateShaderModule = (PFN_vkCreateShaderModule)gpa(dev, "vkCreateShaderModule");
+    table->DestroyShaderModule = (PFN_vkDestroyShaderModule)gpa(dev, "vkDestroyShaderModule");
+    table->CreatePipelineCache = (PFN_vkCreatePipelineCache)gpa(dev, "vkCreatePipelineCache");
+    table->DestroyPipelineCache = (PFN_vkDestroyPipelineCache)gpa(dev, "vkDestroyPipelineCache");
+    table->GetPipelineCacheData = (PFN_vkGetPipelineCacheData)gpa(dev, "vkGetPipelineCacheData");
+    table->MergePipelineCaches = (PFN_vkMergePipelineCaches)gpa(dev, "vkMergePipelineCaches");
+    table->CreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines)gpa(dev, "vkCreateGraphicsPipelines");
+    table->CreateComputePipelines = (PFN_vkCreateComputePipelines)gpa(dev, "vkCreateComputePipelines");
+    table->DestroyPipeline = (PFN_vkDestroyPipeline)gpa(dev, "vkDestroyPipeline");
+    table->CreatePipelineLayout = (PFN_vkCreatePipelineLayout)gpa(dev, "vkCreatePipelineLayout");
+    table->DestroyPipelineLayout = (PFN_vkDestroyPipelineLayout)gpa(dev, "vkDestroyPipelineLayout");
     table->CreateSampler = (PFN_vkCreateSampler)gpa(dev, "vkCreateSampler");
     table->DestroySampler = (PFN_vkDestroySampler)gpa(dev, "vkDestroySampler");
-    table->CreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout)gpa(
-        dev, "vkCreateDescriptorSetLayout");
-    table->DestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout)gpa(
-        dev, "vkDestroyDescriptorSetLayout");
-    table->CreateDescriptorPool =
-        (PFN_vkCreateDescriptorPool)gpa(dev, "vkCreateDescriptorPool");
-    table->DestroyDescriptorPool =
-        (PFN_vkDestroyDescriptorPool)gpa(dev, "vkDestroyDescriptorPool");
-    table->ResetDescriptorPool =
-        (PFN_vkResetDescriptorPool)gpa(dev, "vkResetDescriptorPool");
-    table->AllocateDescriptorSets =
-        (PFN_vkAllocateDescriptorSets)gpa(dev, "vkAllocateDescriptorSets");
-    table->FreeDescriptorSets =
-        (PFN_vkFreeDescriptorSets)gpa(dev, "vkFreeDescriptorSets");
-    table->UpdateDescriptorSets =
-        (PFN_vkUpdateDescriptorSets)gpa(dev, "vkUpdateDescriptorSets");
-    table->CreateFramebuffer =
-        (PFN_vkCreateFramebuffer)gpa(dev, "vkCreateFramebuffer");
-    table->DestroyFramebuffer =
-        (PFN_vkDestroyFramebuffer)gpa(dev, "vkDestroyFramebuffer");
-    table->CreateRenderPass =
-        (PFN_vkCreateRenderPass)gpa(dev, "vkCreateRenderPass");
-    table->DestroyRenderPass =
-        (PFN_vkDestroyRenderPass)gpa(dev, "vkDestroyRenderPass");
-    table->GetRenderAreaGranularity =
-        (PFN_vkGetRenderAreaGranularity)gpa(dev, "vkGetRenderAreaGranularity");
-    table->CreateCommandPool =
-        (PFN_vkCreateCommandPool)gpa(dev, "vkCreateCommandPool");
-    table->DestroyCommandPool =
-        (PFN_vkDestroyCommandPool)gpa(dev, "vkDestroyCommandPool");
-    table->ResetCommandPool =
-        (PFN_vkResetCommandPool)gpa(dev, "vkResetCommandPool");
-    table->AllocateCommandBuffers =
-        (PFN_vkAllocateCommandBuffers)gpa(dev, "vkAllocateCommandBuffers");
-    table->FreeCommandBuffers =
-        (PFN_vkFreeCommandBuffers)gpa(dev, "vkFreeCommandBuffers");
-    table->BeginCommandBuffer =
-        (PFN_vkBeginCommandBuffer)gpa(dev, "vkBeginCommandBuffer");
-    table->EndCommandBuffer =
-        (PFN_vkEndCommandBuffer)gpa(dev, "vkEndCommandBuffer");
-    table->ResetCommandBuffer =
-        (PFN_vkResetCommandBuffer)gpa(dev, "vkResetCommandBuffer");
-    table->CmdBindPipeline =
-        (PFN_vkCmdBindPipeline)gpa(dev, "vkCmdBindPipeline");
+    table->CreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout)gpa(dev, "vkCreateDescriptorSetLayout");
+    table->DestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout)gpa(dev, "vkDestroyDescriptorSetLayout");
+    table->CreateDescriptorPool = (PFN_vkCreateDescriptorPool)gpa(dev, "vkCreateDescriptorPool");
+    table->DestroyDescriptorPool = (PFN_vkDestroyDescriptorPool)gpa(dev, "vkDestroyDescriptorPool");
+    table->ResetDescriptorPool = (PFN_vkResetDescriptorPool)gpa(dev, "vkResetDescriptorPool");
+    table->AllocateDescriptorSets = (PFN_vkAllocateDescriptorSets)gpa(dev, "vkAllocateDescriptorSets");
+    table->FreeDescriptorSets = (PFN_vkFreeDescriptorSets)gpa(dev, "vkFreeDescriptorSets");
+    table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets)gpa(dev, "vkUpdateDescriptorSets");
+    table->CreateFramebuffer = (PFN_vkCreateFramebuffer)gpa(dev, "vkCreateFramebuffer");
+    table->DestroyFramebuffer = (PFN_vkDestroyFramebuffer)gpa(dev, "vkDestroyFramebuffer");
+    table->CreateRenderPass = (PFN_vkCreateRenderPass)gpa(dev, "vkCreateRenderPass");
+    table->DestroyRenderPass = (PFN_vkDestroyRenderPass)gpa(dev, "vkDestroyRenderPass");
+    table->GetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity)gpa(dev, "vkGetRenderAreaGranularity");
+    table->CreateCommandPool = (PFN_vkCreateCommandPool)gpa(dev, "vkCreateCommandPool");
+    table->DestroyCommandPool = (PFN_vkDestroyCommandPool)gpa(dev, "vkDestroyCommandPool");
+    table->ResetCommandPool = (PFN_vkResetCommandPool)gpa(dev, "vkResetCommandPool");
+    table->AllocateCommandBuffers = (PFN_vkAllocateCommandBuffers)gpa(dev, "vkAllocateCommandBuffers");
+    table->FreeCommandBuffers = (PFN_vkFreeCommandBuffers)gpa(dev, "vkFreeCommandBuffers");
+    table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer)gpa(dev, "vkBeginCommandBuffer");
+    table->EndCommandBuffer = (PFN_vkEndCommandBuffer)gpa(dev, "vkEndCommandBuffer");
+    table->ResetCommandBuffer = (PFN_vkResetCommandBuffer)gpa(dev, "vkResetCommandBuffer");
+    table->CmdBindPipeline = (PFN_vkCmdBindPipeline)gpa(dev, "vkCmdBindPipeline");
     table->CmdSetViewport = (PFN_vkCmdSetViewport)gpa(dev, "vkCmdSetViewport");
     table->CmdSetScissor = (PFN_vkCmdSetScissor)gpa(dev, "vkCmdSetScissor");
-    table->CmdSetLineWidth =
-        (PFN_vkCmdSetLineWidth)gpa(dev, "vkCmdSetLineWidth");
-    table->CmdSetDepthBias =
-        (PFN_vkCmdSetDepthBias)gpa(dev, "vkCmdSetDepthBias");
-    table->CmdSetBlendConstants =
-        (PFN_vkCmdSetBlendConstants)gpa(dev, "vkCmdSetBlendConstants");
-    table->CmdSetDepthBounds =
-        (PFN_vkCmdSetDepthBounds)gpa(dev, "vkCmdSetDepthBounds");
-    table->CmdSetStencilCompareMask =
-        (PFN_vkCmdSetStencilCompareMask)gpa(dev, "vkCmdSetStencilCompareMask");
-    table->CmdSetStencilWriteMask =
-        (PFN_vkCmdSetStencilWriteMask)gpa(dev, "vkCmdSetStencilWriteMask");
-    table->CmdSetStencilReference =
-        (PFN_vkCmdSetStencilReference)gpa(dev, "vkCmdSetStencilReference");
-    table->CmdBindDescriptorSets =
-        (PFN_vkCmdBindDescriptorSets)gpa(dev, "vkCmdBindDescriptorSets");
-    table->CmdBindVertexBuffers =
-        (PFN_vkCmdBindVertexBuffers)gpa(dev, "vkCmdBindVertexBuffers");
-    table->CmdBindIndexBuffer =
-        (PFN_vkCmdBindIndexBuffer)gpa(dev, "vkCmdBindIndexBuffer");
+    table->CmdSetLineWidth = (PFN_vkCmdSetLineWidth)gpa(dev, "vkCmdSetLineWidth");
+    table->CmdSetDepthBias = (PFN_vkCmdSetDepthBias)gpa(dev, "vkCmdSetDepthBias");
+    table->CmdSetBlendConstants = (PFN_vkCmdSetBlendConstants)gpa(dev, "vkCmdSetBlendConstants");
+    table->CmdSetDepthBounds = (PFN_vkCmdSetDepthBounds)gpa(dev, "vkCmdSetDepthBounds");
+    table->CmdSetStencilCompareMask = (PFN_vkCmdSetStencilCompareMask)gpa(dev, "vkCmdSetStencilCompareMask");
+    table->CmdSetStencilWriteMask = (PFN_vkCmdSetStencilWriteMask)gpa(dev, "vkCmdSetStencilWriteMask");
+    table->CmdSetStencilReference = (PFN_vkCmdSetStencilReference)gpa(dev, "vkCmdSetStencilReference");
+    table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets)gpa(dev, "vkCmdBindDescriptorSets");
+    table->CmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers)gpa(dev, "vkCmdBindVertexBuffers");
+    table->CmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer)gpa(dev, "vkCmdBindIndexBuffer");
     table->CmdDraw = (PFN_vkCmdDraw)gpa(dev, "vkCmdDraw");
     table->CmdDrawIndexed = (PFN_vkCmdDrawIndexed)gpa(dev, "vkCmdDrawIndexed");
-    table->CmdDrawIndirect =
-        (PFN_vkCmdDrawIndirect)gpa(dev, "vkCmdDrawIndirect");
-    table->CmdDrawIndexedIndirect =
-        (PFN_vkCmdDrawIndexedIndirect)gpa(dev, "vkCmdDrawIndexedIndirect");
+    table->CmdDrawIndirect = (PFN_vkCmdDrawIndirect)gpa(dev, "vkCmdDrawIndirect");
+    table->CmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect)gpa(dev, "vkCmdDrawIndexedIndirect");
     table->CmdDispatch = (PFN_vkCmdDispatch)gpa(dev, "vkCmdDispatch");
-    table->CmdDispatchIndirect =
-        (PFN_vkCmdDispatchIndirect)gpa(dev, "vkCmdDispatchIndirect");
+    table->CmdDispatchIndirect = (PFN_vkCmdDispatchIndirect)gpa(dev, "vkCmdDispatchIndirect");
     table->CmdCopyBuffer = (PFN_vkCmdCopyBuffer)gpa(dev, "vkCmdCopyBuffer");
     table->CmdCopyImage = (PFN_vkCmdCopyImage)gpa(dev, "vkCmdCopyImage");
     table->CmdBlitImage = (PFN_vkCmdBlitImage)gpa(dev, "vkCmdBlitImage");
-    table->CmdCopyBufferToImage =
-        (PFN_vkCmdCopyBufferToImage)gpa(dev, "vkCmdCopyBufferToImage");
-    table->CmdCopyImageToBuffer =
-        (PFN_vkCmdCopyImageToBuffer)gpa(dev, "vkCmdCopyImageToBuffer");
-    table->CmdUpdateBuffer =
-        (PFN_vkCmdUpdateBuffer)gpa(dev, "vkCmdUpdateBuffer");
+    table->CmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage)gpa(dev, "vkCmdCopyBufferToImage");
+    table->CmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer)gpa(dev, "vkCmdCopyImageToBuffer");
+    table->CmdUpdateBuffer = (PFN_vkCmdUpdateBuffer)gpa(dev, "vkCmdUpdateBuffer");
     table->CmdFillBuffer = (PFN_vkCmdFillBuffer)gpa(dev, "vkCmdFillBuffer");
-    table->CmdClearColorImage =
-        (PFN_vkCmdClearColorImage)gpa(dev, "vkCmdClearColorImage");
-    table->CmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage)gpa(
-        dev, "vkCmdClearDepthStencilImage");
-    table->CmdClearAttachments =
-        (PFN_vkCmdClearAttachments)gpa(dev, "vkCmdClearAttachments");
-    table->CmdResolveImage =
-        (PFN_vkCmdResolveImage)gpa(dev, "vkCmdResolveImage");
+    table->CmdClearColorImage = (PFN_vkCmdClearColorImage)gpa(dev, "vkCmdClearColorImage");
+    table->CmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage)gpa(dev, "vkCmdClearDepthStencilImage");
+    table->CmdClearAttachments = (PFN_vkCmdClearAttachments)gpa(dev, "vkCmdClearAttachments");
+    table->CmdResolveImage = (PFN_vkCmdResolveImage)gpa(dev, "vkCmdResolveImage");
     table->CmdSetEvent = (PFN_vkCmdSetEvent)gpa(dev, "vkCmdSetEvent");
     table->CmdResetEvent = (PFN_vkCmdResetEvent)gpa(dev, "vkCmdResetEvent");
     table->CmdWaitEvents = (PFN_vkCmdWaitEvents)gpa(dev, "vkCmdWaitEvents");
-    table->CmdPipelineBarrier =
-        (PFN_vkCmdPipelineBarrier)gpa(dev, "vkCmdPipelineBarrier");
+    table->CmdPipelineBarrier = (PFN_vkCmdPipelineBarrier)gpa(dev, "vkCmdPipelineBarrier");
     table->CmdBeginQuery = (PFN_vkCmdBeginQuery)gpa(dev, "vkCmdBeginQuery");
     table->CmdEndQuery = (PFN_vkCmdEndQuery)gpa(dev, "vkCmdEndQuery");
-    table->CmdResetQueryPool =
-        (PFN_vkCmdResetQueryPool)gpa(dev, "vkCmdResetQueryPool");
-    table->CmdWriteTimestamp =
-        (PFN_vkCmdWriteTimestamp)gpa(dev, "vkCmdWriteTimestamp");
-    table->CmdCopyQueryPoolResults =
-        (PFN_vkCmdCopyQueryPoolResults)gpa(dev, "vkCmdCopyQueryPoolResults");
-    table->CmdPushConstants =
-        (PFN_vkCmdPushConstants)gpa(dev, "vkCmdPushConstants");
-    table->CmdBeginRenderPass =
-        (PFN_vkCmdBeginRenderPass)gpa(dev, "vkCmdBeginRenderPass");
+    table->CmdResetQueryPool = (PFN_vkCmdResetQueryPool)gpa(dev, "vkCmdResetQueryPool");
+    table->CmdWriteTimestamp = (PFN_vkCmdWriteTimestamp)gpa(dev, "vkCmdWriteTimestamp");
+    table->CmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults)gpa(dev, "vkCmdCopyQueryPoolResults");
+    table->CmdPushConstants = (PFN_vkCmdPushConstants)gpa(dev, "vkCmdPushConstants");
+    table->CmdBeginRenderPass = (PFN_vkCmdBeginRenderPass)gpa(dev, "vkCmdBeginRenderPass");
     table->CmdNextSubpass = (PFN_vkCmdNextSubpass)gpa(dev, "vkCmdNextSubpass");
-    table->CmdEndRenderPass =
-        (PFN_vkCmdEndRenderPass)gpa(dev, "vkCmdEndRenderPass");
-    table->CmdExecuteCommands =
-        (PFN_vkCmdExecuteCommands)gpa(dev, "vkCmdExecuteCommands");
+    table->CmdEndRenderPass = (PFN_vkCmdEndRenderPass)gpa(dev, "vkCmdEndRenderPass");
+    table->CmdExecuteCommands = (PFN_vkCmdExecuteCommands)gpa(dev, "vkCmdExecuteCommands");
 }
 
-static inline void loader_init_device_extension_dispatch_table(
-    struct loader_dev_dispatch_table *dev_table, PFN_vkGetDeviceProcAddr gpa,
-    VkDevice dev) {
+static inline void loader_init_device_extension_dispatch_table(struct loader_dev_dispatch_table *dev_table,
+                                                               PFN_vkGetDeviceProcAddr gpa, VkDevice dev) {
     VkLayerDispatchTable *table = &dev_table->core_dispatch;
-    table->AcquireNextImageKHR =
-        (PFN_vkAcquireNextImageKHR)gpa(dev, "vkAcquireNextImageKHR");
-    table->CreateSwapchainKHR =
-        (PFN_vkCreateSwapchainKHR)gpa(dev, "vkCreateSwapchainKHR");
-    table->DestroySwapchainKHR =
-        (PFN_vkDestroySwapchainKHR)gpa(dev, "vkDestroySwapchainKHR");
-    table->GetSwapchainImagesKHR =
-        (PFN_vkGetSwapchainImagesKHR)gpa(dev, "vkGetSwapchainImagesKHR");
-    table->QueuePresentKHR =
-        (PFN_vkQueuePresentKHR)gpa(dev, "vkQueuePresentKHR");
+    table->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR)gpa(dev, "vkAcquireNextImageKHR");
+    table->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)gpa(dev, "vkCreateSwapchainKHR");
+    table->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR)gpa(dev, "vkDestroySwapchainKHR");
+    table->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)gpa(dev, "vkGetSwapchainImagesKHR");
+    table->QueuePresentKHR = (PFN_vkQueuePresentKHR)gpa(dev, "vkQueuePresentKHR");
 
     // KHR_display_swapchain
-    table->CreateSharedSwapchainsKHR = (PFN_vkCreateSharedSwapchainsKHR)gpa(
-        dev, "vkCreateSharedSwapchainsKHR");
+    table->CreateSharedSwapchainsKHR = (PFN_vkCreateSharedSwapchainsKHR)gpa(dev, "vkCreateSharedSwapchainsKHR");
 
     // KHR_maintenance1
-    table->TrimCommandPoolKHR =
-        (PFN_vkTrimCommandPoolKHR)gpa(dev, "vkTrimCommandPoolKHR");
+    table->TrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR)gpa(dev, "vkTrimCommandPoolKHR");
 
     // EXT_display_control
-    table->DisplayPowerControlEXT =
-        (PFN_vkDisplayPowerControlEXT)gpa(dev, "vkDisplayPowerControlEXT");
-    table->RegisterDeviceEventEXT =
-        (PFN_vkRegisterDeviceEventEXT)gpa(dev, "vkRegisterDeviceEventEXT");
-    table->RegisterDisplayEventEXT =
-        (PFN_vkRegisterDisplayEventEXT)gpa(dev, "vkRegisterDisplayEventEXT");
-    table->GetSwapchainCounterEXT =
-        (PFN_vkGetSwapchainCounterEXT)gpa(dev, "vkGetSwapchainCounterEXT");
+    table->DisplayPowerControlEXT = (PFN_vkDisplayPowerControlEXT)gpa(dev, "vkDisplayPowerControlEXT");
+    table->RegisterDeviceEventEXT = (PFN_vkRegisterDeviceEventEXT)gpa(dev, "vkRegisterDeviceEventEXT");
+    table->RegisterDisplayEventEXT = (PFN_vkRegisterDisplayEventEXT)gpa(dev, "vkRegisterDisplayEventEXT");
+    table->GetSwapchainCounterEXT = (PFN_vkGetSwapchainCounterEXT)gpa(dev, "vkGetSwapchainCounterEXT");
 
     // EXT_debug_marker
-    table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)gpa(
-        dev, "vkDebugMarkerSetObjectTagEXT");
-    table->DebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)gpa(
-        dev, "vkDebugMarkerSetObjectNameEXT");
-    table->CmdDebugMarkerBeginEXT =
-        (PFN_vkCmdDebugMarkerBeginEXT)gpa(dev, "vkCmdDebugMarkerBeginEXT");
-    table->CmdDebugMarkerEndEXT =
-        (PFN_vkCmdDebugMarkerEndEXT)gpa(dev, "vkCmdDebugMarkerEndEXT");
-    table->CmdDebugMarkerInsertEXT =
-        (PFN_vkCmdDebugMarkerInsertEXT)gpa(dev, "vkCmdDebugMarkerInsertEXT");
+    table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)gpa(dev, "vkDebugMarkerSetObjectTagEXT");
+    table->DebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)gpa(dev, "vkDebugMarkerSetObjectNameEXT");
+    table->CmdDebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT)gpa(dev, "vkCmdDebugMarkerBeginEXT");
+    table->CmdDebugMarkerEndEXT = (PFN_vkCmdDebugMarkerEndEXT)gpa(dev, "vkCmdDebugMarkerEndEXT");
+    table->CmdDebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT)gpa(dev, "vkCmdDebugMarkerInsertEXT");
 
     // AMD_draw_indirect_count
-    table->CmdDrawIndirectCountAMD =
-        (PFN_vkCmdDrawIndirectCountAMD)gpa(dev, "vkCmdDrawIndirectCountAMD");
-    table->CmdDrawIndexedIndirectCountAMD =
-        (PFN_vkCmdDrawIndexedIndirectCountAMD)gpa(
-            dev, "vkCmdDrawIndexedIndirectCountAMD");
+    table->CmdDrawIndirectCountAMD = (PFN_vkCmdDrawIndirectCountAMD)gpa(dev, "vkCmdDrawIndirectCountAMD");
+    table->CmdDrawIndexedIndirectCountAMD = (PFN_vkCmdDrawIndexedIndirectCountAMD)gpa(dev, "vkCmdDrawIndexedIndirectCountAMD");
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     // NV_external_memory_win32
-    table->GetMemoryWin32HandleNV =
-        (PFN_vkGetMemoryWin32HandleNV)gpa(dev, "vkGetMemoryWin32HandleNV");
+    table->GetMemoryWin32HandleNV = (PFN_vkGetMemoryWin32HandleNV)gpa(dev, "vkGetMemoryWin32HandleNV");
 #endif
 
     // NVX_device_generated_commands
-    table->CmdProcessCommandsNVX =
-        (PFN_vkCmdProcessCommandsNVX)gpa(dev, "vkCmdProcessCommandsNVX");
-    table->CmdReserveSpaceForCommandsNVX =
-        (PFN_vkCmdReserveSpaceForCommandsNVX)gpa(
-            dev, "vkCmdReserveSpaceForCommandsNVX");
-    table->CreateIndirectCommandsLayoutNVX =
-        (PFN_vkCreateIndirectCommandsLayoutNVX)gpa(
-            dev, "vkCreateIndirectCommandsLayoutNVX");
+    table->CmdProcessCommandsNVX = (PFN_vkCmdProcessCommandsNVX)gpa(dev, "vkCmdProcessCommandsNVX");
+    table->CmdReserveSpaceForCommandsNVX = (PFN_vkCmdReserveSpaceForCommandsNVX)gpa(dev, "vkCmdReserveSpaceForCommandsNVX");
+    table->CreateIndirectCommandsLayoutNVX = (PFN_vkCreateIndirectCommandsLayoutNVX)gpa(dev, "vkCreateIndirectCommandsLayoutNVX");
     table->DestroyIndirectCommandsLayoutNVX =
-        (PFN_vkDestroyIndirectCommandsLayoutNVX)gpa(
-            dev, "vkDestroyIndirectCommandsLayoutNVX");
-    table->CreateObjectTableNVX =
-        (PFN_vkCreateObjectTableNVX)gpa(dev, "vkCreateObjectTableNVX");
-    table->DestroyObjectTableNVX =
-        (PFN_vkDestroyObjectTableNVX)gpa(dev, "vkDestroyObjectTableNVX");
-    table->RegisterObjectsNVX =
-        (PFN_vkRegisterObjectsNVX)gpa(dev, "vkRegisterObjectsNVX");
-    table->UnregisterObjectsNVX =
-        (PFN_vkUnregisterObjectsNVX)gpa(dev, "vkUnregisterObjectsNVX");
+        (PFN_vkDestroyIndirectCommandsLayoutNVX)gpa(dev, "vkDestroyIndirectCommandsLayoutNVX");
+    table->CreateObjectTableNVX = (PFN_vkCreateObjectTableNVX)gpa(dev, "vkCreateObjectTableNVX");
+    table->DestroyObjectTableNVX = (PFN_vkDestroyObjectTableNVX)gpa(dev, "vkDestroyObjectTableNVX");
+    table->RegisterObjectsNVX = (PFN_vkRegisterObjectsNVX)gpa(dev, "vkRegisterObjectsNVX");
+    table->UnregisterObjectsNVX = (PFN_vkUnregisterObjectsNVX)gpa(dev, "vkUnregisterObjectsNVX");
 }
 
-static inline void *
-loader_lookup_device_dispatch_table(const VkLayerDispatchTable *table,
-                                    const char *name) {
+static inline void *loader_lookup_device_dispatch_table(const VkLayerDispatchTable *table, const char *name) {
     if (!name || name[0] != 'v' || name[1] != 'k')
         return NULL;
 
@@ -612,180 +495,119 @@
     return NULL;
 }
 
-static inline void
-loader_init_instance_core_dispatch_table(VkLayerInstanceDispatchTable *table,
-                                         PFN_vkGetInstanceProcAddr gpa,
-                                         VkInstance inst) {
-    table->GetInstanceProcAddr =
-        (PFN_vkGetInstanceProcAddr)gpa(inst, "vkGetInstanceProcAddr");
-    table->DestroyInstance =
-        (PFN_vkDestroyInstance)gpa(inst, "vkDestroyInstance");
-    table->EnumeratePhysicalDevices =
-        (PFN_vkEnumeratePhysicalDevices)gpa(inst, "vkEnumeratePhysicalDevices");
-    table->GetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures)gpa(
-        inst, "vkGetPhysicalDeviceFeatures");
+static inline void loader_init_instance_core_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
+                                                            VkInstance inst) {
+    table->GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)gpa(inst, "vkGetInstanceProcAddr");
+    table->DestroyInstance = (PFN_vkDestroyInstance)gpa(inst, "vkDestroyInstance");
+    table->EnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices)gpa(inst, "vkEnumeratePhysicalDevices");
+    table->GetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures)gpa(inst, "vkGetPhysicalDeviceFeatures");
     table->GetPhysicalDeviceImageFormatProperties =
-        (PFN_vkGetPhysicalDeviceImageFormatProperties)gpa(
-            inst, "vkGetPhysicalDeviceImageFormatProperties");
+        (PFN_vkGetPhysicalDeviceImageFormatProperties)gpa(inst, "vkGetPhysicalDeviceImageFormatProperties");
     table->GetPhysicalDeviceFormatProperties =
-        (PFN_vkGetPhysicalDeviceFormatProperties)gpa(
-            inst, "vkGetPhysicalDeviceFormatProperties");
+        (PFN_vkGetPhysicalDeviceFormatProperties)gpa(inst, "vkGetPhysicalDeviceFormatProperties");
     table->GetPhysicalDeviceSparseImageFormatProperties =
-        (PFN_vkGetPhysicalDeviceSparseImageFormatProperties)gpa(
-            inst, "vkGetPhysicalDeviceSparseImageFormatProperties");
-    table->GetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)gpa(
-        inst, "vkGetPhysicalDeviceProperties");
+        (PFN_vkGetPhysicalDeviceSparseImageFormatProperties)gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties");
+    table->GetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)gpa(inst, "vkGetPhysicalDeviceProperties");
     table->GetPhysicalDeviceQueueFamilyProperties =
-        (PFN_vkGetPhysicalDeviceQueueFamilyProperties)gpa(
-            inst, "vkGetPhysicalDeviceQueueFamilyProperties");
+        (PFN_vkGetPhysicalDeviceQueueFamilyProperties)gpa(inst, "vkGetPhysicalDeviceQueueFamilyProperties");
     table->GetPhysicalDeviceMemoryProperties =
-        (PFN_vkGetPhysicalDeviceMemoryProperties)gpa(
-            inst, "vkGetPhysicalDeviceMemoryProperties");
+        (PFN_vkGetPhysicalDeviceMemoryProperties)gpa(inst, "vkGetPhysicalDeviceMemoryProperties");
     table->EnumerateDeviceExtensionProperties =
-        (PFN_vkEnumerateDeviceExtensionProperties)gpa(
-            inst, "vkEnumerateDeviceExtensionProperties");
-    table->EnumerateDeviceLayerProperties =
-        (PFN_vkEnumerateDeviceLayerProperties)gpa(
-            inst, "vkEnumerateDeviceLayerProperties");
+        (PFN_vkEnumerateDeviceExtensionProperties)gpa(inst, "vkEnumerateDeviceExtensionProperties");
+    table->EnumerateDeviceLayerProperties = (PFN_vkEnumerateDeviceLayerProperties)gpa(inst, "vkEnumerateDeviceLayerProperties");
 }
 
-static inline void loader_init_instance_extension_dispatch_table(
-    VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
-    VkInstance inst) {
+static inline void loader_init_instance_extension_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
+                                                                 VkInstance inst) {
     // WSI extensions
-    table->DestroySurfaceKHR =
-        (PFN_vkDestroySurfaceKHR)gpa(inst, "vkDestroySurfaceKHR");
+    table->DestroySurfaceKHR = (PFN_vkDestroySurfaceKHR)gpa(inst, "vkDestroySurfaceKHR");
     table->GetPhysicalDeviceSurfaceSupportKHR =
-        (PFN_vkGetPhysicalDeviceSurfaceSupportKHR)gpa(
-            inst, "vkGetPhysicalDeviceSurfaceSupportKHR");
+        (PFN_vkGetPhysicalDeviceSurfaceSupportKHR)gpa(inst, "vkGetPhysicalDeviceSurfaceSupportKHR");
     table->GetPhysicalDeviceSurfaceCapabilitiesKHR =
-        (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)gpa(
-            inst, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+        (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
     table->GetPhysicalDeviceSurfaceFormatsKHR =
-        (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)gpa(
-            inst, "vkGetPhysicalDeviceSurfaceFormatsKHR");
+        (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)gpa(inst, "vkGetPhysicalDeviceSurfaceFormatsKHR");
     table->GetPhysicalDeviceSurfacePresentModesKHR =
-        (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)gpa(
-            inst, "vkGetPhysicalDeviceSurfacePresentModesKHR");
+        (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)gpa(inst, "vkGetPhysicalDeviceSurfacePresentModesKHR");
 #ifdef VK_USE_PLATFORM_MIR_KHR
-    table->CreateMirSurfaceKHR =
-        (PFN_vkCreateMirSurfaceKHR)gpa(inst, "vkCreateMirSurfaceKHR");
+    table->CreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR)gpa(inst, "vkCreateMirSurfaceKHR");
     table->GetPhysicalDeviceMirPresentationSupportKHR =
-        (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)gpa(
-            inst, "vkGetPhysicalDeviceMirPresentationSupportKHR");
+        (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceMirPresentationSupportKHR");
 #endif
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    table->CreateWaylandSurfaceKHR =
-        (PFN_vkCreateWaylandSurfaceKHR)gpa(inst, "vkCreateWaylandSurfaceKHR");
+    table->CreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR)gpa(inst, "vkCreateWaylandSurfaceKHR");
     table->GetPhysicalDeviceWaylandPresentationSupportKHR =
-        (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)gpa(
-            inst, "vkGetPhysicalDeviceWaylandPresentationSupportKHR");
+        (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceWaylandPresentationSupportKHR");
 #endif
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-    table->CreateWin32SurfaceKHR =
-        (PFN_vkCreateWin32SurfaceKHR)gpa(inst, "vkCreateWin32SurfaceKHR");
+    table->CreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR)gpa(inst, "vkCreateWin32SurfaceKHR");
     table->GetPhysicalDeviceWin32PresentationSupportKHR =
-        (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)gpa(
-            inst, "vkGetPhysicalDeviceWin32PresentationSupportKHR");
+        (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceWin32PresentationSupportKHR");
 #endif
 #ifdef VK_USE_PLATFORM_XCB_KHR
-    table->CreateXcbSurfaceKHR =
-        (PFN_vkCreateXcbSurfaceKHR)gpa(inst, "vkCreateXcbSurfaceKHR");
+    table->CreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR)gpa(inst, "vkCreateXcbSurfaceKHR");
     table->GetPhysicalDeviceXcbPresentationSupportKHR =
-        (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)gpa(
-            inst, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
+        (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
 #endif
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-    table->CreateXlibSurfaceKHR =
-        (PFN_vkCreateXlibSurfaceKHR)gpa(inst, "vkCreateXlibSurfaceKHR");
+    table->CreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR)gpa(inst, "vkCreateXlibSurfaceKHR");
     table->GetPhysicalDeviceXlibPresentationSupportKHR =
-        (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)gpa(
-            inst, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
+        (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
 #endif
     table->GetPhysicalDeviceDisplayPropertiesKHR =
-        (PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)gpa(
-            inst, "vkGetPhysicalDeviceDisplayPropertiesKHR");
+        (PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)gpa(inst, "vkGetPhysicalDeviceDisplayPropertiesKHR");
     table->GetPhysicalDeviceDisplayPlanePropertiesKHR =
-        (PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)gpa(
-            inst, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
+        (PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)gpa(inst, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
     table->GetDisplayPlaneSupportedDisplaysKHR =
-        (PFN_vkGetDisplayPlaneSupportedDisplaysKHR)gpa(
-            inst, "vkGetDisplayPlaneSupportedDisplaysKHR");
-    table->GetDisplayModePropertiesKHR = (PFN_vkGetDisplayModePropertiesKHR)gpa(
-        inst, "vkGetDisplayModePropertiesKHR");
-    table->CreateDisplayModeKHR =
-        (PFN_vkCreateDisplayModeKHR)gpa(inst, "vkCreateDisplayModeKHR");
-    table->GetDisplayPlaneCapabilitiesKHR =
-        (PFN_vkGetDisplayPlaneCapabilitiesKHR)gpa(
-            inst, "vkGetDisplayPlaneCapabilitiesKHR");
-    table->CreateDisplayPlaneSurfaceKHR =
-        (PFN_vkCreateDisplayPlaneSurfaceKHR)gpa(
-            inst, "vkCreateDisplayPlaneSurfaceKHR");
+        (PFN_vkGetDisplayPlaneSupportedDisplaysKHR)gpa(inst, "vkGetDisplayPlaneSupportedDisplaysKHR");
+    table->GetDisplayModePropertiesKHR = (PFN_vkGetDisplayModePropertiesKHR)gpa(inst, "vkGetDisplayModePropertiesKHR");
+    table->CreateDisplayModeKHR = (PFN_vkCreateDisplayModeKHR)gpa(inst, "vkCreateDisplayModeKHR");
+    table->GetDisplayPlaneCapabilitiesKHR = (PFN_vkGetDisplayPlaneCapabilitiesKHR)gpa(inst, "vkGetDisplayPlaneCapabilitiesKHR");
+    table->CreateDisplayPlaneSurfaceKHR = (PFN_vkCreateDisplayPlaneSurfaceKHR)gpa(inst, "vkCreateDisplayPlaneSurfaceKHR");
 
     // KHR_get_physical_device_properties2
-    table->GetPhysicalDeviceFeatures2KHR =
-        (PFN_vkGetPhysicalDeviceFeatures2KHR)gpa(
-            inst, "vkGetPhysicalDeviceFeatures2KHR");
-    table->GetPhysicalDeviceProperties2KHR =
-        (PFN_vkGetPhysicalDeviceProperties2KHR)gpa(
-            inst, "vkGetPhysicalDeviceProperties2KHR");
+    table->GetPhysicalDeviceFeatures2KHR = (PFN_vkGetPhysicalDeviceFeatures2KHR)gpa(inst, "vkGetPhysicalDeviceFeatures2KHR");
+    table->GetPhysicalDeviceProperties2KHR = (PFN_vkGetPhysicalDeviceProperties2KHR)gpa(inst, "vkGetPhysicalDeviceProperties2KHR");
     table->GetPhysicalDeviceFormatProperties2KHR =
-        (PFN_vkGetPhysicalDeviceFormatProperties2KHR)gpa(
-            inst, "vkGetPhysicalDeviceFormatProperties2KHR");
+        (PFN_vkGetPhysicalDeviceFormatProperties2KHR)gpa(inst, "vkGetPhysicalDeviceFormatProperties2KHR");
     table->GetPhysicalDeviceImageFormatProperties2KHR =
-        (PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)gpa(
-            inst, "vkGetPhysicalDeviceImageFormatProperties2KHR");
+        (PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)gpa(inst, "vkGetPhysicalDeviceImageFormatProperties2KHR");
     table->GetPhysicalDeviceQueueFamilyProperties2KHR =
-        (PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)gpa(
-            inst, "vkGetPhysicalDeviceQueueFamilyProperties2KHR");
+        (PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)gpa(inst, "vkGetPhysicalDeviceQueueFamilyProperties2KHR");
     table->GetPhysicalDeviceMemoryProperties2KHR =
-        (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)gpa(
-            inst, "vkGetPhysicalDeviceMemoryProperties2KHR");
+        (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)gpa(inst, "vkGetPhysicalDeviceMemoryProperties2KHR");
     table->GetPhysicalDeviceSparseImageFormatProperties2KHR =
-        (PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)gpa(
-            inst, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
+        (PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     // EXT_acquire_xlib_display
-    table->AcquireXlibDisplayEXT =
-        (PFN_vkAcquireXlibDisplayEXT)gpa(inst, "vkAcquireXlibDisplayEXT");
-    table->GetRandROutputDisplayEXT =
-        (PFN_vkGetRandROutputDisplayEXT)gpa(inst, "vkGetRandROutputDisplayEXT");
+    table->AcquireXlibDisplayEXT = (PFN_vkAcquireXlibDisplayEXT)gpa(inst, "vkAcquireXlibDisplayEXT");
+    table->GetRandROutputDisplayEXT = (PFN_vkGetRandROutputDisplayEXT)gpa(inst, "vkGetRandROutputDisplayEXT");
 #endif
 
     // EXT_debug_report
-    table->CreateDebugReportCallbackEXT =
-        (PFN_vkCreateDebugReportCallbackEXT)gpa(
-            inst, "vkCreateDebugReportCallbackEXT");
-    table->DestroyDebugReportCallbackEXT =
-        (PFN_vkDestroyDebugReportCallbackEXT)gpa(
-            inst, "vkDestroyDebugReportCallbackEXT");
-    table->DebugReportMessageEXT =
-        (PFN_vkDebugReportMessageEXT)gpa(inst, "vkDebugReportMessageEXT");
+    table->CreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)gpa(inst, "vkCreateDebugReportCallbackEXT");
+    table->DestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)gpa(inst, "vkDestroyDebugReportCallbackEXT");
+    table->DebugReportMessageEXT = (PFN_vkDebugReportMessageEXT)gpa(inst, "vkDebugReportMessageEXT");
 
     // EXT_direct_mode_display
-    table->ReleaseDisplayEXT =
-        (PFN_vkReleaseDisplayEXT)gpa(inst, "vkReleaseDisplayEXT");
+    table->ReleaseDisplayEXT = (PFN_vkReleaseDisplayEXT)gpa(inst, "vkReleaseDisplayEXT");
 
     // EXT_display_surface_counter
     table->GetPhysicalDeviceSurfaceCapabilities2EXT =
-        (PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)gpa(
-            inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT");
+        (PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT");
 
     // NV_external_memory_capabilities
     table->GetPhysicalDeviceExternalImageFormatPropertiesNV =
-        (PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)gpa(
-            inst, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
+        (PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)gpa(inst, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
 
     // NVX_device_generated_commands (physical device command)
     table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX =
-        (PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)gpa(
-            inst, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
+        (PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)gpa(inst, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
 }
 
-static inline void *loader_lookup_instance_extension_dispatch_table(
-    const VkLayerInstanceDispatchTable *table, const char *name,
-    bool *found_name) {
+static inline void *loader_lookup_instance_extension_dispatch_table(const VkLayerInstanceDispatchTable *table, const char *name,
+                                                                    bool *found_name) {
 
     *found_name = true;
 
@@ -841,9 +663,8 @@
     return NULL;
 }
 
-static inline void *
-loader_lookup_instance_dispatch_table(const VkLayerInstanceDispatchTable *table,
-                                      const char *name, bool *found_name) {
+static inline void *loader_lookup_instance_dispatch_table(const VkLayerInstanceDispatchTable *table, const char *name,
+                                                          bool *found_name) {
     if (!name || name[0] != 'v' || name[1] != 'k') {
         *found_name = false;
         return NULL;
@@ -930,6 +751,5 @@
     if (!strcmp(name, "CreateDisplayPlaneSurfaceKHR"))
         return (void *)table->CreateDisplayPlaneSurfaceKHR;
 
-    return loader_lookup_instance_extension_dispatch_table(table, name,
-                                                           found_name);
+    return loader_lookup_instance_extension_dispatch_table(table, name, found_name);
 }
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 207a747..31352ae 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -45,8 +45,7 @@
  * Vulkan
  *    functions both core and extensions.
  */
-LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
-vkGetInstanceProcAddr(VkInstance instance, const char *pName) {
+LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName) {
 
     void *addr;
 
@@ -81,8 +80,7 @@
  *    entry points both core and extensions.
  *    Device relative means call down the device chain.
  */
-LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
-vkGetDeviceProcAddr(VkDevice device, const char *pName) {
+LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName) {
     void *addr;
 
     /* for entrypoints that loader must handle (ie non-dispatchable or create
@@ -113,10 +111,9 @@
     return disp_table->GetDeviceProcAddr(device, pName);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateInstanceExtensionProperties(const char *pLayerName,
-                                       uint32_t *pPropertyCount,
-                                       VkExtensionProperties *pProperties) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName,
+                                                                                    uint32_t *pPropertyCount,
+                                                                                    VkExtensionProperties *pProperties) {
     struct loader_extension_list *global_ext_list = NULL;
     struct loader_layer_list instance_layers;
     struct loader_extension_list local_ext_list;
@@ -131,8 +128,7 @@
 
     /* get layer libraries if needed */
     if (pLayerName && strlen(pLayerName) != 0) {
-        if (vk_string_validate(MaxLoaderStringLength, pLayerName) !=
-            VK_STRING_ERROR_NONE) {
+        if (vk_string_validate(MaxLoaderStringLength, pLayerName) != VK_STRING_ERROR_NONE) {
             assert(VK_FALSE && "vkEnumerateInstanceExtensionProperties:  "
                                "pLayerName is too long or is badly formed");
             res = VK_ERROR_EXTENSION_NOT_PRESENT;
@@ -143,26 +139,20 @@
         if (strcmp(pLayerName, std_validation_str) == 0) {
             struct loader_layer_list local_list;
             memset(&local_list, 0, sizeof(local_list));
-            for (uint32_t i = 0; i < sizeof(std_validation_names) /
-                                         sizeof(std_validation_names[0]);
-                 i++) {
-                loader_find_layer_name_add_list(NULL, std_validation_names[i],
-                                                VK_LAYER_TYPE_INSTANCE_EXPLICIT,
-                                                &instance_layers, &local_list);
+            for (uint32_t i = 0; i < sizeof(std_validation_names) / sizeof(std_validation_names[0]); i++) {
+                loader_find_layer_name_add_list(NULL, std_validation_names[i], VK_LAYER_TYPE_INSTANCE_EXPLICIT, &instance_layers,
+                                                &local_list);
             }
             for (uint32_t i = 0; i < local_list.count; i++) {
-                struct loader_extension_list *ext_list =
-                    &local_list.list[i].instance_extension_list;
-                loader_add_to_ext_list(NULL, &local_ext_list, ext_list->count,
-                                       ext_list->list);
+                struct loader_extension_list *ext_list = &local_list.list[i].instance_extension_list;
+                loader_add_to_ext_list(NULL, &local_ext_list, ext_list->count, ext_list->list);
             }
             loader_destroy_layer_list(NULL, NULL, &local_list);
             global_ext_list = &local_ext_list;
 
         } else {
             for (uint32_t i = 0; i < instance_layers.count; i++) {
-                struct loader_layer_properties *props =
-                    &instance_layers.list[i];
+                struct loader_layer_properties *props = &instance_layers.list[i];
                 if (strcmp(props->info.layerName, pLayerName) == 0) {
                     global_ext_list = &props->instance_extension_list;
                     break;
@@ -177,8 +167,7 @@
             goto out;
         }
         /* get extensions from all ICD's, merge so no duplicates */
-        res = loader_get_icd_loader_instance_extensions(NULL, &icd_tramp_list,
-                                                        &local_ext_list);
+        res = loader_get_icd_loader_instance_extensions(NULL, &icd_tramp_list, &local_ext_list);
         if (VK_SUCCESS != res) {
             goto out;
         }
@@ -187,10 +176,8 @@
         // Append implicit layers.
         loader_implicit_layer_scan(NULL, &instance_layers);
         for (uint32_t i = 0; i < instance_layers.count; i++) {
-            struct loader_extension_list *ext_list =
-                &instance_layers.list[i].instance_extension_list;
-            loader_add_to_ext_list(NULL, &local_ext_list, ext_list->count,
-                                   ext_list->list);
+            struct loader_extension_list *ext_list = &instance_layers.list[i].instance_extension_list;
+            loader_add_to_ext_list(NULL, &local_ext_list, ext_list->count, ext_list->list);
         }
 
         global_ext_list = &local_ext_list;
@@ -206,12 +193,9 @@
         goto out;
     }
 
-    copy_size = *pPropertyCount < global_ext_list->count
-                    ? *pPropertyCount
-                    : global_ext_list->count;
+    copy_size = *pPropertyCount < global_ext_list->count ? *pPropertyCount : global_ext_list->count;
     for (uint32_t i = 0; i < copy_size; i++) {
-        memcpy(&pProperties[i], &global_ext_list->list[i],
-               sizeof(VkExtensionProperties));
+        memcpy(&pProperties[i], &global_ext_list->list[i], sizeof(VkExtensionProperties));
     }
     *pPropertyCount = copy_size;
 
@@ -222,14 +206,13 @@
 
 out:
 
-    loader_destroy_generic_list(NULL,
-                                (struct loader_generic_list *)&local_ext_list);
+    loader_destroy_generic_list(NULL, (struct loader_generic_list *)&local_ext_list);
     loader_delete_layer_properties(NULL, &instance_layers);
     return res;
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
-    uint32_t *pPropertyCount, VkLayerProperties *pProperties) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
+                                                                                VkLayerProperties *pProperties) {
 
     struct loader_layer_list instance_layer_list;
     tls_instance = NULL;
@@ -248,12 +231,9 @@
         return VK_SUCCESS;
     }
 
-    copy_size = (*pPropertyCount < instance_layer_list.count)
-                    ? *pPropertyCount
-                    : instance_layer_list.count;
+    copy_size = (*pPropertyCount < instance_layer_list.count) ? *pPropertyCount : instance_layer_list.count;
     for (uint32_t i = 0; i < copy_size; i++) {
-        memcpy(&pProperties[i], &instance_layer_list.list[i].info,
-               sizeof(VkLayerProperties));
+        memcpy(&pProperties[i], &instance_layer_list.list[i].info, sizeof(VkLayerProperties));
     }
 
     *pPropertyCount = copy_size;
@@ -268,9 +248,8 @@
     return VK_SUCCESS;
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
-    const VkInstanceCreateInfo *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
+                                                              const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
     struct loader_instance *ptr_instance = NULL;
     VkInstance created_instance = VK_NULL_HANDLE;
     bool loaderLocked = false;
@@ -282,13 +261,11 @@
     {
 #else
     if (pAllocator) {
-        ptr_instance = (struct loader_instance *)pAllocator->pfnAllocation(
-            pAllocator->pUserData, sizeof(struct loader_instance),
-            sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        ptr_instance = (struct loader_instance *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(struct loader_instance),
+                                                                           sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     } else {
 #endif
-        ptr_instance =
-            (struct loader_instance *)malloc(sizeof(struct loader_instance));
+        ptr_instance = (struct loader_instance *)malloc(sizeof(struct loader_instance));
     }
 
     VkInstanceCreateInfo ici = *pCreateInfo;
@@ -313,20 +290,16 @@
     ptr_instance->num_tmp_callbacks = 0;
     ptr_instance->tmp_dbg_create_infos = NULL;
     ptr_instance->tmp_callbacks = NULL;
-    if (util_CopyDebugReportCreateInfos(pCreateInfo->pNext, pAllocator,
-                                        &ptr_instance->num_tmp_callbacks,
-                                        &ptr_instance->tmp_dbg_create_infos,
-                                        &ptr_instance->tmp_callbacks)) {
+    if (util_CopyDebugReportCreateInfos(pCreateInfo->pNext, pAllocator, &ptr_instance->num_tmp_callbacks,
+                                        &ptr_instance->tmp_dbg_create_infos, &ptr_instance->tmp_callbacks)) {
         // One or more were found, but allocation failed.  Therefore, clean up
         // and fail this function:
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     } else if (ptr_instance->num_tmp_callbacks > 0) {
         // Setup the temporary callback(s) here to catch early issues:
-        if (util_CreateDebugReportCallbacks(ptr_instance, pAllocator,
-                                            ptr_instance->num_tmp_callbacks,
-                                            ptr_instance->tmp_dbg_create_infos,
-                                            ptr_instance->tmp_callbacks)) {
+        if (util_CreateDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
+                                            ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks)) {
             // Failure of setting up one or more of the callback.  Therefore,
             // clean up and fail this function:
             res = VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -337,59 +310,49 @@
     /* Due to implicit layers need to get layer list even if
      * enabledLayerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
      * get layer list via loader_layer_scan(). */
-    memset(&ptr_instance->instance_layer_list, 0,
-           sizeof(ptr_instance->instance_layer_list));
+    memset(&ptr_instance->instance_layer_list, 0, sizeof(ptr_instance->instance_layer_list));
     loader_layer_scan(ptr_instance, &ptr_instance->instance_layer_list);
 
     /* validate the app requested layers to be enabled */
     if (pCreateInfo->enabledLayerCount > 0) {
-        res =
-            loader_validate_layers(ptr_instance, pCreateInfo->enabledLayerCount,
-                                   pCreateInfo->ppEnabledLayerNames,
-                                   &ptr_instance->instance_layer_list);
+        res = loader_validate_layers(ptr_instance, pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames,
+                                     &ptr_instance->instance_layer_list);
         if (res != VK_SUCCESS) {
             goto out;
         }
     }
 
     /* convert any meta layers to the actual layers makes a copy of layer name*/
-    VkResult layerErr = loader_expand_layer_names(
-        ptr_instance, std_validation_str,
-        sizeof(std_validation_names) / sizeof(std_validation_names[0]),
-        std_validation_names, &ici.enabledLayerCount, &ici.ppEnabledLayerNames);
+    VkResult layerErr =
+        loader_expand_layer_names(ptr_instance, std_validation_str, sizeof(std_validation_names) / sizeof(std_validation_names[0]),
+                                  std_validation_names, &ici.enabledLayerCount, &ici.ppEnabledLayerNames);
     if (VK_SUCCESS != layerErr) {
         res = layerErr;
         goto out;
     }
 
     /* Scan/discover all ICD libraries */
-    memset(&ptr_instance->icd_tramp_list, 0,
-           sizeof(ptr_instance->icd_tramp_list));
+    memset(&ptr_instance->icd_tramp_list, 0, sizeof(ptr_instance->icd_tramp_list));
     res = loader_icd_scan(ptr_instance, &ptr_instance->icd_tramp_list);
     if (res != VK_SUCCESS) {
         goto out;
     }
 
     /* get extensions from all ICD's, merge so no duplicates, then validate */
-    res = loader_get_icd_loader_instance_extensions(
-        ptr_instance, &ptr_instance->icd_tramp_list, &ptr_instance->ext_list);
+    res = loader_get_icd_loader_instance_extensions(ptr_instance, &ptr_instance->icd_tramp_list, &ptr_instance->ext_list);
     if (res != VK_SUCCESS) {
         goto out;
     }
-    res = loader_validate_instance_extensions(
-        ptr_instance, &ptr_instance->ext_list,
-        &ptr_instance->instance_layer_list, &ici);
+    res = loader_validate_instance_extensions(ptr_instance, &ptr_instance->ext_list, &ptr_instance->instance_layer_list, &ici);
     if (res != VK_SUCCESS) {
         goto out;
     }
 
-    ptr_instance->disp = loader_instance_heap_alloc(
-        ptr_instance, sizeof(VkLayerInstanceDispatchTable),
-        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    ptr_instance->disp =
+        loader_instance_heap_alloc(ptr_instance, sizeof(VkLayerInstanceDispatchTable), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (ptr_instance->disp == NULL) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkCreateInstance:  Failed to allocate Instance dispatch"
-                   " table.");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateInstance:  Failed to allocate Instance dispatch"
+                                                                   " table.");
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     }
@@ -398,15 +361,13 @@
     loader.instances = ptr_instance;
 
     /* activate any layers on instance chain */
-    res = loader_enable_instance_layers(ptr_instance, &ici,
-                                        &ptr_instance->instance_layer_list);
+    res = loader_enable_instance_layers(ptr_instance, &ici, &ptr_instance->instance_layer_list);
     if (res != VK_SUCCESS) {
         goto out;
     }
 
     created_instance = (VkInstance)ptr_instance;
-    res = loader_create_instance_chain(&ici, pAllocator, ptr_instance,
-                                       &created_instance);
+    res = loader_create_instance_chain(&ici, pAllocator, ptr_instance, &created_instance);
 
     if (res == VK_SUCCESS) {
         memset(ptr_instance->enabled_known_extensions.padding, 0, sizeof(uint64_t) * 4);
@@ -437,35 +398,24 @@
                 loader_instance_heap_free(ptr_instance, ptr_instance->disp);
             }
             if (ptr_instance->num_tmp_callbacks > 0) {
-                util_DestroyDebugReportCallbacks(
-                    ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
-                    ptr_instance->tmp_callbacks);
-                util_FreeDebugReportCreateInfos(
-                    pAllocator, ptr_instance->tmp_dbg_create_infos,
-                    ptr_instance->tmp_callbacks);
+                util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
+                                                 ptr_instance->tmp_callbacks);
+                util_FreeDebugReportCreateInfos(pAllocator, ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks);
             }
 
-            loader_deactivate_layers(ptr_instance, NULL,
-                                     &ptr_instance->activated_layer_list);
+            loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->activated_layer_list);
 
-            loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo,
-                                                  &ici);
-            loader_delete_layer_properties(ptr_instance,
-                                           &ptr_instance->instance_layer_list);
-            loader_scanned_icd_clear(ptr_instance,
-                                     &ptr_instance->icd_tramp_list);
-            loader_destroy_generic_list(
-                ptr_instance,
-                (struct loader_generic_list *)&ptr_instance->ext_list);
+            loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo, &ici);
+            loader_delete_layer_properties(ptr_instance, &ptr_instance->instance_layer_list);
+            loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_tramp_list);
+            loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&ptr_instance->ext_list);
 
             loader_instance_heap_free(ptr_instance, ptr_instance);
         } else {
             /* Remove temporary debug_report callback */
-            util_DestroyDebugReportCallbacks(ptr_instance, pAllocator,
-                                             ptr_instance->num_tmp_callbacks,
+            util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
                                              ptr_instance->tmp_callbacks);
-            loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo,
-                                                  &ici);
+            loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo, &ici);
         }
 
         if (loaderLocked) {
@@ -476,8 +426,7 @@
     return res;
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
-    VkInstance instance, const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
     const VkLayerInstanceDispatchTable *disp;
     struct loader_instance *ptr_instance = NULL;
     bool callback_setup = false;
@@ -498,43 +447,34 @@
 
     if (ptr_instance->num_tmp_callbacks > 0) {
         // Setup the temporary callback(s) here to catch cleanup issues:
-        if (!util_CreateDebugReportCallbacks(ptr_instance, pAllocator,
-                                             ptr_instance->num_tmp_callbacks,
-                                             ptr_instance->tmp_dbg_create_infos,
-                                             ptr_instance->tmp_callbacks)) {
+        if (!util_CreateDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
+                                             ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks)) {
             callback_setup = true;
         }
     }
 
     disp->DestroyInstance(instance, pAllocator);
 
-    loader_deactivate_layers(ptr_instance, NULL,
-                             &ptr_instance->activated_layer_list);
+    loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->activated_layer_list);
 
     if (ptr_instance->phys_devs_tramp) {
         for (uint32_t i = 0; i < ptr_instance->phys_dev_count_tramp; i++) {
-            loader_instance_heap_free(ptr_instance,
-                                      ptr_instance->phys_devs_tramp[i]);
+            loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_tramp[i]);
         }
         loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_tramp);
     }
 
     if (callback_setup) {
-        util_DestroyDebugReportCallbacks(ptr_instance, pAllocator,
-                                         ptr_instance->num_tmp_callbacks,
-                                         ptr_instance->tmp_callbacks);
-        util_FreeDebugReportCreateInfos(pAllocator,
-                                        ptr_instance->tmp_dbg_create_infos,
-                                        ptr_instance->tmp_callbacks);
+        util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks, ptr_instance->tmp_callbacks);
+        util_FreeDebugReportCreateInfos(pAllocator, ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks);
     }
     loader_instance_heap_free(ptr_instance, ptr_instance->disp);
     loader_instance_heap_free(ptr_instance, ptr_instance);
     loader_platform_thread_unlock_mutex(&loader_lock);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
-                           VkPhysicalDevice *pPhysicalDevices) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
+                                                                        VkPhysicalDevice *pPhysicalDevices) {
     const VkLayerInstanceDispatchTable *disp;
     VkResult res = VK_SUCCESS;
     uint32_t count, i;
@@ -552,12 +492,10 @@
     if (NULL == pPhysicalDevices || 0 == inst->total_gpu_count) {
         // Call down.  At the lower levels, this will setup the terminator
         // structures in the loader.
-        res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount,
-                                             pPhysicalDevices);
+        res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
         if (VK_SUCCESS != res) {
-             loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                        "vkEnumeratePhysicalDevices: Failed in dispatch call"
-                        " used to determine number of available GPUs");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkEnumeratePhysicalDevices: Failed in dispatch call"
+                                                               " used to determine number of available GPUs");
         }
     }
 
@@ -574,9 +512,8 @@
 
     // Wrap the PhysDev object for loader usage, return wrapped objects
     if (inst->total_gpu_count > *pPhysicalDeviceCount) {
-        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkEnumeratePhysicalDevices: Trimming device count down"
-                   " by application request from %d to %d physical devices",
+        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "vkEnumeratePhysicalDevices: Trimming device count down"
+                                                                 " by application request from %d to %d physical devices",
                    inst->total_gpu_count, *pPhysicalDeviceCount);
         count = *pPhysicalDeviceCount;
         res = VK_INCOMPLETE;
@@ -595,74 +532,59 @@
     return res;
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
-    VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+                                                                     VkPhysicalDeviceFeatures *pFeatures) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
     disp->GetPhysicalDeviceFeatures(unwrapped_phys_dev, pFeatures);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
-    VkPhysicalDevice physicalDevice, VkFormat format,
-    VkFormatProperties *pFormatInfo) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                             VkFormatProperties *pFormatInfo) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_pd =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_pd = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
     disp->GetPhysicalDeviceFormatProperties(unwrapped_pd, format, pFormatInfo);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetPhysicalDeviceImageFormatProperties(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
-    VkImageFormatProperties *pImageFormatProperties) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
+    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage,
+    VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetPhysicalDeviceImageFormatProperties(
-        unwrapped_phys_dev, format, type, tiling, usage, flags,
-        pImageFormatProperties);
+    return disp->GetPhysicalDeviceImageFormatProperties(unwrapped_phys_dev, format, type, tiling, usage, flags,
+                                                        pImageFormatProperties);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
-    VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+                                                                       VkPhysicalDeviceProperties *pProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
     disp->GetPhysicalDeviceProperties(unwrapped_phys_dev, pProperties);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetPhysicalDeviceQueueFamilyProperties(
-    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
-    VkQueueFamilyProperties *pQueueProperties) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
+                                                                                  uint32_t *pQueueFamilyPropertyCount,
+                                                                                  VkQueueFamilyProperties *pQueueProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceQueueFamilyProperties(
-        unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueProperties);
+    disp->GetPhysicalDeviceQueueFamilyProperties(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueProperties);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
+                                                                             VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceMemoryProperties(unwrapped_phys_dev,
-                                            pMemoryProperties);
+    disp->GetPhysicalDeviceMemoryProperties(unwrapped_phys_dev, pMemoryProperties);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
-    VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
+                                                            const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
     VkResult res;
     struct loader_physical_device_tramp *phys_dev = NULL;
     struct loader_device *dev = NULL;
@@ -678,30 +600,23 @@
     /* Get the physical device (ICD) extensions  */
     struct loader_extension_list icd_exts;
     icd_exts.list = NULL;
-    res =
-        loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts,
-                                 sizeof(VkExtensionProperties));
+    res = loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
     if (VK_SUCCESS != res) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkCreateDevice:  Failed to create ICD extension list");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to create ICD extension list");
         goto out;
     }
 
-    res = loader_add_device_extensions(
-        inst, inst->disp->layer_inst_disp.EnumerateDeviceExtensionProperties,
-        phys_dev->phys_dev, "Unknown", &icd_exts);
+    res = loader_add_device_extensions(inst, inst->disp->layer_inst_disp.EnumerateDeviceExtensionProperties, phys_dev->phys_dev,
+                                       "Unknown", &icd_exts);
     if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkCreateDevice:  Failed to add extensions to list");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to add extensions to list");
         goto out;
     }
 
     /* make sure requested extensions to be enabled are supported */
-    res = loader_validate_device_extensions(
-        phys_dev, &inst->activated_layer_list, &icd_exts, pCreateInfo);
+    res = loader_validate_device_extensions(phys_dev, &inst->activated_layer_list, &icd_exts, pCreateInfo);
     if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkCreateDevice:  Failed to validate extensions in list");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to validate extensions in list");
         goto out;
     }
 
@@ -715,25 +630,20 @@
     dev->activated_layer_list.capacity = inst->activated_layer_list.capacity;
     dev->activated_layer_list.count = inst->activated_layer_list.count;
     dev->activated_layer_list.list =
-        loader_device_heap_alloc(dev, inst->activated_layer_list.capacity,
-                                 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+        loader_device_heap_alloc(dev, inst->activated_layer_list.capacity, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
     if (dev->activated_layer_list.list == NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkCreateDevice:  Failed to allocate activated layer"
-                   "list of size %d.",
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to allocate activated layer"
+                                                           "list of size %d.",
                    inst->activated_layer_list.capacity);
         res = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
     }
     memcpy(dev->activated_layer_list.list, inst->activated_layer_list.list,
-           sizeof(*dev->activated_layer_list.list) *
-               dev->activated_layer_list.count);
+           sizeof(*dev->activated_layer_list.list) * dev->activated_layer_list.count);
 
-    res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst,
-                                     dev);
+    res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst, dev);
     if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkCreateDevice:  Failed to create device chain.");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to create device chain.");
         goto out;
     }
 
@@ -744,9 +654,8 @@
 
     // Initialize WSI device extensions as part of core dispatch since loader
     // has dedicated trampoline code for these*/
-    loader_init_device_extension_dispatch_table(
-        &dev->loader_dispatch,
-        dev->loader_dispatch.core_dispatch.GetDeviceProcAddr, *pDevice);
+    loader_init_device_extension_dispatch_table(&dev->loader_dispatch, dev->loader_dispatch.core_dispatch.GetDeviceProcAddr,
+                                                *pDevice);
 
 out:
 
@@ -758,15 +667,13 @@
     }
 
     if (NULL != icd_exts.list) {
-        loader_destroy_generic_list(inst,
-                                    (struct loader_generic_list *)&icd_exts);
+        loader_destroy_generic_list(inst, (struct loader_generic_list *)&icd_exts);
     }
     loader_platform_thread_unlock_mutex(&loader_lock);
     return res;
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
     struct loader_device *dev;
 
@@ -776,8 +683,7 @@
 
     loader_platform_thread_lock_mutex(&loader_lock);
 
-    struct loader_icd_term *icd_term =
-        loader_get_icd_and_device(device, &dev, NULL);
+    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, NULL);
     const struct loader_instance *inst = icd_term->this_instance;
     disp = loader_get_dispatch(device);
 
@@ -789,11 +695,9 @@
     loader_platform_thread_unlock_mutex(&loader_lock);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
-                                     const char *pLayerName,
-                                     uint32_t *pPropertyCount,
-                                     VkExtensionProperties *pProperties) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
+                                                                                  const char *pLayerName, uint32_t *pPropertyCount,
+                                                                                  VkExtensionProperties *pProperties) {
     VkResult res = VK_SUCCESS;
     struct loader_physical_device_tramp *phys_dev;
     phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
@@ -808,8 +712,7 @@
         const VkLayerInstanceDispatchTable *disp;
 
         disp = loader_get_instance_layer_dispatch(physicalDevice);
-        res = disp->EnumerateDeviceExtensionProperties(
-            phys_dev->phys_dev, NULL, pPropertyCount, pProperties);
+        res = disp->EnumerateDeviceExtensionProperties(phys_dev->phys_dev, NULL, pPropertyCount, pProperties);
     } else {
 
         uint32_t count;
@@ -818,34 +721,25 @@
         struct loader_device_extension_list *dev_ext_list = NULL;
         struct loader_device_extension_list local_ext_list;
         memset(&local_ext_list, 0, sizeof(local_ext_list));
-        if (vk_string_validate(MaxLoaderStringLength, pLayerName) ==
-            VK_STRING_ERROR_NONE) {
+        if (vk_string_validate(MaxLoaderStringLength, pLayerName) == VK_STRING_ERROR_NONE) {
             if (strcmp(pLayerName, std_validation_str) == 0) {
                 struct loader_layer_list local_list;
                 memset(&local_list, 0, sizeof(local_list));
-                for (uint32_t i = 0; i < sizeof(std_validation_names) /
-                                             sizeof(std_validation_names[0]);
-                     i++) {
-                    loader_find_layer_name_add_list(
-                        NULL, std_validation_names[i],
-                        VK_LAYER_TYPE_INSTANCE_EXPLICIT,
-                        &inst->instance_layer_list, &local_list);
+                for (uint32_t i = 0; i < sizeof(std_validation_names) / sizeof(std_validation_names[0]); i++) {
+                    loader_find_layer_name_add_list(NULL, std_validation_names[i], VK_LAYER_TYPE_INSTANCE_EXPLICIT,
+                                                    &inst->instance_layer_list, &local_list);
                 }
                 for (uint32_t i = 0; i < local_list.count; i++) {
-                    struct loader_device_extension_list *ext_list =
-                        &local_list.list[i].device_extension_list;
+                    struct loader_device_extension_list *ext_list = &local_list.list[i].device_extension_list;
                     for (uint32_t j = 0; j < ext_list->count; j++) {
-                        loader_add_to_dev_ext_list(NULL, &local_ext_list,
-                                                   &ext_list->list[j].props, 0,
-                                                   NULL);
+                        loader_add_to_dev_ext_list(NULL, &local_ext_list, &ext_list->list[j].props, 0, NULL);
                     }
                 }
                 dev_ext_list = &local_ext_list;
 
             } else {
                 for (uint32_t i = 0; i < inst->instance_layer_list.count; i++) {
-                    struct loader_layer_properties *props =
-                        &inst->instance_layer_list.list[i];
+                    struct loader_layer_properties *props = &inst->instance_layer_list.list[i];
                     if (strcmp(props->info.layerName, pLayerName) == 0) {
                         dev_ext_list = &props->device_extension_list;
                     }
@@ -855,29 +749,25 @@
             count = (dev_ext_list == NULL) ? 0 : dev_ext_list->count;
             if (pProperties == NULL) {
                 *pPropertyCount = count;
-                loader_destroy_generic_list(
-                    inst, (struct loader_generic_list *)&local_ext_list);
+                loader_destroy_generic_list(inst, (struct loader_generic_list *)&local_ext_list);
                 loader_platform_thread_unlock_mutex(&loader_lock);
                 return VK_SUCCESS;
             }
 
             copy_size = *pPropertyCount < count ? *pPropertyCount : count;
             for (uint32_t i = 0; i < copy_size; i++) {
-                memcpy(&pProperties[i], &dev_ext_list->list[i].props,
-                       sizeof(VkExtensionProperties));
+                memcpy(&pProperties[i], &dev_ext_list->list[i].props, sizeof(VkExtensionProperties));
             }
             *pPropertyCount = copy_size;
 
-            loader_destroy_generic_list(
-                inst, (struct loader_generic_list *)&local_ext_list);
+            loader_destroy_generic_list(inst, (struct loader_generic_list *)&local_ext_list);
             if (copy_size < count) {
                 loader_platform_thread_unlock_mutex(&loader_lock);
                 return VK_INCOMPLETE;
             }
         } else {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "vkEnumerateDeviceExtensionProperties:  pLayerName "
-                       "is too long or is badly formed");
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkEnumerateDeviceExtensionProperties:  pLayerName "
+                                                               "is too long or is badly formed");
             loader_platform_thread_unlock_mutex(&loader_lock);
             return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
@@ -887,15 +777,13 @@
     return res;
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
-                                 uint32_t *pPropertyCount,
-                                 VkLayerProperties *pProperties) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
+                                                                              uint32_t *pPropertyCount,
+                                                                              VkLayerProperties *pProperties) {
     uint32_t copy_size;
     struct loader_physical_device_tramp *phys_dev;
     struct loader_layer_list *enabled_layers, layers_list;
-    uint32_t std_val_count = sizeof(std_validation_names) /
-                                sizeof(std_validation_names[0]);
+    uint32_t std_val_count = sizeof(std_validation_names) / sizeof(std_validation_names[0]);
     memset(&layers_list, 0, sizeof(layers_list));
     loader_platform_thread_lock_mutex(&loader_lock);
 
@@ -920,54 +808,41 @@
     if (inst->activated_layers_are_std_val) {
         enabled_layers = &layers_list;
         enabled_layers->count = count;
-        enabled_layers->capacity = enabled_layers->count *
-                                 sizeof(struct loader_layer_properties);
-        enabled_layers->list = loader_instance_heap_alloc(inst, enabled_layers->capacity,
-                                VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        enabled_layers->capacity = enabled_layers->count * sizeof(struct loader_layer_properties);
+        enabled_layers->list = loader_instance_heap_alloc(inst, enabled_layers->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (!enabled_layers->list) {
-            loader_log(
-                inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "vkEnumerateDeviceLayerProperties:  Failed to allocate enabled"
-                "layer list of size %d",
-                enabled_layers->capacity);
+            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkEnumerateDeviceLayerProperties:  Failed to allocate enabled"
+                                                               "layer list of size %d",
+                       enabled_layers->capacity);
             return VK_ERROR_OUT_OF_HOST_MEMORY;
         }
 
         uint32_t j = 0;
         for (uint32_t i = 0; i < inst->activated_layer_list.count; j++) {
 
-            if (loader_find_layer_name_array(
-                    inst->activated_layer_list.list[i].info.layerName,
-                    std_val_count, std_validation_names)) {
+            if (loader_find_layer_name_array(inst->activated_layer_list.list[i].info.layerName, std_val_count,
+                                             std_validation_names)) {
                 struct loader_layer_properties props;
                 loader_init_std_validation_props(&props);
-                VkResult err = loader_copy_layer_properties(inst,
-                                                            &enabled_layers->list[j],
-                                                            &props);
+                VkResult err = loader_copy_layer_properties(inst, &enabled_layers->list[j], &props);
                 if (err != VK_SUCCESS) {
                     return err;
                 }
                 i += std_val_count;
-            }
-            else {
-                VkResult err = loader_copy_layer_properties(inst,
-                                                            &enabled_layers->list[j],
-                                                            &inst->activated_layer_list.list[i++]);
+            } else {
+                VkResult err = loader_copy_layer_properties(inst, &enabled_layers->list[j], &inst->activated_layer_list.list[i++]);
                 if (err != VK_SUCCESS) {
                     return err;
                 }
             }
         }
+    } else {
+        enabled_layers = (struct loader_layer_list *)&inst->activated_layer_list;
     }
-    else {
-        enabled_layers = (struct loader_layer_list *) &inst->activated_layer_list;
-    }
-
 
     copy_size = (*pPropertyCount < count) ? *pPropertyCount : count;
     for (uint32_t i = 0; i < copy_size; i++) {
-        memcpy(&pProperties[i], &(enabled_layers->list[i].info),
-               sizeof(VkLayerProperties));
+        memcpy(&pProperties[i], &(enabled_layers->list[i].info), sizeof(VkLayerProperties));
     }
     *pPropertyCount = copy_size;
 
@@ -983,9 +858,8 @@
     return VK_SUCCESS;
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex,
-                 VkQueue *pQueue) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex,
+                                                          VkQueue *pQueue) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -994,9 +868,8 @@
     loader_set_dispatch(*pQueue, disp);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits,
-              VkFence fence) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits,
+                                                           VkFence fence) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
@@ -1020,10 +893,8 @@
     return disp->DeviceWaitIdle(device);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
-                 const VkAllocationCallbacks *pAllocator,
-                 VkDeviceMemory *pMemory) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
+                                                              const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1031,9 +902,8 @@
     return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkFreeMemory(VkDevice device, VkDeviceMemory mem,
-             const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory mem,
+                                                      const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1041,9 +911,8 @@
     disp->FreeMemory(device, mem, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset,
-            VkDeviceSize size, VkFlags flags, void **ppData) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset,
+                                                         VkDeviceSize size, VkFlags flags, void **ppData) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1051,8 +920,7 @@
     return disp->MapMemory(device, mem, offset, size, flags, ppData);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkUnmapMemory(VkDevice device, VkDeviceMemory mem) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory mem) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1060,31 +928,26 @@
     disp->UnmapMemory(device, mem);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
-                          const VkMappedMemoryRange *pMemoryRanges) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                                                       const VkMappedMemoryRange *pMemoryRanges) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->FlushMappedMemoryRanges(device, memoryRangeCount,
-                                         pMemoryRanges);
+    return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
-                               const VkMappedMemoryRange *pMemoryRanges) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                                                            const VkMappedMemoryRange *pMemoryRanges) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount,
-                                              pMemoryRanges);
+    return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
-                            VkDeviceSize *pCommittedMemoryInBytes) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+                                                                     VkDeviceSize *pCommittedMemoryInBytes) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1092,9 +955,8 @@
     disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
-                   VkDeviceSize offset) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
+                                                                VkDeviceSize offset) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1102,9 +964,8 @@
     return disp->BindBufferMemory(device, buffer, mem, offset);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
-                  VkDeviceSize offset) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
+                                                               VkDeviceSize offset) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1112,9 +973,8 @@
     return disp->BindImageMemory(device, image, mem, offset);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
-                              VkMemoryRequirements *pMemoryRequirements) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+                                                                       VkMemoryRequirements *pMemoryRequirements) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1122,9 +982,8 @@
     disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetImageMemoryRequirements(VkDevice device, VkImage image,
-                             VkMemoryRequirements *pMemoryRequirements) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image,
+                                                                      VkMemoryRequirements *pMemoryRequirements) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1132,37 +991,29 @@
     disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
-    VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
-    VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
+vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
+                                   VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->GetImageSparseMemoryRequirements(device, image,
-                                           pSparseMemoryRequirementCount,
-                                           pSparseMemoryRequirements);
+    disp->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetPhysicalDeviceSparseImageFormatProperties(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkSampleCountFlagBits samples, VkImageUsageFlags usage,
-    VkImageTiling tiling, uint32_t *pPropertyCount,
-    VkSparseImageFormatProperties *pProperties) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
+    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage,
+    VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
 
-    disp->GetPhysicalDeviceSparseImageFormatProperties(
-        unwrapped_phys_dev, format, type, samples, usage, tiling,
-        pPropertyCount, pProperties);
+    disp->GetPhysicalDeviceSparseImageFormatProperties(unwrapped_phys_dev, format, type, samples, usage, tiling, pPropertyCount,
+                                                       pProperties);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
-                  const VkBindSparseInfo *pBindInfo, VkFence fence) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+                                                               const VkBindSparseInfo *pBindInfo, VkFence fence) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
@@ -1170,9 +1021,8 @@
     return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
-              const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
+                                                           const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1180,9 +1030,7 @@
     return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyFence(VkDevice device, VkFence fence,
-               const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1190,8 +1038,7 @@
     disp->DestroyFence(device, fence, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1199,8 +1046,7 @@
     return disp->ResetFences(device, fenceCount, pFences);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetFenceStatus(VkDevice device, VkFence fence) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1208,9 +1054,8 @@
     return disp->GetFenceStatus(device, fence);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences,
-                VkBool32 waitAll, uint64_t timeout) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences,
+                                                             VkBool32 waitAll, uint64_t timeout) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1218,10 +1063,8 @@
     return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
-                  const VkAllocationCallbacks *pAllocator,
-                  VkSemaphore *pSemaphore) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1229,9 +1072,8 @@
     return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
-                   const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
+                                                            const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1239,9 +1081,8 @@
     disp->DestroySemaphore(device, semaphore, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
-              const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
+                                                           const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1249,9 +1090,7 @@
     return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyEvent(VkDevice device, VkEvent event,
-               const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1259,8 +1098,7 @@
     disp->DestroyEvent(device, event, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetEventStatus(VkDevice device, VkEvent event) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1268,8 +1106,7 @@
     return disp->GetEventStatus(device, event);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkSetEvent(VkDevice device, VkEvent event) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1277,8 +1114,7 @@
     return disp->SetEvent(device, event);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkResetEvent(VkDevice device, VkEvent event) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1286,10 +1122,8 @@
     return disp->ResetEvent(device, event);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
-                  const VkAllocationCallbacks *pAllocator,
-                  VkQueryPool *pQueryPool) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1297,9 +1131,8 @@
     return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
-                   const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
+                                                            const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1307,22 +1140,18 @@
     disp->DestroyQueryPool(device, queryPool, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
-                      uint32_t firstQuery, uint32_t queryCount, size_t dataSize,
-                      void *pData, VkDeviceSize stride,
-                      VkQueryResultFlags flags) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+                                                                   uint32_t queryCount, size_t dataSize, void *pData,
+                                                                   VkDeviceSize stride, VkQueryResultFlags flags) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount,
-                                     dataSize, pData, stride, flags);
+    return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
-               const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
+                                                            const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1330,9 +1159,8 @@
     return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyBuffer(VkDevice device, VkBuffer buffer,
-                const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer,
+                                                         const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1340,10 +1168,8 @@
     disp->DestroyBuffer(device, buffer, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
-                   const VkAllocationCallbacks *pAllocator,
-                   VkBufferView *pView) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
+                                                                const VkAllocationCallbacks *pAllocator, VkBufferView *pView) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1351,9 +1177,8 @@
     return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
-                    const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
+                                                             const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1361,9 +1186,8 @@
     disp->DestroyBufferView(device, bufferView, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
-              const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
+                                                           const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1371,9 +1195,7 @@
     return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyImage(VkDevice device, VkImage image,
-               const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1381,10 +1203,9 @@
     disp->DestroyImage(device, image, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetImageSubresourceLayout(VkDevice device, VkImage image,
-                            const VkImageSubresource *pSubresource,
-                            VkSubresourceLayout *pLayout) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image,
+                                                                     const VkImageSubresource *pSubresource,
+                                                                     VkSubresourceLayout *pLayout) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1392,9 +1213,8 @@
     disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
-                  const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1402,9 +1222,8 @@
     return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyImageView(VkDevice device, VkImageView imageView,
-                   const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView,
+                                                            const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1412,11 +1231,9 @@
     disp->DestroyImageView(device, imageView, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateShaderModule(VkDevice device,
-                     const VkShaderModuleCreateInfo *pCreateInfo,
-                     const VkAllocationCallbacks *pAllocator,
-                     VkShaderModule *pShader) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo,
+                                                                  const VkAllocationCallbacks *pAllocator,
+                                                                  VkShaderModule *pShader) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1424,9 +1241,8 @@
     return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
-                      const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
+                                                               const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1434,22 +1250,18 @@
     disp->DestroyShaderModule(device, shaderModule, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreatePipelineCache(VkDevice device,
-                      const VkPipelineCacheCreateInfo *pCreateInfo,
-                      const VkAllocationCallbacks *pAllocator,
-                      VkPipelineCache *pPipelineCache) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo,
+                                                                   const VkAllocationCallbacks *pAllocator,
+                                                                   VkPipelineCache *pPipelineCache) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreatePipelineCache(device, pCreateInfo, pAllocator,
-                                     pPipelineCache);
+    return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
-                       const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
+                                                                const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1457,9 +1269,8 @@
     disp->DestroyPipelineCache(device, pipelineCache, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
-                       size_t *pDataSize, void *pData) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
+                                                                    size_t *pDataSize, void *pData) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1467,49 +1278,41 @@
     return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
-                      uint32_t srcCacheCount,
-                      const VkPipelineCache *pSrcCaches) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
+                                                                   uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->MergePipelineCaches(device, dstCache, srcCacheCount,
-                                     pSrcCaches);
+    return disp->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
-                          uint32_t createInfoCount,
-                          const VkGraphicsPipelineCreateInfo *pCreateInfos,
-                          const VkAllocationCallbacks *pAllocator,
-                          VkPipeline *pPipelines) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+                                                                       uint32_t createInfoCount,
+                                                                       const VkGraphicsPipelineCreateInfo *pCreateInfos,
+                                                                       const VkAllocationCallbacks *pAllocator,
+                                                                       VkPipeline *pPipelines) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount,
-                                         pCreateInfos, pAllocator, pPipelines);
+    return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
-                         uint32_t createInfoCount,
-                         const VkComputePipelineCreateInfo *pCreateInfos,
-                         const VkAllocationCallbacks *pAllocator,
-                         VkPipeline *pPipelines) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
+                                                                      uint32_t createInfoCount,
+                                                                      const VkComputePipelineCreateInfo *pCreateInfos,
+                                                                      const VkAllocationCallbacks *pAllocator,
+                                                                      VkPipeline *pPipelines) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateComputePipelines(device, pipelineCache, createInfoCount,
-                                        pCreateInfos, pAllocator, pPipelines);
+    return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
-                  const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
+                                                           const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1517,22 +1320,18 @@
     disp->DestroyPipeline(device, pipeline, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreatePipelineLayout(VkDevice device,
-                       const VkPipelineLayoutCreateInfo *pCreateInfo,
-                       const VkAllocationCallbacks *pAllocator,
-                       VkPipelineLayout *pPipelineLayout) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo,
+                                                                    const VkAllocationCallbacks *pAllocator,
+                                                                    VkPipelineLayout *pPipelineLayout) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator,
-                                      pPipelineLayout);
+    return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
-                        const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
+                                                                 const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1540,9 +1339,8 @@
     disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
-                const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
+                                                             const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1550,9 +1348,8 @@
     return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroySampler(VkDevice device, VkSampler sampler,
-                 const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler,
+                                                          const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1560,23 +1357,19 @@
     disp->DestroySampler(device, sampler, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateDescriptorSetLayout(VkDevice device,
-                            const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
-                            const VkAllocationCallbacks *pAllocator,
-                            VkDescriptorSetLayout *pSetLayout) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device,
+                                                                         const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
+                                                                         const VkAllocationCallbacks *pAllocator,
+                                                                         VkDescriptorSetLayout *pSetLayout) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator,
-                                           pSetLayout);
+    return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyDescriptorSetLayout(VkDevice device,
-                             VkDescriptorSetLayout descriptorSetLayout,
-                             const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
+                                                                      const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1584,22 +1377,18 @@
     disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateDescriptorPool(VkDevice device,
-                       const VkDescriptorPoolCreateInfo *pCreateInfo,
-                       const VkAllocationCallbacks *pAllocator,
-                       VkDescriptorPool *pDescriptorPool) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo,
+                                                                    const VkAllocationCallbacks *pAllocator,
+                                                                    VkDescriptorPool *pDescriptorPool) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator,
-                                      pDescriptorPool);
+    return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
-                        const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                                                                 const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1607,9 +1396,8 @@
     disp->DestroyDescriptorPool(device, descriptorPool, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
-                      VkDescriptorPoolResetFlags flags) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                                                                   VkDescriptorPoolResetFlags flags) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1617,10 +1405,9 @@
     return disp->ResetDescriptorPool(device, descriptorPool, flags);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkAllocateDescriptorSets(VkDevice device,
-                         const VkDescriptorSetAllocateInfo *pAllocateInfo,
-                         VkDescriptorSet *pDescriptorSets) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device,
+                                                                      const VkDescriptorSetAllocateInfo *pAllocateInfo,
+                                                                      VkDescriptorSet *pDescriptorSets) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1628,46 +1415,39 @@
     return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
-                     uint32_t descriptorSetCount,
-                     const VkDescriptorSet *pDescriptorSets) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+                                                                  uint32_t descriptorSetCount,
+                                                                  const VkDescriptorSet *pDescriptorSets) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount,
-                                    pDescriptorSets);
+    return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
-                       const VkWriteDescriptorSet *pDescriptorWrites,
-                       uint32_t descriptorCopyCount,
-                       const VkCopyDescriptorSet *pDescriptorCopies) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+                                                                const VkWriteDescriptorSet *pDescriptorWrites,
+                                                                uint32_t descriptorCopyCount,
+                                                                const VkCopyDescriptorSet *pDescriptorCopies) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites,
-                               descriptorCopyCount, pDescriptorCopies);
+    disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
-                    const VkAllocationCallbacks *pAllocator,
-                    VkFramebuffer *pFramebuffer) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
+                                                                 const VkAllocationCallbacks *pAllocator,
+                                                                 VkFramebuffer *pFramebuffer) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateFramebuffer(device, pCreateInfo, pAllocator,
-                                   pFramebuffer);
+    return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
-                     const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
+                                                              const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1675,10 +1455,9 @@
     disp->DestroyFramebuffer(device, framebuffer, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
-                   const VkAllocationCallbacks *pAllocator,
-                   VkRenderPass *pRenderPass) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
+                                                                const VkAllocationCallbacks *pAllocator,
+                                                                VkRenderPass *pRenderPass) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1686,9 +1465,8 @@
     return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
-                    const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
+                                                             const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1696,9 +1474,8 @@
     disp->DestroyRenderPass(device, renderPass, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
-                           VkExtent2D *pGranularity) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
+                                                                    VkExtent2D *pGranularity) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1706,21 +1483,18 @@
     disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
-                    const VkAllocationCallbacks *pAllocator,
-                    VkCommandPool *pCommandPool) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
+                                                                 const VkAllocationCallbacks *pAllocator,
+                                                                 VkCommandPool *pCommandPool) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateCommandPool(device, pCreateInfo, pAllocator,
-                                   pCommandPool);
+    return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
-                     const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
+                                                              const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1728,9 +1502,8 @@
     disp->DestroyCommandPool(device, commandPool, pAllocator);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
-                   VkCommandPoolResetFlags flags) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
+                                                                VkCommandPoolResetFlags flags) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
@@ -1738,10 +1511,9 @@
     return disp->ResetCommandPool(device, commandPool, flags);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkAllocateCommandBuffers(VkDevice device,
-                         const VkCommandBufferAllocateInfo *pAllocateInfo,
-                         VkCommandBuffer *pCommandBuffers) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device,
+                                                                      const VkCommandBufferAllocateInfo *pAllocateInfo,
+                                                                      VkCommandBuffer *pCommandBuffers) {
     const VkLayerDispatchTable *disp;
     VkResult res;
 
@@ -1759,21 +1531,17 @@
     return res;
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
-                     uint32_t commandBufferCount,
-                     const VkCommandBuffer *pCommandBuffers) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
+                                                              uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->FreeCommandBuffers(device, commandPool, commandBufferCount,
-                             pCommandBuffers);
+    disp->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
-                     const VkCommandBufferBeginInfo *pBeginInfo) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
+                                                                  const VkCommandBufferBeginInfo *pBeginInfo) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1781,8 +1549,7 @@
     return disp->BeginCommandBuffer(commandBuffer, pBeginInfo);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1790,9 +1557,7 @@
     return disp->EndCommandBuffer(commandBuffer);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkResetCommandBuffer(VkCommandBuffer commandBuffer,
-                     VkCommandBufferResetFlags flags) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1800,9 +1565,8 @@
     return disp->ResetCommandBuffer(commandBuffer, flags);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdBindPipeline(VkCommandBuffer commandBuffer,
-                  VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                           VkPipeline pipeline) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1810,20 +1574,17 @@
     disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
-                 uint32_t viewportCount, const VkViewport *pViewports) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+                                                          uint32_t viewportCount, const VkViewport *pViewports) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount,
-                         pViewports);
+    disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
-                uint32_t scissorCount, const VkRect2D *pScissors) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
+                                                         uint32_t scissorCount, const VkRect2D *pScissors) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1831,8 +1592,7 @@
     disp->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1840,20 +1600,16 @@
     disp->CmdSetLineWidth(commandBuffer, lineWidth);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
-                  float depthBiasClamp, float depthBiasSlopeFactor) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
+                                                           float depthBiasClamp, float depthBiasSlopeFactor) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor,
-                          depthBiasClamp, depthBiasSlopeFactor);
+    disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
-                       const float blendConstants[4]) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1861,9 +1617,8 @@
     disp->CmdSetBlendConstants(commandBuffer, blendConstants);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
-                    float maxDepthBounds) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
+                                                             float maxDepthBounds) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1871,9 +1626,8 @@
     disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
-                           VkStencilFaceFlags faceMask, uint32_t compareMask) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                                                    uint32_t compareMask) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1881,9 +1635,8 @@
     disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
-                         VkStencilFaceFlags faceMask, uint32_t writeMask) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                                                  uint32_t writeMask) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1891,9 +1644,8 @@
     disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
-                         VkStencilFaceFlags faceMask, uint32_t reference) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                                                  uint32_t reference) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1901,23 +1653,21 @@
     disp->CmdSetStencilReference(commandBuffer, faceMask, reference);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
-    VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
-    VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount,
-    const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
-    const uint32_t *pDynamicOffsets) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer,
+                                                                 VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+                                                                 uint32_t firstSet, uint32_t descriptorSetCount,
+                                                                 const VkDescriptorSet *pDescriptorSets,
+                                                                 uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout,
-                                firstSet, descriptorSetCount, pDescriptorSets,
+    disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets,
                                 dynamicOffsetCount, pDynamicOffsets);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                     VkDeviceSize offset, VkIndexType indexType) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                              VkIndexType indexType) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1925,45 +1675,37 @@
     disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
-                       uint32_t bindingCount, const VkBuffer *pBuffers,
-                       const VkDeviceSize *pOffsets) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                                                uint32_t bindingCount, const VkBuffer *pBuffers,
+                                                                const VkDeviceSize *pOffsets) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount,
-                               pBuffers, pOffsets);
+    disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
-          uint32_t instanceCount, uint32_t firstVertex,
-          uint32_t firstInstance) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
+                                                   uint32_t firstVertex, uint32_t firstInstance) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex,
-                  firstInstance);
+    disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
-                 uint32_t instanceCount, uint32_t firstIndex,
-                 int32_t vertexOffset, uint32_t firstInstance) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
+                                                          uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
+                                                          uint32_t firstInstance) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex,
-                         vertexOffset, firstInstance);
+    disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                  VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                           uint32_t drawCount, uint32_t stride) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1971,21 +1713,16 @@
     disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                         VkDeviceSize offset, uint32_t drawCount,
-                         uint32_t stride) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                  VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount,
-                                 stride);
+    disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y,
-              uint32_t z) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -1993,9 +1730,8 @@
     disp->CmdDispatch(commandBuffer, x, y, z);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                      VkDeviceSize offset) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                               VkDeviceSize offset) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2003,74 +1739,59 @@
     disp->CmdDispatchIndirect(commandBuffer, buffer, offset);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
-                VkBuffer dstBuffer, uint32_t regionCount,
-                const VkBufferCopy *pRegions) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
+                                                         uint32_t regionCount, const VkBufferCopy *pRegions) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount,
-                        pRegions);
+    disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
-               VkImageLayout srcImageLayout, VkImage dstImage,
-               VkImageLayout dstImageLayout, uint32_t regionCount,
-               const VkImageCopy *pRegions) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                                                        VkImageLayout srcImageLayout, VkImage dstImage,
+                                                        VkImageLayout dstImageLayout, uint32_t regionCount,
+                                                        const VkImageCopy *pRegions) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage,
-                       dstImageLayout, regionCount, pRegions);
+    disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
-               VkImageLayout srcImageLayout, VkImage dstImage,
-               VkImageLayout dstImageLayout, uint32_t regionCount,
-               const VkImageBlit *pRegions, VkFilter filter) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                                                        VkImageLayout srcImageLayout, VkImage dstImage,
+                                                        VkImageLayout dstImageLayout, uint32_t regionCount,
+                                                        const VkImageBlit *pRegions, VkFilter filter) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage,
-                       dstImageLayout, regionCount, pRegions, filter);
+    disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
-                       VkImage dstImage, VkImageLayout dstImageLayout,
-                       uint32_t regionCount,
-                       const VkBufferImageCopy *pRegions) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
+                                                                VkImageLayout dstImageLayout, uint32_t regionCount,
+                                                                const VkBufferImageCopy *pRegions) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage,
-                               dstImageLayout, regionCount, pRegions);
+    disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
-                       VkImageLayout srcImageLayout, VkBuffer dstBuffer,
-                       uint32_t regionCount,
-                       const VkBufferImageCopy *pRegions) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+                                                                VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+                                                                uint32_t regionCount, const VkBufferImageCopy *pRegions) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout,
-                               dstBuffer, regionCount, pRegions);
+    disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
-                  VkDeviceSize dstOffset, VkDeviceSize dataSize,
-                  const void *pData) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+                                                           VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2078,9 +1799,8 @@
     disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
-                VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                                         VkDeviceSize size, uint32_t data) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2088,61 +1808,50 @@
     disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
-                     VkImageLayout imageLayout, const VkClearColorValue *pColor,
-                     uint32_t rangeCount,
-                     const VkImageSubresourceRange *pRanges) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
+                                                              VkImageLayout imageLayout, const VkClearColorValue *pColor,
+                                                              uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor,
-                             rangeCount, pRanges);
+    disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
-                            VkImageLayout imageLayout,
-                            const VkClearDepthStencilValue *pDepthStencil,
-                            uint32_t rangeCount,
-                            const VkImageSubresourceRange *pRanges) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
+                                                                     VkImageLayout imageLayout,
+                                                                     const VkClearDepthStencilValue *pDepthStencil,
+                                                                     uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout,
-                                    pDepthStencil, rangeCount, pRanges);
+    disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
-                      const VkClearAttachment *pAttachments, uint32_t rectCount,
-                      const VkClearRect *pRects) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+                                                               const VkClearAttachment *pAttachments, uint32_t rectCount,
+                                                               const VkClearRect *pRects) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments,
-                              rectCount, pRects);
+    disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
-                  VkImageLayout srcImageLayout, VkImage dstImage,
-                  VkImageLayout dstImageLayout, uint32_t regionCount,
-                  const VkImageResolve *pRegions) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                                                           VkImageLayout srcImageLayout, VkImage dstImage,
+                                                           VkImageLayout dstImageLayout, uint32_t regionCount,
+                                                           const VkImageResolve *pRegions) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage,
-                          dstImageLayout, regionCount, pRegions);
+    disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
-              VkPipelineStageFlags stageMask) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+                                                       VkPipelineStageFlags stageMask) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2150,9 +1859,8 @@
     disp->CmdSetEvent(commandBuffer, event, stageMask);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
-                VkPipelineStageFlags stageMask) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+                                                         VkPipelineStageFlags stageMask) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2160,46 +1868,38 @@
     disp->CmdResetEvent(commandBuffer, event, stageMask);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
-                const VkEvent *pEvents, VkPipelineStageFlags sourceStageMask,
-                VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
-                const VkMemoryBarrier *pMemoryBarriers,
-                uint32_t bufferMemoryBarrierCount,
-                const VkBufferMemoryBarrier *pBufferMemoryBarriers,
-                uint32_t imageMemoryBarrierCount,
-                const VkImageMemoryBarrier *pImageMemoryBarriers) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents,
+                                                         VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask,
+                                                         uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
+                                                         uint32_t bufferMemoryBarrierCount,
+                                                         const VkBufferMemoryBarrier *pBufferMemoryBarriers,
+                                                         uint32_t imageMemoryBarrierCount,
+                                                         const VkImageMemoryBarrier *pImageMemoryBarriers) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask,
-                        dstStageMask, memoryBarrierCount, pMemoryBarriers,
-                        bufferMemoryBarrierCount, pBufferMemoryBarriers,
-                        imageMemoryBarrierCount, pImageMemoryBarriers);
+    disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers,
+                        bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
-    VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
-    VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
-    uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
-    uint32_t bufferMemoryBarrierCount,
-    const VkBufferMemoryBarrier *pBufferMemoryBarriers,
-    uint32_t imageMemoryBarrierCount,
-    const VkImageMemoryBarrier *pImageMemoryBarriers) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
+                                                              VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
+                                                              uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
+                                                              uint32_t bufferMemoryBarrierCount,
+                                                              const VkBufferMemoryBarrier *pBufferMemoryBarriers,
+                                                              uint32_t imageMemoryBarrierCount,
+                                                              const VkImageMemoryBarrier *pImageMemoryBarriers) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdPipelineBarrier(
-        commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
-        memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
-        pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+    disp->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers,
+                             bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                uint32_t slot, VkFlags flags) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot,
+                                                         VkFlags flags) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2207,9 +1907,7 @@
     disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-              uint32_t slot) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2217,9 +1915,8 @@
     disp->CmdEndQuery(commandBuffer, queryPool, slot);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                    uint32_t firstQuery, uint32_t queryCount) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                                             uint32_t firstQuery, uint32_t queryCount) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2227,10 +1924,8 @@
     disp->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
-                    VkPipelineStageFlagBits pipelineStage,
-                    VkQueryPool queryPool, uint32_t slot) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
+                                                             VkQueryPool queryPool, uint32_t slot) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2238,36 +1933,29 @@
     disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                          uint32_t firstQuery, uint32_t queryCount,
-                          VkBuffer dstBuffer, VkDeviceSize dstOffset,
-                          VkDeviceSize stride, VkFlags flags) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                                                   uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer,
+                                                                   VkDeviceSize dstOffset, VkDeviceSize stride, VkFlags flags) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery,
-                                  queryCount, dstBuffer, dstOffset, stride,
-                                  flags);
+    disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
-                   VkShaderStageFlags stageFlags, uint32_t offset,
-                   uint32_t size, const void *pValues) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+                                                            VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
+                                                            const void *pValues) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size,
-                           pValues);
+    disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
-                     const VkRenderPassBeginInfo *pRenderPassBegin,
-                     VkSubpassContents contents) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
+                                                              const VkRenderPassBeginInfo *pRenderPassBegin,
+                                                              VkSubpassContents contents) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2275,8 +1963,7 @@
     disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2284,8 +1971,7 @@
     disp->CmdNextSubpass(commandBuffer, contents);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
@@ -2293,14 +1979,11 @@
     disp->CmdEndRenderPass(commandBuffer);
 }
 
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkCmdExecuteCommands(VkCommandBuffer commandBuffer,
-                     uint32_t commandBuffersCount,
-                     const VkCommandBuffer *pCommandBuffers) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
+                                                              const VkCommandBuffer *pCommandBuffers) {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdExecuteCommands(commandBuffer, commandBuffersCount,
-                             pCommandBuffers);
+    disp->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
 }
diff --git a/loader/vk_loader_layer.h b/loader/vk_loader_layer.h
index 2207c02..425154d 100644
--- a/loader/vk_loader_layer.h
+++ b/loader/vk_loader_layer.h
@@ -29,4 +29,3 @@
     void *pUserData;
     struct VkLayerDbgFunctionNode_ *pNext;
 } VkLayerDbgFunctionNode;
-
diff --git a/loader/vk_loader_platform.h b/loader/vk_loader_platform.h
index dc4ac10..e0af896 100644
--- a/loader/vk_loader_platform.h
+++ b/loader/vk_loader_platform.h
@@ -50,20 +50,17 @@
 #define PATH_SEPARATOR ':'
 #define DIRECTORY_SYMBOL '/'
 
-#define VULKAN_DIR            "/vulkan/"
-#define VULKAN_ICDCONF_DIR    "icd.d"
-#define VULKAN_ICD_DIR        "icd"
+#define VULKAN_DIR "/vulkan/"
+#define VULKAN_ICDCONF_DIR "icd.d"
+#define VULKAN_ICD_DIR "icd"
 #define VULKAN_ELAYERCONF_DIR "explicit_layer.d"
 #define VULKAN_ILAYERCONF_DIR "implicit_layer.d"
-#define VULKAN_LAYER_DIR      "layer"
+#define VULKAN_LAYER_DIR "layer"
 
 #if defined(EXTRASYSCONFDIR)
-#define EXTRA_DRIVERS_SYSCONFDIR_INFO ":"                                      \
-    EXTRASYSCONFDIR VULKAN_DIR VULKAN_ICDCONF_DIR
-#define EXTRA_ELAYERS_SYSCONFDIR_INFO ":"                                      \
-    EXTRASYSCONFDIR VULKAN_DIR VULKAN_ELAYERCONF_DIR
-#define EXTRA_ILAYERS_SYSCONFDIR_INFO ":"                                      \
-    EXTRASYSCONFDIR VULKAN_DIR VULKAN_ILAYERCONF_DIR
+#define EXTRA_DRIVERS_SYSCONFDIR_INFO ":" EXTRASYSCONFDIR VULKAN_DIR VULKAN_ICDCONF_DIR
+#define EXTRA_ELAYERS_SYSCONFDIR_INFO ":" EXTRASYSCONFDIR VULKAN_DIR VULKAN_ELAYERCONF_DIR
+#define EXTRA_ILAYERS_SYSCONFDIR_INFO ":" EXTRASYSCONFDIR VULKAN_DIR VULKAN_ILAYERCONF_DIR
 #else
 #define EXTRA_DRIVERS_SYSCONFDIR_INFO
 #define EXTRA_ELAYERS_SYSCONFDIR_INFO
@@ -71,33 +68,24 @@
 #endif
 
 #if defined(EXTRADATADIR)
-#define EXTRA_DRIVERS_DATADIR_INFO ":"                                         \
-    EXTRADATADIR VULKAN_DIR VULKAN_ICDCONF_DIR
-#define EXTRA_ELAYERS_DATADIR_INFO ":"                                         \
-    EXTRADATADIR VULKAN_DIR VULKAN_ELAYERCONF_DIR
-#define EXTRA_ILAYERS_DATADIR_INFO ":"                                         \
-    EXTRADATADIR VULKAN_DIR VULKAN_ILAYERCONF_DIR
+#define EXTRA_DRIVERS_DATADIR_INFO ":" EXTRADATADIR VULKAN_DIR VULKAN_ICDCONF_DIR
+#define EXTRA_ELAYERS_DATADIR_INFO ":" EXTRADATADIR VULKAN_DIR VULKAN_ELAYERCONF_DIR
+#define EXTRA_ILAYERS_DATADIR_INFO ":" EXTRADATADIR VULKAN_DIR VULKAN_ILAYERCONF_DIR
 #else
 #define EXTRA_DRIVERS_DATADIR_INFO
 #define EXTRA_ELAYERS_DATADIR_INFO
 #define EXTRA_ILAYERS_DATADIR_INFO
 #endif
 
-#define DEFAULT_VK_DRIVERS_INFO                                                \
-    SYSCONFDIR   VULKAN_DIR VULKAN_ICDCONF_DIR ":"                             \
-    DATADIR      VULKAN_DIR VULKAN_ICDCONF_DIR                                 \
-    EXTRA_DRIVERS_SYSCONFDIR_INFO                                              \
-    EXTRA_DRIVERS_DATADIR_INFO
-#define DEFAULT_VK_ELAYERS_INFO                                                \
-    SYSCONFDIR   VULKAN_DIR VULKAN_ELAYERCONF_DIR ":"                          \
-    DATADIR      VULKAN_DIR VULKAN_ELAYERCONF_DIR                              \
-    EXTRA_ELAYERS_SYSCONFDIR_INFO                                              \
-    EXTRA_ELAYERS_DATADIR_INFO
-#define DEFAULT_VK_ILAYERS_INFO                                                \
-    SYSCONFDIR   VULKAN_DIR VULKAN_ILAYERCONF_DIR ":"                          \
-    DATADIR      VULKAN_DIR VULKAN_ILAYERCONF_DIR                              \
-    EXTRA_ILAYERS_SYSCONFDIR_INFO                                              \
-    EXTRA_ILAYERS_DATADIR_INFO
+#define DEFAULT_VK_DRIVERS_INFO                                                                                                    \
+    SYSCONFDIR VULKAN_DIR VULKAN_ICDCONF_DIR                                                                                       \
+        ":" DATADIR VULKAN_DIR VULKAN_ICDCONF_DIR EXTRA_DRIVERS_SYSCONFDIR_INFO EXTRA_DRIVERS_DATADIR_INFO
+#define DEFAULT_VK_ELAYERS_INFO                                                                                                    \
+    SYSCONFDIR VULKAN_DIR VULKAN_ELAYERCONF_DIR                                                                                    \
+        ":" DATADIR VULKAN_DIR VULKAN_ELAYERCONF_DIR EXTRA_ELAYERS_SYSCONFDIR_INFO EXTRA_ELAYERS_DATADIR_INFO
+#define DEFAULT_VK_ILAYERS_INFO                                                                                                    \
+    SYSCONFDIR VULKAN_DIR VULKAN_ILAYERCONF_DIR                                                                                    \
+        ":" DATADIR VULKAN_DIR VULKAN_ILAYERCONF_DIR EXTRA_ILAYERS_SYSCONFDIR_INFO EXTRA_ILAYERS_DATADIR_INFO
 
 #define DEFAULT_VK_DRIVERS_PATH ""
 #if !defined(DEFAULT_VK_LAYERS_PATH)
@@ -131,44 +119,28 @@
         return false;
 }
 
-static inline char *loader_platform_dirname(char *path) {
-    return dirname(path);
-}
+static inline char *loader_platform_dirname(char *path) { return dirname(path); }
 
 // Dynamic Loading of libraries:
 typedef void *loader_platform_dl_handle;
-static inline loader_platform_dl_handle
-loader_platform_open_library(const char *libPath) {
+static inline loader_platform_dl_handle loader_platform_open_library(const char *libPath) {
     return dlopen(libPath, RTLD_LAZY | RTLD_LOCAL);
 }
-static inline const char *
-loader_platform_open_library_error(const char *libPath) {
-    return dlerror();
-}
-static inline void
-loader_platform_close_library(loader_platform_dl_handle library) {
-    dlclose(library);
-}
-static inline void *
-loader_platform_get_proc_address(loader_platform_dl_handle library,
-                                 const char *name) {
+static inline const char *loader_platform_open_library_error(const char *libPath) { return dlerror(); }
+static inline void loader_platform_close_library(loader_platform_dl_handle library) { dlclose(library); }
+static inline void *loader_platform_get_proc_address(loader_platform_dl_handle library, const char *name) {
     assert(library);
     assert(name);
     return dlsym(library, name);
 }
-static inline const char *
-loader_platform_get_proc_address_error(const char *name) {
-    return dlerror();
-}
+static inline const char *loader_platform_get_proc_address_error(const char *name) { return dlerror(); }
 
 // Threads:
 typedef pthread_t loader_platform_thread;
 #define THREAD_LOCAL_DECL __thread
-#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var)                           \
-    pthread_once_t var = PTHREAD_ONCE_INIT;
+#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var) pthread_once_t var = PTHREAD_ONCE_INIT;
 #define LOADER_PLATFORM_THREAD_ONCE_DEFINITION(var) pthread_once_t var;
-static inline void loader_platform_thread_once(pthread_once_t *ctl,
-                                               void (*func)(void)) {
+static inline void loader_platform_thread_once(pthread_once_t *ctl, void (*func)(void)) {
     assert(func != NULL);
     assert(ctl != NULL);
     pthread_once(ctl, func);
@@ -176,42 +148,20 @@
 
 // Thread IDs:
 typedef pthread_t loader_platform_thread_id;
-static inline loader_platform_thread_id loader_platform_get_thread_id() {
-    return pthread_self();
-}
+static inline loader_platform_thread_id loader_platform_get_thread_id() { return pthread_self(); }
 
 // Thread mutex:
 typedef pthread_mutex_t loader_platform_thread_mutex;
-static inline void
-loader_platform_thread_create_mutex(loader_platform_thread_mutex *pMutex) {
-    pthread_mutex_init(pMutex, NULL);
-}
-static inline void
-loader_platform_thread_lock_mutex(loader_platform_thread_mutex *pMutex) {
-    pthread_mutex_lock(pMutex);
-}
-static inline void
-loader_platform_thread_unlock_mutex(loader_platform_thread_mutex *pMutex) {
-    pthread_mutex_unlock(pMutex);
-}
-static inline void
-loader_platform_thread_delete_mutex(loader_platform_thread_mutex *pMutex) {
-    pthread_mutex_destroy(pMutex);
-}
+static inline void loader_platform_thread_create_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_init(pMutex, NULL); }
+static inline void loader_platform_thread_lock_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_lock(pMutex); }
+static inline void loader_platform_thread_unlock_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_unlock(pMutex); }
+static inline void loader_platform_thread_delete_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_destroy(pMutex); }
 typedef pthread_cond_t loader_platform_thread_cond;
-static inline void
-loader_platform_thread_init_cond(loader_platform_thread_cond *pCond) {
-    pthread_cond_init(pCond, NULL);
-}
-static inline void
-loader_platform_thread_cond_wait(loader_platform_thread_cond *pCond,
-                                 loader_platform_thread_mutex *pMutex) {
+static inline void loader_platform_thread_init_cond(loader_platform_thread_cond *pCond) { pthread_cond_init(pCond, NULL); }
+static inline void loader_platform_thread_cond_wait(loader_platform_thread_cond *pCond, loader_platform_thread_mutex *pMutex) {
     pthread_cond_wait(pCond, pMutex);
 }
-static inline void
-loader_platform_thread_cond_broadcast(loader_platform_thread_cond *pCond) {
-    pthread_cond_broadcast(pCond);
-}
+static inline void loader_platform_thread_cond_broadcast(loader_platform_thread_cond *pCond) { pthread_cond_broadcast(pCond); }
 
 #define loader_stack_alloc(size) alloca(size)
 
@@ -264,9 +214,7 @@
         return true;
 }
 
-static bool loader_platform_is_path_absolute(const char *path) {
-    return !PathIsRelative(path);
-}
+static bool loader_platform_is_path_absolute(const char *path) { return !PathIsRelative(path); }
 
 // WIN32 runtime doesn't have dirname().
 static inline char *loader_platform_dirname(char *path) {
@@ -315,40 +263,30 @@
 
 // Dynamic Loading:
 typedef HMODULE loader_platform_dl_handle;
-static loader_platform_dl_handle
-loader_platform_open_library(const char *libPath) {
-    return LoadLibrary(libPath);
-}
+static loader_platform_dl_handle loader_platform_open_library(const char *libPath) { return LoadLibrary(libPath); }
 static char *loader_platform_open_library_error(const char *libPath) {
     static char errorMsg[164];
-    (void)snprintf(errorMsg, 163, "Failed to open dynamic library \"%s\"",
-                   libPath);
+    (void)snprintf(errorMsg, 163, "Failed to open dynamic library \"%s\"", libPath);
     return errorMsg;
 }
-static void loader_platform_close_library(loader_platform_dl_handle library) {
-    FreeLibrary(library);
-}
-static void *loader_platform_get_proc_address(loader_platform_dl_handle library,
-                                              const char *name) {
+static void loader_platform_close_library(loader_platform_dl_handle library) { FreeLibrary(library); }
+static void *loader_platform_get_proc_address(loader_platform_dl_handle library, const char *name) {
     assert(library);
     assert(name);
     return GetProcAddress(library, name);
 }
 static char *loader_platform_get_proc_address_error(const char *name) {
     static char errorMsg[120];
-    (void)snprintf(errorMsg, 119,
-                   "Failed to find function \"%s\" in dynamic library", name);
+    (void)snprintf(errorMsg, 119, "Failed to find function \"%s\" in dynamic library", name);
     return errorMsg;
 }
 
 // Threads:
 typedef HANDLE loader_platform_thread;
 #define THREAD_LOCAL_DECL __declspec(thread)
-#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var)                           \
-    INIT_ONCE var = INIT_ONCE_STATIC_INIT;
+#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var) INIT_ONCE var = INIT_ONCE_STATIC_INIT;
 #define LOADER_PLATFORM_THREAD_ONCE_DEFINITION(var) INIT_ONCE var;
-static BOOL CALLBACK
-InitFuncWrapper(PINIT_ONCE InitOnce, PVOID Parameter, PVOID *Context) {
+static BOOL CALLBACK InitFuncWrapper(PINIT_ONCE InitOnce, PVOID Parameter, PVOID *Context) {
     void (*func)(void) = (void (*)(void))Parameter;
     func();
     return TRUE;
@@ -362,46 +300,23 @@
 
 // Thread IDs:
 typedef DWORD loader_platform_thread_id;
-static loader_platform_thread_id loader_platform_get_thread_id() {
-    return GetCurrentThreadId();
-}
+static loader_platform_thread_id loader_platform_get_thread_id() { return GetCurrentThreadId(); }
 
 // Thread mutex:
 typedef CRITICAL_SECTION loader_platform_thread_mutex;
-static void
-loader_platform_thread_create_mutex(loader_platform_thread_mutex *pMutex) {
-    InitializeCriticalSection(pMutex);
-}
-static void
-loader_platform_thread_lock_mutex(loader_platform_thread_mutex *pMutex) {
-    EnterCriticalSection(pMutex);
-}
-static void
-loader_platform_thread_unlock_mutex(loader_platform_thread_mutex *pMutex) {
-    LeaveCriticalSection(pMutex);
-}
-static void
-loader_platform_thread_delete_mutex(loader_platform_thread_mutex *pMutex) {
-    DeleteCriticalSection(pMutex);
-}
+static void loader_platform_thread_create_mutex(loader_platform_thread_mutex *pMutex) { InitializeCriticalSection(pMutex); }
+static void loader_platform_thread_lock_mutex(loader_platform_thread_mutex *pMutex) { EnterCriticalSection(pMutex); }
+static void loader_platform_thread_unlock_mutex(loader_platform_thread_mutex *pMutex) { LeaveCriticalSection(pMutex); }
+static void loader_platform_thread_delete_mutex(loader_platform_thread_mutex *pMutex) { DeleteCriticalSection(pMutex); }
 typedef CONDITION_VARIABLE loader_platform_thread_cond;
-static void
-loader_platform_thread_init_cond(loader_platform_thread_cond *pCond) {
-    InitializeConditionVariable(pCond);
-}
-static void
-loader_platform_thread_cond_wait(loader_platform_thread_cond *pCond,
-                                 loader_platform_thread_mutex *pMutex) {
+static void loader_platform_thread_init_cond(loader_platform_thread_cond *pCond) { InitializeConditionVariable(pCond); }
+static void loader_platform_thread_cond_wait(loader_platform_thread_cond *pCond, loader_platform_thread_mutex *pMutex) {
     SleepConditionVariableCS(pCond, pMutex, INFINITE);
 }
-static void
-loader_platform_thread_cond_broadcast(loader_platform_thread_cond *pCond) {
-    WakeAllConditionVariable(pCond);
-}
+static void loader_platform_thread_cond_broadcast(loader_platform_thread_cond *pCond) { WakeAllConditionVariable(pCond); }
 
 // Windows Registry:
-char *loader_get_registry_string(const HKEY hive, const LPCTSTR sub_key,
-                                 const char *value);
+char *loader_get_registry_string(const HKEY hive, const LPCTSTR sub_key, const char *value);
 
 #define loader_stack_alloc(size) _alloca(size)
 #else // defined(_WIN32)
@@ -419,6 +334,4 @@
 
 // returns true if the given string appears to be a relative or absolute
 // path, as opposed to a bare filename.
-static inline bool loader_platform_is_path(const char *path) {
-    return strchr(path, DIRECTORY_SYMBOL) != NULL;
-}
+static inline bool loader_platform_is_path(const char *path) { return strchr(path, DIRECTORY_SYMBOL) != NULL; }
diff --git a/loader/wsi.c b/loader/wsi.c
index b2e96f8..a34498f 100644
--- a/loader/wsi.c
+++ b/loader/wsi.c
@@ -34,8 +34,7 @@
 // the ICDs.
 #define ICD_VER_SUPPORTS_ICD_SURFACE_KHR 3
 
-void wsi_create_instance(struct loader_instance *ptr_instance,
-                         const VkInstanceCreateInfo *pCreateInfo) {
+void wsi_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) {
     ptr_instance->wsi_surface_enabled = false;
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
@@ -60,55 +59,47 @@
     ptr_instance->wsi_display_enabled = false;
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_KHR_SURFACE_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_surface_enabled = true;
             continue;
         }
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_win32_surface_enabled = true;
             continue;
         }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 #ifdef VK_USE_PLATFORM_MIR_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_KHR_MIR_SURFACE_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_MIR_SURFACE_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_mir_surface_enabled = true;
             continue;
         }
 #endif // VK_USE_PLATFORM_MIR_KHR
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_wayland_surface_enabled = true;
             continue;
         }
 #endif // VK_USE_PLATFORM_WAYLAND_KHR
 #ifdef VK_USE_PLATFORM_XCB_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_xcb_surface_enabled = true;
             continue;
         }
 #endif // VK_USE_PLATFORM_XCB_KHR
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_xlib_surface_enabled = true;
             continue;
         }
 #endif // VK_USE_PLATFORM_XLIB_KHR
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_android_surface_enabled = true;
             continue;
         }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_KHR_DISPLAY_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_display_enabled = true;
             continue;
         }
@@ -148,9 +139,8 @@
 // Functions for the VK_KHR_surface extension:
 
 // This is the trampoline entrypoint for DestroySurfaceKHR
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
-                    const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
+                                                             const VkAllocationCallbacks *pAllocator) {
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(instance);
     disp->DestroySurfaceKHR(instance, surface, pAllocator);
@@ -159,37 +149,28 @@
 // TODO probably need to lock around all the loader_get_instance() calls.
 
 // This is the instance chain terminator function for DestroySurfaceKHR
-VKAPI_ATTR void VKAPI_CALL
-terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
-                             const VkAllocationCallbacks *pAllocator) {
+VKAPI_ATTR void VKAPI_CALL terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
+                                                        const VkAllocationCallbacks *pAllocator) {
     struct loader_instance *ptr_instance = loader_get_instance(instance);
 
     VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
     if (NULL != icd_surface) {
         if (NULL != icd_surface->real_icd_surfaces) {
             uint32_t i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-                 icd_term != NULL; icd_term = icd_term->next, i++) {
-                if (icd_term->scanned_icd->interface_version >=
-                    ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
-                    if (NULL != icd_term->DestroySurfaceKHR &&
-                        (VkSurfaceKHR)NULL !=
-                            icd_surface->real_icd_surfaces[i]) {
-                        icd_term->DestroySurfaceKHR(
-                            icd_term->instance,
-                            icd_surface->real_icd_surfaces[i], pAllocator);
+            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+                if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
+                    if (NULL != icd_term->DestroySurfaceKHR && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[i]) {
+                        icd_term->DestroySurfaceKHR(icd_term->instance, icd_surface->real_icd_surfaces[i], pAllocator);
                         icd_surface->real_icd_surfaces[i] = (VkSurfaceKHR)NULL;
                     }
                 } else {
                     // The real_icd_surface for any ICD not supporting the
                     // proper interface version should be NULL.  If not, then
                     // we have a problem.
-                    assert((VkSurfaceKHR)NULL ==
-                           icd_surface->real_icd_surfaces[i]);
+                    assert((VkSurfaceKHR)NULL == icd_surface->real_icd_surfaces[i]);
                 }
             }
-            loader_instance_heap_free(ptr_instance,
-                                      icd_surface->real_icd_surfaces);
+            loader_instance_heap_free(ptr_instance, icd_surface->real_icd_surfaces);
         }
 
         loader_instance_heap_free(ptr_instance, (void *)(uintptr_t)surface);
@@ -197,93 +178,71 @@
 }
 
 // This is the trampoline entrypoint for GetPhysicalDeviceSurfaceSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
-                                     uint32_t queueFamilyIndex,
-                                     VkSurfaceKHR surface,
-                                     VkBool32 *pSupported) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                  uint32_t queueFamilyIndex, VkSurfaceKHR surface,
+                                                                                  VkBool32 *pSupported) {
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceSurfaceSupportKHR(
-        unwrapped_phys_dev, queueFamilyIndex, surface, pSupported);
+    VkResult res = disp->GetPhysicalDeviceSurfaceSupportKHR(unwrapped_phys_dev, queueFamilyIndex, surface, pSupported);
     return res;
 }
 
 // This is the instance chain terminator function for
 // GetPhysicalDeviceSurfaceSupportKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-    VkSurfaceKHR surface, VkBool32 *pSupported) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                             uint32_t queueFamilyIndex, VkSurfaceKHR surface,
+                                                                             VkBool32 *pSupported) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_VK_KHR_surface extension not enabled.  "
-                   "vkGetPhysicalDeviceSurfaceSupportKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_VK_KHR_surface extension not enabled.  "
+                                                                   "vkGetPhysicalDeviceSurfaceSupportKHR not executed!\n");
         return VK_SUCCESS;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(pSupported &&
-           "GetPhysicalDeviceSurfaceSupportKHR: Error, null pSupported");
+    assert(pSupported && "GetPhysicalDeviceSurfaceSupportKHR: Error, null pSupported");
     *pSupported = false;
 
-    assert(icd_term->GetPhysicalDeviceSurfaceSupportKHR &&
-           "loader: null GetPhysicalDeviceSurfaceSupportKHR ICD pointer");
+    assert(icd_term->GetPhysicalDeviceSurfaceSupportKHR && "loader: null GetPhysicalDeviceSurfaceSupportKHR ICD pointer");
 
     VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
-    if (NULL != icd_surface->real_icd_surfaces &&
-        (VkSurfaceKHR)NULL !=
-            icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
-        return icd_term->GetPhysicalDeviceSurfaceSupportKHR(
-            phys_dev_term->phys_dev, queueFamilyIndex,
-            icd_surface->real_icd_surfaces[phys_dev_term->icd_index],
-            pSupported);
+    if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
+        return icd_term->GetPhysicalDeviceSurfaceSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex,
+                                                            icd_surface->real_icd_surfaces[phys_dev_term->icd_index], pSupported);
     }
 
-    return icd_term->GetPhysicalDeviceSurfaceSupportKHR(
-        phys_dev_term->phys_dev, queueFamilyIndex, surface, pSupported);
+    return icd_term->GetPhysicalDeviceSurfaceSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, surface, pSupported);
 }
 
 // This is the trampoline entrypoint for GetPhysicalDeviceSurfaceCapabilitiesKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-    VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
 
     const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceSurfaceCapabilitiesKHR(
-        unwrapped_phys_dev, surface, pSurfaceCapabilities);
+    VkResult res = disp->GetPhysicalDeviceSurfaceCapabilitiesKHR(unwrapped_phys_dev, surface, pSurfaceCapabilities);
     return res;
 }
 
 // This is the instance chain terminator function for
 // GetPhysicalDeviceSurfaceCapabilitiesKHR
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-    VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                  VkSurfaceKHR surface,
+                                                                                  VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_surface extension not enabled.  "
-                   "vkGetPhysicalDeviceSurfaceCapabilitiesKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_surface extension not enabled.  "
+                                                                   "vkGetPhysicalDeviceSurfaceCapabilitiesKHR not executed!\n");
         return VK_SUCCESS;
     }
 
@@ -291,111 +250,85 @@
     assert(pSurfaceCapabilities && "GetPhysicalDeviceSurfaceCapabilitiesKHR: "
                                    "Error, null pSurfaceCapabilities");
 
-    assert(icd_term->GetPhysicalDeviceSurfaceCapabilitiesKHR &&
-           "loader: null GetPhysicalDeviceSurfaceCapabilitiesKHR ICD pointer");
+    assert(icd_term->GetPhysicalDeviceSurfaceCapabilitiesKHR && "loader: null GetPhysicalDeviceSurfaceCapabilitiesKHR ICD pointer");
 
     VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
-    if (NULL != icd_surface->real_icd_surfaces &&
-        (VkSurfaceKHR)NULL !=
-            icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
+    if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
         return icd_term->GetPhysicalDeviceSurfaceCapabilitiesKHR(
-            phys_dev_term->phys_dev,
-            icd_surface->real_icd_surfaces[phys_dev_term->icd_index],
-            pSurfaceCapabilities);
+            phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[phys_dev_term->icd_index], pSurfaceCapabilities);
     }
 
-    return icd_term->GetPhysicalDeviceSurfaceCapabilitiesKHR(
-        phys_dev_term->phys_dev, surface, pSurfaceCapabilities);
+    return icd_term->GetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev_term->phys_dev, surface, pSurfaceCapabilities);
 }
 
 // This is the trampoline entrypoint for GetPhysicalDeviceSurfaceFormatsKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
-                                     VkSurfaceKHR surface,
-                                     uint32_t *pSurfaceFormatCount,
-                                     VkSurfaceFormatKHR *pSurfaceFormats) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
+                                                                                  VkSurfaceKHR surface,
+                                                                                  uint32_t *pSurfaceFormatCount,
+                                                                                  VkSurfaceFormatKHR *pSurfaceFormats) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceSurfaceFormatsKHR(
-        unwrapped_phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
+    VkResult res = disp->GetPhysicalDeviceSurfaceFormatsKHR(unwrapped_phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
     return res;
 }
 
 // This is the instance chain terminator function for
 // GetPhysicalDeviceSurfaceFormatsKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-    uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                             uint32_t *pSurfaceFormatCount,
+                                                                             VkSurfaceFormatKHR *pSurfaceFormats) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_surface extension not enabled.  "
-                   "vkGetPhysicalDeviceSurfaceFormatsKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_surface extension not enabled.  "
+                                                                   "vkGetPhysicalDeviceSurfaceFormatsKHR not executed!\n");
         return VK_SUCCESS;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(
-        pSurfaceFormatCount &&
-        "GetPhysicalDeviceSurfaceFormatsKHR: Error, null pSurfaceFormatCount");
+    assert(pSurfaceFormatCount && "GetPhysicalDeviceSurfaceFormatsKHR: Error, null pSurfaceFormatCount");
 
-    assert(icd_term->GetPhysicalDeviceSurfaceFormatsKHR &&
-           "loader: null GetPhysicalDeviceSurfaceFormatsKHR ICD pointer");
+    assert(icd_term->GetPhysicalDeviceSurfaceFormatsKHR && "loader: null GetPhysicalDeviceSurfaceFormatsKHR ICD pointer");
 
     VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
-    if (NULL != icd_surface->real_icd_surfaces &&
-        (VkSurfaceKHR)NULL !=
-            icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
-        return icd_term->GetPhysicalDeviceSurfaceFormatsKHR(
-            phys_dev_term->phys_dev,
-            icd_surface->real_icd_surfaces[phys_dev_term->icd_index],
-            pSurfaceFormatCount, pSurfaceFormats);
+    if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
+        return icd_term->GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev,
+                                                            icd_surface->real_icd_surfaces[phys_dev_term->icd_index],
+                                                            pSurfaceFormatCount, pSurfaceFormats);
     }
 
-    return icd_term->GetPhysicalDeviceSurfaceFormatsKHR(
-        phys_dev_term->phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
+    return icd_term->GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
 }
 
 // This is the trampoline entrypoint for GetPhysicalDeviceSurfacePresentModesKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
-                                          VkSurfaceKHR surface,
-                                          uint32_t *pPresentModeCount,
-                                          VkPresentModeKHR *pPresentModes) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
+                                                                                       VkSurfaceKHR surface,
+                                                                                       uint32_t *pPresentModeCount,
+                                                                                       VkPresentModeKHR *pPresentModes) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceSurfacePresentModesKHR(
-        unwrapped_phys_dev, surface, pPresentModeCount, pPresentModes);
+    VkResult res = disp->GetPhysicalDeviceSurfacePresentModesKHR(unwrapped_phys_dev, surface, pPresentModeCount, pPresentModes);
     return res;
 }
 
 // This is the instance chain terminator function for
 // GetPhysicalDeviceSurfacePresentModesKHR
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceSurfacePresentModesKHR(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-    uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
+                                                                                  VkSurfaceKHR surface, uint32_t *pPresentModeCount,
+                                                                                  VkPresentModeKHR *pPresentModes) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_surface extension not enabled.  "
-                   "vkGetPhysicalDeviceSurfacePresentModesKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_surface extension not enabled.  "
+                                                                   "vkGetPhysicalDeviceSurfacePresentModesKHR not executed!\n");
         return VK_SUCCESS;
     }
 
@@ -403,74 +336,58 @@
     assert(pPresentModeCount && "GetPhysicalDeviceSurfacePresentModesKHR: "
                                 "Error, null pPresentModeCount");
 
-    assert(icd_term->GetPhysicalDeviceSurfacePresentModesKHR &&
-           "loader: null GetPhysicalDeviceSurfacePresentModesKHR ICD pointer");
+    assert(icd_term->GetPhysicalDeviceSurfacePresentModesKHR && "loader: null GetPhysicalDeviceSurfacePresentModesKHR ICD pointer");
 
     VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
-    if (NULL != icd_surface->real_icd_surfaces &&
-        (VkSurfaceKHR)NULL !=
-            icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
+    if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
         return icd_term->GetPhysicalDeviceSurfacePresentModesKHR(
-            phys_dev_term->phys_dev,
-            icd_surface->real_icd_surfaces[phys_dev_term->icd_index],
-            pPresentModeCount, pPresentModes);
+            phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[phys_dev_term->icd_index], pPresentModeCount, pPresentModes);
     }
 
-    return icd_term->GetPhysicalDeviceSurfacePresentModesKHR(
-        phys_dev_term->phys_dev, surface, pPresentModeCount, pPresentModes);
+    return icd_term->GetPhysicalDeviceSurfacePresentModesKHR(phys_dev_term->phys_dev, surface, pPresentModeCount, pPresentModes);
 }
 
 // Functions for the VK_KHR_swapchain extension:
 
 // This is the trampoline entrypoint for CreateSwapchainKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
-    VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
+                                                                  const VkAllocationCallbacks *pAllocator,
+                                                                  VkSwapchainKHR *pSwapchain) {
     const VkLayerDispatchTable *disp;
     disp = loader_get_dispatch(device);
-    return disp->CreateSwapchainKHR(device, pCreateInfo, pAllocator,
-                                    pSwapchain);
+    return disp->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_vkCreateSwapchainKHR(
-    VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator,
+                                                               VkSwapchainKHR *pSwapchain) {
     uint32_t icd_index = 0;
     struct loader_device *dev;
-    struct loader_icd_term *icd_term =
-        loader_get_icd_and_device(device, &dev, &icd_index);
+    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
     if (NULL != icd_term && NULL != icd_term->CreateSwapchainKHR) {
-        VkIcdSurface *icd_surface =
-            (VkIcdSurface *)(uintptr_t)pCreateInfo->surface;
+        VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pCreateInfo->surface;
         if (NULL != icd_surface->real_icd_surfaces) {
-            if ((VkSurfaceKHR)NULL !=
-                icd_surface->real_icd_surfaces[icd_index]) {
+            if ((VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[icd_index]) {
                 // We found the ICD, and there is an ICD KHR surface
                 // associated with it, so copy the CreateInfo struct
                 // and point it at the ICD's surface.
-                VkSwapchainCreateInfoKHR *pCreateCopy =
-                    loader_stack_alloc(sizeof(VkSwapchainCreateInfoKHR));
+                VkSwapchainCreateInfoKHR *pCreateCopy = loader_stack_alloc(sizeof(VkSwapchainCreateInfoKHR));
                 if (NULL == pCreateCopy) {
                     return VK_ERROR_OUT_OF_HOST_MEMORY;
                 }
-                memcpy(pCreateCopy, pCreateInfo,
-                       sizeof(VkSwapchainCreateInfoKHR));
-                pCreateCopy->surface =
-                    icd_surface->real_icd_surfaces[icd_index];
-                return icd_term->CreateSwapchainKHR(device, pCreateCopy,
-                                                    pAllocator, pSwapchain);
+                memcpy(pCreateCopy, pCreateInfo, sizeof(VkSwapchainCreateInfoKHR));
+                pCreateCopy->surface = icd_surface->real_icd_surfaces[icd_index];
+                return icd_term->CreateSwapchainKHR(device, pCreateCopy, pAllocator, pSwapchain);
             }
         }
-        return icd_term->CreateSwapchainKHR(device, pCreateInfo, pAllocator,
-                                            pSwapchain);
+        return icd_term->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
     }
     return VK_SUCCESS;
 }
 
 // This is the trampoline entrypoint for DestroySwapchainKHR
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
-                      const VkAllocationCallbacks *pAllocator) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
+                                                               const VkAllocationCallbacks *pAllocator) {
     const VkLayerDispatchTable *disp;
     disp = loader_get_dispatch(device);
     disp->DestroySwapchainKHR(device, swapchain, pAllocator);
@@ -480,60 +397,49 @@
  * This is the trampoline entrypoint
  * for GetSwapchainImagesKHR
  */
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
-    VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount,
-    VkImage *pSwapchainImages) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
+                                                                     uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) {
     const VkLayerDispatchTable *disp;
     disp = loader_get_dispatch(device);
-    return disp->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount,
-                                       pSwapchainImages);
+    return disp->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
 }
 
 /*
  * This is the trampoline entrypoint
  * for AcquireNextImageKHR
  */
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
-    VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
-    VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
+                                                                   VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) {
     const VkLayerDispatchTable *disp;
     disp = loader_get_dispatch(device);
-    return disp->AcquireNextImageKHR(device, swapchain, timeout, semaphore,
-                                     fence, pImageIndex);
+    return disp->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
 }
 
 // This is the trampoline entrypoint for QueuePresentKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
     const VkLayerDispatchTable *disp;
     disp = loader_get_dispatch(queue);
     return disp->QueuePresentKHR(queue, pPresentInfo);
 }
 
-static VkIcdSurface *AllocateIcdSurfaceStruct(struct loader_instance *instance,
-                                              size_t base_size,
-                                              size_t platform_size) {
+static VkIcdSurface *AllocateIcdSurfaceStruct(struct loader_instance *instance, size_t base_size, size_t platform_size) {
     // Next, if so, proceed with the implementation of this function:
-    VkIcdSurface *pIcdSurface = loader_instance_heap_alloc(
-        instance, sizeof(VkIcdSurface), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+    VkIcdSurface *pIcdSurface = loader_instance_heap_alloc(instance, sizeof(VkIcdSurface), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     if (pIcdSurface != NULL) {
         // Setup the new sizes and offsets so we can grow the structures in the
         // future without having problems
         pIcdSurface->base_size = (uint32_t)base_size;
         pIcdSurface->platform_size = (uint32_t)platform_size;
-        pIcdSurface->non_platform_offset = (uint32_t)(
-            (uint8_t *)(&pIcdSurface->base_size) - (uint8_t *)pIcdSurface);
+        pIcdSurface->non_platform_offset = (uint32_t)((uint8_t *)(&pIcdSurface->base_size) - (uint8_t *)pIcdSurface);
         pIcdSurface->entire_size = sizeof(VkIcdSurface);
 
-        pIcdSurface->real_icd_surfaces = loader_instance_heap_alloc(
-            instance, sizeof(VkSurfaceKHR) * instance->total_icd_count,
-            VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+        pIcdSurface->real_icd_surfaces = loader_instance_heap_alloc(instance, sizeof(VkSurfaceKHR) * instance->total_icd_count,
+                                                                    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
         if (pIcdSurface->real_icd_surfaces == NULL) {
             loader_instance_heap_free(instance, pIcdSurface);
             pIcdSurface = NULL;
         } else {
-            memset(pIcdSurface->real_icd_surfaces, 0,
-                   sizeof(VkSurfaceKHR) * instance->total_icd_count);
+            memset(pIcdSurface->real_icd_surfaces, 0, sizeof(VkSurfaceKHR) * instance->total_icd_count);
         }
     }
     return pIcdSurface;
@@ -544,22 +450,21 @@
 // Functions for the VK_KHR_win32_surface extension:
 
 // This is the trampoline entrypoint for CreateWin32SurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
-    VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance,
+                                                                     const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
+                                                                     const VkAllocationCallbacks *pAllocator,
+                                                                     VkSurfaceKHR *pSurface) {
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(instance);
     VkResult res;
 
-    res = disp->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator,
-                                      pSurface);
+    res = disp->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     return res;
 }
 
 // This is the instance chain terminator function for CreateWin32SurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWin32SurfaceKHR(
-    VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
+                                                                const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
     VkResult vkRes = VK_SUCCESS;
     VkIcdSurface *pIcdSurface = NULL;
     uint32_t i = 0;
@@ -569,17 +474,14 @@
     // First, check to ensure the appropriate extension was enabled:
     struct loader_instance *ptr_instance = loader_get_instance(instance);
     if (!ptr_instance->wsi_win32_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_win32_surface extension not enabled.  "
-                   "vkCreateWin32SurfaceKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_win32_surface extension not enabled.  "
+                                                                   "vkCreateWin32SurfaceKHR not executed!\n");
         vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
         goto out;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance,
-                                           sizeof(pIcdSurface->win_surf.base),
-                                           sizeof(pIcdSurface->win_surf));
+    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->win_surf.base), sizeof(pIcdSurface->win_surf));
     if (pIcdSurface == NULL) {
         vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
@@ -590,14 +492,11 @@
     pIcdSurface->win_surf.hwnd = pCreateInfo->hwnd;
 
     // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-         icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >=
-            ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
+    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
             if (NULL != icd_term->CreateWin32SurfaceKHR) {
-                vkRes = icd_term->CreateWin32SurfaceKHR(
-                    icd_term->instance, pCreateInfo, pAllocator,
-                    &pIcdSurface->real_icd_surfaces[i]);
+                vkRes = icd_term->CreateWin32SurfaceKHR(icd_term->instance, pCreateInfo, pAllocator,
+                                                        &pIcdSurface->real_icd_surfaces[i]);
                 if (VK_SUCCESS != vkRes) {
                     goto out;
                 }
@@ -612,17 +511,12 @@
     if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
         if (NULL != pIcdSurface->real_icd_surfaces) {
             i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-                 icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] &&
-                    NULL != icd_term->DestroySurfaceKHR) {
-                    icd_term->DestroySurfaceKHR(
-                        icd_term->instance, pIcdSurface->real_icd_surfaces[i],
-                        pAllocator);
+            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->DestroySurfaceKHR) {
+                    icd_term->DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
                 }
             }
-            loader_instance_heap_free(ptr_instance,
-                                      pIcdSurface->real_icd_surfaces);
+            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
         }
         loader_instance_heap_free(ptr_instance, pIcdSurface);
     }
@@ -632,34 +526,27 @@
 
 // This is the trampoline entrypoint for
 // GetPhysicalDeviceWin32PresentationSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL
-vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                               uint32_t queueFamilyIndex) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                            uint32_t queueFamilyIndex) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkBool32 res = disp->GetPhysicalDeviceWin32PresentationSupportKHR(
-        unwrapped_phys_dev, queueFamilyIndex);
+    VkBool32 res = disp->GetPhysicalDeviceWin32PresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex);
     return res;
 }
 
 // This is the instance chain terminator function for
 // GetPhysicalDeviceWin32PresentationSupportKHR
-VKAPI_ATTR VkBool32 VKAPI_CALL
-terminator_GetPhysicalDeviceWin32PresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                       uint32_t queueFamilyIndex) {
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_win32_surface_enabled) {
-        loader_log(
-            ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "VK_KHR_win32_surface extension not enabled.  "
-            "vkGetPhysicalDeviceWin32PresentationSupportKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+                   "VK_KHR_win32_surface extension not enabled.  "
+                   "vkGetPhysicalDeviceWin32PresentationSupportKHR not executed!\n");
         return VK_SUCCESS;
     }
 
@@ -668,8 +555,7 @@
            "loader: null GetPhysicalDeviceWin32PresentationSupportKHR ICD "
            "pointer");
 
-    return icd_term->GetPhysicalDeviceWin32PresentationSupportKHR(
-        phys_dev_term->phys_dev, queueFamilyIndex);
+    return icd_term->GetPhysicalDeviceWin32PresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
@@ -678,22 +564,21 @@
 // Functions for the VK_KHR_mir_surface extension:
 
 // This is the trampoline entrypoint for CreateMirSurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
-    VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(VkInstance instance,
+                                                                   const VkMirSurfaceCreateInfoKHR *pCreateInfo,
+                                                                   const VkAllocationCallbacks *pAllocator,
+                                                                   VkSurfaceKHR *pSurface) {
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(instance);
     VkResult res;
 
-    res =
-        disp->CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+    res = disp->CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     return res;
 }
 
 // This is the instance chain terminator function for CreateMirSurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMirSurfaceKHR(
-    VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo,
+                                                              const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
     VkResult vkRes = VK_SUCCESS;
     VkIcdSurface *pIcdSurface = NULL;
     uint32_t i = 0;
@@ -701,17 +586,14 @@
     // First, check to ensure the appropriate extension was enabled:
     struct loader_instance *ptr_instance = loader_get_instance(instance);
     if (!ptr_instance->wsi_mir_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_mir_surface extension not enabled.  "
-                   "vkCreateMirSurfaceKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_mir_surface extension not enabled.  "
+                                                                   "vkCreateMirSurfaceKHR not executed!\n");
         vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
         goto out;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance,
-                                           sizeof(pIcdSurface->mir_surf.base),
-                                           sizeof(pIcdSurface->mir_surf));
+    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->mir_surf.base), sizeof(pIcdSurface->mir_surf));
     if (pIcdSurface == NULL) {
         vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
@@ -722,14 +604,11 @@
     pIcdSurface->mir_surf.mirSurface = pCreateInfo->mirSurface;
 
     // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-         icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >=
-            ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
+    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
             if (NULL != icd_term->CreateMirSurfaceKHR) {
-                vkRes = icd_term->CreateMirSurfaceKHR(
-                    icd_term->instance, pCreateInfo, pAllocator,
-                    &pIcdSurface->real_icd_surfaces[i]);
+                vkRes =
+                    icd_term->CreateMirSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator, &pIcdSurface->real_icd_surfaces[i]);
                 if (VK_SUCCESS != vkRes) {
                     goto out;
                 }
@@ -744,17 +623,12 @@
     if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
         if (NULL != pIcdSurface->real_icd_surfaces) {
             i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-                 icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] &&
-                    NULL != icd_term->DestroySurfaceKHR) {
-                    icd_term->DestroySurfaceKHR(
-                        icd_term->instance, pIcdSurface->real_icd_surfaces[i],
-                        pAllocator);
+            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->DestroySurfaceKHR) {
+                    icd_term->DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
                 }
             }
-            loader_instance_heap_free(ptr_instance,
-                                      pIcdSurface->real_icd_surfaces);
+            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
         }
         loader_instance_heap_free(ptr_instance, pIcdSurface);
     }
@@ -764,47 +638,37 @@
 
 // This is the trampoline entrypoint for
 // GetPhysicalDeviceMirPresentationSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL
-vkGetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                             uint32_t queueFamilyIndex,
-                                             MirConnection *connection) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                          uint32_t queueFamilyIndex,
+                                                                                          MirConnection *connection) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkBool32 res = disp->GetPhysicalDeviceMirPresentationSupportKHR(
-        unwrapped_phys_dev, queueFamilyIndex, connection);
+    VkBool32 res = disp->GetPhysicalDeviceMirPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, connection);
     return res;
 }
 
 // This is the instance chain terminator function for
 // GetPhysicalDeviceMirPresentationSupportKHR
-VKAPI_ATTR VkBool32 VKAPI_CALL
-terminator_GetPhysicalDeviceMirPresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-    MirConnection *connection) {
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t queueFamilyIndex,
+                                                                                     MirConnection *connection) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_mir_surface_enabled) {
-        loader_log(
-            ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "VK_KHR_mir_surface extension not enabled.  "
-            "vkGetPhysicalDeviceMirPresentationSupportKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_mir_surface extension not enabled.  "
+                                                                   "vkGetPhysicalDeviceMirPresentationSupportKHR not executed!\n");
         return VK_SUCCESS;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(
-        icd_term->GetPhysicalDeviceMirPresentationSupportKHR &&
-        "loader: null GetPhysicalDeviceMirPresentationSupportKHR ICD pointer");
+    assert(icd_term->GetPhysicalDeviceMirPresentationSupportKHR &&
+           "loader: null GetPhysicalDeviceMirPresentationSupportKHR ICD pointer");
 
-    return icd_term->GetPhysicalDeviceMirPresentationSupportKHR(
-        phys_dev_term->phys_dev, queueFamilyIndex, connection);
+    return icd_term->GetPhysicalDeviceMirPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, connection);
 }
 #endif // VK_USE_PLATFORM_MIR_KHR
 
@@ -814,22 +678,22 @@
  * This is the trampoline entrypoint
  * for CreateWaylandSurfaceKHR
  */
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
-    VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance,
+                                                                       const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
+                                                                       const VkAllocationCallbacks *pAllocator,
+                                                                       VkSurfaceKHR *pSurface) {
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(instance);
     VkResult res;
 
-    res = disp->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator,
-                                        pSurface);
+    res = disp->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     return res;
 }
 
 // This is the instance chain terminator function for CreateWaylandSurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR(
-    VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR(VkInstance instance,
+                                                                  const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
+                                                                  const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
     VkResult vkRes = VK_SUCCESS;
     VkIcdSurface *pIcdSurface = NULL;
     uint32_t i = 0;
@@ -837,17 +701,14 @@
     // First, check to ensure the appropriate extension was enabled:
     struct loader_instance *ptr_instance = loader_get_instance(instance);
     if (!ptr_instance->wsi_wayland_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_wayland_surface extension not enabled.  "
-                   "vkCreateWaylandSurfaceKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_wayland_surface extension not enabled.  "
+                                                                   "vkCreateWaylandSurfaceKHR not executed!\n");
         vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
         goto out;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(
-        ptr_instance, sizeof(pIcdSurface->wayland_surf.base),
-        sizeof(pIcdSurface->wayland_surf));
+    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->wayland_surf.base), sizeof(pIcdSurface->wayland_surf));
     if (pIcdSurface == NULL) {
         vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
@@ -858,14 +719,11 @@
     pIcdSurface->wayland_surf.surface = pCreateInfo->surface;
 
     // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-         icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >=
-            ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
+    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
             if (NULL != icd_term->CreateWaylandSurfaceKHR) {
-                vkRes = icd_term->CreateWaylandSurfaceKHR(
-                    icd_term->instance, pCreateInfo, pAllocator,
-                    &pIcdSurface->real_icd_surfaces[i]);
+                vkRes = icd_term->CreateWaylandSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator,
+                                                          &pIcdSurface->real_icd_surfaces[i]);
                 if (VK_SUCCESS != vkRes) {
                     goto out;
                 }
@@ -880,17 +738,12 @@
     if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
         if (NULL != pIcdSurface->real_icd_surfaces) {
             i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-                 icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] &&
-                    NULL != icd_term->DestroySurfaceKHR) {
-                    icd_term->DestroySurfaceKHR(
-                        icd_term->instance, pIcdSurface->real_icd_surfaces[i],
-                        pAllocator);
+            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->DestroySurfaceKHR) {
+                    icd_term->DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
                 }
             }
-            loader_instance_heap_free(ptr_instance,
-                                      pIcdSurface->real_icd_surfaces);
+            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
         }
         loader_instance_heap_free(ptr_instance, pIcdSurface);
     }
@@ -900,37 +753,30 @@
 
 // This is the trampoline entrypoint for
 // GetPhysicalDeviceWaylandPresentationSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL
-vkGetPhysicalDeviceWaylandPresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-    struct wl_display *display) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                              uint32_t queueFamilyIndex,
+                                                                                              struct wl_display *display) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkBool32 res = disp->GetPhysicalDeviceWaylandPresentationSupportKHR(
-        unwrapped_phys_dev, queueFamilyIndex, display);
+    VkBool32 res = disp->GetPhysicalDeviceWaylandPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, display);
     return res;
 }
 
 // This is the instance chain terminator function for
 // GetPhysicalDeviceWaylandPresentationSupportKHR
-VKAPI_ATTR VkBool32 VKAPI_CALL
-terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-    struct wl_display *display) {
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                         uint32_t queueFamilyIndex,
+                                                                                         struct wl_display *display) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_wayland_surface_enabled) {
-        loader_log(
-            ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "VK_KHR_wayland_surface extension not enabled.  "
-            "vkGetPhysicalDeviceWaylandPresentationSupportKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+                   "VK_KHR_wayland_surface extension not enabled.  "
+                   "vkGetPhysicalDeviceWaylandPresentationSupportKHR not executed!\n");
         return VK_SUCCESS;
     }
 
@@ -939,8 +785,7 @@
            "loader: null GetPhysicalDeviceWaylandPresentationSupportKHR ICD "
            "pointer");
 
-    return icd_term->GetPhysicalDeviceWaylandPresentationSupportKHR(
-        phys_dev_term->phys_dev, queueFamilyIndex, display);
+    return icd_term->GetPhysicalDeviceWaylandPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, display);
 }
 #endif // VK_USE_PLATFORM_WAYLAND_KHR
 
@@ -949,22 +794,21 @@
 // Functions for the VK_KHR_xcb_surface extension:
 
 // This is the trampoline entrypoint for CreateXcbSurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
-    VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance,
+                                                                   const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
+                                                                   const VkAllocationCallbacks *pAllocator,
+                                                                   VkSurfaceKHR *pSurface) {
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(instance);
     VkResult res;
 
-    res =
-        disp->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+    res = disp->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     return res;
 }
 
 // This is the instance chain terminator function for CreateXcbSurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXcbSurfaceKHR(
-    VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
+                                                              const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
     VkResult vkRes = VK_SUCCESS;
     VkIcdSurface *pIcdSurface = NULL;
     uint32_t i = 0;
@@ -972,17 +816,14 @@
     // First, check to ensure the appropriate extension was enabled:
     struct loader_instance *ptr_instance = loader_get_instance(instance);
     if (!ptr_instance->wsi_xcb_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_xcb_surface extension not enabled.  "
-                   "vkCreateXcbSurfaceKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_xcb_surface extension not enabled.  "
+                                                                   "vkCreateXcbSurfaceKHR not executed!\n");
         vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
         goto out;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance,
-                                           sizeof(pIcdSurface->xcb_surf.base),
-                                           sizeof(pIcdSurface->xcb_surf));
+    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->xcb_surf.base), sizeof(pIcdSurface->xcb_surf));
     if (pIcdSurface == NULL) {
         vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
@@ -993,14 +834,11 @@
     pIcdSurface->xcb_surf.window = pCreateInfo->window;
 
     // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-         icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >=
-            ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
+    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
             if (NULL != icd_term->CreateXcbSurfaceKHR) {
-                vkRes = icd_term->CreateXcbSurfaceKHR(
-                    icd_term->instance, pCreateInfo, pAllocator,
-                    &pIcdSurface->real_icd_surfaces[i]);
+                vkRes =
+                    icd_term->CreateXcbSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator, &pIcdSurface->real_icd_surfaces[i]);
                 if (VK_SUCCESS != vkRes) {
                     goto out;
                 }
@@ -1015,17 +853,12 @@
     if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
         if (NULL != pIcdSurface->real_icd_surfaces) {
             i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-                 icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] &&
-                    NULL != icd_term->DestroySurfaceKHR) {
-                    icd_term->DestroySurfaceKHR(
-                        icd_term->instance, pIcdSurface->real_icd_surfaces[i],
-                        pAllocator);
+            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->DestroySurfaceKHR) {
+                    icd_term->DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
                 }
             }
-            loader_instance_heap_free(ptr_instance,
-                                      pIcdSurface->real_icd_surfaces);
+            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
         }
         loader_instance_heap_free(ptr_instance, pIcdSurface);
     }
@@ -1035,48 +868,39 @@
 
 // This is the trampoline entrypoint for
 // GetPhysicalDeviceXcbPresentationSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL
-vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                             uint32_t queueFamilyIndex,
-                                             xcb_connection_t *connection,
-                                             xcb_visualid_t visual_id) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                          uint32_t queueFamilyIndex,
+                                                                                          xcb_connection_t *connection,
+                                                                                          xcb_visualid_t visual_id) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkBool32 res = disp->GetPhysicalDeviceXcbPresentationSupportKHR(
-        unwrapped_phys_dev, queueFamilyIndex, connection, visual_id);
+    VkBool32 res = disp->GetPhysicalDeviceXcbPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, connection, visual_id);
     return res;
 }
 
 // This is the instance chain terminator function for
 // GetPhysicalDeviceXcbPresentationSupportKHR
-VKAPI_ATTR VkBool32 VKAPI_CALL
-terminator_GetPhysicalDeviceXcbPresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-    xcb_connection_t *connection, xcb_visualid_t visual_id) {
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t queueFamilyIndex,
+                                                                                     xcb_connection_t *connection,
+                                                                                     xcb_visualid_t visual_id) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_xcb_surface_enabled) {
-        loader_log(
-            ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "VK_KHR_xcb_surface extension not enabled.  "
-            "vkGetPhysicalDeviceXcbPresentationSupportKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_xcb_surface extension not enabled.  "
+                                                                   "vkGetPhysicalDeviceXcbPresentationSupportKHR not executed!\n");
         return VK_SUCCESS;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(
-        icd_term->GetPhysicalDeviceXcbPresentationSupportKHR &&
-        "loader: null GetPhysicalDeviceXcbPresentationSupportKHR ICD pointer");
+    assert(icd_term->GetPhysicalDeviceXcbPresentationSupportKHR &&
+           "loader: null GetPhysicalDeviceXcbPresentationSupportKHR ICD pointer");
 
-    return icd_term->GetPhysicalDeviceXcbPresentationSupportKHR(
-        phys_dev_term->phys_dev, queueFamilyIndex, connection, visual_id);
+    return icd_term->GetPhysicalDeviceXcbPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, connection, visual_id);
 }
 #endif // VK_USE_PLATFORM_XCB_KHR
 
@@ -1085,22 +909,21 @@
 // Functions for the VK_KHR_xlib_surface extension:
 
 // This is the trampoline entrypoint for CreateXlibSurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
-    VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance,
+                                                                    const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
+                                                                    const VkAllocationCallbacks *pAllocator,
+                                                                    VkSurfaceKHR *pSurface) {
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(instance);
     VkResult res;
 
-    res =
-        disp->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+    res = disp->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     return res;
 }
 
 // This is the instance chain terminator function for CreateXlibSurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXlibSurfaceKHR(
-    VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
     VkResult vkRes = VK_SUCCESS;
     VkIcdSurface *pIcdSurface = NULL;
     uint32_t i = 0;
@@ -1108,17 +931,14 @@
     // First, check to ensure the appropriate extension was enabled:
     struct loader_instance *ptr_instance = loader_get_instance(instance);
     if (!ptr_instance->wsi_xlib_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_xlib_surface extension not enabled.  "
-                   "vkCreateXlibSurfaceKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_xlib_surface extension not enabled.  "
+                                                                   "vkCreateXlibSurfaceKHR not executed!\n");
         vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
         goto out;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(
-        ptr_instance, sizeof(pIcdSurface->xlib_surf.base),
-        sizeof(pIcdSurface->xlib_surf));
+    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->xlib_surf.base), sizeof(pIcdSurface->xlib_surf));
     if (pIcdSurface == NULL) {
         vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
@@ -1129,14 +949,11 @@
     pIcdSurface->xlib_surf.window = pCreateInfo->window;
 
     // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-         icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >=
-            ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
+    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
             if (NULL != icd_term->CreateXlibSurfaceKHR) {
-                vkRes = icd_term->CreateXlibSurfaceKHR(
-                    icd_term->instance, pCreateInfo, pAllocator,
-                    &pIcdSurface->real_icd_surfaces[i]);
+                vkRes =
+                    icd_term->CreateXlibSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator, &pIcdSurface->real_icd_surfaces[i]);
                 if (VK_SUCCESS != vkRes) {
                     goto out;
                 }
@@ -1151,17 +968,12 @@
     if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
         if (NULL != pIcdSurface->real_icd_surfaces) {
             i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
-                 icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] &&
-                    NULL != icd_term->DestroySurfaceKHR) {
-                    icd_term->DestroySurfaceKHR(
-                        icd_term->instance, pIcdSurface->real_icd_surfaces[i],
-                        pAllocator);
+            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->DestroySurfaceKHR) {
+                    icd_term->DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
                 }
             }
-            loader_instance_heap_free(ptr_instance,
-                                      pIcdSurface->real_icd_surfaces);
+            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
         }
         loader_instance_heap_free(ptr_instance, pIcdSurface);
     }
@@ -1171,47 +983,37 @@
 
 // This is the trampoline entrypoint for
 // GetPhysicalDeviceXlibPresentationSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL
-vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                              uint32_t queueFamilyIndex,
-                                              Display *dpy, VisualID visualID) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                           uint32_t queueFamilyIndex, Display *dpy,
+                                                                                           VisualID visualID) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkBool32 res = disp->GetPhysicalDeviceXlibPresentationSupportKHR(
-        unwrapped_phys_dev, queueFamilyIndex, dpy, visualID);
+    VkBool32 res = disp->GetPhysicalDeviceXlibPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, dpy, visualID);
     return res;
 }
 
 // This is the instance chain terminator function for
 // GetPhysicalDeviceXlibPresentationSupportKHR
-VKAPI_ATTR VkBool32 VKAPI_CALL
-terminator_GetPhysicalDeviceXlibPresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy,
-    VisualID visualID) {
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                      uint32_t queueFamilyIndex, Display *dpy,
+                                                                                      VisualID visualID) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_xlib_surface_enabled) {
-        loader_log(
-            ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "VK_KHR_xlib_surface extension not enabled.  "
-            "vkGetPhysicalDeviceXlibPresentationSupportKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_xlib_surface extension not enabled.  "
+                                                                   "vkGetPhysicalDeviceXlibPresentationSupportKHR not executed!\n");
         return VK_SUCCESS;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(
-        icd_term->GetPhysicalDeviceXlibPresentationSupportKHR &&
-        "loader: null GetPhysicalDeviceXlibPresentationSupportKHR ICD pointer");
+    assert(icd_term->GetPhysicalDeviceXlibPresentationSupportKHR &&
+           "loader: null GetPhysicalDeviceXlibPresentationSupportKHR ICD pointer");
 
-    return icd_term->GetPhysicalDeviceXlibPresentationSupportKHR(
-        phys_dev_term->phys_dev, queueFamilyIndex, dpy, visualID);
+    return icd_term->GetPhysicalDeviceXlibPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, dpy, visualID);
 }
 #endif // VK_USE_PLATFORM_XLIB_KHR
 
@@ -1220,9 +1022,9 @@
 // Functions for the VK_KHR_android_surface extension:
 
 // This is the trampoline entrypoint for CreateAndroidSurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
-    VkInstance instance, ANativeWindow *window,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, ANativeWindow *window,
+                                                                       const VkAllocationCallbacks *pAllocator,
+                                                                       VkSurfaceKHR *pSurface) {
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(instance);
     VkResult res;
@@ -1232,22 +1034,19 @@
 }
 
 // This is the instance chain terminator function for CreateAndroidSurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateAndroidSurfaceKHR(
-    VkInstance instance, Window window, const VkAllocationCallbacks *pAllocator,
-    VkSurfaceKHR *pSurface) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateAndroidSurfaceKHR(VkInstance instance, Window window,
+                                                                  const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
     // First, check to ensure the appropriate extension was enabled:
     struct loader_instance *ptr_instance = loader_get_instance(instance);
     if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  "
-                   "vkCreateAndroidSurfaceKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled.  "
+                                                                   "vkCreateAndroidSurfaceKHR not executed!\n");
         return VK_ERROR_EXTENSION_NOT_PRESENT;
     }
 
     // Next, if so, proceed with the implementation of this function:
     VkIcdSurfaceAndroid *pIcdSurface =
-        loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceAndroid),
-                                   VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+        loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceAndroid), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     if (pIcdSurface == NULL) {
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -1264,269 +1063,216 @@
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
 // Functions for the VK_KHR_display instance extension:
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
-                                        uint32_t *pPropertyCount,
-                                        VkDisplayPropertiesKHR *pProperties) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t *pPropertyCount,
+                                                                                     VkDisplayPropertiesKHR *pProperties) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceDisplayPropertiesKHR(
-        unwrapped_phys_dev, pPropertyCount, pProperties);
+    VkResult res = disp->GetPhysicalDeviceDisplayPropertiesKHR(unwrapped_phys_dev, pPropertyCount, pProperties);
     return res;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-    VkDisplayPropertiesKHR *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                uint32_t *pPropertyCount,
+                                                                                VkDisplayPropertiesKHR *pProperties) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  "
-                   "vkGetPhysicalDeviceDisplayPropertiesKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled.  "
+                                                                   "vkGetPhysicalDeviceDisplayPropertiesKHR not executed!\n");
         return VK_SUCCESS;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(icd_term->GetPhysicalDeviceDisplayPropertiesKHR &&
-           "loader: null GetPhysicalDeviceDisplayPropertiesKHR ICD pointer");
+    assert(icd_term->GetPhysicalDeviceDisplayPropertiesKHR && "loader: null GetPhysicalDeviceDisplayPropertiesKHR ICD pointer");
 
-    return icd_term->GetPhysicalDeviceDisplayPropertiesKHR(
-        phys_dev_term->phys_dev, pPropertyCount, pProperties);
+    return icd_term->GetPhysicalDeviceDisplayPropertiesKHR(phys_dev_term->phys_dev, pPropertyCount, pProperties);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-    VkDisplayPlanePropertiesKHR *pProperties) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+    VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceDisplayPlanePropertiesKHR(
-        unwrapped_phys_dev, pPropertyCount, pProperties);
+    VkResult res = disp->GetPhysicalDeviceDisplayPlanePropertiesKHR(unwrapped_phys_dev, pPropertyCount, pProperties);
     return res;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-    VkDisplayPlanePropertiesKHR *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t *pPropertyCount,
+                                                                                     VkDisplayPlanePropertiesKHR *pProperties) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_display_enabled) {
-        loader_log(
-            ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "VK_KHR_display extension not enabled.  "
-            "vkGetPhysicalDeviceDisplayPlanePropertiesKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled.  "
+                                                                   "vkGetPhysicalDeviceDisplayPlanePropertiesKHR not executed!\n");
         return VK_SUCCESS;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(
-        icd_term->GetPhysicalDeviceDisplayPlanePropertiesKHR &&
-        "loader: null GetPhysicalDeviceDisplayPlanePropertiesKHR ICD pointer");
+    assert(icd_term->GetPhysicalDeviceDisplayPlanePropertiesKHR &&
+           "loader: null GetPhysicalDeviceDisplayPlanePropertiesKHR ICD pointer");
 
-    return icd_term->GetPhysicalDeviceDisplayPlanePropertiesKHR(
-        phys_dev_term->phys_dev, pPropertyCount, pProperties);
+    return icd_term->GetPhysicalDeviceDisplayPlanePropertiesKHR(phys_dev_term->phys_dev, pPropertyCount, pProperties);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
-                                      uint32_t planeIndex,
-                                      uint32_t *pDisplayCount,
-                                      VkDisplayKHR *pDisplays) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
+                                                                                   uint32_t planeIndex, uint32_t *pDisplayCount,
+                                                                                   VkDisplayKHR *pDisplays) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetDisplayPlaneSupportedDisplaysKHR(
-        unwrapped_phys_dev, planeIndex, pDisplayCount, pDisplays);
+    VkResult res = disp->GetDisplayPlaneSupportedDisplaysKHR(unwrapped_phys_dev, planeIndex, pDisplayCount, pDisplays);
     return res;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneSupportedDisplaysKHR(
-    VkPhysicalDevice physicalDevice, uint32_t planeIndex,
-    uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
+                                                                              uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  "
-                   "vkGetDisplayPlaneSupportedDisplaysKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled.  "
+                                                                   "vkGetDisplayPlaneSupportedDisplaysKHR not executed!\n");
         return VK_SUCCESS;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(icd_term->GetDisplayPlaneSupportedDisplaysKHR &&
-           "loader: null GetDisplayPlaneSupportedDisplaysKHR ICD pointer");
+    assert(icd_term->GetDisplayPlaneSupportedDisplaysKHR && "loader: null GetDisplayPlaneSupportedDisplaysKHR ICD pointer");
 
-    return icd_term->GetDisplayPlaneSupportedDisplaysKHR(
-        phys_dev_term->phys_dev, planeIndex, pDisplayCount, pDisplays);
+    return icd_term->GetDisplayPlaneSupportedDisplaysKHR(phys_dev_term->phys_dev, planeIndex, pDisplayCount, pDisplays);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
-    VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-    uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                                           uint32_t *pPropertyCount,
+                                                                           VkDisplayModePropertiesKHR *pProperties) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetDisplayModePropertiesKHR(
-        unwrapped_phys_dev, display, pPropertyCount, pProperties);
+    VkResult res = disp->GetDisplayModePropertiesKHR(unwrapped_phys_dev, display, pPropertyCount, pProperties);
     return res;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR(
-    VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-    uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                                      uint32_t *pPropertyCount,
+                                                                      VkDisplayModePropertiesKHR *pProperties) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  "
-                   "vkGetDisplayModePropertiesKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled.  "
+                                                                   "vkGetDisplayModePropertiesKHR not executed!\n");
         return VK_SUCCESS;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(icd_term->GetDisplayModePropertiesKHR &&
-           "loader: null GetDisplayModePropertiesKHR ICD pointer");
+    assert(icd_term->GetDisplayModePropertiesKHR && "loader: null GetDisplayModePropertiesKHR ICD pointer");
 
-    return icd_term->GetDisplayModePropertiesKHR(
-        phys_dev_term->phys_dev, display, pPropertyCount, pProperties);
+    return icd_term->GetDisplayModePropertiesKHR(phys_dev_term->phys_dev, display, pPropertyCount, pProperties);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
-    VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-    const VkDisplayModeCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                                    const VkDisplayModeCreateInfoKHR *pCreateInfo,
+                                                                    const VkAllocationCallbacks *pAllocator,
+                                                                    VkDisplayModeKHR *pMode) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->CreateDisplayModeKHR(unwrapped_phys_dev, display,
-                                              pCreateInfo, pAllocator, pMode);
+    VkResult res = disp->CreateDisplayModeKHR(unwrapped_phys_dev, display, pCreateInfo, pAllocator, pMode);
     return res;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayModeKHR(
-    VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-    const VkDisplayModeCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                               const VkDisplayModeCreateInfoKHR *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  "
-                   "vkCreateDisplayModeKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled.  "
+                                                                   "vkCreateDisplayModeKHR not executed!\n");
         return VK_ERROR_EXTENSION_NOT_PRESENT;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(icd_term->CreateDisplayModeKHR &&
-           "loader: null CreateDisplayModeKHR ICD pointer");
+    assert(icd_term->CreateDisplayModeKHR && "loader: null CreateDisplayModeKHR ICD pointer");
 
-    return icd_term->CreateDisplayModeKHR(phys_dev_term->phys_dev, display,
-                                          pCreateInfo, pAllocator, pMode);
+    return icd_term->CreateDisplayModeKHR(phys_dev_term->phys_dev, display, pCreateInfo, pAllocator, pMode);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
-    VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex,
-    VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
-    VkPhysicalDevice unwrapped_phys_dev =
-        loader_unwrap_physical_device(physicalDevice);
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+                                                                              VkDisplayModeKHR mode, uint32_t planeIndex,
+                                                                              VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetDisplayPlaneCapabilitiesKHR(
-        unwrapped_phys_dev, mode, planeIndex, pCapabilities);
+    VkResult res = disp->GetDisplayPlaneCapabilitiesKHR(unwrapped_phys_dev, mode, planeIndex, pCapabilities);
     return res;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(
-    VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex,
-    VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
+                                                                         uint32_t planeIndex,
+                                                                         VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
 
     // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
     struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance =
-        (struct loader_instance *)icd_term->this_instance;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
     if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  "
-                   "vkGetDisplayPlaneCapabilitiesKHR not executed!\n");
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled.  "
+                                                                   "vkGetDisplayPlaneCapabilitiesKHR not executed!\n");
         return VK_SUCCESS;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    assert(icd_term->GetDisplayPlaneCapabilitiesKHR &&
-           "loader: null GetDisplayPlaneCapabilitiesKHR ICD pointer");
+    assert(icd_term->GetDisplayPlaneCapabilitiesKHR && "loader: null GetDisplayPlaneCapabilitiesKHR ICD pointer");
 
-    return icd_term->GetDisplayPlaneCapabilitiesKHR(
-        phys_dev_term->phys_dev, mode, planeIndex, pCapabilities);
+    return icd_term->GetDisplayPlaneCapabilitiesKHR(phys_dev_term->phys_dev, mode, planeIndex, pCapabilities);
 }
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
-    VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,
+                                                                            const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
+                                                                            const VkAllocationCallbacks *pAllocator,
+                                                                            VkSurfaceKHR *pSurface) {
     const VkLayerInstanceDispatchTable *disp;
     disp = loader_get_instance_layer_dispatch(instance);
     VkResult res;
 
-    res = disp->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator,
-                                             pSurface);
+    res = disp->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     return res;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR(
-    VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR(VkInstance instance,
+                                                                       const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
+                                                                       const VkAllocationCallbacks *pAllocator,
+                                                                       VkSurfaceKHR *pSurface) {
     struct loader_instance *inst = loader_get_instance(instance);
     VkIcdSurface *pIcdSurface = NULL;
     VkResult vkRes = VK_SUCCESS;
     uint32_t i = 0;
 
     if (!inst->wsi_display_enabled) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_surface extension not enabled.  "
-                   "vkCreateDisplayPlaneSurfaceKHR not executed!\n");
+        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_surface extension not enabled.  "
+                                                           "vkCreateDisplayPlaneSurfaceKHR not executed!\n");
         vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
         goto out;
     }
 
     // Next, if so, proceed with the implementation of this function:
-    pIcdSurface =
-        AllocateIcdSurfaceStruct(inst, sizeof(pIcdSurface->display_surf.base),
-                                 sizeof(pIcdSurface->display_surf));
+    pIcdSurface = AllocateIcdSurfaceStruct(inst, sizeof(pIcdSurface->display_surf.base), sizeof(pIcdSurface->display_surf));
     if (pIcdSurface == NULL) {
         vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
         goto out;
@@ -1542,14 +1288,11 @@
     pIcdSurface->display_surf.imageExtent = pCreateInfo->imageExtent;
 
     // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL;
-         icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >=
-            ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
+    for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
             if (NULL != icd_term->CreateDisplayPlaneSurfaceKHR) {
-                vkRes = icd_term->CreateDisplayPlaneSurfaceKHR(
-                    icd_term->instance, pCreateInfo, pAllocator,
-                    &pIcdSurface->real_icd_surfaces[i]);
+                vkRes = icd_term->CreateDisplayPlaneSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator,
+                                                               &pIcdSurface->real_icd_surfaces[i]);
                 if (VK_SUCCESS != vkRes) {
                     goto out;
                 }
@@ -1564,13 +1307,9 @@
     if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
         if (NULL != pIcdSurface->real_icd_surfaces) {
             i = 0;
-            for (struct loader_icd_term *icd_term = inst->icd_terms;
-                 icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] &&
-                    NULL != icd_term->DestroySurfaceKHR) {
-                    icd_term->DestroySurfaceKHR(
-                        icd_term->instance, pIcdSurface->real_icd_surfaces[i],
-                        pAllocator);
+            for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->DestroySurfaceKHR) {
+                    icd_term->DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
                 }
             }
             loader_instance_heap_free(inst, pIcdSurface->real_icd_surfaces);
@@ -1583,89 +1322,67 @@
 
 // EXT_display_swapchain Extension command
 
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
-    VkDevice device, uint32_t swapchainCount,
-    const VkSwapchainCreateInfoKHR *pCreateInfos,
-    const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+                                                                         const VkSwapchainCreateInfoKHR *pCreateInfos,
+                                                                         const VkAllocationCallbacks *pAllocator,
+                                                                         VkSwapchainKHR *pSwapchains) {
     const VkLayerDispatchTable *disp;
     disp = loader_get_dispatch(device);
-    return disp->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos,
-                                           pAllocator, pSwapchains);
+    return disp->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_vkCreateSharedSwapchainsKHR(
-    VkDevice device, uint32_t swapchainCount,
-    const VkSwapchainCreateInfoKHR *pCreateInfos,
-    const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+                                                                      const VkSwapchainCreateInfoKHR *pCreateInfos,
+                                                                      const VkAllocationCallbacks *pAllocator,
+                                                                      VkSwapchainKHR *pSwapchains) {
     uint32_t icd_index = 0;
     struct loader_device *dev;
-    struct loader_icd_term *icd_term =
-        loader_get_icd_and_device(device, &dev, &icd_index);
+    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
     if (NULL != icd_term && NULL != icd_term->CreateSharedSwapchainsKHR) {
-        VkIcdSurface *icd_surface =
-            (VkIcdSurface *)(uintptr_t)pCreateInfos->surface;
+        VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pCreateInfos->surface;
         if (NULL != icd_surface->real_icd_surfaces) {
-            if ((VkSurfaceKHR)NULL !=
-                icd_surface->real_icd_surfaces[icd_index]) {
+            if ((VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[icd_index]) {
                 // We found the ICD, and there is an ICD KHR surface
                 // associated with it, so copy the CreateInfo struct
                 // and point it at the ICD's surface.
-                VkSwapchainCreateInfoKHR *pCreateCopy =
-                    loader_stack_alloc(sizeof(VkSwapchainCreateInfoKHR) *
-                        swapchainCount);
+                VkSwapchainCreateInfoKHR *pCreateCopy = loader_stack_alloc(sizeof(VkSwapchainCreateInfoKHR) * swapchainCount);
                 if (NULL == pCreateCopy) {
                     return VK_ERROR_OUT_OF_HOST_MEMORY;
                 }
-                memcpy(pCreateCopy, pCreateInfos,
-                       sizeof(VkSwapchainCreateInfoKHR) * swapchainCount);
+                memcpy(pCreateCopy, pCreateInfos, sizeof(VkSwapchainCreateInfoKHR) * swapchainCount);
                 for (uint32_t sc = 0; sc < swapchainCount; sc++) {
-                    pCreateCopy[sc].surface =
-                        icd_surface->real_icd_surfaces[icd_index];
+                    pCreateCopy[sc].surface = icd_surface->real_icd_surfaces[icd_index];
                 }
-                return icd_term->CreateSharedSwapchainsKHR(
-                    device, swapchainCount, pCreateCopy, pAllocator,
-                    pSwapchains);
+                return icd_term->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateCopy, pAllocator, pSwapchains);
             }
         }
-        return icd_term->CreateSharedSwapchainsKHR(device, swapchainCount,
-                                                   pCreateInfos, pAllocator,
-                                                   pSwapchains);
+        return icd_term->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
     }
     return VK_SUCCESS;
 }
 
-bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance,
-                                const char *name, void **addr) {
+bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) {
     *addr = NULL;
 
     // Functions for the VK_KHR_surface extension:
     if (!strcmp("vkDestroySurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkDestroySurfaceKHR
-                                                  : NULL;
+        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkDestroySurfaceKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceSurfaceSupportKHR", name)) {
-        *addr = ptr_instance->wsi_surface_enabled
-                    ? (void *)vkGetPhysicalDeviceSurfaceSupportKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceSupportKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", name)) {
-        *addr = ptr_instance->wsi_surface_enabled
-                    ? (void *)vkGetPhysicalDeviceSurfaceCapabilitiesKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceCapabilitiesKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceSurfaceFormatsKHR", name)) {
-        *addr = ptr_instance->wsi_surface_enabled
-                    ? (void *)vkGetPhysicalDeviceSurfaceFormatsKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceFormatsKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceSurfacePresentModesKHR", name)) {
-        *addr = ptr_instance->wsi_surface_enabled
-                    ? (void *)vkGetPhysicalDeviceSurfacePresentModesKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfacePresentModesKHR : NULL;
         return true;
     }
 
@@ -1700,15 +1417,11 @@
 
     // Functions for the VK_KHR_win32_surface extension:
     if (!strcmp("vkCreateWin32SurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_win32_surface_enabled
-                    ? (void *)vkCreateWin32SurfaceKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_win32_surface_enabled ? (void *)vkCreateWin32SurfaceKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceWin32PresentationSupportKHR", name)) {
-        *addr = ptr_instance->wsi_win32_surface_enabled
-                    ? (void *)vkGetPhysicalDeviceWin32PresentationSupportKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_win32_surface_enabled ? (void *)vkGetPhysicalDeviceWin32PresentationSupportKHR : NULL;
         return true;
     }
 #endif // VK_USE_PLATFORM_WIN32_KHR
@@ -1716,15 +1429,11 @@
 
     // Functions for the VK_KHR_mir_surface extension:
     if (!strcmp("vkCreateMirSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_mir_surface_enabled
-                    ? (void *)vkCreateMirSurfaceKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_mir_surface_enabled ? (void *)vkCreateMirSurfaceKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceMirPresentationSupportKHR", name)) {
-        *addr = ptr_instance->wsi_mir_surface_enabled
-                    ? (void *)vkGetPhysicalDeviceMirPresentationSupportKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_mir_surface_enabled ? (void *)vkGetPhysicalDeviceMirPresentationSupportKHR : NULL;
         return true;
     }
 #endif // VK_USE_PLATFORM_MIR_KHR
@@ -1732,15 +1441,11 @@
 
     // Functions for the VK_KHR_wayland_surface extension:
     if (!strcmp("vkCreateWaylandSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_wayland_surface_enabled
-                    ? (void *)vkCreateWaylandSurfaceKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_wayland_surface_enabled ? (void *)vkCreateWaylandSurfaceKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceWaylandPresentationSupportKHR", name)) {
-        *addr = ptr_instance->wsi_wayland_surface_enabled
-                    ? (void *)vkGetPhysicalDeviceWaylandPresentationSupportKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_wayland_surface_enabled ? (void *)vkGetPhysicalDeviceWaylandPresentationSupportKHR : NULL;
         return true;
     }
 #endif // VK_USE_PLATFORM_WAYLAND_KHR
@@ -1748,15 +1453,11 @@
 
     // Functions for the VK_KHR_xcb_surface extension:
     if (!strcmp("vkCreateXcbSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_xcb_surface_enabled
-                    ? (void *)vkCreateXcbSurfaceKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_xcb_surface_enabled ? (void *)vkCreateXcbSurfaceKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceXcbPresentationSupportKHR", name)) {
-        *addr = ptr_instance->wsi_xcb_surface_enabled
-                    ? (void *)vkGetPhysicalDeviceXcbPresentationSupportKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_xcb_surface_enabled ? (void *)vkGetPhysicalDeviceXcbPresentationSupportKHR : NULL;
         return true;
     }
 #endif // VK_USE_PLATFORM_XCB_KHR
@@ -1764,15 +1465,11 @@
 
     // Functions for the VK_KHR_xlib_surface extension:
     if (!strcmp("vkCreateXlibSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_xlib_surface_enabled
-                    ? (void *)vkCreateXlibSurfaceKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkCreateXlibSurfaceKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceXlibPresentationSupportKHR", name)) {
-        *addr = ptr_instance->wsi_xlib_surface_enabled
-                    ? (void *)vkGetPhysicalDeviceXlibPresentationSupportKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkGetPhysicalDeviceXlibPresentationSupportKHR : NULL;
         return true;
     }
 #endif // VK_USE_PLATFORM_XLIB_KHR
@@ -1780,54 +1477,38 @@
 
     // Functions for the VK_KHR_android_surface extension:
     if (!strcmp("vkCreateAndroidSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_xlib_surface_enabled
-                    ? (void *)vkCreateAndroidSurfaceKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkCreateAndroidSurfaceKHR : NULL;
         return true;
     }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
     // Functions for VK_KHR_display extension:
     if (!strcmp("vkGetPhysicalDeviceDisplayPropertiesKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled
-                    ? (void *)vkGetPhysicalDeviceDisplayPropertiesKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPropertiesKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetPhysicalDeviceDisplayPlanePropertiesKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled
-                    ? (void *)vkGetPhysicalDeviceDisplayPlanePropertiesKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPlanePropertiesKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetDisplayPlaneSupportedDisplaysKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled
-                    ? (void *)vkGetDisplayPlaneSupportedDisplaysKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayPlaneSupportedDisplaysKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetDisplayModePropertiesKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled
-                    ? (void *)vkGetDisplayModePropertiesKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayModePropertiesKHR : NULL;
         return true;
     }
     if (!strcmp("vkCreateDisplayModeKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled
-                    ? (void *)vkCreateDisplayModeKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_display_enabled ? (void *)vkCreateDisplayModeKHR : NULL;
         return true;
     }
     if (!strcmp("vkGetDisplayPlaneCapabilitiesKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled
-                    ? (void *)vkGetDisplayPlaneCapabilitiesKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayPlaneCapabilitiesKHR : NULL;
         return true;
     }
     if (!strcmp("vkCreateDisplayPlaneSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled
-                    ? (void *)vkCreateDisplayPlaneSurfaceKHR
-                    : NULL;
+        *addr = ptr_instance->wsi_display_enabled ? (void *)vkCreateDisplayPlaneSurfaceKHR : NULL;
         return true;
     }
 
diff --git a/loader/wsi.h b/loader/wsi.h
index b93a53c..c5cf871 100644
--- a/loader/wsi.h
+++ b/loader/wsi.h
@@ -44,134 +44,102 @@
 #endif // VK_USE_PLATFORM_XLIB_KHR
         VkIcdSurfaceDisplay display_surf;
     };
-    uint32_t base_size; // Size of VkIcdSurfaceBase
-    uint32_t platform_size; // Size of corresponding VkIcdSurfaceXXX
+    uint32_t base_size;           // Size of VkIcdSurfaceBase
+    uint32_t platform_size;       // Size of corresponding VkIcdSurfaceXXX
     uint32_t non_platform_offset; // Start offset to base_size
-    uint32_t entire_size; // Size of entire VkIcdSurface
+    uint32_t entire_size;         // Size of entire VkIcdSurface
     VkSurfaceKHR *real_icd_surfaces;
 } VkIcdSurface;
 
-bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance,
-                                const char *name, void **addr);
+bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr);
 
-void wsi_create_instance(struct loader_instance *ptr_instance,
-                         const VkInstanceCreateInfo *pCreateInfo);
+void wsi_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo);
 bool wsi_unsupported_instance_extension(const VkExtensionProperties *ext_prop);
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_vkCreateSwapchainKHR(
-    VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain);
 
-VKAPI_ATTR void VKAPI_CALL
-terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
-                             const VkAllocationCallbacks *pAllocator);
+VKAPI_ATTR void VKAPI_CALL terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
+                                                        const VkAllocationCallbacks *pAllocator);
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
-                                              uint32_t queueFamilyIndex,
-                                              VkSurfaceKHR surface,
-                                              VkBool32 *pSupported);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                             uint32_t queueFamilyIndex, VkSurfaceKHR surface,
+                                                                             VkBool32 *pSupported);
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-    VkSurfaceCapabilitiesKHR *pSurfaceCapabilities);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                  VkSurfaceKHR surface,
+                                                                                  VkSurfaceCapabilitiesKHR *pSurfaceCapabilities);
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-    uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                             uint32_t *pSurfaceFormatCount,
+                                                                             VkSurfaceFormatKHR *pSurfaceFormats);
 
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceSurfacePresentModesKHR(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-    uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
+                                                                                  VkSurfaceKHR surface, uint32_t *pPresentModeCount,
+                                                                                  VkPresentModeKHR *pPresentModes);
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_CreateWin32SurfaceKHR(VkInstance instance,
-                                 const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
-                                 const VkAllocationCallbacks *pAllocator,
-                                 VkSurfaceKHR *pSurface);
-VKAPI_ATTR VkBool32 VKAPI_CALL
-terminator_GetPhysicalDeviceWin32PresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
+                                                                const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                       uint32_t queueFamilyIndex);
 #endif
 #ifdef VK_USE_PLATFORM_MIR_KHR
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_CreateMirSurfaceKHR(VkInstance instance,
-                               const VkMirSurfaceCreateInfoKHR *pCreateInfo,
-                               const VkAllocationCallbacks *pAllocator,
-                               VkSurfaceKHR *pSurface);
-VKAPI_ATTR VkBool32 VKAPI_CALL
-terminator_GetPhysicalDeviceMirPresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-    MirConnection *connection);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo,
+                                                              const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t queueFamilyIndex,
+                                                                                     MirConnection *connection);
 #endif
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR(
-    VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
-VKAPI_ATTR VkBool32 VKAPI_CALL
-terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-    struct wl_display *display);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR(VkInstance instance,
+                                                                  const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
+                                                                  const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                         uint32_t queueFamilyIndex,
+                                                                                         struct wl_display *display);
 #endif
 #ifdef VK_USE_PLATFORM_XCB_KHR
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_CreateXcbSurfaceKHR(VkInstance instance,
-                               const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
-                               const VkAllocationCallbacks *pAllocator,
-                               VkSurfaceKHR *pSurface);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
+                                                              const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
 
-VKAPI_ATTR VkBool32 VKAPI_CALL
-terminator_GetPhysicalDeviceXcbPresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-    xcb_connection_t *connection, xcb_visualid_t visual_id);
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t queueFamilyIndex,
+                                                                                     xcb_connection_t *connection,
+                                                                                     xcb_visualid_t visual_id);
 #endif
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_CreateXlibSurfaceKHR(VkInstance instance,
-                                const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
-                                const VkAllocationCallbacks *pAllocator,
-                                VkSurfaceKHR *pSurface);
-VKAPI_ATTR VkBool32 VKAPI_CALL
-terminator_GetPhysicalDeviceXlibPresentationSupportKHR(
-    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy,
-    VisualID visualID);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                      uint32_t queueFamilyIndex, Display *dpy,
+                                                                                      VisualID visualID);
 #endif
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-    VkDisplayPropertiesKHR *pProperties);
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-    VkDisplayPlanePropertiesKHR *pProperties);
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
-                                               uint32_t planeIndex,
-                                               uint32_t *pDisplayCount,
-                                               VkDisplayKHR *pDisplays);
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,
-                                       VkDisplayKHR display,
-                                       uint32_t *pPropertyCount,
-                                       VkDisplayModePropertiesKHR *pProperties);
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice,
-                                VkDisplayKHR display,
-                                const VkDisplayModeCreateInfoKHR *pCreateInfo,
-                                const VkAllocationCallbacks *pAllocator,
-                                VkDisplayModeKHR *pMode);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(
-    VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex,
-    VkDisplayPlaneCapabilitiesKHR *pCapabilities);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR(
-    VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                uint32_t *pPropertyCount,
+                                                                                VkDisplayPropertiesKHR *pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t *pPropertyCount,
+                                                                                     VkDisplayPlanePropertiesKHR *pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
+                                                                              uint32_t *pDisplayCount, VkDisplayKHR *pDisplays);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                                      uint32_t *pPropertyCount,
+                                                                      VkDisplayModePropertiesKHR *pProperties);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                               const VkDisplayModeCreateInfoKHR *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
+                                                                         uint32_t planeIndex,
+                                                                         VkDisplayPlaneCapabilitiesKHR *pCapabilities);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR(VkInstance instance,
+                                                                       const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
+                                                                       const VkAllocationCallbacks *pAllocator,
+                                                                       VkSurfaceKHR *pSurface);
 
-VKAPI_ATTR VkResult VKAPI_CALL terminator_vkCreateSharedSwapchainsKHR(
-    VkDevice device, uint32_t swapchainCount,
-    const VkSwapchainCreateInfoKHR *pCreateInfos,
-    const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains);
+VKAPI_ATTR VkResult VKAPI_CALL terminator_vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+                                                                      const VkSwapchainCreateInfoKHR *pCreateInfos,
+                                                                      const VkAllocationCallbacks *pAllocator,
+                                                                      VkSwapchainKHR *pSwapchains);
 
 #endif /* WSI_H */
diff --git a/tests/icd-spv.h b/tests/icd-spv.h
index 2275220..6952561 100644
--- a/tests/icd-spv.h
+++ b/tests/icd-spv.h
@@ -17,13 +17,13 @@
 
 #include <stdint.h>
 
-#define ICD_SPV_MAGIC   0x07230203
+#define ICD_SPV_MAGIC 0x07230203
 #define ICD_SPV_VERSION 99
 
 struct icd_spv_header {
     uint32_t magic;
     uint32_t version;
-    uint32_t gen_magic;  // Generator's magic number
+    uint32_t gen_magic; // Generator's magic number
 };
 
 #endif /* ICD_SPV_H */
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 9e48f45..91015d7 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -274,15 +274,15 @@
     }
 
   private:
-    VkFlags                         message_flags_;
-    std::unordered_set<uint32_t>    desired_message_ids_;
-    std::unordered_set<string>      desired_message_strings_;
-    std::unordered_set<string>      failure_message_strings_;
-    vector<string>                  other_messages_;
-    test_platform_thread_mutex      mutex_;
-    bool                            *bailout_;
-    VkBool32                        message_found_;
-    int                             message_outstanding_count_;
+    VkFlags message_flags_;
+    std::unordered_set<uint32_t> desired_message_ids_;
+    std::unordered_set<string> desired_message_strings_;
+    std::unordered_set<string> failure_message_strings_;
+    vector<string> other_messages_;
+    test_platform_thread_mutex mutex_;
+    bool *bailout_;
+    VkBool32 message_found_;
+    int message_outstanding_count_;
 };
 
 static VKAPI_ATTR VkBool32 VKAPI_CALL myDbgFunc(VkFlags msgFlags, VkDebugReportObjectTypeEXT objType, uint64_t srcObject,
@@ -1549,7 +1549,7 @@
     vkFreeMemory(m_device->device(), mem, NULL);
 }
 
-#if 0   // disabled until PV gets real extension enable checks
+#if 0 // disabled until PV gets real extension enable checks
 TEST_F(VkLayerTest, EnableWsiBeforeUse) {
     VkResult err;
     bool pass;
@@ -1641,7 +1641,7 @@
 // Set this (for now, until all platforms are supported and tested):
 #define NEED_TO_TEST_THIS_ON_PLATFORM
 #endif // VK_USE_PLATFORM_WIN32_KHR
-#if defined(VK_USE_PLATFORM_XCB_KHR) || defined (VK_USE_PLATFORM_XLIB_KHR)
+#if defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
     // FIXME: REMOVE THIS HERE, AND UNCOMMENT ABOVE, WHEN THIS TEST HAS BEEN PORTED
     // TO NON-LINUX PLATFORMS:
     VkSurfaceKHR surface = VK_NULL_HANDLE;
@@ -2018,7 +2018,6 @@
     m_errorMonitor->VerifyFound();
 }
 
-
 #endif // MEM_TRACKER_TESTS
 
 #if OBJ_TRACKER_TESTS
@@ -2505,19 +2504,19 @@
 
     input_attribs.location = 0;
     char const *vsSource = "#version 450\n"
-        "\n"
-        "out gl_PerVertex {\n"
-        "    vec4 gl_Position;\n"
-        "};\n"
-        "void main(){\n"
-        "   gl_Position = vec4(1);\n"
-        "}\n";
+                           "\n"
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "   gl_Position = vec4(1);\n"
+                           "}\n";
     char const *fsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) out vec4 color;\n"
-        "void main(){\n"
-        "   color = vec4(1);\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) out vec4 color;\n"
+                           "void main(){\n"
+                           "   color = vec4(1);\n"
+                           "}\n";
 
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, VALIDATION_ERROR_01413);
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -2688,8 +2687,8 @@
 
     // Unsigned int vs not an int
     m_commandBuffer->BeginCommandBuffer();
-    vkCmdBlitImage(m_commandBuffer->handle(), src_image.image(), src_image.layout(), dst_image.image(),
-                   dst_image.layout(), 1, &blitRegion, VK_FILTER_NEAREST);
+    vkCmdBlitImage(m_commandBuffer->handle(), src_image.image(), src_image.layout(), dst_image.image(), dst_image.layout(), 1,
+                   &blitRegion, VK_FILTER_NEAREST);
 
     m_errorMonitor->VerifyFound();
 
@@ -2698,8 +2697,8 @@
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, VALIDATION_ERROR_02191);
 
     // Unsigned int vs signed int
-    vkCmdBlitImage(m_commandBuffer->handle(), src_image.image(), src_image.layout(), dst_image2.image(),
-                   dst_image2.layout(), 1, &blitRegion, VK_FILTER_NEAREST);
+    vkCmdBlitImage(m_commandBuffer->handle(), src_image.image(), src_image.layout(), dst_image2.image(), dst_image2.layout(), 1,
+                   &blitRegion, VK_FILTER_NEAREST);
 
     // TODO: Note that this only verifies that at least one of the VU enums was found
     //       Also, if any were not seen, they'll remain in the target list (Soln TBD, JIRA task: VL-72)
@@ -2708,7 +2707,6 @@
     m_commandBuffer->EndCommandBuffer();
 }
 
-
 TEST_F(VkLayerTest, DSImageTransferGranularityTests) {
     VkResult err;
     bool pass;
@@ -2920,24 +2918,14 @@
     // There are no attachments, but refer to attachment 0.
     VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
     VkSubpassDescription subpasses[] = {
-        {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr,
-         nullptr, 0, nullptr},
+        {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
     };
 
-    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
-                                   nullptr,
-                                   0,
-                                   0,
-                                   nullptr,
-                                   1,
-                                   subpasses,
-                                   0,
-                                   nullptr};
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 0, nullptr, 1, subpasses, 0, nullptr};
     VkRenderPass rp;
 
     // "... must be less than the total number of attachments ..."
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                                         VALIDATION_ERROR_00325);
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, VALIDATION_ERROR_00325);
     vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
     m_errorMonitor->VerifyFound();
 }
@@ -2948,56 +2936,41 @@
 
     // A renderpass with two subpasses, both writing the same attachment.
     VkAttachmentDescription attach[] = {
-        { 0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT,
-            VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
-            VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
-            VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
-        },
+        {0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
+         VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
+         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL},
     };
-    VkAttachmentReference ref = { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+    VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
     VkSubpassDescription subpasses[] = {
-        { 0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr,
-            1, &ref, nullptr, nullptr, 0, nullptr },
-        { 0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr,
-            1, &ref, nullptr, nullptr, 0, nullptr },
+        {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
+        {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
     };
-    VkSubpassDependency dep = {
-        0, 1,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        VK_DEPENDENCY_BY_REGION_BIT
-    };
-    VkRenderPassCreateInfo rpci = {
-        VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr,
-        0, 1, attach, 2, subpasses, 1, &dep
-    };
+    VkSubpassDependency dep = {0,
+                               1,
+                               VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                               VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                               VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                               VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                               VK_DEPENDENCY_BY_REGION_BIT};
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, attach, 2, subpasses, 1, &dep};
     VkRenderPass rp;
     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
     ASSERT_VK_SUCCESS(err);
 
     VkImageObj image(m_device);
-    image.init_no_layout(32, 32, VK_FORMAT_R8G8B8A8_UNORM,
-                         VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
-                         VK_IMAGE_TILING_OPTIMAL, 0);
+    image.init_no_layout(32, 32, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
     VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM);
 
-    VkFramebufferCreateInfo fbci = {
-        VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr,
-        0, rp, 1, &imageView, 32, 32, 1
-    };
+    VkFramebufferCreateInfo fbci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &imageView, 32, 32, 1};
     VkFramebuffer fb;
     err = vkCreateFramebuffer(m_device->device(), &fbci, nullptr, &fb);
     ASSERT_VK_SUCCESS(err);
 
-    char const *vsSource =
-        "#version 450\n"
-        "void main() { gl_Position = vec4(1); }\n";
-    char const *fsSource =
-        "#version 450\n"
-        "layout(location=0) out vec4 color;\n"
-        "void main() { color = vec4(1); }\n";
+    char const *vsSource = "#version 450\n"
+                           "void main() { gl_Position = vec4(1); }\n";
+    char const *fsSource = "#version 450\n"
+                           "layout(location=0) out vec4 color;\n"
+                           "void main() { color = vec4(1); }\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -3012,10 +2985,7 @@
     m_scissors.push_back(rect);
     pipe.SetScissor(m_scissors);
 
-    VkPipelineLayoutCreateInfo plci = {
-        VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr,
-        0, 0, nullptr, 0, nullptr
-    };
+    VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0, 0, nullptr, 0, nullptr};
     VkPipelineLayout pl;
     err = vkCreatePipelineLayout(m_device->device(), &plci, nullptr, &pl);
     ASSERT_VK_SUCCESS(err);
@@ -3023,16 +2993,21 @@
 
     m_commandBuffer->BeginCommandBuffer();
 
-    VkRenderPassBeginInfo rpbi = {
-        VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr,
-        rp, fb, { { 0, 0, }, { 32, 32 } }, 0, nullptr
-    };
+    VkRenderPassBeginInfo rpbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+                                  nullptr,
+                                  rp,
+                                  fb,
+                                  {{
+                                       0, 0,
+                                   },
+                                   {32, 32}},
+                                  0,
+                                  nullptr};
 
     // subtest 1: bind in the wrong subpass
     vkCmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_INLINE);
     vkCmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                                         "built for subpass 0 but used in subpass 1");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "built for subpass 0 but used in subpass 1");
     vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
     vkCmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
     m_errorMonitor->VerifyFound();
@@ -3043,8 +3018,7 @@
     vkCmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_INLINE);
     vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
     vkCmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                                         "built for subpass 0 but used in subpass 1");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "built for subpass 0 but used in subpass 1");
     vkCmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
     m_errorMonitor->VerifyFound();
 
@@ -3564,7 +3538,8 @@
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     // Dynamic viewport state
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Dynamic viewport(s) 0 are used by pipeline state object, but were not provided");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                         "Dynamic viewport(s) 0 are used by pipeline state object, but were not provided");
     VKTriangleTest(bindStateVertShaderText, bindStateFragShaderText, BsoFailViewport);
     m_errorMonitor->VerifyFound();
 }
@@ -3575,7 +3550,8 @@
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     // Dynamic scissor state
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Dynamic scissor(s) 0 are used by pipeline state object, but were not provided");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                         "Dynamic scissor(s) 0 are used by pipeline state object, but were not provided");
     VKTriangleTest(bindStateVertShaderText, bindStateFragShaderText, BsoFailScissor);
     m_errorMonitor->VerifyFound();
 }
@@ -6820,7 +6796,8 @@
     // Attempt to Create Gfx Pipeline w/o a VS
     VkResult err;
 
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Invalid Pipeline CreateInfo State: Vertex Shader required");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                         "Invalid Pipeline CreateInfo State: Vertex Shader required");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
@@ -7206,7 +7183,6 @@
             err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
             m_errorMonitor->VerifyFound();
 
-
             // Check case where multiViewport is enabled and viewport count is greater than max
             // We check scissor/viewport simultaneously since separating them would trigger the mismatch error, 1434.
             m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, VALIDATION_ERROR_01432);
@@ -7686,7 +7662,8 @@
     // Now hit second fail case where we set scissor w/ different count than PSO
     // First need to successfully create the PSO from above by setting
     // pViewports
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Dynamic viewport(s) 0 are used by pipeline state object, ");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                         "Dynamic viewport(s) 0 are used by pipeline state object, ");
 
     VkRect2D sc = {}; // Just need dummy vp to point to
     vp_state_ci.pScissors = &sc;
@@ -7981,8 +7958,8 @@
 
 TEST_F(VkLayerTest, RenderPassClearOpTooManyValues) {
     TEST_DESCRIPTION("Begin a renderPass where clearValueCount is greater than"
-        "the number of renderPass attachments that use loadOp"
-        "VK_ATTACHMENT_LOAD_OP_CLEAR.");
+                     "the number of renderPass attachments that use loadOp"
+                     "VK_ATTACHMENT_LOAD_OP_CLEAR.");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
@@ -8018,8 +7995,9 @@
     rp_begin.framebuffer = framebuffer();
     rp_begin.clearValueCount = 2; // Should be 1
 
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT, " has a clearValueCount of"
-        " 2 but only first 1 entries in pClearValues array are used");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT,
+                                         " has a clearValueCount of"
+                                         " 2 but only first 1 entries in pClearValues array are used");
 
     vkCmdBeginRenderPass(m_commandBuffer->GetBufferHandle(), &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
 
@@ -8028,7 +8006,6 @@
     vkDestroyRenderPass(m_device->device(), rp, NULL);
 }
 
-
 TEST_F(VkLayerTest, EndCommandBufferWithinRenderPass) {
 
     TEST_DESCRIPTION("End a command buffer with an active render pass");
@@ -8160,8 +8137,8 @@
 
     const VkImageSubresourceRange range = vk_testing::Image::subresource_range(image_create_info, VK_IMAGE_ASPECT_DEPTH_BIT);
 
-    vkCmdClearDepthStencilImage(m_commandBuffer->GetBufferHandle(), dstImage.handle(),
-                                VK_IMAGE_LAYOUT_GENERAL, &clear_value, 1, &range);
+    vkCmdClearDepthStencilImage(m_commandBuffer->GetBufferHandle(), dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_value, 1,
+                                &range);
 
     m_errorMonitor->VerifyFound();
 }
@@ -8533,9 +8510,7 @@
 TEST_F(VkLayerTest, LayoutFromPresentWithoutAccessMemoryRead) {
     // Transition an image away from PRESENT_SRC_KHR without ACCESS_MEMORY_READ in srcAccessMask
 
-    m_errorMonitor->SetDesiredFailureMsg(
-        VK_DEBUG_REPORT_WARNING_BIT_EXT,
-        "must have required access bit");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT, "must have required access bit");
     ASSERT_NO_FATAL_FAILURE(InitState());
     VkImageObj image(m_device);
     image.init(128, 128, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
@@ -8629,7 +8604,7 @@
 }
 
 TEST_F(VkLayerTest, ExecuteCommandsPrimaryCB) {
-TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a primary command buffer"
+    TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a primary command buffer"
                      " (should only be secondary)");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
@@ -10292,11 +10267,10 @@
 
     // Call for full-sized FB Color attachment prior to issuing a Draw
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
-        "vkCmdClearAttachments() issued on command buffer object ");
+                                         "vkCmdClearAttachments() issued on command buffer object ");
     vkCmdClearAttachments(m_commandBuffer->GetBufferHandle(), 1, &color_attachment, 1, &clear_rect);
     m_errorMonitor->VerifyFound();
 
-
     clear_rect.rect.extent.width = renderPassBeginInfo().renderArea.extent.width + 4;
     clear_rect.rect.extent.height = clear_rect.rect.extent.height / 2;
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, VALIDATION_ERROR_01115);
@@ -12085,10 +12059,7 @@
     vkBeginCommandBuffer(sec_cb, &cbbi);
     vkEndCommandBuffer(sec_cb);
 
-    VkCommandBufferBeginInfo cbbi2 = {
-        VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr,
-        0, nullptr
-    };
+    VkCommandBufferBeginInfo cbbi2 = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, 0, nullptr};
     vkBeginCommandBuffer(m_commandBuffer->GetBufferHandle(), &cbbi2);
     vkCmdBeginRenderPass(m_commandBuffer->GetBufferHandle(), &m_renderPassBeginInfo, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
 
@@ -12419,26 +12390,24 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
     const char *bad_specialization_message =
-            "Specialization entry 0 (for constant id 0) references memory outside provided specialization data ";
+        "Specialization entry 0 (for constant id 0) references memory outside provided specialization data ";
 
-    char const *vsSource =
-            "#version 450\n"
-            "\n"
-            "out gl_PerVertex {\n"
-            "    vec4 gl_Position;\n"
-            "};\n"
-            "void main(){\n"
-            "   gl_Position = vec4(1);\n"
-            "}\n";
+    char const *vsSource = "#version 450\n"
+                           "\n"
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "   gl_Position = vec4(1);\n"
+                           "}\n";
 
-    char const *fsSource =
-            "#version 450\n"
-            "\n"
-            "layout (constant_id = 0) const float r = 0.0f;\n"
-            "layout(location = 0) out vec4 uFragColor;\n"
-            "void main(){\n"
-            "   uFragColor = vec4(r,1,0,1);\n"
-            "}\n";
+    char const *fsSource = "#version 450\n"
+                           "\n"
+                           "layout (constant_id = 0) const float r = 0.0f;\n"
+                           "layout(location = 0) out vec4 uFragColor;\n"
+                           "void main(){\n"
+                           "   uFragColor = vec4(r,1,0,1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -12465,10 +12434,7 @@
     pipeline_dynamic_state_create_info.dynamicStateCount = 1;
     pipeline_dynamic_state_create_info.pDynamicStates = &scissor_state;
 
-    VkPipelineShaderStageCreateInfo shader_stage_create_info[2] = {
-        vs.GetStageCreateInfo(),
-        fs.GetStageCreateInfo()
-    };
+    VkPipelineShaderStageCreateInfo shader_stage_create_info[2] = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
 
     VkPipelineVertexInputStateCreateInfo vertex_input_create_info = {};
     vertex_input_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
@@ -12515,16 +12481,13 @@
     // This structure maps constant ids to data locations.
     const VkSpecializationMapEntry entry =
         // id,  offset,                size
-        {0, 4, sizeof(uint32_t)};  // Challenge core validation by using a bogus offset.
+        {0, 4, sizeof(uint32_t)}; // Challenge core validation by using a bogus offset.
 
     uint32_t data = 1;
 
     // Set up the info describing spec map and data
     const VkSpecializationInfo specialization_info = {
-        1,
-        &entry,
-        1 * sizeof(float),
-        &data,
+        1, &entry, 1 * sizeof(float), &data,
     };
     shader_stage_create_info[0].pSpecializationInfo = &specialization_info;
 
@@ -12572,7 +12535,8 @@
     descriptorset_layout_create_info.pBindings = &descriptorset_layout_binding;
 
     VkDescriptorSetLayout descriptorset_layout;
-    ASSERT_VK_SUCCESS(vkCreateDescriptorSetLayout(m_device->device(), &descriptorset_layout_create_info, nullptr, &descriptorset_layout));
+    ASSERT_VK_SUCCESS(
+        vkCreateDescriptorSetLayout(m_device->device(), &descriptorset_layout_create_info, nullptr, &descriptorset_layout));
 
     VkDescriptorSetAllocateInfo descriptorset_allocate_info = {};
     descriptorset_allocate_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
@@ -12585,26 +12549,24 @@
     // Challenge core_validation with a non uniform buffer type.
     VkBufferTest storage_buffer_test(m_device, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
 
-    char const *vsSource =
-            "#version 450\n"
-            "\n"
-            "layout (std140, set = 0, binding = 0) uniform buf {\n"
-            "    mat4 mvp;\n"
-            "} ubuf;\n"
-            "out gl_PerVertex {\n"
-            "    vec4 gl_Position;\n"
-            "};\n"
-            "void main(){\n"
-            "   gl_Position = ubuf.mvp * vec4(1);\n"
-            "}\n";
+    char const *vsSource = "#version 450\n"
+                           "\n"
+                           "layout (std140, set = 0, binding = 0) uniform buf {\n"
+                           "    mat4 mvp;\n"
+                           "} ubuf;\n"
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "   gl_Position = ubuf.mvp * vec4(1);\n"
+                           "}\n";
 
-    char const *fsSource =
-            "#version 450\n"
-            "\n"
-            "layout(location = 0) out vec4 uFragColor;\n"
-            "void main(){\n"
-            "   uFragColor = vec4(0,1,0,1);\n"
-            "}\n";
+    char const *fsSource = "#version 450\n"
+                           "\n"
+                           "layout(location = 0) out vec4 uFragColor;\n"
+                           "void main(){\n"
+                           "   uFragColor = vec4(0,1,0,1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -12666,8 +12628,8 @@
     descriptorset_layout_create_info.pBindings = &descriptorset_layout_binding;
 
     VkDescriptorSetLayout descriptorset_layout;
-    ASSERT_VK_SUCCESS(vkCreateDescriptorSetLayout(m_device->device(), &descriptorset_layout_create_info,
-                                                  nullptr, &descriptorset_layout));
+    ASSERT_VK_SUCCESS(
+        vkCreateDescriptorSetLayout(m_device->device(), &descriptorset_layout_create_info, nullptr, &descriptorset_layout));
 
     VkDescriptorSetAllocateInfo descriptorset_allocate_info = {};
     descriptorset_allocate_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
@@ -12679,26 +12641,24 @@
 
     VkBufferTest buffer_test(m_device, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
 
-    char const *vsSource =
-            "#version 450\n"
-            "\n"
-            "layout (std140, set = 0, binding = 0) uniform buf {\n"
-            "    mat4 mvp;\n"
-            "} ubuf;\n"
-            "out gl_PerVertex {\n"
-            "    vec4 gl_Position;\n"
-            "};\n"
-            "void main(){\n"
-            "   gl_Position = ubuf.mvp * vec4(1);\n"
-            "}\n";
+    char const *vsSource = "#version 450\n"
+                           "\n"
+                           "layout (std140, set = 0, binding = 0) uniform buf {\n"
+                           "    mat4 mvp;\n"
+                           "} ubuf;\n"
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "   gl_Position = ubuf.mvp * vec4(1);\n"
+                           "}\n";
 
-    char const *fsSource =
-            "#version 450\n"
-            "\n"
-            "layout(location = 0) out vec4 uFragColor;\n"
-            "void main(){\n"
-            "   uFragColor = vec4(0,1,0,1);\n"
-            "}\n";
+    char const *fsSource = "#version 450\n"
+                           "\n"
+                           "layout(location = 0) out vec4 uFragColor;\n"
+                           "void main(){\n"
+                           "   uFragColor = vec4(0,1,0,1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -12733,26 +12693,24 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
     const char *push_constant_not_accessible_message =
-            "Push constant range covering variable starting at offset 0 not accessible from stage VK_SHADER_STAGE_VERTEX_BIT";
+        "Push constant range covering variable starting at offset 0 not accessible from stage VK_SHADER_STAGE_VERTEX_BIT";
 
-    char const *vsSource =
-            "#version 450\n"
-            "\n"
-            "layout(push_constant, std430) uniform foo { float x; } consts;\n"
-            "out gl_PerVertex {\n"
-            "    vec4 gl_Position;\n"
-            "};\n"
-            "void main(){\n"
-            "   gl_Position = vec4(consts.x);\n"
-            "}\n";
+    char const *vsSource = "#version 450\n"
+                           "\n"
+                           "layout(push_constant, std430) uniform foo { float x; } consts;\n"
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "   gl_Position = vec4(consts.x);\n"
+                           "}\n";
 
-    char const *fsSource =
-            "#version 450\n"
-            "\n"
-            "layout(location = 0) out vec4 uFragColor;\n"
-            "void main(){\n"
-            "   uFragColor = vec4(0,1,0,1);\n"
-            "}\n";
+    char const *fsSource = "#version 450\n"
+                           "\n"
+                           "layout(location = 0) out vec4 uFragColor;\n"
+                           "void main(){\n"
+                           "   uFragColor = vec4(0,1,0,1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -12792,7 +12750,7 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
     const char *feature_not_enabled_message =
-            "Shader requires VkPhysicalDeviceFeatures::shaderFloat64 but is not enabled on the device";
+        "Shader requires VkPhysicalDeviceFeatures::shaderFloat64 but is not enabled on the device";
 
     // Some awkward steps are required to test with custom device features.
     std::vector<const char *> device_extension_names;
@@ -13359,7 +13317,8 @@
 TEST_F(VkLayerTest, CreatePipelineAttribNotProvided) {
     TEST_DESCRIPTION("Test that an error is produced for a vertex shader input which is not "
                      "provided by a vertex attribute");
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Vertex shader consumes input at location 0 but not provided");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                         "Vertex shader consumes input at location 0 but not provided");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
@@ -13479,7 +13438,7 @@
     VkPipelineObj pipe(m_device);
     pipe.AddColorAttachment();
     pipe.AddShader(&vs);
-    pipe.AddShader(&vs);        // intentionally duplicate vertex shader attachment
+    pipe.AddShader(&vs); // intentionally duplicate vertex shader attachment
     pipe.AddShader(&fs);
 
     VkDescriptorSetObj descriptorSet(m_device);
@@ -13492,8 +13451,7 @@
 }
 
 TEST_F(VkLayerTest, CreatePipelineMissingEntrypoint) {
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                                         "No entrypoint found named `foo`");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "No entrypoint found named `foo`");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
@@ -13530,10 +13488,9 @@
 }
 
 TEST_F(VkLayerTest, CreatePipelineDepthStencilRequired) {
-    m_errorMonitor->SetDesiredFailureMsg(
-        VK_DEBUG_REPORT_ERROR_BIT_EXT,
-        "pDepthStencilState is NULL when rasterization is enabled and subpass "
-        "uses a depth/stencil attachment");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                         "pDepthStencilState is NULL when rasterization is enabled and subpass "
+                                         "uses a depth/stencil attachment");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
@@ -13560,30 +13517,22 @@
     descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     VkAttachmentDescription attachments[] = {
-        { 0, VK_FORMAT_B8G8R8A8_UNORM, VK_SAMPLE_COUNT_1_BIT,
-          VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
-          VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
-          VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+        {
+            0, VK_FORMAT_B8G8R8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
+            VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
+            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
         },
-        { 0, VK_FORMAT_D16_UNORM, VK_SAMPLE_COUNT_1_BIT,
-          VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
-          VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
-          VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+        {
+            0, VK_FORMAT_D16_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
+            VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
+            VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
         },
     };
     VkAttachmentReference refs[] = {
-        { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL },
-        { 1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL },
+        {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}, {1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL},
     };
-    VkSubpassDescription subpass = {
-        0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr,
-        1, &refs[0], nullptr, &refs[1],
-        0, nullptr
-    };
-    VkRenderPassCreateInfo rpci = {
-        VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr,
-        0, 2, attachments, 1, &subpass, 0, nullptr
-    };
+    VkSubpassDescription subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &refs[0], nullptr, &refs[1], 0, nullptr};
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 2, attachments, 1, &subpass, 0, nullptr};
     VkRenderPass rp;
     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
     ASSERT_VK_SUCCESS(err);
@@ -14821,7 +14770,7 @@
 
     VkImageObj image2(m_device);
     image2.init(128, 128, VK_FORMAT_R8G8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
-               VK_IMAGE_TILING_OPTIMAL, 0); // 16bpp
+                VK_IMAGE_TILING_OPTIMAL, 0); // 16bpp
     ASSERT_TRUE(image2.initialized());
     vk_testing::Buffer buffer2;
     VkMemoryPropertyFlags reqs2 = 0;
@@ -14842,7 +14791,7 @@
     region.imageExtent.depth = 0;
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, VALIDATION_ERROR_01269);
     vkCmdCopyBufferToImage(m_commandBuffer->GetBufferHandle(), buffer.handle(), image.handle(),
-        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
+                           VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
     m_errorMonitor->VerifyFound();
 
     region.imageExtent.depth = 1;
@@ -14852,7 +14801,7 @@
     region.imageOffset.z = 4;
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, VALIDATION_ERROR_01269);
     vkCmdCopyBufferToImage(m_commandBuffer->GetBufferHandle(), buffer.handle(), image.handle(),
-        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
+                           VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
     m_errorMonitor->VerifyFound();
 
     region.imageOffset.z = 0;
@@ -14893,7 +14842,8 @@
     m_errorMonitor->VerifyFound();
 
     region.bufferImageHeight = 128;
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "If the format of srcImage is an "
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                         "If the format of srcImage is an "
                                          "integer-based format then filter must be VK_FILTER_NEAREST");
     // Expect INVALID_FILTER
     VkImageObj intImage1(m_device);
@@ -15783,7 +15733,8 @@
     image_alloc_info.pNext = NULL;
     image_alloc_info.memoryTypeIndex = 0;
     image_alloc_info.allocationSize = img_mem_reqs.size;
-    bool pass = m_device->phy().set_memory_type(img_mem_reqs.memoryTypeBits, &image_alloc_info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+    bool pass =
+        m_device->phy().set_memory_type(img_mem_reqs.memoryTypeBits, &image_alloc_info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
     ASSERT_TRUE(pass);
     VkDeviceMemory mem;
     err = vkAllocateMemory(m_device->device(), &image_alloc_info, NULL, &mem);
@@ -15887,14 +15838,13 @@
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
                                          "vkCmdClearDepthStencilImage called without a depth/stencil image.");
 
-    vkCmdClearDepthStencilImage(m_commandBuffer->GetBufferHandle(), color_image.handle(),
-                                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_value, 1, &ds_range);
+    vkCmdClearDepthStencilImage(m_commandBuffer->GetBufferHandle(), color_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                                &clear_value, 1, &ds_range);
 
     m_errorMonitor->VerifyFound();
 }
 #endif // IMAGE_TESTS
 
-
 // WSI Enabled Tests
 //
 #if 0
@@ -16328,11 +16278,11 @@
 // This is a positive test. No failures are expected.
 TEST_F(VkPositiveLayerTest, IgnoreUnrelatedDescriptor) {
     TEST_DESCRIPTION("Ensure that the vkUpdateDescriptorSets validation code "
-        "is ignoring VkWriteDescriptorSet members that are not "
-        "related to the descriptor type specified by "
-        "VkWriteDescriptorSet::descriptorType.  Correct "
-        "validation behavior will result in the test running to "
-        "completion without validation errors.");
+                     "is ignoring VkWriteDescriptorSet members that are not "
+                     "related to the descriptor type specified by "
+                     "VkWriteDescriptorSet::descriptorType.  Correct "
+                     "validation behavior will result in the test running to "
+                     "completion without validation errors.");
 
     const uintptr_t invalid_ptr = 0xcdcdcdcd;
 
@@ -16922,8 +16872,8 @@
     bool pass;
 
     TEST_DESCRIPTION("Create a buffer, allocate memory, bind memory, destroy "
-        "the buffer, create an image, and bind the same memory to "
-        "it");
+                     "the buffer, create an image, and bind the same memory to "
+                     "it");
 
     m_errorMonitor->ExpectSuccess();
 
@@ -17240,8 +17190,8 @@
 TEST_F(VkPositiveLayerTest, NonCoherentMemoryMapping) {
 
     TEST_DESCRIPTION("Ensure that validations handling of non-coherent memory "
-        "mapping while using VK_WHOLE_SIZE does not cause access "
-        "violations");
+                     "mapping while using VK_WHOLE_SIZE does not cause access "
+                     "violations");
     VkResult err;
     uint8_t *pData;
     ASSERT_NO_FATAL_FAILURE(InitState());
@@ -17260,16 +17210,16 @@
 
     // Find a memory configurations WITHOUT a COHERENT bit, otherwise exit
     bool pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+                                                VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
     if (!pass) {
         pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info,
-            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
-            VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+                                               VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+                                               VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
         if (!pass) {
             pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &alloc_info,
-                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
-                VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
-                VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+                                                   VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
+                                                       VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
+                                                   VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
             if (!pass) {
                 return;
             }
@@ -17356,7 +17306,7 @@
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     testFence.init(*m_device, fenceInfo);
-    VkFence fences[1] = { testFence.handle() };
+    VkFence fences[1] = {testFence.handle()};
     VkResult result = vkResetFences(m_device->device(), 1, fences);
     ASSERT_VK_SUCCESS(result);
 
@@ -17371,17 +17321,17 @@
 
     // Record (empty!) command buffer that can be submitted multiple times
     // simultaneously.
-    VkCommandBufferBeginInfo cbbi = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr,
-        VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, nullptr };
+    VkCommandBufferBeginInfo cbbi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr,
+                                     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, nullptr};
     m_commandBuffer->BeginCommandBuffer(&cbbi);
     m_commandBuffer->EndCommandBuffer();
 
-    VkFenceCreateInfo fci = { VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr, 0 };
+    VkFenceCreateInfo fci = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr, 0};
     VkFence fence;
     err = vkCreateFence(m_device->device(), &fci, nullptr, &fence);
     ASSERT_VK_SUCCESS(err);
 
-    VkSemaphoreCreateInfo sci = { VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, 0 };
+    VkSemaphoreCreateInfo sci = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, 0};
     VkSemaphore s1, s2;
     err = vkCreateSemaphore(m_device->device(), &sci, nullptr, &s1);
     ASSERT_VK_SUCCESS(err);
@@ -17389,7 +17339,7 @@
     ASSERT_VK_SUCCESS(err);
 
     // Submit CB once signaling s1, with fence so we can roll forward to its retirement.
-    VkSubmitInfo si = { VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr, 0, nullptr, nullptr, 1, &m_commandBuffer->handle(), 1, &s1 };
+    VkSubmitInfo si = {VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr, 0, nullptr, nullptr, 1, &m_commandBuffer->handle(), 1, &s1};
     err = vkQueueSubmit(m_device->m_queue, 1, &si, fence);
     ASSERT_VK_SUCCESS(err);
 
@@ -17421,23 +17371,23 @@
     VkResult err;
 
     // A fence created signaled
-    VkFenceCreateInfo fci1 = { VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr, VK_FENCE_CREATE_SIGNALED_BIT };
+    VkFenceCreateInfo fci1 = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr, VK_FENCE_CREATE_SIGNALED_BIT};
     VkFence f1;
     err = vkCreateFence(m_device->device(), &fci1, nullptr, &f1);
     ASSERT_VK_SUCCESS(err);
 
     // A fence created not
-    VkFenceCreateInfo fci2 = { VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr, 0 };
+    VkFenceCreateInfo fci2 = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr, 0};
     VkFence f2;
     err = vkCreateFence(m_device->device(), &fci2, nullptr, &f2);
     ASSERT_VK_SUCCESS(err);
 
     // Submit the unsignaled fence
-    VkSubmitInfo si = { VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr, 0, nullptr, nullptr, 0, nullptr, 0, nullptr };
+    VkSubmitInfo si = {VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr, 0, nullptr, nullptr, 0, nullptr, 0, nullptr};
     err = vkQueueSubmit(m_device->m_queue, 1, &si, f2);
 
     // Wait on both fences, with signaled first.
-    VkFence fences[] = { f1, f2 };
+    VkFence fences[] = {f1, f2};
     vkWaitForFences(m_device->device(), 2, fences, VK_TRUE, UINT64_MAX);
 
     // Should have both retired!
@@ -17449,7 +17399,7 @@
 
 TEST_F(VkPositiveLayerTest, ValidUsage) {
     TEST_DESCRIPTION("Verify that creating an image view from an image with valid usage "
-        "doesn't generate validation errors");
+                     "doesn't generate validation errors");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
@@ -17477,7 +17427,7 @@
 // This is a positive test. No failures are expected.
 TEST_F(VkPositiveLayerTest, BindSparse) {
     TEST_DESCRIPTION("Bind 2 memory ranges to one image using vkQueueBindSparse, destroy the image"
-        "and then free the memory");
+                     "and then free the memory");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
@@ -17568,30 +17518,30 @@
 
 TEST_F(VkPositiveLayerTest, RenderPassInitialLayoutUndefined) {
     TEST_DESCRIPTION("Ensure that CmdBeginRenderPass with an attachment's "
-        "initialLayout of VK_IMAGE_LAYOUT_UNDEFINED works when "
-        "the command buffer has prior knowledge of that "
-        "attachment's layout.");
+                     "initialLayout of VK_IMAGE_LAYOUT_UNDEFINED works when "
+                     "the command buffer has prior knowledge of that "
+                     "attachment's layout.");
 
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
     // A renderpass with one color attachment.
-    VkAttachmentDescription attachment = { 0,
-        VK_FORMAT_R8G8B8A8_UNORM,
-        VK_SAMPLE_COUNT_1_BIT,
-        VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-        VK_ATTACHMENT_STORE_OP_STORE,
-        VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-        VK_ATTACHMENT_STORE_OP_DONT_CARE,
-        VK_IMAGE_LAYOUT_UNDEFINED,
-        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+    VkAttachmentDescription attachment = {0,
+                                          VK_FORMAT_R8G8B8A8_UNORM,
+                                          VK_SAMPLE_COUNT_1_BIT,
+                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                          VK_ATTACHMENT_STORE_OP_STORE,
+                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                          VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                                          VK_IMAGE_LAYOUT_UNDEFINED,
+                                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
 
-    VkAttachmentReference att_ref = { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+    VkAttachmentReference att_ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
 
-    VkSubpassDescription subpass = { 0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &att_ref, nullptr, nullptr, 0, nullptr };
+    VkSubpassDescription subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &att_ref, nullptr, nullptr, 0, nullptr};
 
-    VkRenderPassCreateInfo rpci = { VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, &attachment, 1, &subpass, 0, nullptr };
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, &attachment, 1, &subpass, 0, nullptr};
 
     VkRenderPass rp;
     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
@@ -17609,15 +17559,15 @@
         image.handle(),
         VK_IMAGE_VIEW_TYPE_2D,
         VK_FORMAT_R8G8B8A8_UNORM,
-        { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-        VK_COMPONENT_SWIZZLE_IDENTITY },
-        { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 },
+        {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
+         VK_COMPONENT_SWIZZLE_IDENTITY},
+        {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1},
     };
     VkImageView view;
     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
     ASSERT_VK_SUCCESS(err);
 
-    VkFramebufferCreateInfo fci = { VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &view, 32, 32, 1 };
+    VkFramebufferCreateInfo fci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &view, 32, 32, 1};
     VkFramebuffer fb;
     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
     ASSERT_VK_SUCCESS(err);
@@ -17625,7 +17575,7 @@
     // Record a single command buffer which uses this renderpass twice. The
     // bug is triggered at the beginning of the second renderpass, when the
     // command buffer already has a layout recorded for the attachment.
-    VkRenderPassBeginInfo rpbi = { VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb,{ { 0, 0 },{ 32, 32 } }, 0, nullptr };
+    VkRenderPassBeginInfo rpbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb, {{0, 0}, {32, 32}}, 0, nullptr};
     m_commandBuffer->BeginCommandBuffer();
     vkCmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_INLINE);
     vkCmdEndRenderPass(m_commandBuffer->handle());
@@ -17643,30 +17593,30 @@
 
 TEST_F(VkPositiveLayerTest, FramebufferBindingDestroyCommandPool) {
     TEST_DESCRIPTION("This test should pass. Create a Framebuffer and "
-        "command buffer, bind them together, then destroy "
-        "command pool and framebuffer and verify there are no "
-        "errors.");
+                     "command buffer, bind them together, then destroy "
+                     "command pool and framebuffer and verify there are no "
+                     "errors.");
 
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
     // A renderpass with one color attachment.
-    VkAttachmentDescription attachment = { 0,
-        VK_FORMAT_R8G8B8A8_UNORM,
-        VK_SAMPLE_COUNT_1_BIT,
-        VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-        VK_ATTACHMENT_STORE_OP_STORE,
-        VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-        VK_ATTACHMENT_STORE_OP_DONT_CARE,
-        VK_IMAGE_LAYOUT_UNDEFINED,
-        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+    VkAttachmentDescription attachment = {0,
+                                          VK_FORMAT_R8G8B8A8_UNORM,
+                                          VK_SAMPLE_COUNT_1_BIT,
+                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                          VK_ATTACHMENT_STORE_OP_STORE,
+                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                          VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                                          VK_IMAGE_LAYOUT_UNDEFINED,
+                                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
 
-    VkAttachmentReference att_ref = { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+    VkAttachmentReference att_ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
 
-    VkSubpassDescription subpass = { 0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &att_ref, nullptr, nullptr, 0, nullptr };
+    VkSubpassDescription subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &att_ref, nullptr, nullptr, 0, nullptr};
 
-    VkRenderPassCreateInfo rpci = { VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, &attachment, 1, &subpass, 0, nullptr };
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, &attachment, 1, &subpass, 0, nullptr};
 
     VkRenderPass rp;
     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
@@ -17684,15 +17634,15 @@
         image.handle(),
         VK_IMAGE_VIEW_TYPE_2D,
         VK_FORMAT_R8G8B8A8_UNORM,
-        { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-        VK_COMPONENT_SWIZZLE_IDENTITY },
-        { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 },
+        {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
+         VK_COMPONENT_SWIZZLE_IDENTITY},
+        {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1},
     };
     VkImageView view;
     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
     ASSERT_VK_SUCCESS(err);
 
-    VkFramebufferCreateInfo fci = { VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &view, 32, 32, 1 };
+    VkFramebufferCreateInfo fci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &view, 32, 32, 1};
     VkFramebuffer fb;
     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
     ASSERT_VK_SUCCESS(err);
@@ -17715,7 +17665,7 @@
     vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &command_buffer);
 
     // Begin our cmd buffer with renderpass using our framebuffer
-    VkRenderPassBeginInfo rpbi = { VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb,{ { 0, 0 },{ 32, 32 } }, 0, nullptr };
+    VkRenderPassBeginInfo rpbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb, {{0, 0}, {32, 32}}, 0, nullptr};
     VkCommandBufferBeginInfo begin_info{};
     begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     vkBeginCommandBuffer(command_buffer, &begin_info);
@@ -17733,36 +17683,36 @@
 
 TEST_F(VkPositiveLayerTest, RenderPassSubpassZeroTransitionsApplied) {
     TEST_DESCRIPTION("Ensure that CmdBeginRenderPass applies the layout "
-        "transitions for the first subpass");
+                     "transitions for the first subpass");
 
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
     // A renderpass with one color attachment.
-    VkAttachmentDescription attachment = { 0,
-        VK_FORMAT_R8G8B8A8_UNORM,
-        VK_SAMPLE_COUNT_1_BIT,
-        VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-        VK_ATTACHMENT_STORE_OP_STORE,
-        VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-        VK_ATTACHMENT_STORE_OP_DONT_CARE,
-        VK_IMAGE_LAYOUT_UNDEFINED,
-        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+    VkAttachmentDescription attachment = {0,
+                                          VK_FORMAT_R8G8B8A8_UNORM,
+                                          VK_SAMPLE_COUNT_1_BIT,
+                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                          VK_ATTACHMENT_STORE_OP_STORE,
+                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                          VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                                          VK_IMAGE_LAYOUT_UNDEFINED,
+                                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
 
-    VkAttachmentReference att_ref = { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+    VkAttachmentReference att_ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
 
-    VkSubpassDescription subpass = { 0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &att_ref, nullptr, nullptr, 0, nullptr };
+    VkSubpassDescription subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &att_ref, nullptr, nullptr, 0, nullptr};
 
-    VkSubpassDependency dep = { 0,
-        0,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        VK_DEPENDENCY_BY_REGION_BIT };
+    VkSubpassDependency dep = {0,
+                               0,
+                               VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                               VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                               VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                               VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                               VK_DEPENDENCY_BY_REGION_BIT};
 
-    VkRenderPassCreateInfo rpci = { VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, &attachment, 1, &subpass, 1, &dep };
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, &attachment, 1, &subpass, 1, &dep};
 
     VkResult err;
     VkRenderPass rp;
@@ -17781,15 +17731,15 @@
         image.handle(),
         VK_IMAGE_VIEW_TYPE_2D,
         VK_FORMAT_R8G8B8A8_UNORM,
-        { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
-        VK_COMPONENT_SWIZZLE_IDENTITY },
-        { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 },
+        {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
+         VK_COMPONENT_SWIZZLE_IDENTITY},
+        {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1},
     };
     VkImageView view;
     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
     ASSERT_VK_SUCCESS(err);
 
-    VkFramebufferCreateInfo fci = { VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &view, 32, 32, 1 };
+    VkFramebufferCreateInfo fci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &view, 32, 32, 1};
     VkFramebuffer fb;
     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
     ASSERT_VK_SUCCESS(err);
@@ -17798,23 +17748,23 @@
     // image memory barrier for the attachment. This detects the previously
     // missing tracking of the subpass layout by throwing a validation error
     // if it doesn't occur.
-    VkRenderPassBeginInfo rpbi = { VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb,{ { 0, 0 },{ 32, 32 } }, 0, nullptr };
+    VkRenderPassBeginInfo rpbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb, {{0, 0}, {32, 32}}, 0, nullptr};
     m_commandBuffer->BeginCommandBuffer();
     vkCmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_INLINE);
 
-    VkImageMemoryBarrier imb = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-        nullptr,
-        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-        VK_QUEUE_FAMILY_IGNORED,
-        VK_QUEUE_FAMILY_IGNORED,
-        image.handle(),
-        { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } };
+    VkImageMemoryBarrier imb = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                                nullptr,
+                                VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                                VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                                VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                                VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                                VK_QUEUE_FAMILY_IGNORED,
+                                VK_QUEUE_FAMILY_IGNORED,
+                                image.handle(),
+                                {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
     vkCmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 1,
-        &imb);
+                         VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 1,
+                         &imb);
 
     vkCmdEndRenderPass(m_commandBuffer->handle());
     m_errorMonitor->VerifyNotFound();
@@ -17827,9 +17777,9 @@
 
 TEST_F(VkPositiveLayerTest, DepthStencilLayoutTransitionForDepthOnlyImageview) {
     TEST_DESCRIPTION("Validate that when an imageView of a depth/stencil image "
-        "is used as a depth/stencil framebuffer attachment, the "
-        "aspectMask is ignored and both depth and stencil image "
-        "subresources are used.");
+                     "is used as a depth/stencil framebuffer attachment, the "
+                     "aspectMask is ignored and both depth and stencil image "
+                     "subresources are used.");
 
     VkFormatProperties format_properties;
     vkGetPhysicalDeviceFormatProperties(gpu(), VK_FORMAT_D32_SFLOAT_S8_UINT, &format_properties);
@@ -17841,29 +17791,29 @@
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
-    VkAttachmentDescription attachment = { 0,
-        VK_FORMAT_D32_SFLOAT_S8_UINT,
-        VK_SAMPLE_COUNT_1_BIT,
-        VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-        VK_ATTACHMENT_STORE_OP_STORE,
-        VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-        VK_ATTACHMENT_STORE_OP_DONT_CARE,
-        VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-        VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };
+    VkAttachmentDescription attachment = {0,
+                                          VK_FORMAT_D32_SFLOAT_S8_UINT,
+                                          VK_SAMPLE_COUNT_1_BIT,
+                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                          VK_ATTACHMENT_STORE_OP_STORE,
+                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                          VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL};
 
-    VkAttachmentReference att_ref = { 0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };
+    VkAttachmentReference att_ref = {0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL};
 
-    VkSubpassDescription subpass = { 0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 0, nullptr, nullptr, &att_ref, 0, nullptr };
+    VkSubpassDescription subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 0, nullptr, nullptr, &att_ref, 0, nullptr};
 
-    VkSubpassDependency dep = { 0,
-        0,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        VK_DEPENDENCY_BY_REGION_BIT};
+    VkSubpassDependency dep = {0,
+                               0,
+                               VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                               VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                               VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                               VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                               VK_DEPENDENCY_BY_REGION_BIT};
 
-    VkRenderPassCreateInfo rpci = { VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, &attachment, 1, &subpass, 1, &dep };
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, &attachment, 1, &subpass, 1, &dep};
 
     VkResult err;
     VkRenderPass rp;
@@ -17872,8 +17822,8 @@
 
     VkImageObj image(m_device);
     image.init_no_layout(32, 32, VK_FORMAT_D32_SFLOAT_S8_UINT,
-        0x26, // usage
-        VK_IMAGE_TILING_OPTIMAL, 0);
+                         0x26, // usage
+                         VK_IMAGE_TILING_OPTIMAL, 0);
     ASSERT_TRUE(image.initialized());
     image.SetLayout(0x6, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
 
@@ -17884,19 +17834,19 @@
         image.handle(),
         VK_IMAGE_VIEW_TYPE_2D,
         VK_FORMAT_D32_SFLOAT_S8_UINT,
-        { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A },
-        { 0x2, 0, 1, 0, 1 },
+        {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A},
+        {0x2, 0, 1, 0, 1},
     };
     VkImageView view;
     err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
     ASSERT_VK_SUCCESS(err);
 
-    VkFramebufferCreateInfo fci = { VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &view, 32, 32, 1 };
+    VkFramebufferCreateInfo fci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &view, 32, 32, 1};
     VkFramebuffer fb;
     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
     ASSERT_VK_SUCCESS(err);
 
-    VkRenderPassBeginInfo rpbi = { VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb,{ { 0, 0 },{ 32, 32 } }, 0, nullptr };
+    VkRenderPassBeginInfo rpbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb, {{0, 0}, {32, 32}}, 0, nullptr};
     m_commandBuffer->BeginCommandBuffer();
     vkCmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_INLINE);
 
@@ -17917,8 +17867,8 @@
     imb.subresourceRange.layerCount = 0x1;
 
     vkCmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 1,
-        &imb);
+                         VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 1,
+                         &imb);
 
     vkCmdEndRenderPass(m_commandBuffer->handle());
     m_commandBuffer->EndCommandBuffer();
@@ -17932,33 +17882,33 @@
 
 TEST_F(VkPositiveLayerTest, RenderPassTransitionsAttachmentUnused) {
     TEST_DESCRIPTION("Ensure that layout transitions work correctly without "
-        "errors, when an attachment reference is "
-        "VK_ATTACHMENT_UNUSED");
+                     "errors, when an attachment reference is "
+                     "VK_ATTACHMENT_UNUSED");
 
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
     // A renderpass with no attachments
-    VkAttachmentReference att_ref = { VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
+    VkAttachmentReference att_ref = {VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
 
-    VkSubpassDescription subpass = { 0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &att_ref, nullptr, nullptr, 0, nullptr };
+    VkSubpassDescription subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &att_ref, nullptr, nullptr, 0, nullptr};
 
-    VkRenderPassCreateInfo rpci = { VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 0, nullptr, 1, &subpass, 0, nullptr };
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 0, nullptr, 1, &subpass, 0, nullptr};
 
     VkRenderPass rp;
     VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
     ASSERT_VK_SUCCESS(err);
 
     // A compatible framebuffer.
-    VkFramebufferCreateInfo fci = { VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 0, nullptr, 32, 32, 1 };
+    VkFramebufferCreateInfo fci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 0, nullptr, 32, 32, 1};
     VkFramebuffer fb;
     err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
     ASSERT_VK_SUCCESS(err);
 
     // Record a command buffer which just begins and ends the renderpass. The
     // bug manifests in BeginRenderPass.
-    VkRenderPassBeginInfo rpbi = { VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb,{ { 0, 0 },{ 32, 32 } }, 0, nullptr };
+    VkRenderPassBeginInfo rpbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb, {{0, 0}, {32, 32}}, 0, nullptr};
     m_commandBuffer->BeginCommandBuffer();
     vkCmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_INLINE);
     vkCmdEndRenderPass(m_commandBuffer->handle());
@@ -17972,12 +17922,12 @@
 // This is a positive test. No errors are expected.
 TEST_F(VkPositiveLayerTest, StencilLoadOp) {
     TEST_DESCRIPTION("Create a stencil-only attachment with a LOAD_OP set to "
-        "CLEAR. stencil[Load|Store]Op used to be ignored.");
+                     "CLEAR. stencil[Load|Store]Op used to be ignored.");
     VkResult result = VK_SUCCESS;
     VkImageFormatProperties formatProps;
     vkGetPhysicalDeviceImageFormatProperties(gpu(), VK_FORMAT_D24_UNORM_S8_UINT, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL,
-        VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0,
-        &formatProps);
+                                             VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0,
+                                             &formatProps);
     if (formatProps.maxExtent.width < 100 || formatProps.maxExtent.height < 100) {
         return;
     }
@@ -17985,7 +17935,7 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     VkFormat depth_stencil_fmt = VK_FORMAT_D24_UNORM_S8_UINT;
     m_depthStencil->Init(m_device, 100, 100, depth_stencil_fmt,
-        VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
+                         VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
     VkAttachmentDescription att = {};
     VkAttachmentReference ref = {};
     att.format = depth_stencil_fmt;
@@ -18067,7 +18017,7 @@
 
     VkImageObj destImage(m_device);
     destImage.init(100, 100, depth_stencil_fmt, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
-        VK_IMAGE_TILING_OPTIMAL, 0);
+                   VK_IMAGE_TILING_OPTIMAL, 0);
     VkImageMemoryBarrier barrier = {};
     VkImageSubresourceRange range;
     barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -18086,14 +18036,14 @@
     VkCommandBufferObj cmdbuf(m_device, m_commandPool);
     cmdbuf.BeginCommandBuffer();
     cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1,
-        &barrier);
+                           &barrier);
     barrier.srcAccessMask = 0;
     barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
     barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
     barrier.image = destImage.handle();
     barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
     cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1,
-        &barrier);
+                           &barrier);
     VkImageCopy cregion;
     cregion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
     cregion.srcSubresource.mipLevel = 0;
@@ -18113,7 +18063,7 @@
     cregion.extent.height = 100;
     cregion.extent.depth = 1;
     cmdbuf.CopyImage(m_depthStencil->handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, destImage.handle(),
-        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &cregion);
+                     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &cregion);
     cmdbuf.EndCommandBuffer();
 
     VkSubmitInfo submit_info;
@@ -18173,7 +18123,7 @@
         vkBeginCommandBuffer(command_buffer, &begin_info);
 
         vkCmdWaitEvents(command_buffer, 1, &event, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, nullptr, 0,
-            nullptr, 0, nullptr);
+                        nullptr, 0, nullptr);
         vkCmdResetEvent(command_buffer, event, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
         vkEndCommandBuffer(command_buffer);
     }
@@ -18467,7 +18417,7 @@
     }
     {
         m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "that is already in use by a "
-            "command buffer.");
+                                                                            "command buffer.");
         vkSetEvent(m_device->device(), event);
         m_errorMonitor->VerifyFound();
     }
@@ -18482,9 +18432,9 @@
 // This is a positive test.  No errors should be generated.
 TEST_F(VkPositiveLayerTest, TwoFencesThreeFrames) {
     TEST_DESCRIPTION("Two command buffers with two separate fences are each "
-        "run through a Submit & WaitForFences cycle 3 times. This "
-        "previously revealed a bug so running this positive test "
-        "to prevent a regression.");
+                     "run through a Submit & WaitForFences cycle 3 times. This "
+                     "previously revealed a bug so running this positive test "
+                     "to prevent a regression.");
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
@@ -18556,7 +18506,7 @@
 TEST_F(VkPositiveLayerTest, TwoQueueSubmitsSeparateQueuesWithSemaphoreAndOneFenceQWI) {
 
     TEST_DESCRIPTION("Two command buffers, each in a separate QueueSubmit call "
-        "submitted on separate queues followed by a QueueWaitIdle.");
+                     "submitted on separate queues followed by a QueueWaitIdle.");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2))
@@ -18593,7 +18543,7 @@
         vkBeginCommandBuffer(command_buffer[0], &begin_info);
 
         vkCmdPipelineBarrier(command_buffer[0], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0,
-            nullptr, 0, nullptr, 0, nullptr);
+                             nullptr, 0, nullptr, 0, nullptr);
 
         VkViewport viewport{};
         viewport.maxDepth = 1.0f;
@@ -18630,7 +18580,7 @@
         vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
     }
     {
-        VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT };
+        VkPipelineStageFlags flags[]{VK_PIPELINE_STAGE_ALL_COMMANDS_BIT};
         VkSubmitInfo submit_info{};
         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submit_info.commandBufferCount = 1;
@@ -18654,8 +18604,8 @@
 TEST_F(VkPositiveLayerTest, TwoQueueSubmitsSeparateQueuesWithSemaphoreAndOneFenceQWIFence) {
 
     TEST_DESCRIPTION("Two command buffers, each in a separate QueueSubmit call "
-        "submitted on separate queues, the second having a fence"
-        "followed by a QueueWaitIdle.");
+                     "submitted on separate queues, the second having a fence"
+                     "followed by a QueueWaitIdle.");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2))
@@ -18697,7 +18647,7 @@
         vkBeginCommandBuffer(command_buffer[0], &begin_info);
 
         vkCmdPipelineBarrier(command_buffer[0], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0,
-            nullptr, 0, nullptr, 0, nullptr);
+                             nullptr, 0, nullptr, 0, nullptr);
 
         VkViewport viewport{};
         viewport.maxDepth = 1.0f;
@@ -18734,7 +18684,7 @@
         vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
     }
     {
-        VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT };
+        VkPipelineStageFlags flags[]{VK_PIPELINE_STAGE_ALL_COMMANDS_BIT};
         VkSubmitInfo submit_info{};
         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submit_info.commandBufferCount = 1;
@@ -18759,8 +18709,8 @@
 TEST_F(VkPositiveLayerTest, TwoQueueSubmitsSeparateQueuesWithSemaphoreAndOneFenceTwoWFF) {
 
     TEST_DESCRIPTION("Two command buffers, each in a separate QueueSubmit call "
-        "submitted on separate queues, the second having a fence"
-        "followed by two consecutive WaitForFences calls on the same fence.");
+                     "submitted on separate queues, the second having a fence"
+                     "followed by two consecutive WaitForFences calls on the same fence.");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2))
@@ -18802,7 +18752,7 @@
         vkBeginCommandBuffer(command_buffer[0], &begin_info);
 
         vkCmdPipelineBarrier(command_buffer[0], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0,
-            nullptr, 0, nullptr, 0, nullptr);
+                             nullptr, 0, nullptr, 0, nullptr);
 
         VkViewport viewport{};
         viewport.maxDepth = 1.0f;
@@ -18839,7 +18789,7 @@
         vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
     }
     {
-        VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT };
+        VkPipelineStageFlags flags[]{VK_PIPELINE_STAGE_ALL_COMMANDS_BIT};
         VkSubmitInfo submit_info{};
         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submit_info.commandBufferCount = 1;
@@ -18880,36 +18830,36 @@
 
     // An (empty) command buffer. We must have work in the first submission --
     // the layer treats unfenced work differently from fenced work.
-    VkCommandPoolCreateInfo cpci = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, nullptr, 0, 0 };
+    VkCommandPoolCreateInfo cpci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, nullptr, 0, 0};
     VkCommandPool pool;
     err = vkCreateCommandPool(m_device->device(), &cpci, nullptr, &pool);
     ASSERT_VK_SUCCESS(err);
-    VkCommandBufferAllocateInfo cbai = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, nullptr, pool,
-        VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1 };
+    VkCommandBufferAllocateInfo cbai = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, nullptr, pool,
+                                        VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1};
     VkCommandBuffer cb;
     err = vkAllocateCommandBuffers(m_device->device(), &cbai, &cb);
     ASSERT_VK_SUCCESS(err);
-    VkCommandBufferBeginInfo cbbi = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, 0, nullptr };
+    VkCommandBufferBeginInfo cbbi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, 0, nullptr};
     err = vkBeginCommandBuffer(cb, &cbbi);
     ASSERT_VK_SUCCESS(err);
     err = vkEndCommandBuffer(cb);
     ASSERT_VK_SUCCESS(err);
 
     // A semaphore
-    VkSemaphoreCreateInfo sci = { VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, 0 };
+    VkSemaphoreCreateInfo sci = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, 0};
     VkSemaphore s;
     err = vkCreateSemaphore(m_device->device(), &sci, nullptr, &s);
     ASSERT_VK_SUCCESS(err);
 
     // First submission, to q0
-    VkSubmitInfo s0 = { VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr, 0, nullptr, nullptr, 1, &cb, 1, &s };
+    VkSubmitInfo s0 = {VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr, 0, nullptr, nullptr, 1, &cb, 1, &s};
 
     err = vkQueueSubmit(q0, 1, &s0, VK_NULL_HANDLE);
     ASSERT_VK_SUCCESS(err);
 
     // Second submission, to q1, waiting on s
     VkFlags waitmask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; // doesn't really matter what this value is.
-    VkSubmitInfo s1 = { VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr, 1, &s, &waitmask, 0, nullptr, 0, nullptr };
+    VkSubmitInfo s1 = {VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr, 1, &s, &waitmask, 0, nullptr, 0, nullptr};
 
     err = vkQueueSubmit(q1, 1, &s1, VK_NULL_HANDLE);
     ASSERT_VK_SUCCESS(err);
@@ -18933,8 +18883,8 @@
 TEST_F(VkPositiveLayerTest, TwoQueueSubmitsSeparateQueuesWithSemaphoreAndOneFence) {
 
     TEST_DESCRIPTION("Two command buffers, each in a separate QueueSubmit call "
-        "submitted on separate queues, the second having a fence, "
-        "followed by a WaitForFences call.");
+                     "submitted on separate queues, the second having a fence, "
+                     "followed by a WaitForFences call.");
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     if ((m_device->queue_props.empty()) || (m_device->queue_props[0].queueCount < 2))
@@ -18977,7 +18927,7 @@
         vkBeginCommandBuffer(command_buffer[0], &begin_info);
 
         vkCmdPipelineBarrier(command_buffer[0], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0,
-            nullptr, 0, nullptr, 0, nullptr);
+                             nullptr, 0, nullptr, 0, nullptr);
 
         VkViewport viewport{};
         viewport.maxDepth = 1.0f;
@@ -19014,7 +18964,7 @@
         vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
     }
     {
-        VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT };
+        VkPipelineStageFlags flags[]{VK_PIPELINE_STAGE_ALL_COMMANDS_BIT};
         VkSubmitInfo submit_info{};
         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submit_info.commandBufferCount = 1;
@@ -19039,9 +18989,9 @@
 TEST_F(VkPositiveLayerTest, TwoQueueSubmitsOneQueueWithSemaphoreAndOneFence) {
 
     TEST_DESCRIPTION("Two command buffers, each in a separate QueueSubmit call "
-        "on the same queue, sharing a signal/wait semaphore, the "
-        "second having a fence, "
-        "followed by a WaitForFences call.");
+                     "on the same queue, sharing a signal/wait semaphore, the "
+                     "second having a fence, "
+                     "followed by a WaitForFences call.");
 
     m_errorMonitor->ExpectSuccess();
 
@@ -19077,7 +19027,7 @@
         vkBeginCommandBuffer(command_buffer[0], &begin_info);
 
         vkCmdPipelineBarrier(command_buffer[0], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0,
-            nullptr, 0, nullptr, 0, nullptr);
+                             nullptr, 0, nullptr, 0, nullptr);
 
         VkViewport viewport{};
         viewport.maxDepth = 1.0f;
@@ -19114,7 +19064,7 @@
         vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
     }
     {
-        VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT };
+        VkPipelineStageFlags flags[]{VK_PIPELINE_STAGE_ALL_COMMANDS_BIT};
         VkSubmitInfo submit_info{};
         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submit_info.commandBufferCount = 1;
@@ -19139,8 +19089,8 @@
 TEST_F(VkPositiveLayerTest, TwoQueueSubmitsOneQueueNullQueueSubmitWithFence) {
 
     TEST_DESCRIPTION("Two command buffers, each in a separate QueueSubmit call "
-        "on the same queue, no fences, followed by a third QueueSubmit with NO "
-        "SubmitInfos but with a fence, followed by a WaitForFences call.");
+                     "on the same queue, no fences, followed by a third QueueSubmit with NO "
+                     "SubmitInfos but with a fence, followed by a WaitForFences call.");
 
     m_errorMonitor->ExpectSuccess();
 
@@ -19171,7 +19121,7 @@
         vkBeginCommandBuffer(command_buffer[0], &begin_info);
 
         vkCmdPipelineBarrier(command_buffer[0], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0,
-            nullptr, 0, nullptr, 0, nullptr);
+                             nullptr, 0, nullptr, 0, nullptr);
 
         VkViewport viewport{};
         viewport.maxDepth = 1.0f;
@@ -19208,7 +19158,7 @@
         vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
     }
     {
-        VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT };
+        VkPipelineStageFlags flags[]{VK_PIPELINE_STAGE_ALL_COMMANDS_BIT};
         VkSubmitInfo submit_info{};
         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submit_info.commandBufferCount = 1;
@@ -19235,8 +19185,8 @@
 TEST_F(VkPositiveLayerTest, TwoQueueSubmitsOneQueueOneFence) {
 
     TEST_DESCRIPTION("Two command buffers, each in a separate QueueSubmit call "
-        "on the same queue, the second having a fence, followed "
-        "by a WaitForFences call.");
+                     "on the same queue, the second having a fence, followed "
+                     "by a WaitForFences call.");
 
     m_errorMonitor->ExpectSuccess();
 
@@ -19267,7 +19217,7 @@
         vkBeginCommandBuffer(command_buffer[0], &begin_info);
 
         vkCmdPipelineBarrier(command_buffer[0], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0,
-            nullptr, 0, nullptr, 0, nullptr);
+                             nullptr, 0, nullptr, 0, nullptr);
 
         VkViewport viewport{};
         viewport.maxDepth = 1.0f;
@@ -19304,7 +19254,7 @@
         vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
     }
     {
-        VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT };
+        VkPipelineStageFlags flags[]{VK_PIPELINE_STAGE_ALL_COMMANDS_BIT};
         VkSubmitInfo submit_info{};
         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submit_info.commandBufferCount = 1;
@@ -19328,7 +19278,7 @@
 TEST_F(VkPositiveLayerTest, TwoSubmitInfosWithSemaphoreOneQueueSubmitsOneFence) {
 
     TEST_DESCRIPTION("Two command buffers each in a separate SubmitInfo sent in a single "
-        "QueueSubmit call followed by a WaitForFences call.");
+                     "QueueSubmit call followed by a WaitForFences call.");
     ASSERT_NO_FATAL_FAILURE(InitState());
 
     m_errorMonitor->ExpectSuccess();
@@ -19364,7 +19314,7 @@
         vkBeginCommandBuffer(command_buffer[0], &begin_info);
 
         vkCmdPipelineBarrier(command_buffer[0], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0,
-            nullptr, 0, nullptr, 0, nullptr);
+                             nullptr, 0, nullptr, 0, nullptr);
 
         VkViewport viewport{};
         viewport.maxDepth = 1.0f;
@@ -19393,7 +19343,7 @@
     }
     {
         VkSubmitInfo submit_info[2];
-        VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT };
+        VkPipelineStageFlags flags[]{VK_PIPELINE_STAGE_ALL_COMMANDS_BIT};
 
         submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submit_info[0].pNext = NULL;
@@ -19492,7 +19442,7 @@
 
 TEST_F(VkPositiveLayerTest, CreatePipelineAttribMatrixType) {
     TEST_DESCRIPTION("Test that pipeline validation accepts matrices passed "
-        "as vertex attributes");
+                     "as vertex attributes");
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
@@ -19510,20 +19460,20 @@
     }
 
     char const *vsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) in mat2x4 x;\n"
-        "out gl_PerVertex {\n"
-        "    vec4 gl_Position;\n"
-        "};\n"
-        "void main(){\n"
-        "   gl_Position = x[0] + x[1];\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) in mat2x4 x;\n"
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "   gl_Position = x[0] + x[1];\n"
+                           "}\n";
     char const *fsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) out vec4 color;\n"
-        "void main(){\n"
-        "   color = vec4(1);\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) out vec4 color;\n"
+                           "void main(){\n"
+                           "   color = vec4(1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -19564,20 +19514,20 @@
     }
 
     char const *vsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) in vec4 x[2];\n"
-        "out gl_PerVertex {\n"
-        "    vec4 gl_Position;\n"
-        "};\n"
-        "void main(){\n"
-        "   gl_Position = x[0] + x[1];\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) in vec4 x[2];\n"
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "   gl_Position = x[0] + x[1];\n"
+                           "}\n";
     char const *fsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) out vec4 color;\n"
-        "void main(){\n"
-        "   color = vec4(1);\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) out vec4 color;\n"
+                           "void main(){\n"
+                           "   color = vec4(1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -19601,8 +19551,8 @@
 
 TEST_F(VkPositiveLayerTest, CreatePipelineAttribComponents) {
     TEST_DESCRIPTION("Test that pipeline validation accepts consuming a vertex attribute "
-        "through multiple vertex shader inputs, each consuming a different "
-        "subset of the components.");
+                     "through multiple vertex shader inputs, each consuming a different "
+                     "subset of the components.");
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
@@ -19620,23 +19570,23 @@
     }
 
     char const *vsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) in vec4 x;\n"
-        "layout(location=1) in vec3 y1;\n"
-        "layout(location=1, component=3) in float y2;\n"
-        "layout(location=2) in vec4 z;\n"
-        "out gl_PerVertex {\n"
-        "    vec4 gl_Position;\n"
-        "};\n"
-        "void main(){\n"
-        "   gl_Position = x + vec4(y1, y2) + z;\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) in vec4 x;\n"
+                           "layout(location=1) in vec3 y1;\n"
+                           "layout(location=1, component=3) in float y2;\n"
+                           "layout(location=2) in vec4 z;\n"
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "   gl_Position = x + vec4(y1, y2) + z;\n"
+                           "}\n";
     char const *fsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) out vec4 color;\n"
-        "void main(){\n"
-        "   color = vec4(1);\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) out vec4 color;\n"
+                           "void main(){\n"
+                           "   color = vec4(1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -19665,18 +19615,18 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
     char const *vsSource = "#version 450\n"
-        "out gl_PerVertex {\n"
-        "    vec4 gl_Position;\n"
-        "};\n"
-        "void main(){\n"
-        "   gl_Position = vec4(0);\n"
-        "}\n";
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "   gl_Position = vec4(0);\n"
+                           "}\n";
     char const *fsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) out vec4 color;\n"
-        "void main(){\n"
-        "   color = vec4(1);\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) out vec4 color;\n"
+                           "void main(){\n"
+                           "   color = vec4(1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -19697,8 +19647,8 @@
 
 TEST_F(VkPositiveLayerTest, CreatePipelineRelaxedTypeMatch) {
     TEST_DESCRIPTION("Test that pipeline validation accepts the relaxed type matching rules "
-        "set out in 14.1.3: fundamental type must match, and producer side must "
-        "have at least as many components");
+                     "set out in 14.1.3: fundamental type must match, and producer side must "
+                     "have at least as many components");
     m_errorMonitor->ExpectSuccess();
 
     // VK 1.0.8 Specification, 14.1.3 "Additionally,..." block
@@ -19707,25 +19657,25 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
     char const *vsSource = "#version 450\n"
-        "out gl_PerVertex {\n"
-        "    vec4 gl_Position;\n"
-        "};\n"
-        "layout(location=0) out vec3 x;\n"
-        "layout(location=1) out ivec3 y;\n"
-        "layout(location=2) out vec3 z;\n"
-        "void main(){\n"
-        "   gl_Position = vec4(0);\n"
-        "   x = vec3(0); y = ivec3(0); z = vec3(0);\n"
-        "}\n";
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "layout(location=0) out vec3 x;\n"
+                           "layout(location=1) out ivec3 y;\n"
+                           "layout(location=2) out vec3 z;\n"
+                           "void main(){\n"
+                           "   gl_Position = vec4(0);\n"
+                           "   x = vec3(0); y = ivec3(0); z = vec3(0);\n"
+                           "}\n";
     char const *fsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) out vec4 color;\n"
-        "layout(location=0) in float x;\n"
-        "layout(location=1) flat in int y;\n"
-        "layout(location=2) in vec2 z;\n"
-        "void main(){\n"
-        "   color = vec4(1 + x + y + z.x);\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) out vec4 color;\n"
+                           "layout(location=0) in float x;\n"
+                           "layout(location=1) flat in int y;\n"
+                           "layout(location=2) in vec2 z;\n"
+                           "void main(){\n"
+                           "   color = vec4(1 + x + y + z.x);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -19748,7 +19698,7 @@
 
 TEST_F(VkPositiveLayerTest, CreatePipelineTessPerVertex) {
     TEST_DESCRIPTION("Test that pipeline validation accepts per-vertex variables "
-        "passed between the TCS and TES stages");
+                     "passed between the TCS and TES stages");
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
@@ -19760,38 +19710,38 @@
     }
 
     char const *vsSource = "#version 450\n"
-        "void main(){}\n";
+                           "void main(){}\n";
     char const *tcsSource = "#version 450\n"
-        "layout(location=0) out int x[];\n"
-        "layout(vertices=3) out;\n"
-        "void main(){\n"
-        "   gl_TessLevelOuter[0] = gl_TessLevelOuter[1] = gl_TessLevelOuter[2] = 1;\n"
-        "   gl_TessLevelInner[0] = 1;\n"
-        "   x[gl_InvocationID] = gl_InvocationID;\n"
-        "}\n";
+                            "layout(location=0) out int x[];\n"
+                            "layout(vertices=3) out;\n"
+                            "void main(){\n"
+                            "   gl_TessLevelOuter[0] = gl_TessLevelOuter[1] = gl_TessLevelOuter[2] = 1;\n"
+                            "   gl_TessLevelInner[0] = 1;\n"
+                            "   x[gl_InvocationID] = gl_InvocationID;\n"
+                            "}\n";
     char const *tesSource = "#version 450\n"
-        "layout(triangles, equal_spacing, cw) in;\n"
-        "layout(location=0) in int x[];\n"
-        "out gl_PerVertex { vec4 gl_Position; };\n"
-        "void main(){\n"
-        "   gl_Position.xyz = gl_TessCoord;\n"
-        "   gl_Position.w = x[0] + x[1] + x[2];\n"
-        "}\n";
+                            "layout(triangles, equal_spacing, cw) in;\n"
+                            "layout(location=0) in int x[];\n"
+                            "out gl_PerVertex { vec4 gl_Position; };\n"
+                            "void main(){\n"
+                            "   gl_Position.xyz = gl_TessCoord;\n"
+                            "   gl_Position.w = x[0] + x[1] + x[2];\n"
+                            "}\n";
     char const *fsSource = "#version 450\n"
-        "layout(location=0) out vec4 color;\n"
-        "void main(){\n"
-        "   color = vec4(1);\n"
-        "}\n";
+                           "layout(location=0) out vec4 color;\n"
+                           "void main(){\n"
+                           "   color = vec4(1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj tcs(m_device, tcsSource, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, this);
     VkShaderObj tes(m_device, tesSource, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
 
-    VkPipelineInputAssemblyStateCreateInfo iasci{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, nullptr, 0,
-        VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, VK_FALSE };
+    VkPipelineInputAssemblyStateCreateInfo iasci{VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, nullptr, 0,
+                                                 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, VK_FALSE};
 
-    VkPipelineTessellationStateCreateInfo tsci{ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, nullptr, 0, 3 };
+    VkPipelineTessellationStateCreateInfo tsci{VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, nullptr, 0, 3};
 
     VkPipelineObj pipe(m_device);
     pipe.SetInputAssembly(&iasci);
@@ -19813,9 +19763,9 @@
 
 TEST_F(VkPositiveLayerTest, CreatePipelineGeometryInputBlockPositive) {
     TEST_DESCRIPTION("Test that pipeline validation accepts a user-defined "
-        "interface block passed into the geometry shader. This "
-        "is interesting because the 'extra' array level is not "
-        "present on the member type, but on the block instance.");
+                     "interface block passed into the geometry shader. This "
+                     "is interesting because the 'extra' array level is not "
+                     "present on the member type, but on the block instance.");
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
@@ -19827,24 +19777,24 @@
     }
 
     char const *vsSource = "#version 450\n"
-        "layout(location=0) out VertexData { vec4 x; } vs_out;\n"
-        "void main(){\n"
-        "   vs_out.x = vec4(1);\n"
-        "}\n";
+                           "layout(location=0) out VertexData { vec4 x; } vs_out;\n"
+                           "void main(){\n"
+                           "   vs_out.x = vec4(1);\n"
+                           "}\n";
     char const *gsSource = "#version 450\n"
-        "layout(triangles) in;\n"
-        "layout(triangle_strip, max_vertices=3) out;\n"
-        "layout(location=0) in VertexData { vec4 x; } gs_in[];\n"
-        "out gl_PerVertex { vec4 gl_Position; };\n"
-        "void main() {\n"
-        "   gl_Position = gs_in[0].x;\n"
-        "   EmitVertex();\n"
-        "}\n";
+                           "layout(triangles) in;\n"
+                           "layout(triangle_strip, max_vertices=3) out;\n"
+                           "layout(location=0) in VertexData { vec4 x; } gs_in[];\n"
+                           "out gl_PerVertex { vec4 gl_Position; };\n"
+                           "void main() {\n"
+                           "   gl_Position = gs_in[0].x;\n"
+                           "   EmitVertex();\n"
+                           "}\n";
     char const *fsSource = "#version 450\n"
-        "layout(location=0) out vec4 color;\n"
-        "void main(){\n"
-        "   color = vec4(1);\n"
-        "}\n";
+                           "layout(location=0) out vec4 color;\n"
+                           "void main(){\n"
+                           "   color = vec4(1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj gs(m_device, gsSource, VK_SHADER_STAGE_GEOMETRY_BIT, this);
@@ -19867,8 +19817,8 @@
 
 TEST_F(VkPositiveLayerTest, CreatePipeline64BitAttributesPositive) {
     TEST_DESCRIPTION("Test that pipeline validation accepts basic use of 64bit vertex "
-        "attributes. This is interesting because they consume multiple "
-        "locations.");
+                     "attributes. This is interesting because they consume multiple "
+                     "locations.");
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
@@ -19898,20 +19848,20 @@
     input_attribs[3].format = VK_FORMAT_R64G64B64A64_SFLOAT;
 
     char const *vsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) in dmat4 x;\n"
-        "out gl_PerVertex {\n"
-        "    vec4 gl_Position;\n"
-        "};\n"
-        "void main(){\n"
-        "   gl_Position = vec4(x[0][0]);\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) in dmat4 x;\n"
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "   gl_Position = vec4(x[0][0]);\n"
+                           "}\n";
     char const *fsSource = "#version 450\n"
-        "\n"
-        "layout(location=0) out vec4 color;\n"
-        "void main(){\n"
-        "   color = vec4(1);\n"
-        "}\n";
+                           "\n"
+                           "layout(location=0) out vec4 color;\n"
+                           "void main(){\n"
+                           "   color = vec4(1);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -19940,20 +19890,20 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
 
     char const *vsSource = "#version 450\n"
-        "\n"
-        "out gl_PerVertex {\n"
-        "    vec4 gl_Position;\n"
-        "};\n"
-        "void main(){\n"
-        "    gl_Position = vec4(1);\n"
-        "}\n";
+                           "\n"
+                           "out gl_PerVertex {\n"
+                           "    vec4 gl_Position;\n"
+                           "};\n"
+                           "void main(){\n"
+                           "    gl_Position = vec4(1);\n"
+                           "}\n";
     char const *fsSource = "#version 450\n"
-        "\n"
-        "layout(input_attachment_index=0, set=0, binding=0) uniform subpassInput x;\n"
-        "layout(location=0) out vec4 color;\n"
-        "void main() {\n"
-        "   color = subpassLoad(x);\n"
-        "}\n";
+                           "\n"
+                           "layout(input_attachment_index=0, set=0, binding=0) uniform subpassInput x;\n"
+                           "layout(location=0) out vec4 color;\n"
+                           "void main() {\n"
+                           "   color = subpassLoad(x);\n"
+                           "}\n";
 
     VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
     VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
@@ -19964,23 +19914,23 @@
     pipe.AddColorAttachment();
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
-    VkDescriptorSetLayoutBinding dslb = { 0, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr };
-    VkDescriptorSetLayoutCreateInfo dslci = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0, 1, &dslb };
+    VkDescriptorSetLayoutBinding dslb = {0, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr};
+    VkDescriptorSetLayoutCreateInfo dslci = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0, 1, &dslb};
     VkDescriptorSetLayout dsl;
     VkResult err = vkCreateDescriptorSetLayout(m_device->device(), &dslci, nullptr, &dsl);
     ASSERT_VK_SUCCESS(err);
 
-    VkPipelineLayoutCreateInfo plci = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0, 1, &dsl, 0, nullptr };
+    VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0, 1, &dsl, 0, nullptr};
     VkPipelineLayout pl;
     err = vkCreatePipelineLayout(m_device->device(), &plci, nullptr, &pl);
     ASSERT_VK_SUCCESS(err);
 
     VkAttachmentDescription descs[2] = {
-        { 0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE,
-        VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL },
-        { 0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE,
-        VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL },
+        {0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE,
+         VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL},
+        {0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE,
+         VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL},
     };
     VkAttachmentReference color = {
         0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
@@ -19989,9 +19939,9 @@
         1, VK_IMAGE_LAYOUT_GENERAL,
     };
 
-    VkSubpassDescription sd = { 0, VK_PIPELINE_BIND_POINT_GRAPHICS, 1, &input, 1, &color, nullptr, nullptr, 0, nullptr };
+    VkSubpassDescription sd = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 1, &input, 1, &color, nullptr, nullptr, 0, nullptr};
 
-    VkRenderPassCreateInfo rpci = { VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 2, descs, 1, &sd, 0, nullptr };
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 2, descs, 1, &sd, 0, nullptr};
     VkRenderPass rp;
     err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
     ASSERT_VK_SUCCESS(err);
@@ -20008,34 +19958,34 @@
 
 TEST_F(VkPositiveLayerTest, CreateComputePipelineMissingDescriptorUnusedPositive) {
     TEST_DESCRIPTION("Test that pipeline validation accepts a compute pipeline which declares a "
-        "descriptor-backed resource which is not provided, but the shader does not "
-        "statically use it. This is interesting because it requires compute pipelines "
-        "to have a proper descriptor use walk, which they didn't for some time.");
+                     "descriptor-backed resource which is not provided, but the shader does not "
+                     "statically use it. This is interesting because it requires compute pipelines "
+                     "to have a proper descriptor use walk, which they didn't for some time.");
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
     char const *csSource = "#version 450\n"
-        "\n"
-        "layout(local_size_x=1) in;\n"
-        "layout(set=0, binding=0) buffer block { vec4 x; };\n"
-        "void main(){\n"
-        "   // x is not used.\n"
-        "}\n";
+                           "\n"
+                           "layout(local_size_x=1) in;\n"
+                           "layout(set=0, binding=0) buffer block { vec4 x; };\n"
+                           "void main(){\n"
+                           "   // x is not used.\n"
+                           "}\n";
 
     VkShaderObj cs(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
-    VkComputePipelineCreateInfo cpci = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-        nullptr,
-        0,
-        { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
-        VK_SHADER_STAGE_COMPUTE_BIT, cs.handle(), "main", nullptr },
-        descriptorSet.GetPipelineLayout(),
-        VK_NULL_HANDLE,
-        -1 };
+    VkComputePipelineCreateInfo cpci = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
+                                        nullptr,
+                                        0,
+                                        {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
+                                         VK_SHADER_STAGE_COMPUTE_BIT, cs.handle(), "main", nullptr},
+                                        descriptorSet.GetPipelineLayout(),
+                                        VK_NULL_HANDLE,
+                                        -1};
 
     VkPipeline pipe;
     VkResult err = vkCreateComputePipelines(m_device->device(), VK_NULL_HANDLE, 1, &cpci, nullptr, &pipe);
@@ -20049,45 +19999,45 @@
 
 TEST_F(VkPositiveLayerTest, CreateComputePipelineCombinedImageSamplerConsumedAsSampler) {
     TEST_DESCRIPTION("Test that pipeline validation accepts a shader consuming only the "
-        "sampler portion of a combined image + sampler");
+                     "sampler portion of a combined image + sampler");
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
     VkDescriptorSetLayoutBinding bindings[] = {
-        { 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
-        { 1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
-        { 2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
+        {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
+        {1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
+        {2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
     };
-    VkDescriptorSetLayoutCreateInfo dslci = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0, 3, bindings };
+    VkDescriptorSetLayoutCreateInfo dslci = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0, 3, bindings};
     VkDescriptorSetLayout dsl;
     VkResult err = vkCreateDescriptorSetLayout(m_device->device(), &dslci, nullptr, &dsl);
     ASSERT_VK_SUCCESS(err);
 
-    VkPipelineLayoutCreateInfo plci = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0, 1, &dsl, 0, nullptr };
+    VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0, 1, &dsl, 0, nullptr};
     VkPipelineLayout pl;
     err = vkCreatePipelineLayout(m_device->device(), &plci, nullptr, &pl);
     ASSERT_VK_SUCCESS(err);
 
     char const *csSource = "#version 450\n"
-        "\n"
-        "layout(local_size_x=1) in;\n"
-        "layout(set=0, binding=0) uniform sampler s;\n"
-        "layout(set=0, binding=1) uniform texture2D t;\n"
-        "layout(set=0, binding=2) buffer block { vec4 x; };\n"
-        "void main() {\n"
-        "   x = texture(sampler2D(t, s), vec2(0));\n"
-        "}\n";
+                           "\n"
+                           "layout(local_size_x=1) in;\n"
+                           "layout(set=0, binding=0) uniform sampler s;\n"
+                           "layout(set=0, binding=1) uniform texture2D t;\n"
+                           "layout(set=0, binding=2) buffer block { vec4 x; };\n"
+                           "void main() {\n"
+                           "   x = texture(sampler2D(t, s), vec2(0));\n"
+                           "}\n";
     VkShaderObj cs(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
 
-    VkComputePipelineCreateInfo cpci = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-        nullptr,
-        0,
-        { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
-        VK_SHADER_STAGE_COMPUTE_BIT, cs.handle(), "main", nullptr },
-        pl,
-        VK_NULL_HANDLE,
-        -1 };
+    VkComputePipelineCreateInfo cpci = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
+                                        nullptr,
+                                        0,
+                                        {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
+                                         VK_SHADER_STAGE_COMPUTE_BIT, cs.handle(), "main", nullptr},
+                                        pl,
+                                        VK_NULL_HANDLE,
+                                        -1};
 
     VkPipeline pipe;
     err = vkCreateComputePipelines(m_device->device(), VK_NULL_HANDLE, 1, &cpci, nullptr, &pipe);
@@ -20104,45 +20054,45 @@
 
 TEST_F(VkPositiveLayerTest, CreateComputePipelineCombinedImageSamplerConsumedAsImage) {
     TEST_DESCRIPTION("Test that pipeline validation accepts a shader consuming only the "
-        "image portion of a combined image + sampler");
+                     "image portion of a combined image + sampler");
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
     VkDescriptorSetLayoutBinding bindings[] = {
-        { 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
-        { 1, VK_DESCRIPTOR_TYPE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
-        { 2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
+        {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
+        {1, VK_DESCRIPTOR_TYPE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
+        {2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
     };
-    VkDescriptorSetLayoutCreateInfo dslci = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0, 3, bindings };
+    VkDescriptorSetLayoutCreateInfo dslci = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0, 3, bindings};
     VkDescriptorSetLayout dsl;
     VkResult err = vkCreateDescriptorSetLayout(m_device->device(), &dslci, nullptr, &dsl);
     ASSERT_VK_SUCCESS(err);
 
-    VkPipelineLayoutCreateInfo plci = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0, 1, &dsl, 0, nullptr };
+    VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0, 1, &dsl, 0, nullptr};
     VkPipelineLayout pl;
     err = vkCreatePipelineLayout(m_device->device(), &plci, nullptr, &pl);
     ASSERT_VK_SUCCESS(err);
 
     char const *csSource = "#version 450\n"
-        "\n"
-        "layout(local_size_x=1) in;\n"
-        "layout(set=0, binding=0) uniform texture2D t;\n"
-        "layout(set=0, binding=1) uniform sampler s;\n"
-        "layout(set=0, binding=2) buffer block { vec4 x; };\n"
-        "void main() {\n"
-        "   x = texture(sampler2D(t, s), vec2(0));\n"
-        "}\n";
+                           "\n"
+                           "layout(local_size_x=1) in;\n"
+                           "layout(set=0, binding=0) uniform texture2D t;\n"
+                           "layout(set=0, binding=1) uniform sampler s;\n"
+                           "layout(set=0, binding=2) buffer block { vec4 x; };\n"
+                           "void main() {\n"
+                           "   x = texture(sampler2D(t, s), vec2(0));\n"
+                           "}\n";
     VkShaderObj cs(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
 
-    VkComputePipelineCreateInfo cpci = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-        nullptr,
-        0,
-        { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
-        VK_SHADER_STAGE_COMPUTE_BIT, cs.handle(), "main", nullptr },
-        pl,
-        VK_NULL_HANDLE,
-        -1 };
+    VkComputePipelineCreateInfo cpci = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
+                                        nullptr,
+                                        0,
+                                        {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
+                                         VK_SHADER_STAGE_COMPUTE_BIT, cs.handle(), "main", nullptr},
+                                        pl,
+                                        VK_NULL_HANDLE,
+                                        -1};
 
     VkPipeline pipe;
     err = vkCreateComputePipelines(m_device->device(), VK_NULL_HANDLE, 1, &cpci, nullptr, &pipe);
@@ -20159,45 +20109,45 @@
 
 TEST_F(VkPositiveLayerTest, CreateComputePipelineCombinedImageSamplerConsumedAsBoth) {
     TEST_DESCRIPTION("Test that pipeline validation accepts a shader consuming "
-        "both the sampler and the image of a combined image+sampler "
-        "but via separate variables");
+                     "both the sampler and the image of a combined image+sampler "
+                     "but via separate variables");
     m_errorMonitor->ExpectSuccess();
 
     ASSERT_NO_FATAL_FAILURE(InitState());
 
     VkDescriptorSetLayoutBinding bindings[] = {
-        { 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
-        { 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
+        {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
+        {1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
     };
-    VkDescriptorSetLayoutCreateInfo dslci = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0, 2, bindings };
+    VkDescriptorSetLayoutCreateInfo dslci = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0, 2, bindings};
     VkDescriptorSetLayout dsl;
     VkResult err = vkCreateDescriptorSetLayout(m_device->device(), &dslci, nullptr, &dsl);
     ASSERT_VK_SUCCESS(err);
 
-    VkPipelineLayoutCreateInfo plci = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0, 1, &dsl, 0, nullptr };
+    VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0, 1, &dsl, 0, nullptr};
     VkPipelineLayout pl;
     err = vkCreatePipelineLayout(m_device->device(), &plci, nullptr, &pl);
     ASSERT_VK_SUCCESS(err);
 
     char const *csSource = "#version 450\n"
-        "\n"
-        "layout(local_size_x=1) in;\n"
-        "layout(set=0, binding=0) uniform texture2D t;\n"
-        "layout(set=0, binding=0) uniform sampler s;  // both binding 0!\n"
-        "layout(set=0, binding=1) buffer block { vec4 x; };\n"
-        "void main() {\n"
-        "   x = texture(sampler2D(t, s), vec2(0));\n"
-        "}\n";
+                           "\n"
+                           "layout(local_size_x=1) in;\n"
+                           "layout(set=0, binding=0) uniform texture2D t;\n"
+                           "layout(set=0, binding=0) uniform sampler s;  // both binding 0!\n"
+                           "layout(set=0, binding=1) buffer block { vec4 x; };\n"
+                           "void main() {\n"
+                           "   x = texture(sampler2D(t, s), vec2(0));\n"
+                           "}\n";
     VkShaderObj cs(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
 
-    VkComputePipelineCreateInfo cpci = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-        nullptr,
-        0,
-        { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
-        VK_SHADER_STAGE_COMPUTE_BIT, cs.handle(), "main", nullptr },
-        pl,
-        VK_NULL_HANDLE,
-        -1 };
+    VkComputePipelineCreateInfo cpci = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
+                                        nullptr,
+                                        0,
+                                        {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0,
+                                         VK_SHADER_STAGE_COMPUTE_BIT, cs.handle(), "main", nullptr},
+                                        pl,
+                                        VK_NULL_HANDLE,
+                                        -1};
 
     VkPipeline pipe;
     err = vkCreateComputePipelines(m_device->device(), VK_NULL_HANDLE, 1, &cpci, nullptr, &pipe);
@@ -20371,18 +20321,18 @@
     };
 
     // Run some positive tests to make sure overlap checking in the layer is OK
-    const std::array<OverlappingRangeTestCase, 2> overlapping_range_tests_pos = { { { { { VK_SHADER_STAGE_VERTEX_BIT, 0, 4 },
-    { VK_SHADER_STAGE_VERTEX_BIT, 4, 4 },
-    { VK_SHADER_STAGE_VERTEX_BIT, 8, 4 },
-    { VK_SHADER_STAGE_VERTEX_BIT, 12, 4 },
-    { VK_SHADER_STAGE_VERTEX_BIT, 16, 4 } },
-        "" },
-        { { { VK_SHADER_STAGE_VERTEX_BIT, 92, 24 },
-        { VK_SHADER_STAGE_VERTEX_BIT, 80, 4 },
-        { VK_SHADER_STAGE_VERTEX_BIT, 64, 8 },
-        { VK_SHADER_STAGE_VERTEX_BIT, 4, 16 },
-        { VK_SHADER_STAGE_VERTEX_BIT, 0, 4 } },
-        "" } } };
+    const std::array<OverlappingRangeTestCase, 2> overlapping_range_tests_pos = {{{{{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
+                                                                                    {VK_SHADER_STAGE_VERTEX_BIT, 4, 4},
+                                                                                    {VK_SHADER_STAGE_VERTEX_BIT, 8, 4},
+                                                                                    {VK_SHADER_STAGE_VERTEX_BIT, 12, 4},
+                                                                                    {VK_SHADER_STAGE_VERTEX_BIT, 16, 4}},
+                                                                                   ""},
+                                                                                  {{{VK_SHADER_STAGE_VERTEX_BIT, 92, 24},
+                                                                                    {VK_SHADER_STAGE_VERTEX_BIT, 80, 4},
+                                                                                    {VK_SHADER_STAGE_VERTEX_BIT, 64, 8},
+                                                                                    {VK_SHADER_STAGE_VERTEX_BIT, 4, 16},
+                                                                                    {VK_SHADER_STAGE_VERTEX_BIT, 0, 4}},
+                                                                                   ""}}};
     for (const auto &iter : overlapping_range_tests_pos) {
         pipeline_layout_ci.pPushConstantRanges = iter.ranges;
         m_errorMonitor->ExpectSuccess();
@@ -20401,17 +20351,17 @@
     m_commandBuffer->BeginCommandBuffer();
 
     // positive overlapping range tests with cmd
-    const std::array<PipelineLayoutTestCase, 4> cmd_overlap_tests_pos = { {
-        { { VK_SHADER_STAGE_VERTEX_BIT, 0, 16 }, "" },
-        { { VK_SHADER_STAGE_VERTEX_BIT, 0, 4 }, "" },
-        { { VK_SHADER_STAGE_VERTEX_BIT, 20, 12 }, "" },
-        { { VK_SHADER_STAGE_VERTEX_BIT, 56, 36 }, "" },
-        } };
+    const std::array<PipelineLayoutTestCase, 4> cmd_overlap_tests_pos = {{
+        {{VK_SHADER_STAGE_VERTEX_BIT, 0, 16}, ""},
+        {{VK_SHADER_STAGE_VERTEX_BIT, 0, 4}, ""},
+        {{VK_SHADER_STAGE_VERTEX_BIT, 20, 12}, ""},
+        {{VK_SHADER_STAGE_VERTEX_BIT, 56, 36}, ""},
+    }};
 
     // Setup ranges: [0,16) [20,36) [36,44) [44,52) [56,80) [80,92)
     const VkPushConstantRange pc_range4[] = {
-        { VK_SHADER_STAGE_VERTEX_BIT, 20, 16 },{ VK_SHADER_STAGE_VERTEX_BIT, 0, 16 },{ VK_SHADER_STAGE_VERTEX_BIT, 44, 8 },
-        { VK_SHADER_STAGE_VERTEX_BIT, 80, 12 },{ VK_SHADER_STAGE_VERTEX_BIT, 36, 8 },{ VK_SHADER_STAGE_VERTEX_BIT, 56, 24 },
+        {VK_SHADER_STAGE_VERTEX_BIT, 20, 16}, {VK_SHADER_STAGE_VERTEX_BIT, 0, 16}, {VK_SHADER_STAGE_VERTEX_BIT, 44, 8},
+        {VK_SHADER_STAGE_VERTEX_BIT, 80, 12}, {VK_SHADER_STAGE_VERTEX_BIT, 36, 8}, {VK_SHADER_STAGE_VERTEX_BIT, 56, 24},
     };
 
     pipeline_layout_ci.pushConstantRangeCount = sizeof(pc_range4) / sizeof(VkPushConstantRange);
@@ -20421,7 +20371,7 @@
     for (const auto &iter : cmd_overlap_tests_pos) {
         m_errorMonitor->ExpectSuccess();
         vkCmdPushConstants(m_commandBuffer->GetBufferHandle(), pipeline_layout, iter.range.stageFlags, iter.range.offset,
-            iter.range.size, dummy_values);
+                           iter.range.size, dummy_values);
         m_errorMonitor->VerifyNotFound();
     }
     vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
@@ -20429,12 +20379,6 @@
     m_commandBuffer->EndCommandBuffer();
 }
 
-
-
-
-
-
-
 #if 0 // A few devices have issues with this test so disabling for now
 TEST_F(VkPositiveLayerTest, LongFenceChain)
 {
@@ -20472,7 +20416,6 @@
 }
 #endif
 
-
 #if defined(ANDROID) && defined(VALIDATION_APK)
 static bool initialized = false;
 static bool active = false;
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index f3a37fe..7491d09 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -1194,9 +1194,7 @@
     m_colorAttachments[binding] = *att;
 }
 
-void VkPipelineObj::SetDepthStencil(const VkPipelineDepthStencilStateCreateInfo *ds_state) {
-    m_ds_state = ds_state;
-}
+void VkPipelineObj::SetDepthStencil(const VkPipelineDepthStencilStateCreateInfo *ds_state) { m_ds_state = ds_state; }
 
 void VkPipelineObj::SetViewport(const vector<VkViewport> viewports) {
     m_viewports = viewports;