diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 905cc13..1cdeec2 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -56,27 +56,25 @@
     debug_report_data *report_data;
     std::vector<VkDebugReportCallbackEXT> logging_callback;
 
-    //TODO: Split instance/device structs
-    //Device Data
-    //Map for queue family index to queue count
+    // TODO: Split instance/device structs
+    // Device Data
+    // Map for queue family index to queue count
     std::unordered_map<uint32_t, uint32_t> queueFamilyIndexMap;
 
-    layer_data() :
-        report_data(nullptr)
-    {};
+    layer_data() : report_data(nullptr){};
 };
 
-static std::unordered_map<void*, layer_data*> layer_data_map;
+static std::unordered_map<void *, layer_data *> layer_data_map;
 static device_table_map pc_device_table_map;
 static instance_table_map pc_instance_table_map;
 
 // "my instance data"
-debug_report_data *mid(VkInstance object)
-{
+debug_report_data *mid(VkInstance object) {
     dispatch_key key = get_dispatch_key(object);
     layer_data *data = get_my_data_ptr(key, layer_data_map);
 #if DISPATCH_MAP_DEBUG
-    fprintf(stderr, "MID: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, data);
+    fprintf(stderr, "MID: map: %p, object: %p, key: %p, data: %p\n",
+            &layer_data_map, object, key, data);
 #endif
     assert(data != NULL);
 
@@ -84,28 +82,27 @@
 }
 
 // "my device data"
-debug_report_data *mdd(void* object)
-{
+debug_report_data *mdd(void *object) {
     dispatch_key key = get_dispatch_key(object);
     layer_data *data = get_my_data_ptr(key, layer_data_map);
 #if DISPATCH_MAP_DEBUG
-    fprintf(stderr, "MDD: map: %p, object: %p, key: %p, data: %p\n", &layer_data_map, object, key, data);
+    fprintf(stderr, "MDD: map: %p, object: %p, key: %p, data: %p\n",
+            &layer_data_map, object, key, data);
 #endif
     assert(data != NULL);
     return data->report_data;
 }
 
-static void InitParamChecker(layer_data *data, const VkAllocationCallbacks *pAllocator)
-{
+static void InitParamChecker(layer_data *data,
+                             const VkAllocationCallbacks *pAllocator) {
     VkDebugReportCallbackEXT callback;
     uint32_t report_flags = getLayerOptionFlags("ParamCheckerReportFlags", 0);
 
     uint32_t debug_action = 0;
-    getLayerOptionEnum("ParamCheckerDebugAction", (uint32_t *) &debug_action);
-    if(debug_action & VK_DBG_LAYER_ACTION_LOG_MSG)
-    {
+    getLayerOptionEnum("ParamCheckerDebugAction", (uint32_t *)&debug_action);
+    if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG) {
         FILE *log_output = NULL;
-        const char* option_str = getLayerOption("ParamCheckerLogFilename");
+        const char *option_str = getLayerOption("ParamCheckerLogFilename");
         log_output = getLayerLogOutput(option_str, "ParamChecker");
         VkDebugReportCallbackCreateInfoEXT dbgCreateInfo;
         memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
@@ -114,7 +111,8 @@
         dbgCreateInfo.pfnCallback = log_callback;
         dbgCreateInfo.pUserData = log_output;
 
-        layer_create_msg_callback(data->report_data, &dbgCreateInfo, pAllocator, &callback);
+        layer_create_msg_callback(data->report_data, &dbgCreateInfo, pAllocator,
+                                  &callback);
         data->logging_callback.push_back(callback);
     }
 
@@ -126,209 +124,174 @@
         dbgCreateInfo.pfnCallback = win32_debug_output_msg;
         dbgCreateInfo.pUserData = NULL;
 
-        layer_create_msg_callback(data->report_data, &dbgCreateInfo, pAllocator, &callback);
+        layer_create_msg_callback(data->report_data, &dbgCreateInfo, pAllocator,
+                                  &callback);
         data->logging_callback.push_back(callback);
     }
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
-    VkInstance instance,
-    const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+    VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
     const VkAllocationCallbacks *pAllocator,
-    VkDebugReportCallbackEXT* pMsgCallback)
-{
-    VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
-    VkResult result =  pTable->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
+    VkDebugReportCallbackEXT *pMsgCallback) {
+    VkLayerInstanceDispatchTable *pTable =
+        get_dispatch_table(pc_instance_table_map, instance);
+    VkResult result = pTable->CreateDebugReportCallbackEXT(
+        instance, pCreateInfo, pAllocator, pMsgCallback);
 
-    if (result == VK_SUCCESS)
-    {
-        layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-        result = layer_create_msg_callback(data->report_data, pCreateInfo, pAllocator, pMsgCallback);
+    if (result == VK_SUCCESS) {
+        layer_data *data =
+            get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+        result = layer_create_msg_callback(data->report_data, pCreateInfo,
+                                           pAllocator, pMsgCallback);
     }
 
     return result;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
-    VkInstance instance,
-    VkDebugReportCallbackEXT msgCallback,
-    const VkAllocationCallbacks *pAllocator)
-{
-    VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkDestroyDebugReportCallbackEXT(VkInstance instance,
+                                    VkDebugReportCallbackEXT msgCallback,
+                                    const VkAllocationCallbacks *pAllocator) {
+    VkLayerInstanceDispatchTable *pTable =
+        get_dispatch_table(pc_instance_table_map, instance);
     pTable->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
 
-    layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+    layer_data *data =
+        get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     layer_destroy_msg_callback(data->report_data, msgCallback, pAllocator);
 }
 
-VK_LAYER_EXPORT 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)
-{
-    VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
-    pTable->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
+VK_LAYER_EXPORT 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) {
+    VkLayerInstanceDispatchTable *pTable =
+        get_dispatch_table(pc_instance_table_map, instance);
+    pTable->DebugReportMessageEXT(instance, flags, objType, object, location,
+                                  msgCode, pLayerPrefix, pMsg);
 }
 
 static const VkExtensionProperties instance_extensions[] = {
-    {
-        VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
-        VK_EXT_DEBUG_REPORT_SPEC_VERSION
-    }
-};
+    {VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}};
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
-        const char *pLayerName,
-        uint32_t *pCount,
-        VkExtensionProperties* pProperties)
-{
-    return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkEnumerateInstanceExtensionProperties(const char *pLayerName,
+                                           uint32_t *pCount,
+                                           VkExtensionProperties *pProperties) {
+    return util_GetExtensionProperties(1, instance_extensions, pCount,
+                                       pProperties);
 }
 
-static const VkLayerProperties pc_global_layers[] = {
-    {
-        "VK_LAYER_LUNARG_param_checker",
-        VK_API_VERSION,
-        VK_MAKE_VERSION(0, 1, 0),
-        "Validation layer: param_checker",
-    }
-};
+static const VkLayerProperties pc_global_layers[] = {{
+    "VK_LAYER_LUNARG_param_checker", VK_API_VERSION, VK_MAKE_VERSION(0, 1, 0),
+    "Validation layer: param_checker",
+}};
 
-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 util_GetLayerProperties(ARRAY_SIZE(pc_global_layers),
-                                   pc_global_layers,
-                                   pCount, pProperties);
+                                   pc_global_layers, pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
-        VkPhysicalDevice                            physicalDevice,
-        const char*                                 pLayerName,
-        uint32_t*                                   pCount,
-        VkExtensionProperties*                      pProperties)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
+                                         const char *pLayerName,
+                                         uint32_t *pCount,
+                                         VkExtensionProperties *pProperties) {
     /* ParamChecker does not have any physical device extensions */
     if (pLayerName == NULL) {
-        return get_dispatch_table(pc_instance_table_map, physicalDevice)->EnumerateDeviceExtensionProperties(
-                                    physicalDevice,
-                                    NULL,
-                                    pCount,
-                                    pProperties);
+        return get_dispatch_table(pc_instance_table_map, physicalDevice)
+            ->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount,
+                                                 pProperties);
     } else {
         return util_GetExtensionProperties(0, NULL, 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) {
     /* ParamChecker's physical device layers are the same as global */
-    return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers), pc_global_layers,
-                                   pCount, pProperties);
+    return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers),
+                                   pc_global_layers, pCount, pProperties);
 }
 
 // Version: 0.138.2
 
-static
-std::string EnumeratorString(VkResult const& enumerator)
-{
-    switch(enumerator)
-    {
-        case VK_RESULT_MAX_ENUM:
-        {
-            return "VK_RESULT_MAX_ENUM";
-            break;
-        }
-        case VK_ERROR_LAYER_NOT_PRESENT:
-        {
-            return "VK_ERROR_LAYER_NOT_PRESENT";
-            break;
-        }
-        case VK_ERROR_INCOMPATIBLE_DRIVER:
-        {
-            return "VK_ERROR_INCOMPATIBLE_DRIVER";
-            break;
-        }
-        case VK_ERROR_MEMORY_MAP_FAILED:
-        {
-            return "VK_ERROR_MEMORY_MAP_FAILED";
-            break;
-        }
-        case VK_INCOMPLETE:
-        {
-            return "VK_INCOMPLETE";
-            break;
-        }
-        case VK_ERROR_OUT_OF_HOST_MEMORY:
-        {
-            return "VK_ERROR_OUT_OF_HOST_MEMORY";
-            break;
-        }
-        case VK_ERROR_INITIALIZATION_FAILED:
-        {
-            return "VK_ERROR_INITIALIZATION_FAILED";
-            break;
-        }
-        case VK_NOT_READY:
-        {
-            return "VK_NOT_READY";
-            break;
-        }
-        case VK_ERROR_OUT_OF_DEVICE_MEMORY:
-        {
-            return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
-            break;
-        }
-        case VK_EVENT_SET:
-        {
-            return "VK_EVENT_SET";
-            break;
-        }
-        case VK_TIMEOUT:
-        {
-            return "VK_TIMEOUT";
-            break;
-        }
-        case VK_EVENT_RESET:
-        {
-            return "VK_EVENT_RESET";
-            break;
-        }
-        case VK_SUCCESS:
-        {
-            return "VK_SUCCESS";
-            break;
-        }
-        case VK_ERROR_EXTENSION_NOT_PRESENT:
-        {
-            return "VK_ERROR_EXTENSION_NOT_PRESENT";
-            break;
-        }
-        case VK_ERROR_DEVICE_LOST:
-        {
-            return "VK_ERROR_DEVICE_LOST";
-            break;
-        }
-        default:
-        {
-            return "unrecognized enumerator";
-            break;
-        }
+static std::string EnumeratorString(VkResult const &enumerator) {
+    switch (enumerator) {
+    case VK_RESULT_MAX_ENUM: {
+        return "VK_RESULT_MAX_ENUM";
+        break;
+    }
+    case VK_ERROR_LAYER_NOT_PRESENT: {
+        return "VK_ERROR_LAYER_NOT_PRESENT";
+        break;
+    }
+    case VK_ERROR_INCOMPATIBLE_DRIVER: {
+        return "VK_ERROR_INCOMPATIBLE_DRIVER";
+        break;
+    }
+    case VK_ERROR_MEMORY_MAP_FAILED: {
+        return "VK_ERROR_MEMORY_MAP_FAILED";
+        break;
+    }
+    case VK_INCOMPLETE: {
+        return "VK_INCOMPLETE";
+        break;
+    }
+    case VK_ERROR_OUT_OF_HOST_MEMORY: {
+        return "VK_ERROR_OUT_OF_HOST_MEMORY";
+        break;
+    }
+    case VK_ERROR_INITIALIZATION_FAILED: {
+        return "VK_ERROR_INITIALIZATION_FAILED";
+        break;
+    }
+    case VK_NOT_READY: {
+        return "VK_NOT_READY";
+        break;
+    }
+    case VK_ERROR_OUT_OF_DEVICE_MEMORY: {
+        return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
+        break;
+    }
+    case VK_EVENT_SET: {
+        return "VK_EVENT_SET";
+        break;
+    }
+    case VK_TIMEOUT: {
+        return "VK_TIMEOUT";
+        break;
+    }
+    case VK_EVENT_RESET: {
+        return "VK_EVENT_RESET";
+        break;
+    }
+    case VK_SUCCESS: {
+        return "VK_SUCCESS";
+        break;
+    }
+    case VK_ERROR_EXTENSION_NOT_PRESENT: {
+        return "VK_ERROR_EXTENSION_NOT_PRESENT";
+        break;
+    }
+    case VK_ERROR_DEVICE_LOST: {
+        return "VK_ERROR_DEVICE_LOST";
+        break;
+    }
+    default: {
+        return "unrecognized enumerator";
+        break;
+    }
     }
 }
 
-static
-bool ValidateEnumerator(VkFormatFeatureFlagBits const& enumerator)
-{
+static bool ValidateEnumerator(VkFormatFeatureFlagBits const &enumerator) {
     VkFormatFeatureFlagBits allFlags = (VkFormatFeatureFlagBits)(
         VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT |
         VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT |
@@ -340,86 +303,66 @@
         VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT |
         VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
         VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT |
-        VK_FORMAT_FEATURE_BLIT_SRC_BIT |
-        VK_FORMAT_FEATURE_BLIT_DST_BIT |
+        VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT |
         VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT);
-    if(enumerator & (~allFlags))
-    {
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkFormatFeatureFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkFormatFeatureFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_BLIT_SRC_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_BLIT_SRC_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_BLIT_SRC_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_BLIT_DST_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_BLIT_DST_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_BLIT_DST_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)
-    {
+    if (enumerator & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT) {
         strings.push_back("VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -427,74 +370,57 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkImageUsageFlagBits const& enumerator)
-{
-    VkImageUsageFlagBits allFlags = (VkImageUsageFlagBits)(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
+static bool ValidateEnumerator(VkImageUsageFlagBits const &enumerator) {
+    VkImageUsageFlagBits allFlags = (VkImageUsageFlagBits)(
+        VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
         VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
-        VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
-        VK_IMAGE_USAGE_STORAGE_BIT |
-        VK_IMAGE_USAGE_SAMPLED_BIT |
-        VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+        VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
+        VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
         VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT |
         VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
-    if(enumerator & (~allFlags))
-    {
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkImageUsageFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkImageUsageFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)
-    {
+    if (enumerator & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) {
         strings.push_back("VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT");
     }
-    if(enumerator & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
-    {
+    if (enumerator & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
         strings.push_back("VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT");
     }
-    if(enumerator & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
-    {
+    if (enumerator & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
         strings.push_back("VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT");
     }
-    if(enumerator & VK_IMAGE_USAGE_STORAGE_BIT)
-    {
+    if (enumerator & VK_IMAGE_USAGE_STORAGE_BIT) {
         strings.push_back("VK_IMAGE_USAGE_STORAGE_BIT");
     }
-    if(enumerator & VK_IMAGE_USAGE_SAMPLED_BIT)
-    {
+    if (enumerator & VK_IMAGE_USAGE_SAMPLED_BIT) {
         strings.push_back("VK_IMAGE_USAGE_SAMPLED_BIT");
     }
-    if(enumerator & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
-    {
+    if (enumerator & VK_IMAGE_USAGE_TRANSFER_DST_BIT) {
         strings.push_back("VK_IMAGE_USAGE_TRANSFER_DST_BIT");
     }
-    if(enumerator & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT)
-    {
+    if (enumerator & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) {
         strings.push_back("VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT");
     }
-    if(enumerator & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
-    {
+    if (enumerator & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) {
         strings.push_back("VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -502,55 +428,41 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkQueueFlagBits const& enumerator)
-{
-    VkQueueFlagBits allFlags = (VkQueueFlagBits)(
-        VK_QUEUE_TRANSFER_BIT |
-        VK_QUEUE_COMPUTE_BIT |
-        VK_QUEUE_SPARSE_BINDING_BIT |
-        VK_QUEUE_GRAPHICS_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkQueueFlagBits const &enumerator) {
+    VkQueueFlagBits allFlags =
+        (VkQueueFlagBits)(VK_QUEUE_TRANSFER_BIT | VK_QUEUE_COMPUTE_BIT |
+                          VK_QUEUE_SPARSE_BINDING_BIT | VK_QUEUE_GRAPHICS_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkQueueFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkQueueFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_QUEUE_TRANSFER_BIT)
-    {
+    if (enumerator & VK_QUEUE_TRANSFER_BIT) {
         strings.push_back("VK_QUEUE_TRANSFER_BIT");
     }
-    if(enumerator & VK_QUEUE_COMPUTE_BIT)
-    {
+    if (enumerator & VK_QUEUE_COMPUTE_BIT) {
         strings.push_back("VK_QUEUE_COMPUTE_BIT");
     }
-    if(enumerator & VK_QUEUE_SPARSE_BINDING_BIT)
-    {
+    if (enumerator & VK_QUEUE_SPARSE_BINDING_BIT) {
         strings.push_back("VK_QUEUE_SPARSE_BINDING_BIT");
     }
-    if(enumerator & VK_QUEUE_GRAPHICS_BIT)
-    {
+    if (enumerator & VK_QUEUE_GRAPHICS_BIT) {
         strings.push_back("VK_QUEUE_GRAPHICS_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -558,59 +470,48 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkMemoryPropertyFlagBits const& enumerator)
-{
-    VkMemoryPropertyFlagBits allFlags = (VkMemoryPropertyFlagBits)(VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT |
-        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
-        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-        VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
-        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkMemoryPropertyFlagBits const &enumerator) {
+    VkMemoryPropertyFlagBits allFlags =
+        (VkMemoryPropertyFlagBits)(VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT |
+                                   VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+                                   VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                                   VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
+                                   VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkMemoryPropertyFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string
+EnumeratorString(VkMemoryPropertyFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)
-    {
+    if (enumerator & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) {
         strings.push_back("VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT");
     }
-    if(enumerator & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
-    {
+    if (enumerator & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) {
         strings.push_back("VK_MEMORY_PROPERTY_HOST_COHERENT_BIT");
     }
-    if(enumerator & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
-    {
+    if (enumerator & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
         strings.push_back("VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT");
     }
-    if(enumerator & VK_MEMORY_PROPERTY_HOST_CACHED_BIT)
-    {
+    if (enumerator & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) {
         strings.push_back("VK_MEMORY_PROPERTY_HOST_CACHED_BIT");
     }
-    if(enumerator & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
-    {
+    if (enumerator & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {
         strings.push_back("VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -618,39 +519,31 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkMemoryHeapFlagBits const& enumerator)
-{
-    VkMemoryHeapFlagBits allFlags = (VkMemoryHeapFlagBits)(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkMemoryHeapFlagBits const &enumerator) {
+    VkMemoryHeapFlagBits allFlags =
+        (VkMemoryHeapFlagBits)(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkMemoryHeapFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkMemoryHeapFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
-    {
+    if (enumerator & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) {
         strings.push_back("VK_MEMORY_HEAP_DEVICE_LOCAL_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -658,49 +551,40 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkSparseImageFormatFlagBits const& enumerator)
-{
-    VkSparseImageFormatFlagBits allFlags = (VkSparseImageFormatFlagBits)(VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT |
+static bool ValidateEnumerator(VkSparseImageFormatFlagBits const &enumerator) {
+    VkSparseImageFormatFlagBits allFlags = (VkSparseImageFormatFlagBits)(
+        VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT |
         VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT |
         VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT);
-    if(enumerator & (~allFlags))
-    {
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkSparseImageFormatFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string
+EnumeratorString(VkSparseImageFormatFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT)
-    {
+    if (enumerator & VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT) {
         strings.push_back("VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT");
     }
-    if(enumerator & VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT)
-    {
+    if (enumerator & VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT) {
         strings.push_back("VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT");
     }
-    if(enumerator & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT)
-    {
+    if (enumerator & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) {
         strings.push_back("VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -708,39 +592,31 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkFenceCreateFlagBits const& enumerator)
-{
-    VkFenceCreateFlagBits allFlags = (VkFenceCreateFlagBits)(VK_FENCE_CREATE_SIGNALED_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkFenceCreateFlagBits const &enumerator) {
+    VkFenceCreateFlagBits allFlags =
+        (VkFenceCreateFlagBits)(VK_FENCE_CREATE_SIGNALED_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkFenceCreateFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkFenceCreateFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_FENCE_CREATE_SIGNALED_BIT)
-    {
+    if (enumerator & VK_FENCE_CREATE_SIGNALED_BIT) {
         strings.push_back("VK_FENCE_CREATE_SIGNALED_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -748,10 +624,10 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkQueryPipelineStatisticFlagBits const& enumerator)
-{
-    VkQueryPipelineStatisticFlagBits allFlags = (VkQueryPipelineStatisticFlagBits)(VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT |
+static bool
+ValidateEnumerator(VkQueryPipelineStatisticFlagBits const &enumerator) {
+    VkQueryPipelineStatisticFlagBits allFlags = (VkQueryPipelineStatisticFlagBits)(
+        VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT |
         VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT |
         VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT |
         VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT |
@@ -762,75 +638,78 @@
         VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT |
         VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT |
         VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT);
-    if(enumerator & (~allFlags))
-    {
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkQueryPipelineStatisticFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string
+EnumeratorString(VkQueryPipelineStatisticFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT");
+    if (enumerator &
+        VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT) {
+        strings.push_back(
+            "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT");
     }
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT");
+    if (enumerator & VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT) {
+        strings.push_back(
+            "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT");
     }
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT");
+    if (enumerator &
+        VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT) {
+        strings.push_back(
+            "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT");
     }
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT");
+    if (enumerator & VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT) {
+        strings.push_back(
+            "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT");
     }
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT");
+    if (enumerator &
+        VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT) {
+        strings.push_back(
+            "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT");
     }
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT");
+    if (enumerator &
+        VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT) {
+        strings.push_back(
+            "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT");
     }
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT");
+    if (enumerator &
+        VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT) {
+        strings.push_back(
+            "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT");
     }
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT");
+    if (enumerator & VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT) {
+        strings.push_back(
+            "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT");
     }
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT");
+    if (enumerator &
+        VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT) {
+        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_"
+                          "SHADER_PATCHES_BIT");
     }
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT");
+    if (enumerator &
+        VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT) {
+        strings.push_back(
+            "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT");
     }
-    if(enumerator & VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT)
-    {
-        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT");
+    if (enumerator &
+        VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT) {
+        strings.push_back("VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_"
+                          "SHADER_INVOCATIONS_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -838,54 +717,41 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkQueryResultFlagBits const& enumerator)
-{
-    VkQueryResultFlagBits allFlags = (VkQueryResultFlagBits)(VK_QUERY_RESULT_PARTIAL_BIT |
-        VK_QUERY_RESULT_WITH_AVAILABILITY_BIT |
-        VK_QUERY_RESULT_WAIT_BIT |
-        VK_QUERY_RESULT_64_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkQueryResultFlagBits const &enumerator) {
+    VkQueryResultFlagBits allFlags = (VkQueryResultFlagBits)(
+        VK_QUERY_RESULT_PARTIAL_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT |
+        VK_QUERY_RESULT_WAIT_BIT | VK_QUERY_RESULT_64_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkQueryResultFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkQueryResultFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_QUERY_RESULT_PARTIAL_BIT)
-    {
+    if (enumerator & VK_QUERY_RESULT_PARTIAL_BIT) {
         strings.push_back("VK_QUERY_RESULT_PARTIAL_BIT");
     }
-    if(enumerator & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)
-    {
+    if (enumerator & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) {
         strings.push_back("VK_QUERY_RESULT_WITH_AVAILABILITY_BIT");
     }
-    if(enumerator & VK_QUERY_RESULT_WAIT_BIT)
-    {
+    if (enumerator & VK_QUERY_RESULT_WAIT_BIT) {
         strings.push_back("VK_QUERY_RESULT_WAIT_BIT");
     }
-    if(enumerator & VK_QUERY_RESULT_64_BIT)
-    {
+    if (enumerator & VK_QUERY_RESULT_64_BIT) {
         strings.push_back("VK_QUERY_RESULT_64_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -893,79 +759,60 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkBufferUsageFlagBits const& enumerator)
-{
-    VkBufferUsageFlagBits allFlags = (VkBufferUsageFlagBits)(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT |
-        VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
+static bool ValidateEnumerator(VkBufferUsageFlagBits const &enumerator) {
+    VkBufferUsageFlagBits allFlags = (VkBufferUsageFlagBits)(
+        VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
         VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT |
         VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT |
-        VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
-        VK_BUFFER_USAGE_TRANSFER_DST_BIT |
+        VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
         VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
-        VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
-        VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
-    if(enumerator & (~allFlags))
-    {
+        VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkBufferUsageFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkBufferUsageFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
-    {
+    if (enumerator & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) {
         strings.push_back("VK_BUFFER_USAGE_VERTEX_BUFFER_BIT");
     }
-    if(enumerator & VK_BUFFER_USAGE_INDEX_BUFFER_BIT)
-    {
+    if (enumerator & VK_BUFFER_USAGE_INDEX_BUFFER_BIT) {
         strings.push_back("VK_BUFFER_USAGE_INDEX_BUFFER_BIT");
     }
-    if(enumerator & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT)
-    {
+    if (enumerator & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT) {
         strings.push_back("VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT");
     }
-    if(enumerator & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)
-    {
+    if (enumerator & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT) {
         strings.push_back("VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT");
     }
-    if(enumerator & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
-    {
+    if (enumerator & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) {
         strings.push_back("VK_BUFFER_USAGE_STORAGE_BUFFER_BIT");
     }
-    if(enumerator & VK_BUFFER_USAGE_TRANSFER_DST_BIT)
-    {
+    if (enumerator & VK_BUFFER_USAGE_TRANSFER_DST_BIT) {
         strings.push_back("VK_BUFFER_USAGE_TRANSFER_DST_BIT");
     }
-    if(enumerator & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)
-    {
+    if (enumerator & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) {
         strings.push_back("VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT");
     }
-    if(enumerator & VK_BUFFER_USAGE_TRANSFER_SRC_BIT)
-    {
+    if (enumerator & VK_BUFFER_USAGE_TRANSFER_SRC_BIT) {
         strings.push_back("VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
     }
-    if(enumerator & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
-    {
+    if (enumerator & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
         strings.push_back("VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -973,49 +820,39 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkBufferCreateFlagBits const& enumerator)
-{
-    VkBufferCreateFlagBits allFlags = (VkBufferCreateFlagBits)(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT |
-        VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT |
-        VK_BUFFER_CREATE_SPARSE_BINDING_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkBufferCreateFlagBits const &enumerator) {
+    VkBufferCreateFlagBits allFlags =
+        (VkBufferCreateFlagBits)(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT |
+                                 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT |
+                                 VK_BUFFER_CREATE_SPARSE_BINDING_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkBufferCreateFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkBufferCreateFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT)
-    {
+    if (enumerator & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT) {
         strings.push_back("VK_BUFFER_CREATE_SPARSE_ALIASED_BIT");
     }
-    if(enumerator & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT)
-    {
+    if (enumerator & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT) {
         strings.push_back("VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT");
     }
-    if(enumerator & VK_BUFFER_CREATE_SPARSE_BINDING_BIT)
-    {
+    if (enumerator & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) {
         strings.push_back("VK_BUFFER_CREATE_SPARSE_BINDING_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1023,59 +860,47 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkImageCreateFlagBits const& enumerator)
-{
-    VkImageCreateFlagBits allFlags = (VkImageCreateFlagBits)(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT |
-        VK_IMAGE_CREATE_SPARSE_ALIASED_BIT |
-        VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT |
-        VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT |
-        VK_IMAGE_CREATE_SPARSE_BINDING_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkImageCreateFlagBits const &enumerator) {
+    VkImageCreateFlagBits allFlags =
+        (VkImageCreateFlagBits)(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT |
+                                VK_IMAGE_CREATE_SPARSE_ALIASED_BIT |
+                                VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT |
+                                VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT |
+                                VK_IMAGE_CREATE_SPARSE_BINDING_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkImageCreateFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkImageCreateFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
-    {
+    if (enumerator & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) {
         strings.push_back("VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT");
     }
-    if(enumerator & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT)
-    {
+    if (enumerator & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT) {
         strings.push_back("VK_IMAGE_CREATE_SPARSE_ALIASED_BIT");
     }
-    if(enumerator & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)
-    {
+    if (enumerator & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) {
         strings.push_back("VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT");
     }
-    if(enumerator & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT)
-    {
+    if (enumerator & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) {
         strings.push_back("VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT");
     }
-    if(enumerator & VK_IMAGE_CREATE_SPARSE_BINDING_BIT)
-    {
+    if (enumerator & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) {
         strings.push_back("VK_IMAGE_CREATE_SPARSE_BINDING_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1083,54 +908,42 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkColorComponentFlagBits const& enumerator)
-{
-    VkColorComponentFlagBits allFlags = (VkColorComponentFlagBits)(VK_COLOR_COMPONENT_A_BIT |
-        VK_COLOR_COMPONENT_B_BIT |
-        VK_COLOR_COMPONENT_G_BIT |
-        VK_COLOR_COMPONENT_R_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkColorComponentFlagBits const &enumerator) {
+    VkColorComponentFlagBits allFlags = (VkColorComponentFlagBits)(
+        VK_COLOR_COMPONENT_A_BIT | VK_COLOR_COMPONENT_B_BIT |
+        VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_R_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkColorComponentFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string
+EnumeratorString(VkColorComponentFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_COLOR_COMPONENT_A_BIT)
-    {
+    if (enumerator & VK_COLOR_COMPONENT_A_BIT) {
         strings.push_back("VK_COLOR_COMPONENT_A_BIT");
     }
-    if(enumerator & VK_COLOR_COMPONENT_B_BIT)
-    {
+    if (enumerator & VK_COLOR_COMPONENT_B_BIT) {
         strings.push_back("VK_COLOR_COMPONENT_B_BIT");
     }
-    if(enumerator & VK_COLOR_COMPONENT_G_BIT)
-    {
+    if (enumerator & VK_COLOR_COMPONENT_G_BIT) {
         strings.push_back("VK_COLOR_COMPONENT_G_BIT");
     }
-    if(enumerator & VK_COLOR_COMPONENT_R_BIT)
-    {
+    if (enumerator & VK_COLOR_COMPONENT_R_BIT) {
         strings.push_back("VK_COLOR_COMPONENT_R_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1138,49 +951,40 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkPipelineCreateFlagBits const& enumerator)
-{
-    VkPipelineCreateFlagBits allFlags = (VkPipelineCreateFlagBits)(VK_PIPELINE_CREATE_DERIVATIVE_BIT |
-        VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT |
-        VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkPipelineCreateFlagBits const &enumerator) {
+    VkPipelineCreateFlagBits allFlags =
+        (VkPipelineCreateFlagBits)(VK_PIPELINE_CREATE_DERIVATIVE_BIT |
+                                   VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT |
+                                   VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkPipelineCreateFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string
+EnumeratorString(VkPipelineCreateFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
-    {
+    if (enumerator & VK_PIPELINE_CREATE_DERIVATIVE_BIT) {
         strings.push_back("VK_PIPELINE_CREATE_DERIVATIVE_BIT");
     }
-    if(enumerator & VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)
-    {
+    if (enumerator & VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT) {
         strings.push_back("VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT");
     }
-    if(enumerator & VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT)
-    {
+    if (enumerator & VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT) {
         strings.push_back("VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1188,69 +992,52 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkShaderStageFlagBits const& enumerator)
-{
-    VkShaderStageFlagBits allFlags = (VkShaderStageFlagBits)(VK_SHADER_STAGE_ALL |
-        VK_SHADER_STAGE_FRAGMENT_BIT |
-        VK_SHADER_STAGE_GEOMETRY_BIT |
-        VK_SHADER_STAGE_COMPUTE_BIT |
+static bool ValidateEnumerator(VkShaderStageFlagBits const &enumerator) {
+    VkShaderStageFlagBits allFlags = (VkShaderStageFlagBits)(
+        VK_SHADER_STAGE_ALL | VK_SHADER_STAGE_FRAGMENT_BIT |
+        VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_COMPUTE_BIT |
         VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT |
-        VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT |
-        VK_SHADER_STAGE_VERTEX_BIT);
-    if(enumerator & (~allFlags))
-    {
+        VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_VERTEX_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkShaderStageFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkShaderStageFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_SHADER_STAGE_ALL)
-    {
+    if (enumerator & VK_SHADER_STAGE_ALL) {
         strings.push_back("VK_SHADER_STAGE_ALL");
     }
-    if(enumerator & VK_SHADER_STAGE_FRAGMENT_BIT)
-    {
+    if (enumerator & VK_SHADER_STAGE_FRAGMENT_BIT) {
         strings.push_back("VK_SHADER_STAGE_FRAGMENT_BIT");
     }
-    if(enumerator & VK_SHADER_STAGE_GEOMETRY_BIT)
-    {
+    if (enumerator & VK_SHADER_STAGE_GEOMETRY_BIT) {
         strings.push_back("VK_SHADER_STAGE_GEOMETRY_BIT");
     }
-    if(enumerator & VK_SHADER_STAGE_COMPUTE_BIT)
-    {
+    if (enumerator & VK_SHADER_STAGE_COMPUTE_BIT) {
         strings.push_back("VK_SHADER_STAGE_COMPUTE_BIT");
     }
-    if(enumerator & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
-    {
+    if (enumerator & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) {
         strings.push_back("VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT");
     }
-    if(enumerator & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT)
-    {
+    if (enumerator & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) {
         strings.push_back("VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT");
     }
-    if(enumerator & VK_SHADER_STAGE_VERTEX_BIT)
-    {
+    if (enumerator & VK_SHADER_STAGE_VERTEX_BIT) {
         strings.push_back("VK_SHADER_STAGE_VERTEX_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1258,15 +1045,11 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkPipelineStageFlagBits const& enumerator)
-{
+static bool ValidateEnumerator(VkPipelineStageFlagBits const &enumerator) {
     VkPipelineStageFlagBits allFlags = (VkPipelineStageFlagBits)(
         VK_PIPELINE_STAGE_ALL_COMMANDS_BIT |
-        VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT |
-        VK_PIPELINE_STAGE_HOST_BIT |
-        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT |
-        VK_PIPELINE_STAGE_TRANSFER_BIT |
+        VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_HOST_BIT |
+        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT |
         VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
         VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
         VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
@@ -1279,99 +1062,77 @@
         VK_PIPELINE_STAGE_VERTEX_INPUT_BIT |
         VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT |
         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
-    if(enumerator & (~allFlags))
-    {
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkPipelineStageFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkPipelineStageFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_PIPELINE_STAGE_ALL_COMMANDS_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_ALL_COMMANDS_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_HOST_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_HOST_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_HOST_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_TRANSFER_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_TRANSFER_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_TRANSFER_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_VERTEX_SHADER_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_VERTEX_SHADER_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_VERTEX_SHADER_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT)
-    {
-        strings.push_back("VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT");
+    if (enumerator & VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT) {
+        strings.push_back(
+            "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_VERTEX_INPUT_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_VERTEX_INPUT_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_VERTEX_INPUT_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT");
     }
-    if(enumerator & VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT)
-    {
+    if (enumerator & VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT) {
         strings.push_back("VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1379,121 +1140,89 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkAccessFlagBits const& enumerator)
-{
+static bool ValidateEnumerator(VkAccessFlagBits const &enumerator) {
     VkAccessFlagBits allFlags = (VkAccessFlagBits)(
-            VK_ACCESS_INDIRECT_COMMAND_READ_BIT |
-            VK_ACCESS_INDEX_READ_BIT |
-            VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |
-            VK_ACCESS_UNIFORM_READ_BIT |
-            VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
-            VK_ACCESS_SHADER_READ_BIT |
-            VK_ACCESS_SHADER_WRITE_BIT |
-            VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
-            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
-            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
-            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
-            VK_ACCESS_TRANSFER_READ_BIT |
-            VK_ACCESS_TRANSFER_WRITE_BIT |
-            VK_ACCESS_HOST_READ_BIT |
-            VK_ACCESS_HOST_WRITE_BIT |
-            VK_ACCESS_MEMORY_READ_BIT |
-            VK_ACCESS_MEMORY_WRITE_BIT);
+        VK_ACCESS_INDIRECT_COMMAND_READ_BIT | VK_ACCESS_INDEX_READ_BIT |
+        VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT | VK_ACCESS_UNIFORM_READ_BIT |
+        VK_ACCESS_INPUT_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT |
+        VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
+        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
+        VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
+        VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+        VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT |
+        VK_ACCESS_HOST_READ_BIT | VK_ACCESS_HOST_WRITE_BIT |
+        VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT);
 
-    if(enumerator & (~allFlags))
-    {
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkAccessFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkAccessFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_ACCESS_INDIRECT_COMMAND_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_INDIRECT_COMMAND_READ_BIT) {
         strings.push_back("VK_ACCESS_INDIRECT_COMMAND_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_INDEX_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_INDEX_READ_BIT) {
         strings.push_back("VK_ACCESS_INDEX_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT) {
         strings.push_back("VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_UNIFORM_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_UNIFORM_READ_BIT) {
         strings.push_back("VK_ACCESS_UNIFORM_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_INPUT_ATTACHMENT_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_INPUT_ATTACHMENT_READ_BIT) {
         strings.push_back("VK_ACCESS_INPUT_ATTACHMENT_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_SHADER_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_SHADER_READ_BIT) {
         strings.push_back("VK_ACCESS_SHADER_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_SHADER_WRITE_BIT)
-    {
+    if (enumerator & VK_ACCESS_SHADER_WRITE_BIT) {
         strings.push_back("VK_ACCESS_SHADER_WRITE_BIT");
     }
-    if(enumerator & VK_ACCESS_COLOR_ATTACHMENT_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_COLOR_ATTACHMENT_READ_BIT) {
         strings.push_back("VK_ACCESS_COLOR_ATTACHMENT_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT)
-    {
+    if (enumerator & VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT) {
         strings.push_back("VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT");
     }
-    if(enumerator & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT) {
         strings.push_back("VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT)
-    {
+    if (enumerator & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT) {
         strings.push_back("VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT");
     }
-    if(enumerator & VK_ACCESS_TRANSFER_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_TRANSFER_READ_BIT) {
         strings.push_back("VK_ACCESS_TRANSFER_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_TRANSFER_WRITE_BIT)
-    {
+    if (enumerator & VK_ACCESS_TRANSFER_WRITE_BIT) {
         strings.push_back("VK_ACCESS_TRANSFER_WRITE_BIT");
     }
-    if(enumerator & VK_ACCESS_HOST_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_HOST_READ_BIT) {
         strings.push_back("VK_ACCESS_HOST_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_HOST_WRITE_BIT)
-    {
+    if (enumerator & VK_ACCESS_HOST_WRITE_BIT) {
         strings.push_back("VK_ACCESS_HOST_WRITE_BIT");
     }
-    if(enumerator & VK_ACCESS_MEMORY_READ_BIT)
-    {
+    if (enumerator & VK_ACCESS_MEMORY_READ_BIT) {
         strings.push_back("VK_ACCESS_MEMORY_READ_BIT");
     }
-    if(enumerator & VK_ACCESS_MEMORY_WRITE_BIT)
-    {
+    if (enumerator & VK_ACCESS_MEMORY_WRITE_BIT) {
         strings.push_back("VK_ACCESS_MEMORY_WRITE_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1501,44 +1230,36 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkCommandPoolCreateFlagBits const& enumerator)
-{
-    VkCommandPoolCreateFlagBits allFlags = (VkCommandPoolCreateFlagBits)(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT |
+static bool ValidateEnumerator(VkCommandPoolCreateFlagBits const &enumerator) {
+    VkCommandPoolCreateFlagBits allFlags = (VkCommandPoolCreateFlagBits)(
+        VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT |
         VK_COMMAND_POOL_CREATE_TRANSIENT_BIT);
-    if(enumerator & (~allFlags))
-    {
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkCommandPoolCreateFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string
+EnumeratorString(VkCommandPoolCreateFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)
-    {
+    if (enumerator & VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT) {
         strings.push_back("VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT");
     }
-    if(enumerator & VK_COMMAND_POOL_CREATE_TRANSIENT_BIT)
-    {
+    if (enumerator & VK_COMMAND_POOL_CREATE_TRANSIENT_BIT) {
         strings.push_back("VK_COMMAND_POOL_CREATE_TRANSIENT_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1546,39 +1267,32 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkCommandPoolResetFlagBits const& enumerator)
-{
-    VkCommandPoolResetFlagBits allFlags = (VkCommandPoolResetFlagBits)(VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkCommandPoolResetFlagBits const &enumerator) {
+    VkCommandPoolResetFlagBits allFlags = (VkCommandPoolResetFlagBits)(
+        VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkCommandPoolResetFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string
+EnumeratorString(VkCommandPoolResetFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT)
-    {
+    if (enumerator & VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT) {
         strings.push_back("VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1586,49 +1300,40 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkCommandBufferUsageFlags const& enumerator)
-{
-    VkCommandBufferUsageFlags allFlags = (VkCommandBufferUsageFlags)(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT |
+static bool ValidateEnumerator(VkCommandBufferUsageFlags const &enumerator) {
+    VkCommandBufferUsageFlags allFlags = (VkCommandBufferUsageFlags)(
+        VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT |
         VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT |
         VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT);
-    if(enumerator & (~allFlags))
-    {
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkCommandBufferUsageFlags const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string
+EnumeratorString(VkCommandBufferUsageFlags const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)
-    {
+    if (enumerator & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT) {
         strings.push_back("VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT");
     }
-    if(enumerator & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
-    {
+    if (enumerator & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) {
         strings.push_back("VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT");
     }
-    if(enumerator & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)
-    {
+    if (enumerator & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) {
         strings.push_back("VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1636,39 +1341,32 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkCommandBufferResetFlagBits const& enumerator)
-{
-    VkCommandBufferResetFlagBits allFlags = (VkCommandBufferResetFlagBits)(VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkCommandBufferResetFlagBits const &enumerator) {
+    VkCommandBufferResetFlagBits allFlags = (VkCommandBufferResetFlagBits)(
+        VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkCommandBufferResetFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string
+EnumeratorString(VkCommandBufferResetFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT)
-    {
+    if (enumerator & VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT) {
         strings.push_back("VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1676,54 +1374,41 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkImageAspectFlagBits const& enumerator)
-{
-    VkImageAspectFlagBits allFlags = (VkImageAspectFlagBits)(VK_IMAGE_ASPECT_METADATA_BIT |
-        VK_IMAGE_ASPECT_STENCIL_BIT |
-        VK_IMAGE_ASPECT_DEPTH_BIT |
-        VK_IMAGE_ASPECT_COLOR_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkImageAspectFlagBits const &enumerator) {
+    VkImageAspectFlagBits allFlags = (VkImageAspectFlagBits)(
+        VK_IMAGE_ASPECT_METADATA_BIT | VK_IMAGE_ASPECT_STENCIL_BIT |
+        VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_COLOR_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkImageAspectFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkImageAspectFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_IMAGE_ASPECT_METADATA_BIT)
-    {
+    if (enumerator & VK_IMAGE_ASPECT_METADATA_BIT) {
         strings.push_back("VK_IMAGE_ASPECT_METADATA_BIT");
     }
-    if(enumerator & VK_IMAGE_ASPECT_STENCIL_BIT)
-    {
+    if (enumerator & VK_IMAGE_ASPECT_STENCIL_BIT) {
         strings.push_back("VK_IMAGE_ASPECT_STENCIL_BIT");
     }
-    if(enumerator & VK_IMAGE_ASPECT_DEPTH_BIT)
-    {
+    if (enumerator & VK_IMAGE_ASPECT_DEPTH_BIT) {
         strings.push_back("VK_IMAGE_ASPECT_DEPTH_BIT");
     }
-    if(enumerator & VK_IMAGE_ASPECT_COLOR_BIT)
-    {
+    if (enumerator & VK_IMAGE_ASPECT_COLOR_BIT) {
         strings.push_back("VK_IMAGE_ASPECT_COLOR_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1731,39 +1416,31 @@
     return enumeratorString;
 }
 
-static
-bool ValidateEnumerator(VkQueryControlFlagBits const& enumerator)
-{
-    VkQueryControlFlagBits allFlags = (VkQueryControlFlagBits)(VK_QUERY_CONTROL_PRECISE_BIT);
-    if(enumerator & (~allFlags))
-    {
+static bool ValidateEnumerator(VkQueryControlFlagBits const &enumerator) {
+    VkQueryControlFlagBits allFlags =
+        (VkQueryControlFlagBits)(VK_QUERY_CONTROL_PRECISE_BIT);
+    if (enumerator & (~allFlags)) {
         return false;
     }
 
     return true;
 }
 
-static
-std::string EnumeratorString(VkQueryControlFlagBits const& enumerator)
-{
-    if(!ValidateEnumerator(enumerator))
-    {
+static std::string EnumeratorString(VkQueryControlFlagBits const &enumerator) {
+    if (!ValidateEnumerator(enumerator)) {
         return "unrecognized enumerator";
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_QUERY_CONTROL_PRECISE_BIT)
-    {
+    if (enumerator & VK_QUERY_CONTROL_PRECISE_BIT) {
         strings.push_back("VK_QUERY_CONTROL_PRECISE_BIT");
     }
 
     std::string enumeratorString;
-    for(auto const& string : strings)
-    {
+    for (auto const &string : strings) {
         enumeratorString += string;
 
-        if(string != strings.back())
-        {
+        if (string != strings.back()) {
             enumeratorString += '|';
         }
     }
@@ -1771,16 +1448,18 @@
     return enumeratorString;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
-    const VkInstanceCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkInstance* pInstance)
-{
-    VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
+                     const VkAllocationCallbacks *pAllocator,
+                     VkInstance *pInstance) {
+    VkLayerInstanceCreateInfo *chain_info =
+        get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
 
     assert(chain_info->u.pLayerInfo);
-    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
-    PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance) fpGetInstanceProcAddr(NULL, "vkCreateInstance");
+    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr =
+        chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
+    PFN_vkCreateInstance fpCreateInstance =
+        (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance");
     if (fpCreateInstance == NULL) {
         return VK_ERROR_INITIALIZATION_FAILED;
     }
@@ -1792,27 +1471,27 @@
     if (result != VK_SUCCESS)
         return result;
 
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
-    VkLayerInstanceDispatchTable *pTable = initInstanceTable(*pInstance, fpGetInstanceProcAddr, pc_instance_table_map);
+    layer_data *my_data =
+        get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
+    VkLayerInstanceDispatchTable *pTable = initInstanceTable(
+        *pInstance, fpGetInstanceProcAddr, pc_instance_table_map);
 
     my_data->report_data = debug_report_create_instance(
-                               pTable,
-                               *pInstance,
-                               pCreateInfo->enabledExtensionCount,
-                               pCreateInfo->ppEnabledExtensionNames);
+        pTable, *pInstance, pCreateInfo->enabledExtensionCount,
+        pCreateInfo->ppEnabledExtensionNames);
 
     InitParamChecker(my_data, pAllocator);
 
     return result;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
-    VkInstance instance,
-    const VkAllocationCallbacks* pAllocator)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkDestroyInstance(VkInstance instance,
+                      const VkAllocationCallbacks *pAllocator) {
     // Grab the key before the instance is destroyed.
     dispatch_key key = get_dispatch_key(instance);
-    VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
+    VkLayerInstanceDispatchTable *pTable =
+        get_dispatch_table(pc_instance_table_map, instance);
     pTable->DestroyInstance(instance, pAllocator);
 
     // Clean up logging callback, if any
@@ -1829,223 +1508,213 @@
     pc_instance_table_map.erase(key);
 }
 
-bool PostEnumeratePhysicalDevices(
-    VkInstance instance,
-    uint32_t* pPhysicalDeviceCount,
-    VkPhysicalDevice* pPhysicalDevices,
-    VkResult result)
-{
+bool PostEnumeratePhysicalDevices(VkInstance instance,
+                                  uint32_t *pPhysicalDeviceCount,
+                                  VkPhysicalDevice *pPhysicalDevices,
+                                  VkResult result) {
 
-    if(pPhysicalDeviceCount != nullptr)
-    {
+    if (pPhysicalDeviceCount != nullptr) {
     }
 
-    if(pPhysicalDevices != nullptr)
-    {
+    if (pPhysicalDevices != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkEnumeratePhysicalDevices parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkEnumeratePhysicalDevices parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
-    VkInstance instance,
-    uint32_t* pPhysicalDeviceCount,
-    VkPhysicalDevice* pPhysicalDevices)
-{
-    VkResult result = get_dispatch_table(pc_instance_table_map, instance)->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkEnumeratePhysicalDevices(VkInstance instance,
+                               uint32_t *pPhysicalDeviceCount,
+                               VkPhysicalDevice *pPhysicalDevices) {
+    VkResult result = get_dispatch_table(pc_instance_table_map, instance)
+                          ->EnumeratePhysicalDevices(
+                              instance, pPhysicalDeviceCount, pPhysicalDevices);
 
-    PostEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices, result);
+    PostEnumeratePhysicalDevices(instance, pPhysicalDeviceCount,
+                                 pPhysicalDevices, result);
 
     return result;
 }
 
-bool PostGetPhysicalDeviceFeatures(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceFeatures* pFeatures)
-{
+bool PostGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+                                   VkPhysicalDeviceFeatures *pFeatures) {
 
-    if(pFeatures != nullptr)
-    {
+    if (pFeatures != nullptr) {
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceFeatures* pFeatures)
-{
-    get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+                                VkPhysicalDeviceFeatures *pFeatures) {
+    get_dispatch_table(pc_instance_table_map, physicalDevice)
+        ->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
 
     PostGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
 }
 
-bool PostGetPhysicalDeviceFormatProperties(
-    VkPhysicalDevice physicalDevice,
-    VkFormat format,
-    VkFormatProperties* pFormatProperties)
-{
+bool
+PostGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
+                                      VkFormat format,
+                                      VkFormatProperties *pFormatProperties) {
 
-    if(format < VK_FORMAT_BEGIN_RANGE ||
-        format > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetPhysicalDeviceFormatProperties parameter, VkFormat format, is an unrecognized enumerator");
+    if (format < VK_FORMAT_BEGIN_RANGE || format > VK_FORMAT_END_RANGE) {
+        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkGetPhysicalDeviceFormatProperties parameter, VkFormat "
+                "format, is an unrecognized enumerator");
         return false;
     }
 
-    if(pFormatProperties != nullptr)
-    {
+    if (pFormatProperties != nullptr) {
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
-    VkPhysicalDevice physicalDevice,
-    VkFormat format,
-    VkFormatProperties* pFormatProperties)
-{
-    get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
+                                        VkFormat format,
+                                        VkFormatProperties *pFormatProperties) {
+    get_dispatch_table(pc_instance_table_map, physicalDevice)
+        ->GetPhysicalDeviceFormatProperties(physicalDevice, format,
+                                            pFormatProperties);
 
-    PostGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+    PostGetPhysicalDeviceFormatProperties(physicalDevice, format,
+                                          pFormatProperties);
 }
 
 bool PostGetPhysicalDeviceImageFormatProperties(
-    VkPhysicalDevice physicalDevice,
-    VkFormat format,
-    VkImageType type,
-    VkImageTiling tiling,
-    VkImageUsageFlags usage,
-    VkImageCreateFlags flags,
-    VkImageFormatProperties* pImageFormatProperties,
-    VkResult result)
-{
+    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
+    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
+    VkImageFormatProperties *pImageFormatProperties, VkResult result) {
 
-    if(format < VK_FORMAT_BEGIN_RANGE ||
-        format > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetPhysicalDeviceImageFormatProperties parameter, VkFormat format, is an unrecognized enumerator");
+    if (format < VK_FORMAT_BEGIN_RANGE || format > VK_FORMAT_END_RANGE) {
+        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkGetPhysicalDeviceImageFormatProperties parameter, VkFormat "
+                "format, is an unrecognized enumerator");
         return false;
     }
 
-    if(type < VK_IMAGE_TYPE_BEGIN_RANGE ||
-        type > VK_IMAGE_TYPE_END_RANGE)
-    {
-        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetPhysicalDeviceImageFormatProperties parameter, VkImageType type, is an unrecognized enumerator");
+    if (type < VK_IMAGE_TYPE_BEGIN_RANGE || type > VK_IMAGE_TYPE_END_RANGE) {
+        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkGetPhysicalDeviceImageFormatProperties parameter, "
+                "VkImageType type, is an unrecognized enumerator");
         return false;
     }
 
-    if(tiling < VK_IMAGE_TILING_BEGIN_RANGE ||
-        tiling > VK_IMAGE_TILING_END_RANGE)
-    {
-        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetPhysicalDeviceImageFormatProperties parameter, VkImageTiling tiling, is an unrecognized enumerator");
+    if (tiling < VK_IMAGE_TILING_BEGIN_RANGE ||
+        tiling > VK_IMAGE_TILING_END_RANGE) {
+        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkGetPhysicalDeviceImageFormatProperties parameter, "
+                "VkImageTiling tiling, is an unrecognized enumerator");
         return false;
     }
 
-
-    if(pImageFormatProperties != nullptr)
-    {
+    if (pImageFormatProperties != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkGetPhysicalDeviceImageFormatProperties parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkGetPhysicalDeviceImageFormatProperties "
+                             "parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
-    VkPhysicalDevice physicalDevice,
-    VkFormat format,
-    VkImageType type,
-    VkImageTiling tiling,
-    VkImageUsageFlags usage,
-    VkImageCreateFlags flags,
-    VkImageFormatProperties* pImageFormatProperties)
-{
-    VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkGetPhysicalDeviceImageFormatProperties(
+        VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
+        VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
+        VkImageFormatProperties *pImageFormatProperties) {
+    VkResult result = get_dispatch_table(pc_instance_table_map, physicalDevice)
+                          ->GetPhysicalDeviceImageFormatProperties(
+                              physicalDevice, format, type, tiling, usage,
+                              flags, pImageFormatProperties);
 
-    PostGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, result);
+    PostGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type,
+                                               tiling, usage, flags,
+                                               pImageFormatProperties, result);
 
     return result;
 }
 
-bool PostGetPhysicalDeviceProperties(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceProperties* pProperties)
-{
+bool PostGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+                                     VkPhysicalDeviceProperties *pProperties) {
 
-    if(pProperties != nullptr)
-    {
-    if(pProperties->deviceType < VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE ||
-        pProperties->deviceType > VK_PHYSICAL_DEVICE_TYPE_END_RANGE)
-    {
-        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetPhysicalDeviceProperties parameter, VkPhysicalDeviceType pProperties->deviceType, is an unrecognized enumerator");
-        return false;
-    }
+    if (pProperties != nullptr) {
+        if (pProperties->deviceType < VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE ||
+            pProperties->deviceType > VK_PHYSICAL_DEVICE_TYPE_END_RANGE) {
+            log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkGetPhysicalDeviceProperties parameter, "
+                    "VkPhysicalDeviceType pProperties->deviceType, is an "
+                    "unrecognized enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceProperties* pProperties)
-{
-    get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+                                  VkPhysicalDeviceProperties *pProperties) {
+    get_dispatch_table(pc_instance_table_map, physicalDevice)
+        ->GetPhysicalDeviceProperties(physicalDevice, pProperties);
 
     PostGetPhysicalDeviceProperties(physicalDevice, pProperties);
 }
 
 bool PostGetPhysicalDeviceQueueFamilyProperties(
-    VkPhysicalDevice physicalDevice,
-    uint32_t* pCount,
-    VkQueueFamilyProperties* pQueueProperties)
-{
+    VkPhysicalDevice physicalDevice, uint32_t *pCount,
+    VkQueueFamilyProperties *pQueueProperties) {
 
-    if(pQueueProperties == nullptr && pCount != nullptr)
-    {
+    if (pQueueProperties == nullptr && pCount != nullptr) {
     }
 
-    if(pQueueProperties != nullptr)
-    {
+    if (pQueueProperties != nullptr) {
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
-    VkPhysicalDevice physicalDevice,
-    uint32_t* pCount,
-    VkQueueFamilyProperties* pQueueProperties)
-{
-    get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueProperties);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetPhysicalDeviceQueueFamilyProperties(
+        VkPhysicalDevice physicalDevice, uint32_t *pCount,
+        VkQueueFamilyProperties *pQueueProperties) {
+    get_dispatch_table(pc_instance_table_map, physicalDevice)
+        ->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount,
+                                                 pQueueProperties);
 
-    PostGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueProperties);
+    PostGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount,
+                                               pQueueProperties);
 }
 
 bool PostGetPhysicalDeviceMemoryProperties(
     VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceMemoryProperties* pMemoryProperties)
-{
+    VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
 
-    if(pMemoryProperties != nullptr)
-    {
+    if (pMemoryProperties != nullptr) {
     }
 
     return true;
@@ -2053,66 +1722,99 @@
 
 VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
     VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceMemoryProperties* pMemoryProperties)
-{
-    get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+    VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
+    get_dispatch_table(pc_instance_table_map, physicalDevice)
+        ->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
 
     PostGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
 }
 
-void validateDeviceCreateInfo(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const std::vector<VkQueueFamilyProperties> properties) {
+void validateDeviceCreateInfo(
+    VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
+    const std::vector<VkQueueFamilyProperties> properties) {
     std::unordered_set<uint32_t> set;
     for (uint32_t i = 0; i < pCreateInfo->queueCreateInfoCount; ++i) {
         if (set.count(pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex)) {
-            log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-                "VkDeviceCreateInfo parameter, uint32_t pQueueCreateInfos[%d]->queueFamilyIndex, is not unique within this structure.", i);
+            log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "VkDeviceCreateInfo parameter, uint32_t "
+                    "pQueueCreateInfos[%d]->queueFamilyIndex, is not unique "
+                    "within this structure.",
+                    i);
         } else {
             set.insert(pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex);
         }
         if (pCreateInfo->pQueueCreateInfos[i].queueCount == 0) {
-            log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-                "VkDeviceCreateInfo parameter, uint32_t pQueueCreateInfos[%d]->queueCount, cannot be zero.", i);
+            log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "VkDeviceCreateInfo parameter, uint32_t "
+                    "pQueueCreateInfos[%d]->queueCount, cannot be zero.",
+                    i);
         }
-        for (uint32_t j = 0; j < pCreateInfo->pQueueCreateInfos[i].queueCount; ++j) {
-            if (pCreateInfo->pQueueCreateInfos[i].pQueuePriorities[j] < 0.f || pCreateInfo->pQueueCreateInfos[i].pQueuePriorities[j] > 1.f) {
-                log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-                    "VkDeviceCreateInfo parameter, uint32_t pQueueCreateInfos[%d]->pQueuePriorities[%d], must be between 0 and 1. Actual value is %f", i, j, pCreateInfo->pQueueCreateInfos[i].pQueuePriorities[j]);
+        for (uint32_t j = 0; j < pCreateInfo->pQueueCreateInfos[i].queueCount;
+             ++j) {
+            if (pCreateInfo->pQueueCreateInfos[i].pQueuePriorities[j] < 0.f ||
+                pCreateInfo->pQueueCreateInfos[i].pQueuePriorities[j] > 1.f) {
+                log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "VkDeviceCreateInfo parameter, uint32_t "
+                                      "pQueueCreateInfos[%d]->pQueuePriorities["
+                                      "%d], must be between 0 and 1. Actual "
+                                      "value is %f",
+                        i, j,
+                        pCreateInfo->pQueueCreateInfos[i].pQueuePriorities[j]);
             }
         }
-        if (pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex >= properties.size()) {
-            log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-                "VkDeviceCreateInfo parameter, uint32_t pQueueCreateInfos[%d]->queueFamilyIndex cannot be more than the number of queue families.", i);
-        } else if (pCreateInfo->pQueueCreateInfos[i].queueCount > properties[pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex].queueCount) {
-            log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-                "VkDeviceCreateInfo parameter, uint32_t pQueueCreateInfos[%d]->queueCount cannot be more than the number of queues for the given family index.", i);
+        if (pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex >=
+            properties.size()) {
+            log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "VkDeviceCreateInfo parameter, uint32_t "
+                    "pQueueCreateInfos[%d]->queueFamilyIndex cannot be more "
+                    "than the number of queue families.",
+                    i);
+        } else if (pCreateInfo->pQueueCreateInfos[i].queueCount >
+                   properties[pCreateInfo->pQueueCreateInfos[i]
+                                  .queueFamilyIndex].queueCount) {
+            log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "VkDeviceCreateInfo parameter, uint32_t "
+                    "pQueueCreateInfos[%d]->queueCount cannot be more than the "
+                    "number of queues for the given family index.",
+                    i);
         }
     }
 }
 
-void storeCreateDeviceData(VkDevice device, const VkDeviceCreateInfo* pCreateInfo) {
-    layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+void storeCreateDeviceData(VkDevice device,
+                           const VkDeviceCreateInfo *pCreateInfo) {
+    layer_data *my_device_data =
+        get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     for (uint32_t i = 0; i < pCreateInfo->queueCreateInfoCount; ++i) {
         my_device_data->queueFamilyIndexMap.insert(
-            std::make_pair(pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex, pCreateInfo->pQueueCreateInfos[i].queueCount));
+            std::make_pair(pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex,
+                           pCreateInfo->pQueueCreateInfos[i].queueCount));
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
-    VkPhysicalDevice physicalDevice,
-    const VkDeviceCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkDevice* pDevice)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateDevice(VkPhysicalDevice physicalDevice,
+                   const VkDeviceCreateInfo *pCreateInfo,
+                   const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
     /*
      * NOTE: We do not validate physicalDevice or any dispatchable
      * object as the first parameter. We couldn't get here if it was wrong!
      */
-    VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
+    VkLayerDeviceCreateInfo *chain_info =
+        get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
 
     assert(chain_info->u.pLayerInfo);
-    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
-    PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
-    PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice) fpGetInstanceProcAddr(NULL, "vkCreateDevice");
+    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr =
+        chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
+    PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr =
+        chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
+    PFN_vkCreateDevice fpCreateDevice =
+        (PFN_vkCreateDevice)fpGetInstanceProcAddr(NULL, "vkCreateDevice");
     if (fpCreateDevice == NULL) {
         return VK_ERROR_INITIALIZATION_FAILED;
     }
@@ -2120,20 +1822,28 @@
     // Advance the link info for the next element on the chain
     chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
 
-    VkResult result = fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+    VkResult result =
+        fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
     if (result != VK_SUCCESS) {
         return result;
     }
 
-    layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
-    layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
-    my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
+    layer_data *my_instance_data =
+        get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+    layer_data *my_device_data =
+        get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
+    my_device_data->report_data = layer_debug_report_create_device(
+        my_instance_data->report_data, *pDevice);
     initDeviceTable(*pDevice, fpGetDeviceProcAddr, pc_device_table_map);
 
     uint32_t count;
-    get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, &count, nullptr);
+    get_dispatch_table(pc_instance_table_map, physicalDevice)
+        ->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, &count,
+                                                 nullptr);
     std::vector<VkQueueFamilyProperties> properties(count);
-    get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, &count, &properties[0]);
+    get_dispatch_table(pc_instance_table_map, physicalDevice)
+        ->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, &count,
+                                                 &properties[0]);
 
     validateDeviceCreateInfo(physicalDevice, pCreateInfo, properties);
     storeCreateDeviceData(*pDevice, pCreateInfo);
@@ -2141,10 +1851,8 @@
     return result;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
-    VkDevice device,
-    const VkAllocationCallbacks* pAllocator)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
     layer_debug_report_destroy_device(device);
 
     dispatch_key key = get_dispatch_key(device);
@@ -2152,2196 +1860,2178 @@
     fprintf(stderr, "Device: %p, key: %p\n", device, key);
 #endif
 
-    get_dispatch_table(pc_device_table_map, device)->DestroyDevice(device, pAllocator);
+    get_dispatch_table(pc_device_table_map, device)
+        ->DestroyDevice(device, pAllocator);
     pc_device_table_map.erase(key);
 }
 
-bool PreGetDeviceQueue(
-    VkDevice device,
-    uint32_t queueFamilyIndex,
-    uint32_t queueIndex)
-{
-    layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    auto queue_data = my_device_data->queueFamilyIndexMap.find(queueFamilyIndex);
+bool PreGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex,
+                       uint32_t queueIndex) {
+    layer_data *my_device_data =
+        get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+    auto queue_data =
+        my_device_data->queueFamilyIndexMap.find(queueFamilyIndex);
     if (queue_data == my_device_data->queueFamilyIndexMap.end()) {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-            "VkGetDeviceQueue parameter, uint32_t queueFamilyIndex %d, must have been given when the device was created.", queueFamilyIndex);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "VkGetDeviceQueue parameter, uint32_t queueFamilyIndex %d, "
+                "must have been given when the device was created.",
+                queueFamilyIndex);
         return false;
     }
     if (queue_data->second <= queueIndex) {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-            "VkGetDeviceQueue parameter, uint32_t queueIndex %d, must be less than the number of queues given when the device was created.", queueIndex);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "VkGetDeviceQueue parameter, uint32_t queueIndex %d, must be "
+                "less than the number of queues given when the device was "
+                "created.",
+                queueIndex);
         return false;
     }
     return true;
 }
 
-bool PostGetDeviceQueue(
-    VkDevice device,
-    uint32_t queueFamilyIndex,
-    uint32_t queueIndex,
-    VkQueue* pQueue)
-{
+bool PostGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex,
+                        uint32_t queueIndex, VkQueue *pQueue) {
 
-
-
-    if(pQueue != nullptr)
-    {
+    if (pQueue != nullptr) {
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
-    VkDevice device,
-    uint32_t queueFamilyIndex,
-    uint32_t queueIndex,
-    VkQueue* pQueue)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex,
+                     uint32_t queueIndex, VkQueue *pQueue) {
     PreGetDeviceQueue(device, queueFamilyIndex, queueIndex);
 
-    get_dispatch_table(pc_device_table_map, device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+    get_dispatch_table(pc_device_table_map, device)
+        ->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
 
     PostGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
 }
 
-bool PreQueueSubmit(
-    VkQueue queue,
-    const VkSubmitInfo* submit)
-{
-    if(submit->sType != VK_STRUCTURE_TYPE_SUBMIT_INFO) {
-        log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkQueueSubmit parameter, VkStructureType pSubmits->sType, is an invalid enumerator");
+bool PreQueueSubmit(VkQueue queue, const VkSubmitInfo *submit) {
+    if (submit->sType != VK_STRUCTURE_TYPE_SUBMIT_INFO) {
+        log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkQueueSubmit parameter, VkStructureType pSubmits->sType, is "
+                "an invalid enumerator");
         return false;
     }
 
-    if(submit->pCommandBuffers != nullptr)
-    {
+    if (submit->pCommandBuffers != nullptr) {
     }
 
     return true;
 }
 
-bool PostQueueSubmit(
-    VkQueue queue,
-    uint32_t commandBufferCount,
-    VkFence fence,
-    VkResult result)
-{
+bool PostQueueSubmit(VkQueue queue, uint32_t commandBufferCount, VkFence fence,
+                     VkResult result) {
 
-
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkQueueSubmit parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkQueueSubmit parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
-    VkQueue queue,
-    uint32_t submitCount,
-    const VkSubmitInfo* pSubmits,
-    VkFence fence)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkQueueSubmit(VkQueue queue, uint32_t submitCount,
+                  const VkSubmitInfo *pSubmits, VkFence fence) {
     for (uint32_t i = 0; i < submitCount; i++) {
         PreQueueSubmit(queue, &pSubmits[i]);
     }
 
-    VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueSubmit(queue, submitCount, pSubmits, fence);
+    VkResult result = get_dispatch_table(pc_device_table_map, queue)
+                          ->QueueSubmit(queue, submitCount, pSubmits, fence);
 
     PostQueueSubmit(queue, submitCount, fence, result);
 
     return result;
 }
 
-bool PostQueueWaitIdle(
-    VkQueue queue,
-    VkResult result)
-{
+bool PostQueueWaitIdle(VkQueue queue, VkResult result) {
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkQueueWaitIdle parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkQueueWaitIdle parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
-    VkQueue queue)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueWaitIdle(queue);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) {
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, queue)->QueueWaitIdle(queue);
 
     PostQueueWaitIdle(queue, result);
 
     return result;
 }
 
-bool PostDeviceWaitIdle(
-    VkDevice device,
-    VkResult result)
-{
+bool PostDeviceWaitIdle(VkDevice device, VkResult result) {
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkDeviceWaitIdle parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkDeviceWaitIdle parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
-    VkDevice device)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->DeviceWaitIdle(device);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkDeviceWaitIdle(VkDevice device) {
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)->DeviceWaitIdle(device);
 
     PostDeviceWaitIdle(device, result);
 
     return result;
 }
 
-bool PreAllocateMemory(
-    VkDevice device,
-    const VkMemoryAllocateInfo* pAllocateInfo)
-{
-    if(pAllocateInfo != nullptr)
-    {
-    if(pAllocateInfo->sType != VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkAllocateMemory parameter, VkStructureType pAllocateInfo->sType, is an invalid enumerator");
-        return false;
-    }
+bool PreAllocateMemory(VkDevice device,
+                       const VkMemoryAllocateInfo *pAllocateInfo) {
+    if (pAllocateInfo != nullptr) {
+        if (pAllocateInfo->sType != VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkAllocateMemory parameter, VkStructureType "
+                    "pAllocateInfo->sType, is an invalid enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostAllocateMemory(
-    VkDevice device,
-    VkDeviceMemory* pMemory,
-    VkResult result)
-{
+bool PostAllocateMemory(VkDevice device, VkDeviceMemory *pMemory,
+                        VkResult result) {
 
-    if(pMemory != nullptr)
-    {
+    if (pMemory != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkAllocateMemory parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkAllocateMemory parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
-    VkDevice device,
-    const VkMemoryAllocateInfo* pAllocateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkDeviceMemory* pMemory)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
+                     const VkAllocationCallbacks *pAllocator,
+                     VkDeviceMemory *pMemory) {
     PreAllocateMemory(device, pAllocateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
 
     PostAllocateMemory(device, pMemory, result);
 
     return result;
 }
 
-bool PostMapMemory(
-    VkDevice device,
-    VkDeviceMemory mem,
-    VkDeviceSize offset,
-    VkDeviceSize size,
-    VkMemoryMapFlags flags,
-    void** ppData,
-    VkResult result)
-{
+bool PostMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset,
+                   VkDeviceSize size, VkMemoryMapFlags flags, void **ppData,
+                   VkResult result) {
 
-
-
-
-
-    if(ppData != nullptr)
-    {
+    if (ppData != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkMapMemory parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkMapMemory parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
-    VkDevice device,
-    VkDeviceMemory mem,
-    VkDeviceSize offset,
-    VkDeviceSize size,
-    VkMemoryMapFlags flags,
-    void** ppData)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->MapMemory(device, mem, offset, size, flags, ppData);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset,
+                VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) {
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->MapMemory(device, mem, offset, size, flags, ppData);
 
     PostMapMemory(device, mem, offset, size, flags, ppData, result);
 
     return result;
 }
 
-bool PreFlushMappedMemoryRanges(
-    VkDevice device,
-    const VkMappedMemoryRange* pMemoryRanges)
-{
-    if(pMemoryRanges != nullptr)
-    {
-    if(pMemoryRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkFlushMappedMemoryRanges parameter, VkStructureType pMemoryRanges->sType, is an invalid enumerator");
-        return false;
-    }
+bool PreFlushMappedMemoryRanges(VkDevice device,
+                                const VkMappedMemoryRange *pMemoryRanges) {
+    if (pMemoryRanges != nullptr) {
+        if (pMemoryRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkFlushMappedMemoryRanges parameter, VkStructureType "
+                    "pMemoryRanges->sType, is an invalid enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostFlushMappedMemoryRanges(
-    VkDevice device,
-    uint32_t memoryRangeCount,
-    VkResult result)
-{
+bool PostFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                 VkResult result) {
 
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkFlushMappedMemoryRanges parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkFlushMappedMemoryRanges parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
-    VkDevice device,
-    uint32_t memoryRangeCount,
-    const VkMappedMemoryRange* pMemoryRanges)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                              const VkMappedMemoryRange *pMemoryRanges) {
     PreFlushMappedMemoryRanges(device, pMemoryRanges);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
 
     PostFlushMappedMemoryRanges(device, memoryRangeCount, result);
 
     return result;
 }
 
-bool PreInvalidateMappedMemoryRanges(
-    VkDevice device,
-    const VkMappedMemoryRange* pMemoryRanges)
-{
-    if(pMemoryRanges != nullptr)
-    {
-    if(pMemoryRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkInvalidateMappedMemoryRanges parameter, VkStructureType pMemoryRanges->sType, is an invalid enumerator");
-        return false;
-    }
+bool PreInvalidateMappedMemoryRanges(VkDevice device,
+                                     const VkMappedMemoryRange *pMemoryRanges) {
+    if (pMemoryRanges != nullptr) {
+        if (pMemoryRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkInvalidateMappedMemoryRanges parameter, VkStructureType "
+                    "pMemoryRanges->sType, is an invalid enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostInvalidateMappedMemoryRanges(
-    VkDevice device,
-    uint32_t memoryRangeCount,
-    VkResult result)
-{
+bool PostInvalidateMappedMemoryRanges(VkDevice device,
+                                      uint32_t memoryRangeCount,
+                                      VkResult result) {
 
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkInvalidateMappedMemoryRanges parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkInvalidateMappedMemoryRanges parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
-    VkDevice device,
-    uint32_t memoryRangeCount,
-    const VkMappedMemoryRange* pMemoryRanges)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                   const VkMappedMemoryRange *pMemoryRanges) {
     PreInvalidateMappedMemoryRanges(device, pMemoryRanges);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->InvalidateMappedMemoryRanges(
+                              device, memoryRangeCount, pMemoryRanges);
 
     PostInvalidateMappedMemoryRanges(device, memoryRangeCount, result);
 
     return result;
 }
 
-bool PostGetDeviceMemoryCommitment(
-    VkDevice device,
-    VkDeviceMemory memory,
-    VkDeviceSize* pCommittedMemoryInBytes)
-{
+bool PostGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+                                   VkDeviceSize *pCommittedMemoryInBytes) {
 
-
-    if(pCommittedMemoryInBytes != nullptr)
-    {
+    if (pCommittedMemoryInBytes != nullptr) {
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
-    VkDevice device,
-    VkDeviceMemory memory,
-    VkDeviceSize* pCommittedMemoryInBytes)
-{
-    get_dispatch_table(pc_device_table_map, device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+                                VkDeviceSize *pCommittedMemoryInBytes) {
+    get_dispatch_table(pc_device_table_map, device)
+        ->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
 
     PostGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
 }
 
-bool PostBindBufferMemory(
-    VkDevice device,
-    VkBuffer buffer,
-    VkDeviceMemory mem,
-    VkDeviceSize memoryOffset,
-    VkResult result)
-{
+bool PostBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
+                          VkDeviceSize memoryOffset, VkResult result) {
 
-
-
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkBindBufferMemory parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkBindBufferMemory parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
-    VkDevice device,
-    VkBuffer buffer,
-    VkDeviceMemory mem,
-    VkDeviceSize memoryOffset)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->BindBufferMemory(device, buffer, mem, memoryOffset);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
+                       VkDeviceSize memoryOffset) {
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->BindBufferMemory(device, buffer, mem, memoryOffset);
 
     PostBindBufferMemory(device, buffer, mem, memoryOffset, result);
 
     return result;
 }
 
-bool PostBindImageMemory(
-    VkDevice device,
-    VkImage image,
-    VkDeviceMemory mem,
-    VkDeviceSize memoryOffset,
-    VkResult result)
-{
+bool PostBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
+                         VkDeviceSize memoryOffset, VkResult result) {
 
-
-
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkBindImageMemory parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkBindImageMemory parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
-    VkDevice device,
-    VkImage image,
-    VkDeviceMemory mem,
-    VkDeviceSize memoryOffset)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->BindImageMemory(device, image, mem, memoryOffset);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
+                      VkDeviceSize memoryOffset) {
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->BindImageMemory(device, image, mem, memoryOffset);
 
     PostBindImageMemory(device, image, mem, memoryOffset, result);
 
     return result;
 }
 
-bool PostGetBufferMemoryRequirements(
-    VkDevice device,
-    VkBuffer buffer,
-    VkMemoryRequirements* pMemoryRequirements)
-{
+bool
+PostGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+                                VkMemoryRequirements *pMemoryRequirements) {
 
-
-    if(pMemoryRequirements != nullptr)
-    {
+    if (pMemoryRequirements != nullptr) {
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
-    VkDevice device,
-    VkBuffer buffer,
-    VkMemoryRequirements* pMemoryRequirements)
-{
-    get_dispatch_table(pc_device_table_map, device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+                                  VkMemoryRequirements *pMemoryRequirements) {
+    get_dispatch_table(pc_device_table_map, device)
+        ->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
 
     PostGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
 }
 
-bool PostGetImageMemoryRequirements(
-    VkDevice device,
-    VkImage image,
-    VkMemoryRequirements* pMemoryRequirements)
-{
+bool PostGetImageMemoryRequirements(VkDevice device, VkImage image,
+                                    VkMemoryRequirements *pMemoryRequirements) {
 
-
-    if(pMemoryRequirements != nullptr)
-    {
+    if (pMemoryRequirements != nullptr) {
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
-    VkDevice device,
-    VkImage image,
-    VkMemoryRequirements* pMemoryRequirements)
-{
-    get_dispatch_table(pc_device_table_map, device)->GetImageMemoryRequirements(device, image, pMemoryRequirements);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetImageMemoryRequirements(VkDevice device, VkImage image,
+                                 VkMemoryRequirements *pMemoryRequirements) {
+    get_dispatch_table(pc_device_table_map, device)
+        ->GetImageMemoryRequirements(device, image, pMemoryRequirements);
 
     PostGetImageMemoryRequirements(device, image, pMemoryRequirements);
 }
 
 bool PostGetImageSparseMemoryRequirements(
-    VkDevice device,
-    VkImage image,
-    uint32_t* pNumRequirements,
-    VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
-{
+    VkDevice device, VkImage image, uint32_t *pNumRequirements,
+    VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
 
-
-    if(pNumRequirements != nullptr)
-    {
+    if (pNumRequirements != nullptr) {
     }
 
-    if(pSparseMemoryRequirements != nullptr)
-    {
-    if ((pSparseMemoryRequirements->formatProperties.aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetImageSparseMemoryRequirements parameter, VkImageAspect pSparseMemoryRequirements->formatProperties.aspectMask, is an unrecognized enumerator");
-        return false;
-    }
+    if (pSparseMemoryRequirements != nullptr) {
+        if ((pSparseMemoryRequirements->formatProperties.aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkGetImageSparseMemoryRequirements parameter, "
+                    "VkImageAspect "
+                    "pSparseMemoryRequirements->formatProperties.aspectMask, "
+                    "is an unrecognized enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
-    VkDevice device,
-    VkImage image,
-    uint32_t* pNumRequirements,
-    VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
-{
-    get_dispatch_table(pc_device_table_map, device)->GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+    VkDevice device, VkImage image, uint32_t *pNumRequirements,
+    VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
+    get_dispatch_table(pc_device_table_map, device)
+        ->GetImageSparseMemoryRequirements(device, image, pNumRequirements,
+                                           pSparseMemoryRequirements);
 
-    PostGetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+    PostGetImageSparseMemoryRequirements(device, image, pNumRequirements,
+                                         pSparseMemoryRequirements);
 }
 
 bool PostGetPhysicalDeviceSparseImageFormatProperties(
-    VkPhysicalDevice physicalDevice,
-    VkFormat format,
-    VkImageType type,
-    VkSampleCountFlagBits samples,
-    VkImageUsageFlags usage,
-    VkImageTiling tiling,
-    uint32_t* pNumProperties,
-    VkSparseImageFormatProperties* pProperties)
-{
+    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
+    VkSampleCountFlagBits samples, VkImageUsageFlags usage,
+    VkImageTiling tiling, uint32_t *pNumProperties,
+    VkSparseImageFormatProperties *pProperties) {
 
-    if(format < VK_FORMAT_BEGIN_RANGE ||
-        format > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetPhysicalDeviceSparseImageFormatProperties parameter, VkFormat format, is an unrecognized enumerator");
+    if (format < VK_FORMAT_BEGIN_RANGE || format > VK_FORMAT_END_RANGE) {
+        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkGetPhysicalDeviceSparseImageFormatProperties parameter, "
+                "VkFormat format, is an unrecognized enumerator");
         return false;
     }
 
-    if(type < VK_IMAGE_TYPE_BEGIN_RANGE ||
-        type > VK_IMAGE_TYPE_END_RANGE)
-    {
-        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetPhysicalDeviceSparseImageFormatProperties parameter, VkImageType type, is an unrecognized enumerator");
+    if (type < VK_IMAGE_TYPE_BEGIN_RANGE || type > VK_IMAGE_TYPE_END_RANGE) {
+        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkGetPhysicalDeviceSparseImageFormatProperties parameter, "
+                "VkImageType type, is an unrecognized enumerator");
         return false;
     }
 
-
-
-    if(tiling < VK_IMAGE_TILING_BEGIN_RANGE ||
-        tiling > VK_IMAGE_TILING_END_RANGE)
-    {
-        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetPhysicalDeviceSparseImageFormatProperties parameter, VkImageTiling tiling, is an unrecognized enumerator");
+    if (tiling < VK_IMAGE_TILING_BEGIN_RANGE ||
+        tiling > VK_IMAGE_TILING_END_RANGE) {
+        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkGetPhysicalDeviceSparseImageFormatProperties parameter, "
+                "VkImageTiling tiling, is an unrecognized enumerator");
         return false;
     }
 
-    if(pNumProperties != nullptr)
-    {
+    if (pNumProperties != nullptr) {
     }
 
-    if(pProperties != nullptr)
-    {
-    if ((pProperties->aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetPhysicalDeviceSparseImageFormatProperties parameter, VkImageAspect pProperties->aspectMask, is an unrecognized enumerator");
-        return false;
-    }
+    if (pProperties != nullptr) {
+        if ((pProperties->aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkGetPhysicalDeviceSparseImageFormatProperties parameter, "
+                    "VkImageAspect pProperties->aspectMask, is an unrecognized "
+                    "enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
-    VkPhysicalDevice physicalDevice,
-    VkFormat format,
-    VkImageType type,
-    VkSampleCountFlagBits samples,
-    VkImageUsageFlags usage,
-    VkImageTiling tiling,
-    uint32_t* pNumProperties,
-    VkSparseImageFormatProperties* pProperties)
-{
-    get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetPhysicalDeviceSparseImageFormatProperties(
+        VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
+        VkSampleCountFlagBits samples, VkImageUsageFlags usage,
+        VkImageTiling tiling, uint32_t *pNumProperties,
+        VkSparseImageFormatProperties *pProperties) {
+    get_dispatch_table(pc_instance_table_map, physicalDevice)
+        ->GetPhysicalDeviceSparseImageFormatProperties(
+            physicalDevice, format, type, samples, usage, tiling,
+            pNumProperties, pProperties);
 
-    PostGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+    PostGetPhysicalDeviceSparseImageFormatProperties(
+        physicalDevice, format, type, samples, usage, tiling, pNumProperties,
+        pProperties);
 }
 
-bool PreQueueBindSparse(
-    VkQueue queue,
-    uint32_t                                    bindInfoCount,
-    const VkBindSparseInfo*                     pBindInfo)
-{
-    if(pBindInfo != nullptr)
-    {
+bool PreQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+                        const VkBindSparseInfo *pBindInfo) {
+    if (pBindInfo != nullptr) {
     }
 
     return true;
 }
 
-bool PostQueueBindSparse(
-    VkQueue queue,
-    uint32_t bindInfoCount,
-    const VkBindSparseInfo* pBindInfo,
-    VkFence fence,
-    VkResult result)
-{
+bool PostQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+                         const VkBindSparseInfo *pBindInfo, VkFence fence,
+                         VkResult result) {
 
-
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkQueueBindSparse parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkQueueBindSparse parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
-    VkQueue queue,
-    uint32_t bindInfoCount,
-    const VkBindSparseInfo* pBindInfo,
-    VkFence fence)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+                      const VkBindSparseInfo *pBindInfo, VkFence fence) {
     PreQueueBindSparse(queue, bindInfoCount, pBindInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, queue)
+            ->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
 
     PostQueueBindSparse(queue, bindInfoCount, pBindInfo, fence, result);
 
     return result;
 }
 
-bool PreCreateFence(
-    VkDevice device,
-    const VkFenceCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_FENCE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateFence parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
+bool PreCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_FENCE_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateFence parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCreateFence(
-    VkDevice device,
-    VkFence* pFence,
-    VkResult result)
-{
+bool PostCreateFence(VkDevice device, VkFence *pFence, VkResult result) {
 
-    if(pFence != nullptr)
-    {
+    if (pFence != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateFence parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkCreateFence parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
-    VkDevice device,
-    const VkFenceCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkFence* pFence)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
+                  const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
     PreCreateFence(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFence(device, pCreateInfo, pAllocator, pFence);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateFence(device, pCreateInfo, pAllocator, pFence);
 
     PostCreateFence(device, pFence, result);
 
     return result;
 }
 
-bool PreResetFences(
-    VkDevice device,
-    const VkFence* pFences)
-{
-    if(pFences != nullptr)
-    {
+bool PreResetFences(VkDevice device, const VkFence *pFences) {
+    if (pFences != nullptr) {
     }
 
     return true;
 }
 
-bool PostResetFences(
-    VkDevice device,
-    uint32_t fenceCount,
-    VkResult result)
-{
+bool PostResetFences(VkDevice device, uint32_t fenceCount, VkResult result) {
 
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkResetFences parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkResetFences parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
-    VkDevice device,
-    uint32_t fenceCount,
-    const VkFence* pFences)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkResetFences(VkDevice device, uint32_t fenceCount,
+                  const VkFence *pFences) {
     PreResetFences(device, pFences);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetFences(device, fenceCount, pFences);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->ResetFences(device, fenceCount, pFences);
 
     PostResetFences(device, fenceCount, result);
 
     return result;
 }
 
-bool PostGetFenceStatus(
-    VkDevice device,
-    VkFence fence,
-    VkResult result)
-{
+bool PostGetFenceStatus(VkDevice device, VkFence fence, VkResult result) {
 
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkGetFenceStatus parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkGetFenceStatus parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
-    VkDevice device,
-    VkFence fence)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->GetFenceStatus(device, fence);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkGetFenceStatus(VkDevice device, VkFence fence) {
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->GetFenceStatus(device, fence);
 
     PostGetFenceStatus(device, fence, result);
 
     return result;
 }
 
-bool PreWaitForFences(
-    VkDevice device,
-    const VkFence* pFences)
-{
-    if(pFences != nullptr)
-    {
+bool PreWaitForFences(VkDevice device, const VkFence *pFences) {
+    if (pFences != nullptr) {
     }
 
     return true;
 }
 
-bool PostWaitForFences(
-    VkDevice device,
-    uint32_t fenceCount,
-    VkBool32 waitAll,
-    uint64_t timeout,
-    VkResult result)
-{
+bool PostWaitForFences(VkDevice device, uint32_t fenceCount, VkBool32 waitAll,
+                       uint64_t timeout, VkResult result) {
 
-
-
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkWaitForFences parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkWaitForFences parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
-    VkDevice device,
-    uint32_t fenceCount,
-    const VkFence* pFences,
-    VkBool32 waitAll,
-    uint64_t timeout)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkWaitForFences(VkDevice device, uint32_t fenceCount,
+                    const VkFence *pFences, VkBool32 waitAll,
+                    uint64_t timeout) {
     PreWaitForFences(device, pFences);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
 
     PostWaitForFences(device, fenceCount, waitAll, timeout, result);
 
     return result;
 }
 
-bool PreCreateSemaphore(
-    VkDevice device,
-    const VkSemaphoreCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateSemaphore parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
+bool PreCreateSemaphore(VkDevice device,
+                        const VkSemaphoreCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateSemaphore parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCreateSemaphore(
-    VkDevice device,
-    VkSemaphore* pSemaphore,
-    VkResult result)
-{
+bool PostCreateSemaphore(VkDevice device, VkSemaphore *pSemaphore,
+                         VkResult result) {
 
-    if(pSemaphore != nullptr)
-    {
+    if (pSemaphore != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateSemaphore parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateSemaphore parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
-    VkDevice device,
-    const VkSemaphoreCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkSemaphore* pSemaphore)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
+                      const VkAllocationCallbacks *pAllocator,
+                      VkSemaphore *pSemaphore) {
     PreCreateSemaphore(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
 
     PostCreateSemaphore(device, pSemaphore, result);
 
     return result;
 }
 
-bool PreCreateEvent(
-    VkDevice device,
-    const VkEventCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_EVENT_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateEvent parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
+bool PreCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_EVENT_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateEvent parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCreateEvent(
-    VkDevice device,
-    VkEvent* pEvent,
-    VkResult result)
-{
+bool PostCreateEvent(VkDevice device, VkEvent *pEvent, VkResult result) {
 
-    if(pEvent != nullptr)
-    {
+    if (pEvent != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateEvent parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkCreateEvent parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
-    VkDevice device,
-    const VkEventCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkEvent* pEvent)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
+                  const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
     PreCreateEvent(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
 
     PostCreateEvent(device, pEvent, result);
 
     return result;
 }
 
-bool PostGetEventStatus(
-    VkDevice device,
-    VkEvent event,
-    VkResult result)
-{
+bool PostGetEventStatus(VkDevice device, VkEvent event, VkResult result) {
 
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkGetEventStatus parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkGetEventStatus parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
-    VkDevice device,
-    VkEvent event)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->GetEventStatus(device, event);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkGetEventStatus(VkDevice device, VkEvent event) {
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->GetEventStatus(device, event);
 
     PostGetEventStatus(device, event, result);
 
     return result;
 }
 
-bool PostSetEvent(
-    VkDevice device,
-    VkEvent event,
-    VkResult result)
-{
+bool PostSetEvent(VkDevice device, VkEvent event, VkResult result) {
 
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkSetEvent parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkSetEvent parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
-    VkDevice device,
-    VkEvent event)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->SetEvent(device, event);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkSetEvent(VkDevice device, VkEvent event) {
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->SetEvent(device, event);
 
     PostSetEvent(device, event, result);
 
     return result;
 }
 
-bool PostResetEvent(
-    VkDevice device,
-    VkEvent event,
-    VkResult result)
-{
+bool PostResetEvent(VkDevice device, VkEvent event, VkResult result) {
 
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkResetEvent parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkResetEvent parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
-    VkDevice device,
-    VkEvent event)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetEvent(device, event);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkResetEvent(VkDevice device, VkEvent event) {
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->ResetEvent(device, event);
 
     PostResetEvent(device, event, result);
 
     return result;
 }
 
-bool PreCreateQueryPool(
-    VkDevice device,
-    const VkQueryPoolCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateQueryPool parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->queryType < VK_QUERY_TYPE_BEGIN_RANGE ||
-        pCreateInfo->queryType > VK_QUERY_TYPE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateQueryPool parameter, VkQueryType pCreateInfo->queryType, is an unrecognized enumerator");
-        return false;
-    }
+bool PreCreateQueryPool(VkDevice device,
+                        const VkQueryPoolCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateQueryPool parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->queryType < VK_QUERY_TYPE_BEGIN_RANGE ||
+            pCreateInfo->queryType > VK_QUERY_TYPE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateQueryPool parameter, VkQueryType "
+                    "pCreateInfo->queryType, is an unrecognized enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCreateQueryPool(
-    VkDevice device,
-    VkQueryPool* pQueryPool,
-    VkResult result)
-{
+bool PostCreateQueryPool(VkDevice device, VkQueryPool *pQueryPool,
+                         VkResult result) {
 
-    if(pQueryPool != nullptr)
-    {
+    if (pQueryPool != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateQueryPool parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateQueryPool parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
-    VkDevice device,
-    const VkQueryPoolCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkQueryPool* pQueryPool)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
+                      const VkAllocationCallbacks *pAllocator,
+                      VkQueryPool *pQueryPool) {
     PreCreateQueryPool(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
 
     PostCreateQueryPool(device, pQueryPool, result);
 
     return result;
 }
 
-bool PostGetQueryPoolResults(
-    VkDevice device,
-    VkQueryPool queryPool,
-    uint32_t firstQuery,
-    uint32_t queryCount,
-    size_t dataSize,
-    void* pData,
-    VkDeviceSize stride,
-    VkQueryResultFlags flags,
-    VkResult result)
-{
+bool PostGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
+                             uint32_t firstQuery, uint32_t queryCount,
+                             size_t dataSize, void *pData, VkDeviceSize stride,
+                             VkQueryResultFlags flags, VkResult result) {
 
-
-
-
-    if(pData != nullptr)
-    {
+    if (pData != nullptr) {
     }
 
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkGetQueryPoolResults parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkGetQueryPoolResults parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_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)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+VK_LAYER_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) {
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->GetQueryPoolResults(device, queryPool, firstQuery, queryCount,
+                                  dataSize, pData, stride, flags);
 
-    PostGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, result);
+    PostGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize,
+                            pData, stride, flags, result);
 
     return result;
 }
 
-bool PreCreateBuffer(
-    VkDevice device,
-    const VkBufferCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateBuffer parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->sharingMode < VK_SHARING_MODE_BEGIN_RANGE ||
-        pCreateInfo->sharingMode > VK_SHARING_MODE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateBuffer parameter, VkSharingMode pCreateInfo->sharingMode, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->pQueueFamilyIndices != nullptr)
-    {
-    }
+bool PreCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateBuffer parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->sharingMode < VK_SHARING_MODE_BEGIN_RANGE ||
+            pCreateInfo->sharingMode > VK_SHARING_MODE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateBuffer parameter, VkSharingMode "
+                    "pCreateInfo->sharingMode, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->pQueueFamilyIndices != nullptr) {
+        }
     }
 
     return true;
 }
 
-bool PostCreateBuffer(
-    VkDevice device,
-    VkBuffer* pBuffer,
-    VkResult result)
-{
+bool PostCreateBuffer(VkDevice device, VkBuffer *pBuffer, VkResult result) {
 
-    if(pBuffer != nullptr)
-    {
+    if (pBuffer != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateBuffer parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkCreateBuffer parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
-    VkDevice device,
-    const VkBufferCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkBuffer* pBuffer)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
+                   const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
     PreCreateBuffer(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
 
     PostCreateBuffer(device, pBuffer, result);
 
     return result;
 }
 
-bool PreCreateBufferView(
-    VkDevice device,
-    const VkBufferViewCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateBufferView parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
-        pCreateInfo->format > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateBufferView parameter, VkFormat pCreateInfo->format, is an unrecognized enumerator");
-        return false;
-    }
+bool PreCreateBufferView(VkDevice device,
+                         const VkBufferViewCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateBufferView parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
+            pCreateInfo->format > VK_FORMAT_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateBufferView parameter, VkFormat "
+                    "pCreateInfo->format, is an unrecognized enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCreateBufferView(
-    VkDevice device,
-    VkBufferView* pView,
-    VkResult result)
-{
+bool PostCreateBufferView(VkDevice device, VkBufferView *pView,
+                          VkResult result) {
 
-    if(pView != nullptr)
-    {
+    if (pView != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateBufferView parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateBufferView parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
-    VkDevice device,
-    const VkBufferViewCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkBufferView* pView)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateBufferView(VkDevice device,
+                       const VkBufferViewCreateInfo *pCreateInfo,
+                       const VkAllocationCallbacks *pAllocator,
+                       VkBufferView *pView) {
     PreCreateBufferView(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBufferView(device, pCreateInfo, pAllocator, pView);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateBufferView(device, pCreateInfo, pAllocator, pView);
 
     PostCreateBufferView(device, pView, result);
 
     return result;
 }
 
-bool PreCreateImage(
-    VkDevice device,
-    const VkImageCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImage parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->imageType < VK_IMAGE_TYPE_BEGIN_RANGE ||
-        pCreateInfo->imageType > VK_IMAGE_TYPE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImage parameter, VkImageType pCreateInfo->imageType, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
-        pCreateInfo->format > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImage parameter, VkFormat pCreateInfo->format, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->tiling < VK_IMAGE_TILING_BEGIN_RANGE ||
-        pCreateInfo->tiling > VK_IMAGE_TILING_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImage parameter, VkImageTiling pCreateInfo->tiling, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->sharingMode < VK_SHARING_MODE_BEGIN_RANGE ||
-        pCreateInfo->sharingMode > VK_SHARING_MODE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImage parameter, VkSharingMode pCreateInfo->sharingMode, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->pQueueFamilyIndices != nullptr)
-    {
-    }
+bool PreCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImage parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->imageType < VK_IMAGE_TYPE_BEGIN_RANGE ||
+            pCreateInfo->imageType > VK_IMAGE_TYPE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImage parameter, VkImageType "
+                    "pCreateInfo->imageType, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
+            pCreateInfo->format > VK_FORMAT_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImage parameter, VkFormat pCreateInfo->format, is "
+                    "an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->tiling < VK_IMAGE_TILING_BEGIN_RANGE ||
+            pCreateInfo->tiling > VK_IMAGE_TILING_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImage parameter, VkImageTiling "
+                    "pCreateInfo->tiling, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->sharingMode < VK_SHARING_MODE_BEGIN_RANGE ||
+            pCreateInfo->sharingMode > VK_SHARING_MODE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImage parameter, VkSharingMode "
+                    "pCreateInfo->sharingMode, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->pQueueFamilyIndices != nullptr) {
+        }
     }
 
     return true;
 }
 
-bool PostCreateImage(
-    VkDevice device,
-    VkImage* pImage,
-    VkResult result)
-{
+bool PostCreateImage(VkDevice device, VkImage *pImage, VkResult result) {
 
-    if(pImage != nullptr)
-    {
+    if (pImage != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateImage parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkCreateImage parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
-    VkDevice device,
-    const VkImageCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkImage* pImage)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
+                  const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
     PreCreateImage(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImage(device, pCreateInfo, pAllocator, pImage);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateImage(device, pCreateInfo, pAllocator, pImage);
 
     PostCreateImage(device, pImage, result);
 
     return result;
 }
 
-bool PreGetImageSubresourceLayout(
-    VkDevice device,
-    const VkImageSubresource* pSubresource)
-{
-    if(pSubresource != nullptr)
-    {
-    if ((pSubresource->aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkGetImageSubresourceLayout parameter, VkImageAspect pSubresource->aspectMask, is an unrecognized enumerator");
-        return false;
-    }
+bool PreGetImageSubresourceLayout(VkDevice device,
+                                  const VkImageSubresource *pSubresource) {
+    if (pSubresource != nullptr) {
+        if ((pSubresource->aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkGetImageSubresourceLayout parameter, VkImageAspect "
+                    "pSubresource->aspectMask, is an unrecognized enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostGetImageSubresourceLayout(
-    VkDevice device,
-    VkImage image,
-    VkSubresourceLayout* pLayout)
-{
+bool PostGetImageSubresourceLayout(VkDevice device, VkImage image,
+                                   VkSubresourceLayout *pLayout) {
 
-
-    if(pLayout != nullptr)
-    {
+    if (pLayout != nullptr) {
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
-    VkDevice device,
-    VkImage image,
-    const VkImageSubresource* pSubresource,
-    VkSubresourceLayout* pLayout)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetImageSubresourceLayout(VkDevice device, VkImage image,
+                                const VkImageSubresource *pSubresource,
+                                VkSubresourceLayout *pLayout) {
     PreGetImageSubresourceLayout(device, pSubresource);
 
-    get_dispatch_table(pc_device_table_map, device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+    get_dispatch_table(pc_device_table_map, device)
+        ->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
 
     PostGetImageSubresourceLayout(device, image, pLayout);
 }
 
-bool PreCreateImageView(
-    VkDevice device,
-    const VkImageViewCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->viewType < VK_IMAGE_VIEW_TYPE_BEGIN_RANGE ||
-        pCreateInfo->viewType > VK_IMAGE_VIEW_TYPE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkImageViewType pCreateInfo->viewType, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
-        pCreateInfo->format > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkFormat pCreateInfo->format, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->components.r < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
-        pCreateInfo->components.r > VK_COMPONENT_SWIZZLE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->components.r, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->components.g < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
-        pCreateInfo->components.g > VK_COMPONENT_SWIZZLE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->components.g, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->components.b < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
-        pCreateInfo->components.b > VK_COMPONENT_SWIZZLE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->components.b, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->components.a < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
-        pCreateInfo->components.a > VK_COMPONENT_SWIZZLE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->components.a, is an unrecognized enumerator");
-        return false;
-    }
+bool PreCreateImageView(VkDevice device,
+                        const VkImageViewCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImageView parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->viewType < VK_IMAGE_VIEW_TYPE_BEGIN_RANGE ||
+            pCreateInfo->viewType > VK_IMAGE_VIEW_TYPE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImageView parameter, VkImageViewType "
+                    "pCreateInfo->viewType, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
+            pCreateInfo->format > VK_FORMAT_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImageView parameter, VkFormat "
+                    "pCreateInfo->format, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->components.r < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
+            pCreateInfo->components.r > VK_COMPONENT_SWIZZLE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImageView parameter, VkComponentSwizzle "
+                    "pCreateInfo->components.r, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->components.g < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
+            pCreateInfo->components.g > VK_COMPONENT_SWIZZLE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImageView parameter, VkComponentSwizzle "
+                    "pCreateInfo->components.g, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->components.b < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
+            pCreateInfo->components.b > VK_COMPONENT_SWIZZLE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImageView parameter, VkComponentSwizzle "
+                    "pCreateInfo->components.b, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->components.a < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
+            pCreateInfo->components.a > VK_COMPONENT_SWIZZLE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateImageView parameter, VkComponentSwizzle "
+                    "pCreateInfo->components.a, is an unrecognized enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCreateImageView(
-    VkDevice device,
-    VkImageView* pView,
-    VkResult result)
-{
+bool PostCreateImageView(VkDevice device, VkImageView *pView, VkResult result) {
 
-    if(pView != nullptr)
-    {
+    if (pView != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateImageView parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateImageView parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
-    VkDevice device,
-    const VkImageViewCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkImageView* pView)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
+                      const VkAllocationCallbacks *pAllocator,
+                      VkImageView *pView) {
     PreCreateImageView(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImageView(device, pCreateInfo, pAllocator, pView);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateImageView(device, pCreateInfo, pAllocator, pView);
 
     PostCreateImageView(device, pView, result);
 
     return result;
 }
 
-bool PreCreateShaderModule(
-    VkDevice device,
-    const VkShaderModuleCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo) {
-        if(pCreateInfo->sType != VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO) {
-            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-                "vkCreateShaderModule parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
+bool PreCreateShaderModule(VkDevice device,
+                           const VkShaderModuleCreateInfo *pCreateInfo) {
+    if (pCreateInfo) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateShaderModule parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
             return false;
         }
-        if(!pCreateInfo->pCode) {
-            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-                "vkCreateShaderModule paramter, void* pCreateInfo->pCode, is null");
+        if (!pCreateInfo->pCode) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateShaderModule paramter, void* pCreateInfo->pCode, "
+                    "is null");
             return false;
         }
     } else {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-            "vkCreateShaderModule parameter, VkShaderModuleCreateInfo pCreateInfo, is null");
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCreateShaderModule parameter, VkShaderModuleCreateInfo "
+                "pCreateInfo, is null");
         return false;
     }
 
     return true;
 }
 
-bool PostCreateShaderModule(
-    VkDevice device,
-    VkShaderModule* pShaderModule,
-    VkResult result)
-{
-    if(result < VK_SUCCESS) {
-        std::string reason = "vkCreateShaderModule parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+bool PostCreateShaderModule(VkDevice device, VkShaderModule *pShaderModule,
+                            VkResult result) {
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateShaderModule parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
-    VkDevice device,
-    const VkShaderModuleCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkShaderModule* pShaderModule)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateShaderModule(VkDevice device,
+                         const VkShaderModuleCreateInfo *pCreateInfo,
+                         const VkAllocationCallbacks *pAllocator,
+                         VkShaderModule *pShaderModule) {
     PreCreateShaderModule(device, pCreateInfo);
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->CreateShaderModule(device, pCreateInfo, pAllocator,
+                                               pShaderModule);
     PostCreateShaderModule(device, pShaderModule, result);
     return result;
 }
 
-bool PreCreatePipelineCache(
-    VkDevice device,
-    const VkPipelineCacheCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreatePipelineCache parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->pInitialData != nullptr)
-    {
-    }
+bool PreCreatePipelineCache(VkDevice device,
+                            const VkPipelineCacheCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType !=
+            VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreatePipelineCache parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->pInitialData != nullptr) {
+        }
     }
 
     return true;
 }
 
-bool PostCreatePipelineCache(
-    VkDevice device,
-    VkPipelineCache* pPipelineCache,
-    VkResult result)
-{
+bool PostCreatePipelineCache(VkDevice device, VkPipelineCache *pPipelineCache,
+                             VkResult result) {
 
-    if(pPipelineCache != nullptr)
-    {
+    if (pPipelineCache != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreatePipelineCache parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreatePipelineCache parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
-    VkDevice device,
-    const VkPipelineCacheCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkPipelineCache* pPipelineCache)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreatePipelineCache(VkDevice device,
+                          const VkPipelineCacheCreateInfo *pCreateInfo,
+                          const VkAllocationCallbacks *pAllocator,
+                          VkPipelineCache *pPipelineCache) {
     PreCreatePipelineCache(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->CreatePipelineCache(device, pCreateInfo, pAllocator,
+                                                pPipelineCache);
 
     PostCreatePipelineCache(device, pPipelineCache, result);
 
     return result;
 }
 
-bool PostGetPipelineCacheData(
-    VkDevice device,
-    VkPipelineCache pipelineCache,
-    size_t* pDataSize,
-    void* pData,
-    VkResult result)
-{
+bool PostGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
+                              size_t *pDataSize, void *pData, VkResult result) {
 
-
-    if(pDataSize != nullptr)
-    {
+    if (pDataSize != nullptr) {
     }
 
-    if(pData != nullptr)
-    {
+    if (pData != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkGetPipelineCacheData parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkGetPipelineCacheData parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
-    VkDevice device,
-    VkPipelineCache pipelineCache,
-    size_t* pDataSize,
-    void* pData)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
+                           size_t *pDataSize, void *pData) {
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
 
     PostGetPipelineCacheData(device, pipelineCache, pDataSize, pData, result);
 
     return result;
 }
 
-bool PreMergePipelineCaches(
-    VkDevice device,
-    const VkPipelineCache* pSrcCaches)
-{
-    if(pSrcCaches != nullptr)
-    {
+bool PreMergePipelineCaches(VkDevice device,
+                            const VkPipelineCache *pSrcCaches) {
+    if (pSrcCaches != nullptr) {
     }
 
     return true;
 }
 
-bool PostMergePipelineCaches(
-    VkDevice device,
-    VkPipelineCache dstCache,
-    uint32_t srcCacheCount,
-    VkResult result)
-{
+bool PostMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
+                             uint32_t srcCacheCount, VkResult result) {
 
-
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkMergePipelineCaches parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkMergePipelineCaches parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
-    VkDevice device,
-    VkPipelineCache dstCache,
-    uint32_t srcCacheCount,
-    const VkPipelineCache* pSrcCaches)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
+                          uint32_t srcCacheCount,
+                          const VkPipelineCache *pSrcCaches) {
     PreMergePipelineCaches(device, pSrcCaches);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
 
     PostMergePipelineCaches(device, dstCache, srcCacheCount, result);
 
     return result;
 }
 
-bool PreCreateGraphicsPipelines(
-    VkDevice device,
-    const VkGraphicsPipelineCreateInfo* pCreateInfos)
-{
-    if(pCreateInfos != nullptr)
-    {
-    if(pCreateInfos->sType != VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfos->pStages != nullptr)
-    {
-    if(pCreateInfos->pStages->sType != VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pStages->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfos->pStages->pSpecializationInfo != nullptr)
-    {
-    if(pCreateInfos->pStages->pSpecializationInfo->pMapEntries != nullptr)
-    {
-    }
-    if(pCreateInfos->pStages->pSpecializationInfo->pData != nullptr)
-    {
-    }
-    }
-    }
-    if(pCreateInfos->pVertexInputState != nullptr)
-    {
-    if(pCreateInfos->pVertexInputState->sType != VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pVertexInputState->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfos->pVertexInputState->pVertexBindingDescriptions != nullptr)
-    {
-    if(pCreateInfos->pVertexInputState->pVertexBindingDescriptions->inputRate < VK_VERTEX_INPUT_RATE_BEGIN_RANGE ||
-        pCreateInfos->pVertexInputState->pVertexBindingDescriptions->inputRate > VK_VERTEX_INPUT_RATE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkVertexInputRate pCreateInfos->pVertexInputState->pVertexBindingDescriptions->inputRate, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfos->pVertexInputState->pVertexAttributeDescriptions != nullptr)
-    {
-    if(pCreateInfos->pVertexInputState->pVertexAttributeDescriptions->format < VK_FORMAT_BEGIN_RANGE ||
-        pCreateInfos->pVertexInputState->pVertexAttributeDescriptions->format > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkFormat pCreateInfos->pVertexInputState->pVertexAttributeDescriptions->format, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    }
-    if(pCreateInfos->pInputAssemblyState != nullptr)
-    {
-    if(pCreateInfos->pInputAssemblyState->sType != VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pInputAssemblyState->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfos->pInputAssemblyState->topology < VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE ||
-        pCreateInfos->pInputAssemblyState->topology > VK_PRIMITIVE_TOPOLOGY_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkPrimitiveTopology pCreateInfos->pInputAssemblyState->topology, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfos->pTessellationState != nullptr)
-    {
-    if(pCreateInfos->pTessellationState->sType != VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pTessellationState->sType, is an invalid enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfos->pViewportState != nullptr)
-    {
-    if(pCreateInfos->pViewportState->sType != VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pViewportState->sType, is an invalid enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfos->pRasterizationState != nullptr)
-    {
-    if(pCreateInfos->pRasterizationState->sType != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pRasterizationState->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfos->pRasterizationState->polygonMode < VK_POLYGON_MODE_BEGIN_RANGE ||
-        pCreateInfos->pRasterizationState->polygonMode > VK_POLYGON_MODE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkPolygonMode pCreateInfos->pRasterizationState->polygonMode, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pRasterizationState->cullMode & ~VK_CULL_MODE_FRONT_AND_BACK)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkCullMode pCreateInfos->pRasterizationState->cullMode, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pRasterizationState->frontFace < VK_FRONT_FACE_BEGIN_RANGE ||
-        pCreateInfos->pRasterizationState->frontFace > VK_FRONT_FACE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkFrontFace pCreateInfos->pRasterizationState->frontFace, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfos->pMultisampleState != nullptr)
-    {
-    if(pCreateInfos->pMultisampleState->sType != VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pMultisampleState->sType, is an invalid enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfos->pDepthStencilState != nullptr)
-    {
-    if(pCreateInfos->pDepthStencilState->sType != VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pDepthStencilState->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfos->pDepthStencilState->depthCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->depthCompareOp > VK_COMPARE_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->depthCompareOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pDepthStencilState->front.failOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->front.failOp > VK_STENCIL_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.failOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pDepthStencilState->front.passOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->front.passOp > VK_STENCIL_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.passOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pDepthStencilState->front.depthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->front.depthFailOp > VK_STENCIL_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.depthFailOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pDepthStencilState->front.compareOp < VK_COMPARE_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->front.compareOp > VK_COMPARE_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->front.compareOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pDepthStencilState->back.failOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->back.failOp > VK_STENCIL_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.failOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pDepthStencilState->back.passOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->back.passOp > VK_STENCIL_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.passOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pDepthStencilState->back.depthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->back.depthFailOp > VK_STENCIL_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.depthFailOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pDepthStencilState->back.compareOp < VK_COMPARE_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->back.compareOp > VK_COMPARE_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->back.compareOp, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfos->pColorBlendState != nullptr)
-    {
-    if(pCreateInfos->pColorBlendState->sType != VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pColorBlendState->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfos->pColorBlendState->logicOpEnable == VK_TRUE &&
-        pCreateInfos->pColorBlendState->logicOp < VK_LOGIC_OP_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->logicOp > VK_LOGIC_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkLogicOp pCreateInfos->pColorBlendState->logicOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pColorBlendState->pAttachments != nullptr && pCreateInfos->pColorBlendState->pAttachments->blendEnable == VK_TRUE)
-    {
-    if(pCreateInfos->pColorBlendState->pAttachments->srcColorBlendFactor < VK_BLEND_FACTOR_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->srcColorBlendFactor > VK_BLEND_FACTOR_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->srcColorBlendFactor, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pColorBlendState->pAttachments->dstColorBlendFactor < VK_BLEND_FACTOR_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->dstColorBlendFactor > VK_BLEND_FACTOR_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->dstColorBlendFactor, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pColorBlendState->pAttachments->colorBlendOp < VK_BLEND_OP_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->colorBlendOp > VK_BLEND_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlendOp pCreateInfos->pColorBlendState->pAttachments->colorBlendOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pColorBlendState->pAttachments->srcAlphaBlendFactor < VK_BLEND_FACTOR_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->srcAlphaBlendFactor > VK_BLEND_FACTOR_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->srcAlphaBlendFactor, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pColorBlendState->pAttachments->dstAlphaBlendFactor < VK_BLEND_FACTOR_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->dstAlphaBlendFactor > VK_BLEND_FACTOR_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->dstAlphaBlendFactor, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp < VK_BLEND_OP_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp > VK_BLEND_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlendOp pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    }
-    if(pCreateInfos->renderPass == VK_NULL_HANDLE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkRenderPass pCreateInfos->renderPass, is null pointer");
-    }
+bool
+PreCreateGraphicsPipelines(VkDevice device,
+                           const VkGraphicsPipelineCreateInfo *pCreateInfos) {
+    if (pCreateInfos != nullptr) {
+        if (pCreateInfos->sType !=
+            VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateGraphicsPipelines parameter, VkStructureType "
+                    "pCreateInfos->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfos->pStages != nullptr) {
+            if (pCreateInfos->pStages->sType !=
+                VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO) {
+                log_msg(
+                    mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateGraphicsPipelines parameter, VkStructureType "
+                    "pCreateInfos->pStages->sType, is an invalid enumerator");
+                return false;
+            }
+            if (pCreateInfos->pStages->pSpecializationInfo != nullptr) {
+                if (pCreateInfos->pStages->pSpecializationInfo->pMapEntries !=
+                    nullptr) {
+                }
+                if (pCreateInfos->pStages->pSpecializationInfo->pData !=
+                    nullptr) {
+                }
+            }
+        }
+        if (pCreateInfos->pVertexInputState != nullptr) {
+            if (pCreateInfos->pVertexInputState->sType !=
+                VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStructureType "
+                                      "pCreateInfos->pVertexInputState->sType, "
+                                      "is an invalid enumerator");
+                return false;
+            }
+            if (pCreateInfos->pVertexInputState->pVertexBindingDescriptions !=
+                nullptr) {
+                if (pCreateInfos->pVertexInputState->pVertexBindingDescriptions
+                            ->inputRate < VK_VERTEX_INPUT_RATE_BEGIN_RANGE ||
+                    pCreateInfos->pVertexInputState->pVertexBindingDescriptions
+                            ->inputRate > VK_VERTEX_INPUT_RATE_END_RANGE) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK", "vkCreateGraphicsPipelines "
+                                          "parameter, VkVertexInputRate "
+                                          "pCreateInfos->pVertexInputState->"
+                                          "pVertexBindingDescriptions->"
+                                          "inputRate, is an unrecognized "
+                                          "enumerator");
+                    return false;
+                }
+            }
+            if (pCreateInfos->pVertexInputState->pVertexAttributeDescriptions !=
+                nullptr) {
+                if (pCreateInfos->pVertexInputState
+                            ->pVertexAttributeDescriptions->format <
+                        VK_FORMAT_BEGIN_RANGE ||
+                    pCreateInfos->pVertexInputState
+                            ->pVertexAttributeDescriptions->format >
+                        VK_FORMAT_END_RANGE) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK",
+                            "vkCreateGraphicsPipelines parameter, VkFormat "
+                            "pCreateInfos->pVertexInputState->"
+                            "pVertexAttributeDescriptions->format, is an "
+                            "unrecognized enumerator");
+                    return false;
+                }
+            }
+        }
+        if (pCreateInfos->pInputAssemblyState != nullptr) {
+            if (pCreateInfos->pInputAssemblyState->sType !=
+                VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStructureType "
+                                      "pCreateInfos->pInputAssemblyState->"
+                                      "sType, is an invalid enumerator");
+                return false;
+            }
+            if (pCreateInfos->pInputAssemblyState->topology <
+                    VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE ||
+                pCreateInfos->pInputAssemblyState->topology >
+                    VK_PRIMITIVE_TOPOLOGY_END_RANGE) {
+                log_msg(
+                    mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateGraphicsPipelines parameter, VkPrimitiveTopology "
+                    "pCreateInfos->pInputAssemblyState->topology, is an "
+                    "unrecognized enumerator");
+                return false;
+            }
+        }
+        if (pCreateInfos->pTessellationState != nullptr) {
+            if (pCreateInfos->pTessellationState->sType !=
+                VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStructureType "
+                                      "pCreateInfos->pTessellationState->sType,"
+                                      " is an invalid enumerator");
+                return false;
+            }
+        }
+        if (pCreateInfos->pViewportState != nullptr) {
+            if (pCreateInfos->pViewportState->sType !=
+                VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStructureType "
+                                      "pCreateInfos->pViewportState->sType, is "
+                                      "an invalid enumerator");
+                return false;
+            }
+        }
+        if (pCreateInfos->pRasterizationState != nullptr) {
+            if (pCreateInfos->pRasterizationState->sType !=
+                VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStructureType "
+                                      "pCreateInfos->pRasterizationState->"
+                                      "sType, is an invalid enumerator");
+                return false;
+            }
+            if (pCreateInfos->pRasterizationState->polygonMode <
+                    VK_POLYGON_MODE_BEGIN_RANGE ||
+                pCreateInfos->pRasterizationState->polygonMode >
+                    VK_POLYGON_MODE_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateGraphicsPipelines parameter, VkPolygonMode "
+                        "pCreateInfos->pRasterizationState->polygonMode, is an "
+                        "unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pRasterizationState->cullMode &
+                ~VK_CULL_MODE_FRONT_AND_BACK) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateGraphicsPipelines parameter, VkCullMode "
+                        "pCreateInfos->pRasterizationState->cullMode, is an "
+                        "unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pRasterizationState->frontFace <
+                    VK_FRONT_FACE_BEGIN_RANGE ||
+                pCreateInfos->pRasterizationState->frontFace >
+                    VK_FRONT_FACE_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateGraphicsPipelines parameter, VkFrontFace "
+                        "pCreateInfos->pRasterizationState->frontFace, is an "
+                        "unrecognized enumerator");
+                return false;
+            }
+        }
+        if (pCreateInfos->pMultisampleState != nullptr) {
+            if (pCreateInfos->pMultisampleState->sType !=
+                VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStructureType "
+                                      "pCreateInfos->pMultisampleState->sType, "
+                                      "is an invalid enumerator");
+                return false;
+            }
+        }
+        if (pCreateInfos->pDepthStencilState != nullptr) {
+            if (pCreateInfos->pDepthStencilState->sType !=
+                VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStructureType "
+                                      "pCreateInfos->pDepthStencilState->sType,"
+                                      " is an invalid enumerator");
+                return false;
+            }
+            if (pCreateInfos->pDepthStencilState->depthCompareOp <
+                    VK_COMPARE_OP_BEGIN_RANGE ||
+                pCreateInfos->pDepthStencilState->depthCompareOp >
+                    VK_COMPARE_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateGraphicsPipelines parameter, VkCompareOp "
+                        "pCreateInfos->pDepthStencilState->depthCompareOp, is "
+                        "an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pDepthStencilState->front.failOp <
+                    VK_STENCIL_OP_BEGIN_RANGE ||
+                pCreateInfos->pDepthStencilState->front.failOp >
+                    VK_STENCIL_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStencilOp "
+                                      "pCreateInfos->pDepthStencilState->front."
+                                      "failOp, is an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pDepthStencilState->front.passOp <
+                    VK_STENCIL_OP_BEGIN_RANGE ||
+                pCreateInfos->pDepthStencilState->front.passOp >
+                    VK_STENCIL_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStencilOp "
+                                      "pCreateInfos->pDepthStencilState->front."
+                                      "passOp, is an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pDepthStencilState->front.depthFailOp <
+                    VK_STENCIL_OP_BEGIN_RANGE ||
+                pCreateInfos->pDepthStencilState->front.depthFailOp >
+                    VK_STENCIL_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateGraphicsPipelines parameter, VkStencilOp "
+                        "pCreateInfos->pDepthStencilState->front.depthFailOp, "
+                        "is an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pDepthStencilState->front.compareOp <
+                    VK_COMPARE_OP_BEGIN_RANGE ||
+                pCreateInfos->pDepthStencilState->front.compareOp >
+                    VK_COMPARE_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateGraphicsPipelines parameter, VkCompareOp "
+                        "pCreateInfos->pDepthStencilState->front.compareOp, is "
+                        "an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pDepthStencilState->back.failOp <
+                    VK_STENCIL_OP_BEGIN_RANGE ||
+                pCreateInfos->pDepthStencilState->back.failOp >
+                    VK_STENCIL_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStencilOp "
+                                      "pCreateInfos->pDepthStencilState->back."
+                                      "failOp, is an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pDepthStencilState->back.passOp <
+                    VK_STENCIL_OP_BEGIN_RANGE ||
+                pCreateInfos->pDepthStencilState->back.passOp >
+                    VK_STENCIL_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStencilOp "
+                                      "pCreateInfos->pDepthStencilState->back."
+                                      "passOp, is an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pDepthStencilState->back.depthFailOp <
+                    VK_STENCIL_OP_BEGIN_RANGE ||
+                pCreateInfos->pDepthStencilState->back.depthFailOp >
+                    VK_STENCIL_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateGraphicsPipelines parameter, VkStencilOp "
+                        "pCreateInfos->pDepthStencilState->back.depthFailOp, "
+                        "is an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pDepthStencilState->back.compareOp <
+                    VK_COMPARE_OP_BEGIN_RANGE ||
+                pCreateInfos->pDepthStencilState->back.compareOp >
+                    VK_COMPARE_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateGraphicsPipelines parameter, VkCompareOp "
+                        "pCreateInfos->pDepthStencilState->back.compareOp, is "
+                        "an unrecognized enumerator");
+                return false;
+            }
+        }
+        if (pCreateInfos->pColorBlendState != nullptr) {
+            if (pCreateInfos->pColorBlendState->sType !=
+                VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkStructureType "
+                                      "pCreateInfos->pColorBlendState->sType, "
+                                      "is an invalid enumerator");
+                return false;
+            }
+            if (pCreateInfos->pColorBlendState->logicOpEnable == VK_TRUE &&
+                    pCreateInfos->pColorBlendState->logicOp <
+                        VK_LOGIC_OP_BEGIN_RANGE ||
+                pCreateInfos->pColorBlendState->logicOp >
+                    VK_LOGIC_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateGraphicsPipelines parameter, "
+                                      "VkLogicOp "
+                                      "pCreateInfos->pColorBlendState->logicOp,"
+                                      " is an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfos->pColorBlendState->pAttachments != nullptr &&
+                pCreateInfos->pColorBlendState->pAttachments->blendEnable ==
+                    VK_TRUE) {
+                if (pCreateInfos->pColorBlendState->pAttachments
+                            ->srcColorBlendFactor <
+                        VK_BLEND_FACTOR_BEGIN_RANGE ||
+                    pCreateInfos->pColorBlendState->pAttachments
+                            ->srcColorBlendFactor > VK_BLEND_FACTOR_END_RANGE) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK", "vkCreateGraphicsPipelines "
+                                          "parameter, VkBlendFactor "
+                                          "pCreateInfos->pColorBlendState->"
+                                          "pAttachments->srcColorBlendFactor, "
+                                          "is an unrecognized enumerator");
+                    return false;
+                }
+                if (pCreateInfos->pColorBlendState->pAttachments
+                            ->dstColorBlendFactor <
+                        VK_BLEND_FACTOR_BEGIN_RANGE ||
+                    pCreateInfos->pColorBlendState->pAttachments
+                            ->dstColorBlendFactor > VK_BLEND_FACTOR_END_RANGE) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK", "vkCreateGraphicsPipelines "
+                                          "parameter, VkBlendFactor "
+                                          "pCreateInfos->pColorBlendState->"
+                                          "pAttachments->dstColorBlendFactor, "
+                                          "is an unrecognized enumerator");
+                    return false;
+                }
+                if (pCreateInfos->pColorBlendState->pAttachments->colorBlendOp <
+                        VK_BLEND_OP_BEGIN_RANGE ||
+                    pCreateInfos->pColorBlendState->pAttachments->colorBlendOp >
+                        VK_BLEND_OP_END_RANGE) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK",
+                            "vkCreateGraphicsPipelines parameter, VkBlendOp "
+                            "pCreateInfos->pColorBlendState->pAttachments->"
+                            "colorBlendOp, is an unrecognized enumerator");
+                    return false;
+                }
+                if (pCreateInfos->pColorBlendState->pAttachments
+                            ->srcAlphaBlendFactor <
+                        VK_BLEND_FACTOR_BEGIN_RANGE ||
+                    pCreateInfos->pColorBlendState->pAttachments
+                            ->srcAlphaBlendFactor > VK_BLEND_FACTOR_END_RANGE) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK", "vkCreateGraphicsPipelines "
+                                          "parameter, VkBlendFactor "
+                                          "pCreateInfos->pColorBlendState->"
+                                          "pAttachments->srcAlphaBlendFactor, "
+                                          "is an unrecognized enumerator");
+                    return false;
+                }
+                if (pCreateInfos->pColorBlendState->pAttachments
+                            ->dstAlphaBlendFactor <
+                        VK_BLEND_FACTOR_BEGIN_RANGE ||
+                    pCreateInfos->pColorBlendState->pAttachments
+                            ->dstAlphaBlendFactor > VK_BLEND_FACTOR_END_RANGE) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK", "vkCreateGraphicsPipelines "
+                                          "parameter, VkBlendFactor "
+                                          "pCreateInfos->pColorBlendState->"
+                                          "pAttachments->dstAlphaBlendFactor, "
+                                          "is an unrecognized enumerator");
+                    return false;
+                }
+                if (pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp <
+                        VK_BLEND_OP_BEGIN_RANGE ||
+                    pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp >
+                        VK_BLEND_OP_END_RANGE) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK",
+                            "vkCreateGraphicsPipelines parameter, VkBlendOp "
+                            "pCreateInfos->pColorBlendState->pAttachments->"
+                            "alphaBlendOp, is an unrecognized enumerator");
+                    return false;
+                }
+            }
+        }
+        if (pCreateInfos->renderPass == VK_NULL_HANDLE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateGraphicsPipelines parameter, VkRenderPass "
+                    "pCreateInfos->renderPass, is null pointer");
+        }
     }
 
     return true;
 }
 
-bool PostCreateGraphicsPipelines(
-    VkDevice device,
-    VkPipelineCache pipelineCache,
-    uint32_t count,
-    VkPipeline* pPipelines,
-    VkResult result)
-{
+bool PostCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+                                 uint32_t count, VkPipeline *pPipelines,
+                                 VkResult result) {
 
-
-
-    if(pPipelines != nullptr)
-    {
+    if (pPipelines != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateGraphicsPipelines parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateGraphicsPipelines parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
-    VkDevice device,
-    VkPipelineCache pipelineCache,
-    uint32_t count,
-    const VkGraphicsPipelineCreateInfo* pCreateInfos,
-    const VkAllocationCallbacks* pAllocator,
-    VkPipeline* pPipelines)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+                              uint32_t count,
+                              const VkGraphicsPipelineCreateInfo *pCreateInfos,
+                              const VkAllocationCallbacks *pAllocator,
+                              VkPipeline *pPipelines) {
     PreCreateGraphicsPipelines(device, pCreateInfos);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateGraphicsPipelines(device, pipelineCache, count,
+                                      pCreateInfos, pAllocator, pPipelines);
 
-    PostCreateGraphicsPipelines(device, pipelineCache, count, pPipelines, result);
+    PostCreateGraphicsPipelines(device, pipelineCache, count, pPipelines,
+                                result);
 
     return result;
 }
 
-bool PreCreateComputePipelines(
-    VkDevice device,
-    const VkComputePipelineCreateInfo* pCreateInfos)
-{
-    if(pCreateInfos != nullptr)
-    {
-    if(pCreateInfos->sType != VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateComputePipelines parameter, VkStructureType pCreateInfos->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfos->stage.sType != VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateComputePipelines parameter, VkStructureType pCreateInfos->cs.sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfos->stage.pSpecializationInfo != nullptr)
-    {
-    if(pCreateInfos->stage.pSpecializationInfo->pMapEntries != nullptr)
-    {
-    }
-    if(pCreateInfos->stage.pSpecializationInfo->pData != nullptr)
-    {
-    }
-    }
+bool
+PreCreateComputePipelines(VkDevice device,
+                          const VkComputePipelineCreateInfo *pCreateInfos) {
+    if (pCreateInfos != nullptr) {
+        if (pCreateInfos->sType !=
+            VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateComputePipelines parameter, VkStructureType "
+                    "pCreateInfos->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfos->stage.sType !=
+            VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateComputePipelines parameter, VkStructureType "
+                    "pCreateInfos->cs.sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfos->stage.pSpecializationInfo != nullptr) {
+            if (pCreateInfos->stage.pSpecializationInfo->pMapEntries !=
+                nullptr) {
+            }
+            if (pCreateInfos->stage.pSpecializationInfo->pData != nullptr) {
+            }
+        }
     }
 
     return true;
 }
 
-bool PostCreateComputePipelines(
-    VkDevice device,
-    VkPipelineCache pipelineCache,
-    uint32_t count,
-    VkPipeline* pPipelines,
-    VkResult result)
-{
+bool PostCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
+                                uint32_t count, VkPipeline *pPipelines,
+                                VkResult result) {
 
-
-
-    if(pPipelines != nullptr)
-    {
+    if (pPipelines != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateComputePipelines parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateComputePipelines parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
-    VkDevice device,
-    VkPipelineCache pipelineCache,
-    uint32_t count,
-    const VkComputePipelineCreateInfo* pCreateInfos,
-    const VkAllocationCallbacks* pAllocator,
-    VkPipeline* pPipelines)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
+                             uint32_t count,
+                             const VkComputePipelineCreateInfo *pCreateInfos,
+                             const VkAllocationCallbacks *pAllocator,
+                             VkPipeline *pPipelines) {
     PreCreateComputePipelines(device, pCreateInfos);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)->CreateComputePipelines(
+            device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
 
-    PostCreateComputePipelines(device, pipelineCache, count, pPipelines, result);
+    PostCreateComputePipelines(device, pipelineCache, count, pPipelines,
+                               result);
 
     return result;
 }
 
-bool PreCreatePipelineLayout(
-    VkDevice device,
-    const VkPipelineLayoutCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreatePipelineLayout parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->pSetLayouts != nullptr)
-    {
-    }
-    if(pCreateInfo->pPushConstantRanges != nullptr)
-    {
-    }
+bool PreCreatePipelineLayout(VkDevice device,
+                             const VkPipelineLayoutCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType !=
+            VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreatePipelineLayout parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->pSetLayouts != nullptr) {
+        }
+        if (pCreateInfo->pPushConstantRanges != nullptr) {
+        }
     }
 
     return true;
 }
 
-bool PostCreatePipelineLayout(
-    VkDevice device,
-    VkPipelineLayout* pPipelineLayout,
-    VkResult result)
-{
+bool PostCreatePipelineLayout(VkDevice device,
+                              VkPipelineLayout *pPipelineLayout,
+                              VkResult result) {
 
-    if(pPipelineLayout != nullptr)
-    {
+    if (pPipelineLayout != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreatePipelineLayout parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreatePipelineLayout parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
-    VkDevice device,
-    const VkPipelineLayoutCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkPipelineLayout* pPipelineLayout)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreatePipelineLayout(VkDevice device,
+                           const VkPipelineLayoutCreateInfo *pCreateInfo,
+                           const VkAllocationCallbacks *pAllocator,
+                           VkPipelineLayout *pPipelineLayout) {
     PreCreatePipelineLayout(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->CreatePipelineLayout(device, pCreateInfo,
+                                                 pAllocator, pPipelineLayout);
 
     PostCreatePipelineLayout(device, pPipelineLayout, result);
 
     return result;
 }
 
-bool PreCreateSampler(
-    VkDevice device,
-    const VkSamplerCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateSampler parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->magFilter < VK_FILTER_BEGIN_RANGE ||
-        pCreateInfo->magFilter > VK_FILTER_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateSampler parameter, VkFilter pCreateInfo->magFilter, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->minFilter < VK_FILTER_BEGIN_RANGE ||
-        pCreateInfo->minFilter > VK_FILTER_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateSampler parameter, VkFilter pCreateInfo->minFilter, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->mipmapMode < VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE ||
-        pCreateInfo->mipmapMode > VK_SAMPLER_MIPMAP_MODE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateSampler parameter, VkSamplerMipmapMode pCreateInfo->mipmapMode, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->addressModeU < VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE ||
-        pCreateInfo->addressModeU > VK_SAMPLER_ADDRESS_MODE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressModeU, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->addressModeV < VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE ||
-        pCreateInfo->addressModeV > VK_SAMPLER_ADDRESS_MODE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressModeV, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->addressModeW < VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE ||
-        pCreateInfo->addressModeW > VK_SAMPLER_ADDRESS_MODE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressModeW, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->compareEnable)
-    {
-        if(pCreateInfo->compareOp < VK_COMPARE_OP_BEGIN_RANGE ||
-            pCreateInfo->compareOp > VK_COMPARE_OP_END_RANGE)
-        {
-            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-            "vkCreateSampler parameter, VkCompareOp pCreateInfo->compareOp, is an unrecognized enumerator");
+bool PreCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateSampler parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->magFilter < VK_FILTER_BEGIN_RANGE ||
+            pCreateInfo->magFilter > VK_FILTER_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateSampler parameter, VkFilter "
+                    "pCreateInfo->magFilter, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->minFilter < VK_FILTER_BEGIN_RANGE ||
+            pCreateInfo->minFilter > VK_FILTER_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateSampler parameter, VkFilter "
+                    "pCreateInfo->minFilter, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->mipmapMode < VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE ||
+            pCreateInfo->mipmapMode > VK_SAMPLER_MIPMAP_MODE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateSampler parameter, VkSamplerMipmapMode "
+                    "pCreateInfo->mipmapMode, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->addressModeU < VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE ||
+            pCreateInfo->addressModeU > VK_SAMPLER_ADDRESS_MODE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateSampler parameter, VkTexAddress "
+                    "pCreateInfo->addressModeU, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->addressModeV < VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE ||
+            pCreateInfo->addressModeV > VK_SAMPLER_ADDRESS_MODE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateSampler parameter, VkTexAddress "
+                    "pCreateInfo->addressModeV, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->addressModeW < VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE ||
+            pCreateInfo->addressModeW > VK_SAMPLER_ADDRESS_MODE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateSampler parameter, VkTexAddress "
+                    "pCreateInfo->addressModeW, is an unrecognized enumerator");
+            return false;
+        }
+        if (pCreateInfo->compareEnable) {
+            if (pCreateInfo->compareOp < VK_COMPARE_OP_BEGIN_RANGE ||
+                pCreateInfo->compareOp > VK_COMPARE_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateSampler parameter, VkCompareOp "
+                                      "pCreateInfo->compareOp, is an "
+                                      "unrecognized enumerator");
+                return false;
+            }
+        }
+        if (pCreateInfo->borderColor < VK_BORDER_COLOR_BEGIN_RANGE ||
+            pCreateInfo->borderColor > VK_BORDER_COLOR_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateSampler parameter, VkBorderColor "
+                    "pCreateInfo->borderColor, is an unrecognized enumerator");
             return false;
         }
     }
-    if(pCreateInfo->borderColor < VK_BORDER_COLOR_BEGIN_RANGE ||
-        pCreateInfo->borderColor > VK_BORDER_COLOR_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateSampler parameter, VkBorderColor pCreateInfo->borderColor, is an unrecognized enumerator");
-        return false;
-    }
-    }
 
     return true;
 }
 
-bool PostCreateSampler(
-    VkDevice device,
-    VkSampler* pSampler,
-    VkResult result)
-{
+bool PostCreateSampler(VkDevice device, VkSampler *pSampler, VkResult result) {
 
-    if(pSampler != nullptr)
-    {
+    if (pSampler != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateSampler parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason = "vkCreateSampler parameter, VkResult result, is " +
+                             EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
-    VkDevice device,
-    const VkSamplerCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkSampler* pSampler)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
+                    const VkAllocationCallbacks *pAllocator,
+                    VkSampler *pSampler) {
     PreCreateSampler(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
 
     PostCreateSampler(device, pSampler, result);
 
@@ -4349,49 +4039,51 @@
 }
 
 bool PreCreateDescriptorSetLayout(
-    VkDevice device,
-    const VkDescriptorSetLayoutCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateDescriptorSetLayout parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->pBindings != nullptr)
-    {
-    if(pCreateInfo->pBindings->descriptorType < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
-        pCreateInfo->pBindings->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateDescriptorSetLayout parameter, VkDescriptorType pCreateInfo->pBindings->descriptorType, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->pBindings->pImmutableSamplers != nullptr)
-    {
-    }
-    }
+    VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType !=
+            VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateDescriptorSetLayout parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->pBindings != nullptr) {
+            if (pCreateInfo->pBindings->descriptorType <
+                    VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
+                pCreateInfo->pBindings->descriptorType >
+                    VK_DESCRIPTOR_TYPE_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateDescriptorSetLayout parameter, "
+                                      "VkDescriptorType "
+                                      "pCreateInfo->pBindings->descriptorType, "
+                                      "is an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfo->pBindings->pImmutableSamplers != nullptr) {
+            }
+        }
     }
 
     return true;
 }
 
-bool PostCreateDescriptorSetLayout(
-    VkDevice device,
-    VkDescriptorSetLayout* pSetLayout,
-    VkResult result)
-{
+bool PostCreateDescriptorSetLayout(VkDevice device,
+                                   VkDescriptorSetLayout *pSetLayout,
+                                   VkResult result) {
 
-    if(pSetLayout != nullptr)
-    {
+    if (pSetLayout != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateDescriptorSetLayout parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateDescriptorSetLayout parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
@@ -4399,1562 +4091,1471 @@
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
-    VkDevice device,
-    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkDescriptorSetLayout* pSetLayout)
-{
+    VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
+    const VkAllocationCallbacks *pAllocator,
+    VkDescriptorSetLayout *pSetLayout) {
     PreCreateDescriptorSetLayout(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->CreateDescriptorSetLayout(device, pCreateInfo,
+                                                      pAllocator, pSetLayout);
 
     PostCreateDescriptorSetLayout(device, pSetLayout, result);
 
     return result;
 }
 
-bool PreCreateDescriptorPool(
-    VkDevice device,
-    const VkDescriptorPoolCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateDescriptorPool parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->pPoolSizes != nullptr)
-    {
-    if(pCreateInfo->pPoolSizes->type < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
-        pCreateInfo->pPoolSizes->type > VK_DESCRIPTOR_TYPE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateDescriptorPool parameter, VkDescriptorType pCreateInfo->pTypeCount->type, is an unrecognized enumerator");
-        return false;
-    }
-    }
+bool PreCreateDescriptorPool(VkDevice device,
+                             const VkDescriptorPoolCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType !=
+            VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateDescriptorPool parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->pPoolSizes != nullptr) {
+            if (pCreateInfo->pPoolSizes->type <
+                    VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
+                pCreateInfo->pPoolSizes->type > VK_DESCRIPTOR_TYPE_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateDescriptorPool parameter, "
+                                      "VkDescriptorType "
+                                      "pCreateInfo->pTypeCount->type, is an "
+                                      "unrecognized enumerator");
+                return false;
+            }
+        }
     }
 
     return true;
 }
 
-bool PostCreateDescriptorPool(
-    VkDevice device,
-    uint32_t maxSets,
-    VkDescriptorPool* pDescriptorPool,
-    VkResult result)
-{
+bool PostCreateDescriptorPool(VkDevice device, uint32_t maxSets,
+                              VkDescriptorPool *pDescriptorPool,
+                              VkResult result) {
 
-    /* TODOVV: How do we validate maxSets? Probably belongs in the limits layer? */
+    /* TODOVV: How do we validate maxSets? Probably belongs in the limits layer?
+     */
 
-    if(pDescriptorPool != nullptr)
-    {
+    if (pDescriptorPool != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateDescriptorPool parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateDescriptorPool parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
-    VkDevice device,
-    const VkDescriptorPoolCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkDescriptorPool* pDescriptorPool)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateDescriptorPool(VkDevice device,
+                           const VkDescriptorPoolCreateInfo *pCreateInfo,
+                           const VkAllocationCallbacks *pAllocator,
+                           VkDescriptorPool *pDescriptorPool) {
     PreCreateDescriptorPool(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->CreateDescriptorPool(device, pCreateInfo,
+                                                 pAllocator, pDescriptorPool);
 
-    PostCreateDescriptorPool(device, pCreateInfo->maxSets, pDescriptorPool, result);
+    PostCreateDescriptorPool(device, pCreateInfo->maxSets, pDescriptorPool,
+                             result);
 
     return result;
 }
 
-bool PostResetDescriptorPool(
-    VkDevice device,
-    VkDescriptorPool descriptorPool,
-    VkResult result)
-{
+bool PostResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                             VkResult result) {
 
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkResetDescriptorPool parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkResetDescriptorPool parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
-    VkDevice device,
-    VkDescriptorPool descriptorPool,
-    VkDescriptorPoolResetFlags flags)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetDescriptorPool(device, descriptorPool, flags);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                          VkDescriptorPoolResetFlags flags) {
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->ResetDescriptorPool(device, descriptorPool, flags);
 
     PostResetDescriptorPool(device, descriptorPool, result);
 
     return result;
 }
 
-bool PreAllocateDescriptorSets(
-    VkDevice device,
-    const VkDescriptorSetLayout* pSetLayouts)
-{
-    if(pSetLayouts != nullptr)
-    {
+bool PreAllocateDescriptorSets(VkDevice device,
+                               const VkDescriptorSetLayout *pSetLayouts) {
+    if (pSetLayouts != nullptr) {
     }
 
     return true;
 }
 
-bool PostAllocateDescriptorSets(
-    VkDevice device,
-    VkDescriptorPool descriptorPool,
-    uint32_t count,
-    VkDescriptorSet* pDescriptorSets,
-    VkResult result)
-{
+bool PostAllocateDescriptorSets(VkDevice device,
+                                VkDescriptorPool descriptorPool, uint32_t count,
+                                VkDescriptorSet *pDescriptorSets,
+                                VkResult result) {
 
-
-    if(pDescriptorSets != nullptr)
-    {
+    if (pDescriptorSets != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkAllocateDescriptorSets parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkAllocateDescriptorSets parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
-    VkDevice device,
-    const VkDescriptorSetAllocateInfo* pAllocateInfo,
-    VkDescriptorSet* pDescriptorSets)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkAllocateDescriptorSets(VkDevice device,
+                             const VkDescriptorSetAllocateInfo *pAllocateInfo,
+                             VkDescriptorSet *pDescriptorSets) {
     PreAllocateDescriptorSets(device, pAllocateInfo->pSetLayouts);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
 
-    PostAllocateDescriptorSets(device, pAllocateInfo->descriptorPool, pAllocateInfo->descriptorSetCount, pDescriptorSets, result);
+    PostAllocateDescriptorSets(device, pAllocateInfo->descriptorPool,
+                               pAllocateInfo->descriptorSetCount,
+                               pDescriptorSets, result);
 
     return result;
 }
 
-bool PreFreeDescriptorSets(
-    VkDevice device,
-    const VkDescriptorSet* pDescriptorSets)
-{
-    if(pDescriptorSets != nullptr)
-    {
+bool PreFreeDescriptorSets(VkDevice device,
+                           const VkDescriptorSet *pDescriptorSets) {
+    if (pDescriptorSets != nullptr) {
     }
 
     return true;
 }
 
-bool PostFreeDescriptorSets(
-    VkDevice device,
-    VkDescriptorPool descriptorPool,
-    uint32_t count,
-    VkResult result)
-{
+bool PostFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+                            uint32_t count, VkResult result) {
 
-
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkFreeDescriptorSets parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkFreeDescriptorSets parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
-    VkDevice device,
-    VkDescriptorPool descriptorPool,
-    uint32_t count,
-    const VkDescriptorSet* pDescriptorSets)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+                         uint32_t count,
+                         const VkDescriptorSet *pDescriptorSets) {
     PreFreeDescriptorSets(device, pDescriptorSets);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->FreeDescriptorSets(device, descriptorPool, count,
+                                               pDescriptorSets);
 
     PostFreeDescriptorSets(device, descriptorPool, count, result);
 
     return result;
 }
 
-bool PreUpdateDescriptorSets(
-    VkDevice device,
-    const VkWriteDescriptorSet* pDescriptorWrites,
-    const VkCopyDescriptorSet* pDescriptorCopies)
-{
-    if(pDescriptorWrites != nullptr)
-    {
-    if(pDescriptorWrites->sType != VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkUpdateDescriptorSets parameter, VkStructureType pDescriptorWrites->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pDescriptorWrites->descriptorType < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
-        pDescriptorWrites->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkUpdateDescriptorSets parameter, VkDescriptorType pDescriptorWrites->descriptorType, is an unrecognized enumerator");
-        return false;
-    }
-    /* TODO: Validate other parts of pImageInfo, pBufferInfo, pTexelBufferView? */
-    /* TODO: This test should probably only be done if descriptorType is correct type of descriptor */
-    if(pDescriptorWrites->pImageInfo != nullptr)
-    {
-    if (((pDescriptorWrites->pImageInfo->imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (pDescriptorWrites->pImageInfo->imageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (pDescriptorWrites->pImageInfo->imageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkUpdateDescriptorSets parameter, VkImageLayout pDescriptorWrites->pDescriptors->imageLayout, is an unrecognized enumerator");
-        return false;
-    }
-    }
+bool PreUpdateDescriptorSets(VkDevice device,
+                             const VkWriteDescriptorSet *pDescriptorWrites,
+                             const VkCopyDescriptorSet *pDescriptorCopies) {
+    if (pDescriptorWrites != nullptr) {
+        if (pDescriptorWrites->sType !=
+            VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkUpdateDescriptorSets parameter, VkStructureType "
+                    "pDescriptorWrites->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pDescriptorWrites->descriptorType <
+                VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
+            pDescriptorWrites->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkUpdateDescriptorSets parameter, VkDescriptorType "
+                    "pDescriptorWrites->descriptorType, is an unrecognized "
+                    "enumerator");
+            return false;
+        }
+        /* TODO: Validate other parts of pImageInfo, pBufferInfo,
+         * pTexelBufferView? */
+        /* TODO: This test should probably only be done if descriptorType is
+         * correct type of descriptor */
+        if (pDescriptorWrites->pImageInfo != nullptr) {
+            if (((pDescriptorWrites->pImageInfo->imageLayout <
+                  VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
+                 (pDescriptorWrites->pImageInfo->imageLayout >
+                  VK_IMAGE_LAYOUT_END_RANGE)) &&
+                (pDescriptorWrites->pImageInfo->imageLayout !=
+                 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkUpdateDescriptorSets parameter, VkImageLayout "
+                        "pDescriptorWrites->pDescriptors->imageLayout, is an "
+                        "unrecognized enumerator");
+                return false;
+            }
+        }
     }
 
-    if(pDescriptorCopies != nullptr)
-    {
-    if(pDescriptorCopies->sType != VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkUpdateDescriptorSets parameter, VkStructureType pDescriptorCopies->sType, is an invalid enumerator");
-        return false;
-    }
+    if (pDescriptorCopies != nullptr) {
+        if (pDescriptorCopies->sType != VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkUpdateDescriptorSets parameter, VkStructureType "
+                    "pDescriptorCopies->sType, is an invalid enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
-    VkDevice device,
-    uint32_t descriptorWriteCount,
-    const VkWriteDescriptorSet* pDescriptorWrites,
-    uint32_t descriptorCopyCount,
-    const VkCopyDescriptorSet* pDescriptorCopies)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+                           const VkWriteDescriptorSet *pDescriptorWrites,
+                           uint32_t descriptorCopyCount,
+                           const VkCopyDescriptorSet *pDescriptorCopies) {
     PreUpdateDescriptorSets(device, pDescriptorWrites, pDescriptorCopies);
 
-    get_dispatch_table(pc_device_table_map, device)->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+    get_dispatch_table(pc_device_table_map, device)
+        ->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites,
+                               descriptorCopyCount, pDescriptorCopies);
 }
 
-bool PreCreateFramebuffer(
-    VkDevice device,
-    const VkFramebufferCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateFramebuffer parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->pAttachments != nullptr)
-    {
-    }
+bool PreCreateFramebuffer(VkDevice device,
+                          const VkFramebufferCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateFramebuffer parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->pAttachments != nullptr) {
+        }
     }
 
     return true;
 }
 
-bool PostCreateFramebuffer(
-    VkDevice device,
-    VkFramebuffer* pFramebuffer,
-    VkResult result)
-{
+bool PostCreateFramebuffer(VkDevice device, VkFramebuffer *pFramebuffer,
+                           VkResult result) {
 
-    if(pFramebuffer != nullptr)
-    {
+    if (pFramebuffer != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateFramebuffer parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateFramebuffer parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
-    VkDevice device,
-    const VkFramebufferCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkFramebuffer* pFramebuffer)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateFramebuffer(VkDevice device,
+                        const VkFramebufferCreateInfo *pCreateInfo,
+                        const VkAllocationCallbacks *pAllocator,
+                        VkFramebuffer *pFramebuffer) {
     PreCreateFramebuffer(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
 
     PostCreateFramebuffer(device, pFramebuffer, result);
 
     return result;
 }
 
-bool PreCreateRenderPass(
-    VkDevice device,
-    const VkRenderPassCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->pAttachments != nullptr)
-    {
-    if(pCreateInfo->pAttachments->format < VK_FORMAT_BEGIN_RANGE ||
-        pCreateInfo->pAttachments->format > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkFormat pCreateInfo->pAttachments->format, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->pAttachments->loadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
-        pCreateInfo->pAttachments->loadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->pAttachments->loadOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->pAttachments->storeOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
-        pCreateInfo->pAttachments->storeOp > VK_ATTACHMENT_STORE_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->pAttachments->storeOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->pAttachments->stencilLoadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
-        pCreateInfo->pAttachments->stencilLoadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->pAttachments->stencilLoadOp, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->pAttachments->stencilStoreOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
-        pCreateInfo->pAttachments->stencilStoreOp > VK_ATTACHMENT_STORE_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->pAttachments->stencilStoreOp, is an unrecognized enumerator");
-        return false;
-    }
-    if (((pCreateInfo->pAttachments->initialLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (pCreateInfo->pAttachments->initialLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (pCreateInfo->pAttachments->initialLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pAttachments->initialLayout, is an unrecognized enumerator");
-        return false;
-    }
-    if (((pCreateInfo->pAttachments->initialLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (pCreateInfo->pAttachments->initialLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (pCreateInfo->pAttachments->initialLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pAttachments->finalLayout, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfo->pSubpasses != nullptr)
-    {
-    if(pCreateInfo->pSubpasses->pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
-        pCreateInfo->pSubpasses->pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkPipelineBindPoint pCreateInfo->pSubpasses->pipelineBindPoint, is an unrecognized enumerator");
-        return false;
-    }
-    if(pCreateInfo->pSubpasses->pInputAttachments != nullptr)
-    {
-    if (((pCreateInfo->pSubpasses->pInputAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (pCreateInfo->pSubpasses->pInputAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (pCreateInfo->pSubpasses->pInputAttachments->layout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pSubpasses->pInputAttachments->layout, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfo->pSubpasses->pColorAttachments != nullptr)
-    {
-    if (((pCreateInfo->pSubpasses->pColorAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (pCreateInfo->pSubpasses->pColorAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (pCreateInfo->pSubpasses->pColorAttachments->layout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pSubpasses->pColorAttachments->layout, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfo->pSubpasses->pResolveAttachments != nullptr)
-    {
-    if (((pCreateInfo->pSubpasses->pResolveAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (pCreateInfo->pSubpasses->pResolveAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (pCreateInfo->pSubpasses->pResolveAttachments->layout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pSubpasses->pResolveAttachments->layout, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfo->pSubpasses->pDepthStencilAttachment &&
-        ((pCreateInfo->pSubpasses->pDepthStencilAttachment->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (pCreateInfo->pSubpasses->pDepthStencilAttachment->layout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (pCreateInfo->pSubpasses->pDepthStencilAttachment->layout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pSubpasses->pDepthStencilAttachment->layout, is an unrecognized enumerator");
-        return false;
-    }
-    }
-    if(pCreateInfo->pDependencies != nullptr)
-    {
-    }
+bool PreCreateRenderPass(VkDevice device,
+                         const VkRenderPassCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateRenderPass parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->pAttachments != nullptr) {
+            if (pCreateInfo->pAttachments->format < VK_FORMAT_BEGIN_RANGE ||
+                pCreateInfo->pAttachments->format > VK_FORMAT_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateRenderPass parameter, VkFormat "
+                                      "pCreateInfo->pAttachments->format, is "
+                                      "an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfo->pAttachments->loadOp <
+                    VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
+                pCreateInfo->pAttachments->loadOp >
+                    VK_ATTACHMENT_LOAD_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateRenderPass parameter, "
+                                      "VkAttachmentLoadOp "
+                                      "pCreateInfo->pAttachments->loadOp, is "
+                                      "an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfo->pAttachments->storeOp <
+                    VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
+                pCreateInfo->pAttachments->storeOp >
+                    VK_ATTACHMENT_STORE_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateRenderPass parameter, "
+                                      "VkAttachmentStoreOp "
+                                      "pCreateInfo->pAttachments->storeOp, is "
+                                      "an unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfo->pAttachments->stencilLoadOp <
+                    VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
+                pCreateInfo->pAttachments->stencilLoadOp >
+                    VK_ATTACHMENT_LOAD_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateRenderPass parameter, VkAttachmentLoadOp "
+                        "pCreateInfo->pAttachments->stencilLoadOp, is an "
+                        "unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfo->pAttachments->stencilStoreOp <
+                    VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
+                pCreateInfo->pAttachments->stencilStoreOp >
+                    VK_ATTACHMENT_STORE_OP_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateRenderPass parameter, VkAttachmentStoreOp "
+                        "pCreateInfo->pAttachments->stencilStoreOp, is an "
+                        "unrecognized enumerator");
+                return false;
+            }
+            if (((pCreateInfo->pAttachments->initialLayout <
+                  VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
+                 (pCreateInfo->pAttachments->initialLayout >
+                  VK_IMAGE_LAYOUT_END_RANGE)) &&
+                (pCreateInfo->pAttachments->initialLayout !=
+                 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateRenderPass parameter, VkImageLayout "
+                        "pCreateInfo->pAttachments->initialLayout, is an "
+                        "unrecognized enumerator");
+                return false;
+            }
+            if (((pCreateInfo->pAttachments->initialLayout <
+                  VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
+                 (pCreateInfo->pAttachments->initialLayout >
+                  VK_IMAGE_LAYOUT_END_RANGE)) &&
+                (pCreateInfo->pAttachments->initialLayout !=
+                 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK", "vkCreateRenderPass parameter, "
+                                      "VkImageLayout "
+                                      "pCreateInfo->pAttachments->finalLayout, "
+                                      "is an unrecognized enumerator");
+                return false;
+            }
+        }
+        if (pCreateInfo->pSubpasses != nullptr) {
+            if (pCreateInfo->pSubpasses->pipelineBindPoint <
+                    VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
+                pCreateInfo->pSubpasses->pipelineBindPoint >
+                    VK_PIPELINE_BIND_POINT_END_RANGE) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateRenderPass parameter, VkPipelineBindPoint "
+                        "pCreateInfo->pSubpasses->pipelineBindPoint, is an "
+                        "unrecognized enumerator");
+                return false;
+            }
+            if (pCreateInfo->pSubpasses->pInputAttachments != nullptr) {
+                if (((pCreateInfo->pSubpasses->pInputAttachments->layout <
+                      VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
+                     (pCreateInfo->pSubpasses->pInputAttachments->layout >
+                      VK_IMAGE_LAYOUT_END_RANGE)) &&
+                    (pCreateInfo->pSubpasses->pInputAttachments->layout !=
+                     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK",
+                            "vkCreateRenderPass parameter, VkImageLayout "
+                            "pCreateInfo->pSubpasses->pInputAttachments->"
+                            "layout, is an unrecognized enumerator");
+                    return false;
+                }
+            }
+            if (pCreateInfo->pSubpasses->pColorAttachments != nullptr) {
+                if (((pCreateInfo->pSubpasses->pColorAttachments->layout <
+                      VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
+                     (pCreateInfo->pSubpasses->pColorAttachments->layout >
+                      VK_IMAGE_LAYOUT_END_RANGE)) &&
+                    (pCreateInfo->pSubpasses->pColorAttachments->layout !=
+                     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK",
+                            "vkCreateRenderPass parameter, VkImageLayout "
+                            "pCreateInfo->pSubpasses->pColorAttachments->"
+                            "layout, is an unrecognized enumerator");
+                    return false;
+                }
+            }
+            if (pCreateInfo->pSubpasses->pResolveAttachments != nullptr) {
+                if (((pCreateInfo->pSubpasses->pResolveAttachments->layout <
+                      VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
+                     (pCreateInfo->pSubpasses->pResolveAttachments->layout >
+                      VK_IMAGE_LAYOUT_END_RANGE)) &&
+                    (pCreateInfo->pSubpasses->pResolveAttachments->layout !=
+                     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+                    log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                            "PARAMCHECK",
+                            "vkCreateRenderPass parameter, VkImageLayout "
+                            "pCreateInfo->pSubpasses->pResolveAttachments->"
+                            "layout, is an unrecognized enumerator");
+                    return false;
+                }
+            }
+            if (pCreateInfo->pSubpasses->pDepthStencilAttachment &&
+                ((pCreateInfo->pSubpasses->pDepthStencilAttachment->layout <
+                  VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
+                 (pCreateInfo->pSubpasses->pDepthStencilAttachment->layout >
+                  VK_IMAGE_LAYOUT_END_RANGE)) &&
+                (pCreateInfo->pSubpasses->pDepthStencilAttachment->layout !=
+                 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+                log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1,
+                        "PARAMCHECK",
+                        "vkCreateRenderPass parameter, VkImageLayout "
+                        "pCreateInfo->pSubpasses->pDepthStencilAttachment->"
+                        "layout, is an unrecognized enumerator");
+                return false;
+            }
+        }
+        if (pCreateInfo->pDependencies != nullptr) {
+        }
     }
 
     return true;
 }
 
-bool PostCreateRenderPass(
-    VkDevice device,
-    VkRenderPass* pRenderPass,
-    VkResult result)
-{
+bool PostCreateRenderPass(VkDevice device, VkRenderPass *pRenderPass,
+                          VkResult result) {
 
-    if(pRenderPass != nullptr)
-    {
+    if (pRenderPass != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateRenderPass parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateRenderPass parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
-    VkDevice device,
-    const VkRenderPassCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkRenderPass* pRenderPass)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateRenderPass(VkDevice device,
+                       const VkRenderPassCreateInfo *pCreateInfo,
+                       const VkAllocationCallbacks *pAllocator,
+                       VkRenderPass *pRenderPass) {
     PreCreateRenderPass(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 
     PostCreateRenderPass(device, pRenderPass, result);
 
     return result;
 }
 
-bool PostGetRenderAreaGranularity(
-    VkDevice device,
-    VkRenderPass renderPass,
-    VkExtent2D* pGranularity)
-{
+bool PostGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
+                                  VkExtent2D *pGranularity) {
 
-
-    if(pGranularity != nullptr)
-    {
+    if (pGranularity != nullptr) {
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
-    VkDevice device,
-    VkRenderPass renderPass,
-    VkExtent2D* pGranularity)
-{
-    get_dispatch_table(pc_device_table_map, device)->GetRenderAreaGranularity(device, renderPass, pGranularity);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
+                               VkExtent2D *pGranularity) {
+    get_dispatch_table(pc_device_table_map, device)
+        ->GetRenderAreaGranularity(device, renderPass, pGranularity);
 
     PostGetRenderAreaGranularity(device, renderPass, pGranularity);
 }
 
-bool PreCreateCommandPool(
-    VkDevice device,
-    const VkCommandPoolCreateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCreateCommandPool parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
+bool PreCreateCommandPool(VkDevice device,
+                          const VkCommandPoolCreateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType != VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCreateCommandPool parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCreateCommandPool(
-    VkDevice device,
-    VkCommandPool* pCommandPool,
-    VkResult result)
-{
+bool PostCreateCommandPool(VkDevice device, VkCommandPool *pCommandPool,
+                           VkResult result) {
 
-    if(pCommandPool != nullptr)
-    {
+    if (pCommandPool != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkCreateCommandPool parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkCreateCommandPool parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
-    VkDevice device,
-    const VkCommandPoolCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkCommandPool* pCommandPool)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateCommandPool(VkDevice device,
+                        const VkCommandPoolCreateInfo *pCreateInfo,
+                        const VkAllocationCallbacks *pAllocator,
+                        VkCommandPool *pCommandPool) {
     PreCreateCommandPool(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
 
     PostCreateCommandPool(device, pCommandPool, result);
 
     return result;
 }
 
-bool PostResetCommandPool(
-    VkDevice device,
-    VkCommandPool commandPool,
-    VkCommandPoolResetFlags flags,
-    VkResult result)
-{
+bool PostResetCommandPool(VkDevice device, VkCommandPool commandPool,
+                          VkCommandPoolResetFlags flags, VkResult result) {
 
-
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkResetCommandPool parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkResetCommandPool parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
-    VkDevice device,
-    VkCommandPool commandPool,
-    VkCommandPoolResetFlags flags)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetCommandPool(device, commandPool, flags);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
+                       VkCommandPoolResetFlags flags) {
+    VkResult result = get_dispatch_table(pc_device_table_map, device)
+                          ->ResetCommandPool(device, commandPool, flags);
 
     PostResetCommandPool(device, commandPool, flags, result);
 
     return result;
 }
 
-bool PreCreateCommandBuffer(
-    VkDevice device,
-    const VkCommandBufferAllocateInfo* pCreateInfo)
-{
-    if(pCreateInfo != nullptr)
-    {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkAllocateCommandBuffers parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pCreateInfo->level < VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE ||
-        pCreateInfo->level > VK_COMMAND_BUFFER_LEVEL_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkAllocateCommandBuffers parameter, VkCommandBufferLevel pCreateInfo->level, is an unrecognized enumerator");
-        return false;
-    }
+bool PreCreateCommandBuffer(VkDevice device,
+                            const VkCommandBufferAllocateInfo *pCreateInfo) {
+    if (pCreateInfo != nullptr) {
+        if (pCreateInfo->sType !=
+            VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkAllocateCommandBuffers parameter, VkStructureType "
+                    "pCreateInfo->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pCreateInfo->level < VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE ||
+            pCreateInfo->level > VK_COMMAND_BUFFER_LEVEL_END_RANGE) {
+            log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkAllocateCommandBuffers parameter, VkCommandBufferLevel "
+                    "pCreateInfo->level, is an unrecognized enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCreateCommandBuffer(
-    VkDevice device,
-    VkCommandBuffer* pCommandBuffer,
-    VkResult result)
-{
+bool PostCreateCommandBuffer(VkDevice device, VkCommandBuffer *pCommandBuffer,
+                             VkResult result) {
 
-    if(pCommandBuffer != nullptr)
-    {
+    if (pCommandBuffer != nullptr) {
     }
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkAllocateCommandBuffers parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkAllocateCommandBuffers parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
-    VkDevice device,
-    const VkCommandBufferAllocateInfo* pCreateInfo,
-    VkCommandBuffer* pCommandBuffer)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkAllocateCommandBuffers(VkDevice device,
+                             const VkCommandBufferAllocateInfo *pCreateInfo,
+                             VkCommandBuffer *pCommandBuffer) {
     PreCreateCommandBuffer(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
+    VkResult result =
+        get_dispatch_table(pc_device_table_map, device)
+            ->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
 
     PostCreateCommandBuffer(device, pCommandBuffer, result);
 
     return result;
 }
 
-bool PreBeginCommandBuffer(
-    VkCommandBuffer commandBuffer,
-    const VkCommandBufferBeginInfo* pBeginInfo)
-{
-    if(pBeginInfo != nullptr)
-    {
-    if(pBeginInfo->sType != VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkBeginCommandBuffer parameter, VkStructureType pBeginInfo->sType, is an invalid enumerator");
-        return false;
-    }
+bool PreBeginCommandBuffer(VkCommandBuffer commandBuffer,
+                           const VkCommandBufferBeginInfo *pBeginInfo) {
+    if (pBeginInfo != nullptr) {
+        if (pBeginInfo->sType != VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO) {
+            log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkBeginCommandBuffer parameter, VkStructureType "
+                    "pBeginInfo->sType, is an invalid enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostBeginCommandBuffer(
-    VkCommandBuffer commandBuffer,
-    VkResult result)
-{
+bool PostBeginCommandBuffer(VkCommandBuffer commandBuffer, VkResult result) {
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkBeginCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkBeginCommandBuffer parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
-    VkCommandBuffer commandBuffer,
-    const VkCommandBufferBeginInfo* pBeginInfo)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
+                         const VkCommandBufferBeginInfo *pBeginInfo) {
     PreBeginCommandBuffer(commandBuffer, pBeginInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo);
+    VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)
+                          ->BeginCommandBuffer(commandBuffer, pBeginInfo);
 
     PostBeginCommandBuffer(commandBuffer, result);
 
     return result;
 }
 
-bool PostEndCommandBuffer(
-    VkCommandBuffer commandBuffer,
-    VkResult result)
-{
+bool PostEndCommandBuffer(VkCommandBuffer commandBuffer, VkResult result) {
 
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkEndCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkEndCommandBuffer parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
-    VkCommandBuffer commandBuffer)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)->EndCommandBuffer(commandBuffer);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+    VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)
+                          ->EndCommandBuffer(commandBuffer);
 
     PostEndCommandBuffer(commandBuffer, result);
 
     return result;
 }
 
-bool PostResetCommandBuffer(
-    VkCommandBuffer commandBuffer,
-    VkCommandBufferResetFlags flags,
-    VkResult result)
-{
+bool PostResetCommandBuffer(VkCommandBuffer commandBuffer,
+                            VkCommandBufferResetFlags flags, VkResult result) {
 
-
-    if(result < VK_SUCCESS)
-    {
-        std::string reason = "vkResetCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK", "%s", reason.c_str());
+    if (result < VK_SUCCESS) {
+        std::string reason =
+            "vkResetCommandBuffer parameter, VkResult result, is " +
+            EnumeratorString(result);
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "%s", reason.c_str());
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
-    VkCommandBuffer commandBuffer,
-    VkCommandBufferResetFlags flags)
-{
-    VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)->ResetCommandBuffer(commandBuffer, flags);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkResetCommandBuffer(VkCommandBuffer commandBuffer,
+                         VkCommandBufferResetFlags flags) {
+    VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)
+                          ->ResetCommandBuffer(commandBuffer, flags);
 
     PostResetCommandBuffer(commandBuffer, flags, result);
 
     return result;
 }
 
-bool PostCmdBindPipeline(
-    VkCommandBuffer commandBuffer,
-    VkPipelineBindPoint pipelineBindPoint,
-    VkPipeline pipeline)
-{
+bool PostCmdBindPipeline(VkCommandBuffer commandBuffer,
+                         VkPipelineBindPoint pipelineBindPoint,
+                         VkPipeline pipeline) {
 
-    if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
-        pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdBindPipeline parameter, VkPipelineBindPoint pipelineBindPoint, is an unrecognized enumerator");
+    if (pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
+        pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdBindPipeline parameter, VkPipelineBindPoint "
+                "pipelineBindPoint, is an unrecognized enumerator");
         return false;
     }
 
-
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
-    VkCommandBuffer commandBuffer,
-    VkPipelineBindPoint pipelineBindPoint,
-    VkPipeline pipeline)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdBindPipeline(VkCommandBuffer commandBuffer,
+                      VkPipelineBindPoint pipelineBindPoint,
+                      VkPipeline pipeline) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 
     PostCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+                     uint32_t viewportCount, const VkViewport *pViewports) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetViewport(
+        commandBuffer, firstViewport, viewportCount, pViewports);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
+                    uint32_t scissorCount, const VkRect2D *pScissors) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdSetLineWidth(commandBuffer, lineWidth);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdSetDepthBias(VkCommandBuffer commandBuffer,
+                      float depthBiasConstantFactor, float depthBiasClamp,
+                      float depthBiasSlopeFactor) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor,
+                          depthBiasClamp, depthBiasSlopeFactor);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
+                           const float blendConstants[4]) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdSetBlendConstants(commandBuffer, blendConstants);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
+                        float maxDepthBounds) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
+                               VkStencilFaceFlags faceMask,
+                               uint32_t compareMask) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
+                             VkStencilFaceFlags faceMask, uint32_t writeMask) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
+                             VkStencilFaceFlags faceMask, uint32_t reference) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdSetStencilReference(commandBuffer, faceMask, reference);
 }
 
-bool PreCmdBindDescriptorSets(
-    VkCommandBuffer commandBuffer,
-    const VkDescriptorSet* pDescriptorSets,
-    const uint32_t* pDynamicOffsets)
-{
-    if(pDescriptorSets != nullptr)
-    {
+bool PreCmdBindDescriptorSets(VkCommandBuffer commandBuffer,
+                              const VkDescriptorSet *pDescriptorSets,
+                              const uint32_t *pDynamicOffsets) {
+    if (pDescriptorSets != nullptr) {
     }
 
-    if(pDynamicOffsets != nullptr)
-    {
+    if (pDynamicOffsets != nullptr) {
     }
 
     return true;
 }
 
-bool PostCmdBindDescriptorSets(
-    VkCommandBuffer commandBuffer,
-    VkPipelineBindPoint pipelineBindPoint,
-    VkPipelineLayout layout,
-    uint32_t firstSet,
-    uint32_t setCount,
-    uint32_t dynamicOffsetCount)
-{
+bool PostCmdBindDescriptorSets(VkCommandBuffer commandBuffer,
+                               VkPipelineBindPoint pipelineBindPoint,
+                               VkPipelineLayout layout, uint32_t firstSet,
+                               uint32_t setCount, uint32_t dynamicOffsetCount) {
 
-    if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
-        pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdBindDescriptorSets parameter, VkPipelineBindPoint pipelineBindPoint, is an unrecognized enumerator");
+    if (pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
+        pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdBindDescriptorSets parameter, VkPipelineBindPoint "
+                "pipelineBindPoint, is an unrecognized enumerator");
         return false;
     }
 
-
-
-
-
     return true;
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
-    VkCommandBuffer commandBuffer,
-    VkPipelineBindPoint pipelineBindPoint,
-    VkPipelineLayout layout,
-    uint32_t firstSet,
-    uint32_t setCount,
-    const VkDescriptorSet* pDescriptorSets,
-    uint32_t dynamicOffsetCount,
-    const uint32_t* pDynamicOffsets)
-{
+    VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+    VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount,
+    const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
+    const uint32_t *pDynamicOffsets) {
     PreCmdBindDescriptorSets(commandBuffer, pDescriptorSets, pDynamicOffsets);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout,
+                                firstSet, setCount, pDescriptorSets,
+                                dynamicOffsetCount, pDynamicOffsets);
 
-    PostCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, dynamicOffsetCount);
+    PostCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout,
+                              firstSet, setCount, dynamicOffsetCount);
 }
 
-bool PostCmdBindIndexBuffer(
-    VkCommandBuffer commandBuffer,
-    VkBuffer buffer,
-    VkDeviceSize offset,
-    VkIndexType indexType)
-{
+bool PostCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                            VkDeviceSize offset, VkIndexType indexType) {
 
-
-
-    if(indexType < VK_INDEX_TYPE_BEGIN_RANGE ||
-        indexType > VK_INDEX_TYPE_END_RANGE)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdBindIndexBuffer parameter, VkIndexType indexType, is an unrecognized enumerator");
+    if (indexType < VK_INDEX_TYPE_BEGIN_RANGE ||
+        indexType > VK_INDEX_TYPE_END_RANGE) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdBindIndexBuffer parameter, VkIndexType indexType, is an "
+                "unrecognized enumerator");
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
-    VkCommandBuffer commandBuffer,
-    VkBuffer buffer,
-    VkDeviceSize offset,
-    VkIndexType indexType)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                         VkDeviceSize offset, VkIndexType indexType) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 
     PostCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 }
 
-bool PreCmdBindVertexBuffers(
-    VkCommandBuffer commandBuffer,
-    const VkBuffer* pBuffers,
-    const VkDeviceSize* pOffsets)
-{
-    if(pBuffers != nullptr)
-    {
+bool PreCmdBindVertexBuffers(VkCommandBuffer commandBuffer,
+                             const VkBuffer *pBuffers,
+                             const VkDeviceSize *pOffsets) {
+    if (pBuffers != nullptr) {
     }
 
-    if(pOffsets != nullptr)
-    {
+    if (pOffsets != nullptr) {
     }
 
     return true;
 }
 
-bool PostCmdBindVertexBuffers(
-    VkCommandBuffer commandBuffer,
-    uint32_t firstBinding,
-    uint32_t bindingCount)
-{
-
-
+bool PostCmdBindVertexBuffers(VkCommandBuffer commandBuffer,
+                              uint32_t firstBinding, uint32_t bindingCount) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
-    VkCommandBuffer commandBuffer,
-    uint32_t firstBinding,
-    uint32_t bindingCount,
-    const VkBuffer* pBuffers,
-    const VkDeviceSize* pOffsets)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                           uint32_t bindingCount, const VkBuffer *pBuffers,
+                           const VkDeviceSize *pOffsets) {
     PreCmdBindVertexBuffers(commandBuffer, pBuffers, pOffsets);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount,
+                               pBuffers, pOffsets);
 
     PostCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount);
 }
 
-bool PreCmdDraw(
-    VkCommandBuffer commandBuffer,
-    uint32_t vertexCount,
-    uint32_t instanceCount,
-    uint32_t firstVertex,
-    uint32_t firstInstance)
-{
+bool PreCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
+                uint32_t instanceCount, uint32_t firstVertex,
+                uint32_t firstInstance) {
     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
+        // TODO: Verify against Valid Usage section. I don't see a non-zero
+        // vertexCount listed, may need to add that and make
         // this an error or leave as is.
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdDraw parameter, uint32_t vertexCount, is 0");
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_WARN_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdDraw parameter, uint32_t vertexCount, is 0");
         return false;
     }
 
     if (instanceCount == 0) {
-        // TODO: Verify against Valid Usage section. I don't see a non-zero instanceCount listed, may need to add that and make
+        // TODO: Verify against Valid Usage section. I don't see a non-zero
+        // instanceCount listed, may need to add that and make
         // this an error or leave as is.
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdDraw parameter, uint32_t instanceCount, is 0");
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_WARN_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdDraw parameter, uint32_t instanceCount, is 0");
         return false;
     }
 
     return true;
 }
 
-bool PostCmdDraw(
-    VkCommandBuffer commandBuffer,
-    uint32_t firstVertex,
-    uint32_t vertexCount,
-    uint32_t firstInstance,
-    uint32_t instanceCount)
-{
-
-
-
-
+bool PostCmdDraw(VkCommandBuffer commandBuffer, uint32_t firstVertex,
+                 uint32_t vertexCount, uint32_t firstInstance,
+                 uint32_t instanceCount) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
-    VkCommandBuffer commandBuffer,
-    uint32_t vertexCount,
-    uint32_t instanceCount,
-    uint32_t firstVertex,
-    uint32_t firstInstance)
-{
-    PreCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
+              uint32_t instanceCount, uint32_t firstVertex,
+              uint32_t firstInstance) {
+    PreCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex,
+               firstInstance);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDraw(
+        commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
 
-    PostCmdDraw(commandBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
+    PostCmdDraw(commandBuffer, firstVertex, vertexCount, firstInstance,
+                instanceCount);
 }
 
-bool PostCmdDrawIndexed(
-    VkCommandBuffer commandBuffer,
-    uint32_t firstIndex,
-    uint32_t indexCount,
-    int32_t vertexOffset,
-    uint32_t firstInstance,
-    uint32_t instanceCount)
-{
-
-
-
-
-
+bool PostCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t firstIndex,
+                        uint32_t indexCount, int32_t vertexOffset,
+                        uint32_t firstInstance, uint32_t instanceCount) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
-    VkCommandBuffer commandBuffer,
-    uint32_t indexCount,
-    uint32_t instanceCount,
-    uint32_t firstIndex,
-    int32_t vertexOffset,
-    uint32_t firstInstance)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
+                     uint32_t instanceCount, uint32_t firstIndex,
+                     int32_t vertexOffset, uint32_t firstInstance) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex,
+                         vertexOffset, firstInstance);
 
-    PostCmdDrawIndexed(commandBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+    PostCmdDrawIndexed(commandBuffer, firstIndex, indexCount, vertexOffset,
+                       firstInstance, instanceCount);
 }
 
-bool PostCmdDrawIndirect(
-    VkCommandBuffer commandBuffer,
-    VkBuffer buffer,
-    VkDeviceSize offset,
-    uint32_t count,
-    uint32_t stride)
-{
-
-
-
-
+bool PostCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                         VkDeviceSize offset, uint32_t count, uint32_t stride) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
-    VkCommandBuffer commandBuffer,
-    VkBuffer buffer,
-    VkDeviceSize offset,
-    uint32_t count,
-    uint32_t stride)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                      VkDeviceSize offset, uint32_t count, uint32_t stride) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
 
     PostCmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
 }
 
-bool PostCmdDrawIndexedIndirect(
-    VkCommandBuffer commandBuffer,
-    VkBuffer buffer,
-    VkDeviceSize offset,
-    uint32_t count,
-    uint32_t stride)
-{
-
-
-
-
+bool PostCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                VkDeviceSize offset, uint32_t count,
+                                uint32_t stride) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
-    VkCommandBuffer commandBuffer,
-    VkBuffer buffer,
-    VkDeviceSize offset,
-    uint32_t count,
-    uint32_t stride)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                             VkDeviceSize offset, uint32_t count,
+                             uint32_t stride) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
 
     PostCmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
 }
 
-bool PostCmdDispatch(
-    VkCommandBuffer commandBuffer,
-    uint32_t x,
-    uint32_t y,
-    uint32_t z)
-{
-
-
-
+bool PostCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y,
+                     uint32_t z) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
-    VkCommandBuffer commandBuffer,
-    uint32_t x,
-    uint32_t y,
-    uint32_t z)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDispatch(commandBuffer, x, y, z);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y,
+                  uint32_t z) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdDispatch(commandBuffer, x, y, z);
 
     PostCmdDispatch(commandBuffer, x, y, z);
 }
 
-bool PostCmdDispatchIndirect(
-    VkCommandBuffer commandBuffer,
-    VkBuffer buffer,
-    VkDeviceSize offset)
-{
-
-
+bool PostCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                             VkDeviceSize offset) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
-    VkCommandBuffer commandBuffer,
-    VkBuffer buffer,
-    VkDeviceSize offset)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                          VkDeviceSize offset) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdDispatchIndirect(commandBuffer, buffer, offset);
 
     PostCmdDispatchIndirect(commandBuffer, buffer, offset);
 }
 
-bool PreCmdCopyBuffer(
-    VkCommandBuffer commandBuffer,
-    const VkBufferCopy* pRegions)
-{
-    if(pRegions != nullptr)
-    {
+bool PreCmdCopyBuffer(VkCommandBuffer commandBuffer,
+                      const VkBufferCopy *pRegions) {
+    if (pRegions != nullptr) {
     }
 
     return true;
 }
 
-bool PostCmdCopyBuffer(
-    VkCommandBuffer commandBuffer,
-    VkBuffer srcBuffer,
-    VkBuffer dstBuffer,
-    uint32_t regionCount)
-{
-
-
-
+bool PostCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+                       VkBuffer dstBuffer, uint32_t regionCount) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
-    VkCommandBuffer commandBuffer,
-    VkBuffer srcBuffer,
-    VkBuffer dstBuffer,
-    uint32_t regionCount,
-    const VkBufferCopy* pRegions)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+                    VkBuffer dstBuffer, uint32_t regionCount,
+                    const VkBufferCopy *pRegions) {
     PreCmdCopyBuffer(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyBuffer(
+        commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
 
     PostCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount);
 }
 
-bool PreCmdCopyImage(
-    VkCommandBuffer commandBuffer,
-    const VkImageCopy* pRegions)
-{
-    if(pRegions != nullptr)
-    {
-    if ((pRegions->srcSubresource.aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdCopyImage parameter, VkImageAspect pRegions->srcSubresource.aspectMask, is an unrecognized enumerator");
-        return false;
-    }
-    if ((pRegions->dstSubresource.aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdCopyImage parameter, VkImageAspect pRegions->dstSubresource.aspectMask, is an unrecognized enumerator");
-        return false;
-    }
+bool PreCmdCopyImage(VkCommandBuffer commandBuffer,
+                     const VkImageCopy *pRegions) {
+    if (pRegions != nullptr) {
+        if ((pRegions->srcSubresource.aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCmdCopyImage parameter, VkImageAspect "
+                    "pRegions->srcSubresource.aspectMask, is an unrecognized "
+                    "enumerator");
+            return false;
+        }
+        if ((pRegions->dstSubresource.aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCmdCopyImage parameter, VkImageAspect "
+                    "pRegions->dstSubresource.aspectMask, is an unrecognized "
+                    "enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCmdCopyImage(
-    VkCommandBuffer commandBuffer,
-    VkImage srcImage,
-    VkImageLayout srcImageLayout,
-    VkImage dstImage,
-    VkImageLayout dstImageLayout,
-    uint32_t regionCount)
-{
+bool PostCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                      VkImageLayout srcImageLayout, VkImage dstImage,
+                      VkImageLayout dstImageLayout, uint32_t regionCount) {
     if (((srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (srcImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdCopyImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
+         (srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)) &&
+        (srcImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdCopyImage parameter, VkImageLayout srcImageLayout, is an "
+                "unrecognized enumerator");
         return false;
     }
 
-
     if (((dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (dstImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdCopyImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
+         (dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)) &&
+        (dstImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdCopyImage parameter, VkImageLayout dstImageLayout, is an "
+                "unrecognized enumerator");
         return false;
     }
 
-
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
-    VkCommandBuffer commandBuffer,
-    VkImage srcImage,
-    VkImageLayout srcImageLayout,
-    VkImage dstImage,
-    VkImageLayout dstImageLayout,
-    uint32_t regionCount,
-    const VkImageCopy* pRegions)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                   VkImageLayout srcImageLayout, VkImage dstImage,
+                   VkImageLayout dstImageLayout, uint32_t regionCount,
+                   const VkImageCopy *pRegions) {
     PreCmdCopyImage(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage,
+                       dstImageLayout, regionCount, pRegions);
 
-    PostCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount);
+    PostCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage,
+                     dstImageLayout, regionCount);
 }
 
-bool PreCmdBlitImage(
-    VkCommandBuffer commandBuffer,
-    const VkImageBlit* pRegions)
-{
-    if(pRegions != nullptr)
-    {
-    if ((pRegions->srcSubresource.aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdCopyImage parameter, VkImageAspect pRegions->srcSubresource.aspectMask, is an unrecognized enumerator");
-        return false;
-    }
-    if ((pRegions->dstSubresource.aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdCopyImage parameter, VkImageAspect pRegions->dstSubresource.aspectMask, is an unrecognized enumerator");
-        return false;
-    }
+bool PreCmdBlitImage(VkCommandBuffer commandBuffer,
+                     const VkImageBlit *pRegions) {
+    if (pRegions != nullptr) {
+        if ((pRegions->srcSubresource.aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCmdCopyImage parameter, VkImageAspect "
+                    "pRegions->srcSubresource.aspectMask, is an unrecognized "
+                    "enumerator");
+            return false;
+        }
+        if ((pRegions->dstSubresource.aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCmdCopyImage parameter, VkImageAspect "
+                    "pRegions->dstSubresource.aspectMask, is an unrecognized "
+                    "enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCmdBlitImage(
-    VkCommandBuffer commandBuffer,
-    VkImage srcImage,
-    VkImageLayout srcImageLayout,
-    VkImage dstImage,
-    VkImageLayout dstImageLayout,
-    uint32_t regionCount,
-    VkFilter filter)
-{
-
+bool PostCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                      VkImageLayout srcImageLayout, VkImage dstImage,
+                      VkImageLayout dstImageLayout, uint32_t regionCount,
+                      VkFilter filter) {
 
     if (((srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (srcImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdBlitImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
+         (srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)) &&
+        (srcImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdBlitImage parameter, VkImageLayout srcImageLayout, is an "
+                "unrecognized enumerator");
         return false;
     }
 
-
     if (((dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (dstImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdBlitImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
+         (dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)) &&
+        (dstImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdBlitImage parameter, VkImageLayout dstImageLayout, is an "
+                "unrecognized enumerator");
         return false;
     }
 
-
-    if(filter < VK_FILTER_BEGIN_RANGE ||
-        filter > VK_FILTER_END_RANGE)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdBlitImage parameter, VkFilter filter, is an unrecognized enumerator");
+    if (filter < VK_FILTER_BEGIN_RANGE || filter > VK_FILTER_END_RANGE) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdBlitImage parameter, VkFilter filter, is an unrecognized "
+                "enumerator");
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_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)
-{
+VK_LAYER_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) {
     PreCmdBlitImage(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage,
+                       dstImageLayout, regionCount, pRegions, filter);
 
-    PostCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, filter);
+    PostCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage,
+                     dstImageLayout, regionCount, filter);
 }
 
-bool PreCmdCopyBufferToImage(
-    VkCommandBuffer commandBuffer,
-    const VkBufferImageCopy* pRegions)
-{
-    if(pRegions != nullptr)
-    {
-    if ((pRegions->imageSubresource.aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdCopyBufferToImage parameter, VkImageAspect pRegions->imageSubresource.aspectMask, is an unrecognized enumerator");
-        return false;
-    }
+bool PreCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
+                             const VkBufferImageCopy *pRegions) {
+    if (pRegions != nullptr) {
+        if ((pRegions->imageSubresource.aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCmdCopyBufferToImage parameter, VkImageAspect "
+                    "pRegions->imageSubresource.aspectMask, is an unrecognized "
+                    "enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCmdCopyBufferToImage(
-    VkCommandBuffer commandBuffer,
-    VkBuffer srcBuffer,
-    VkImage dstImage,
-    VkImageLayout dstImageLayout,
-    uint32_t regionCount)
-{
-
-
+bool PostCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+                              VkImage dstImage, VkImageLayout dstImageLayout,
+                              uint32_t regionCount) {
 
     if (((dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (dstImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdCopyBufferToImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
+         (dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)) &&
+        (dstImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdCopyBufferToImage parameter, VkImageLayout "
+                "dstImageLayout, is an unrecognized enumerator");
         return false;
     }
 
-
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
-    VkCommandBuffer commandBuffer,
-    VkBuffer srcBuffer,
-    VkImage dstImage,
-    VkImageLayout dstImageLayout,
-    uint32_t regionCount,
-    const VkBufferImageCopy* pRegions)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+                           VkImage dstImage, VkImageLayout dstImageLayout,
+                           uint32_t regionCount,
+                           const VkBufferImageCopy *pRegions) {
     PreCmdCopyBufferToImage(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage,
+                               dstImageLayout, regionCount, pRegions);
 
-    PostCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount);
+    PostCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout,
+                             regionCount);
 }
 
-bool PreCmdCopyImageToBuffer(
-    VkCommandBuffer commandBuffer,
-    const VkBufferImageCopy* pRegions)
-{
-    if(pRegions != nullptr)
-    {
-    if ((pRegions->imageSubresource.aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdCopyImageToBuffer parameter, VkImageAspect pRegions->imageSubresource.aspectMask, is an unrecognized enumerator");
-        return false;
-    }
+bool PreCmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
+                             const VkBufferImageCopy *pRegions) {
+    if (pRegions != nullptr) {
+        if ((pRegions->imageSubresource.aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCmdCopyImageToBuffer parameter, VkImageAspect "
+                    "pRegions->imageSubresource.aspectMask, is an unrecognized "
+                    "enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCmdCopyImageToBuffer(
-    VkCommandBuffer commandBuffer,
-    VkImage srcImage,
-    VkImageLayout srcImageLayout,
-    VkBuffer dstBuffer,
-    uint32_t regionCount)
-{
-
+bool PostCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+                              VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+                              uint32_t regionCount) {
 
     if (((srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (srcImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdCopyImageToBuffer parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
+         (srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)) &&
+        (srcImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdCopyImageToBuffer parameter, VkImageLayout "
+                "srcImageLayout, is an unrecognized enumerator");
         return false;
     }
 
-
-
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
-    VkCommandBuffer commandBuffer,
-    VkImage srcImage,
-    VkImageLayout srcImageLayout,
-    VkBuffer dstBuffer,
-    uint32_t regionCount,
-    const VkBufferImageCopy* pRegions)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+                           VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+                           uint32_t regionCount,
+                           const VkBufferImageCopy *pRegions) {
     PreCmdCopyImageToBuffer(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout,
+                               dstBuffer, regionCount, pRegions);
 
-    PostCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount);
+    PostCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer,
+                             regionCount);
 }
 
-bool PreCmdUpdateBuffer(
-    VkCommandBuffer commandBuffer,
-    const uint32_t* pData)
-{
-    if(pData != nullptr)
-    {
+bool PreCmdUpdateBuffer(VkCommandBuffer commandBuffer, const uint32_t *pData) {
+    if (pData != nullptr) {
     }
 
     return true;
 }
 
-bool PostCmdUpdateBuffer(
-    VkCommandBuffer commandBuffer,
-    VkBuffer dstBuffer,
-    VkDeviceSize dstOffset,
-    VkDeviceSize dataSize)
-{
-
-
-
+bool PostCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+                         VkDeviceSize dstOffset, VkDeviceSize dataSize) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
-    VkCommandBuffer commandBuffer,
-    VkBuffer dstBuffer,
-    VkDeviceSize dstOffset,
-    VkDeviceSize dataSize,
-    const uint32_t* pData)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+                      VkDeviceSize dstOffset, VkDeviceSize dataSize,
+                      const uint32_t *pData) {
     PreCmdUpdateBuffer(commandBuffer, pData);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 
     PostCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize);
 }
 
-bool PostCmdFillBuffer(
-    VkCommandBuffer commandBuffer,
-    VkBuffer dstBuffer,
-    VkDeviceSize dstOffset,
-    VkDeviceSize size,
-    uint32_t data)
-{
-
-
-
-
+bool PostCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+                       VkDeviceSize dstOffset, VkDeviceSize size,
+                       uint32_t data) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
-    VkCommandBuffer commandBuffer,
-    VkBuffer dstBuffer,
-    VkDeviceSize dstOffset,
-    VkDeviceSize size,
-    uint32_t data)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+                    VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 
     PostCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 }
 
-bool PreCmdClearColorImage(
-    VkCommandBuffer commandBuffer,
-    const VkClearColorValue* pColor,
-    const VkImageSubresourceRange* pRanges)
-{
-    if(pColor != nullptr)
-    {
+bool PreCmdClearColorImage(VkCommandBuffer commandBuffer,
+                           const VkClearColorValue *pColor,
+                           const VkImageSubresourceRange *pRanges) {
+    if (pColor != nullptr) {
     }
 
-    if(pRanges != nullptr)
-    {
+    if (pRanges != nullptr) {
         /* TODO: How should we validate pRanges->aspectMask */
     }
 
     return true;
 }
 
-bool PostCmdClearColorImage(
-    VkCommandBuffer commandBuffer,
-    VkImage image,
-    VkImageLayout imageLayout,
-    uint32_t rangeCount)
-{
-
+bool PostCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
+                            VkImageLayout imageLayout, uint32_t rangeCount) {
 
     if (((imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (imageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (imageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdClearColorImage parameter, VkImageLayout imageLayout, is an unrecognized enumerator");
+         (imageLayout > VK_IMAGE_LAYOUT_END_RANGE)) &&
+        (imageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdClearColorImage parameter, VkImageLayout imageLayout, is "
+                "an unrecognized enumerator");
         return false;
     }
 
-
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
-    VkCommandBuffer commandBuffer,
-    VkImage image,
-    VkImageLayout imageLayout,
-    const VkClearColorValue* pColor,
-    uint32_t rangeCount,
-    const VkImageSubresourceRange* pRanges)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
+                         VkImageLayout imageLayout,
+                         const VkClearColorValue *pColor, uint32_t rangeCount,
+                         const VkImageSubresourceRange *pRanges) {
     PreCmdClearColorImage(commandBuffer, pColor, pRanges);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearColorImage(
+        commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 
     PostCmdClearColorImage(commandBuffer, image, imageLayout, rangeCount);
 }
 
-bool PreCmdClearDepthStencilImage(
-    VkCommandBuffer commandBuffer,
-    const VkImageSubresourceRange* pRanges)
-{
-    if(pRanges != nullptr)
-    {
+bool PreCmdClearDepthStencilImage(VkCommandBuffer commandBuffer,
+                                  const VkImageSubresourceRange *pRanges) {
+    if (pRanges != nullptr) {
         /*
          * TODO: How do we validation pRanges->aspectMask?
          * Allows values are: VK_IMAGE_ASPECT_DEPTH_BIT and
@@ -5966,794 +5567,693 @@
 }
 
 bool PostCmdClearDepthStencilImage(
-    VkCommandBuffer commandBuffer,
-    VkImage image,
-    VkImageLayout imageLayout,
-    const VkClearDepthStencilValue* pDepthStencil,
-    uint32_t rangeCount)
-{
-
+    VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
+    const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount) {
 
     if (((imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (imageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (imageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdClearDepthStencilImage parameter, VkImageLayout imageLayout, is an unrecognized enumerator");
+         (imageLayout > VK_IMAGE_LAYOUT_END_RANGE)) &&
+        (imageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdClearDepthStencilImage parameter, VkImageLayout "
+                "imageLayout, is an unrecognized enumerator");
         return false;
     }
 
-
-
-
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
-    VkCommandBuffer commandBuffer,
-    VkImage image,
-    VkImageLayout imageLayout,
-    const VkClearDepthStencilValue* pDepthStencil,
-    uint32_t rangeCount,
-    const VkImageSubresourceRange* pRanges)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
+                                VkImageLayout imageLayout,
+                                const VkClearDepthStencilValue *pDepthStencil,
+                                uint32_t rangeCount,
+                                const VkImageSubresourceRange *pRanges) {
     PreCmdClearDepthStencilImage(commandBuffer, pRanges);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdClearDepthStencilImage(commandBuffer, image, imageLayout,
+                                    pDepthStencil, rangeCount, pRanges);
 
-    PostCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount);
+    PostCmdClearDepthStencilImage(commandBuffer, image, imageLayout,
+                                  pDepthStencil, rangeCount);
 }
 
-bool PreCmdClearAttachments(
-    VkCommandBuffer commandBuffer,
-    const VkClearColorValue* pColor,
-    const VkClearRect* pRects)
-{
-    if(pColor != nullptr)
-    {
+bool PreCmdClearAttachments(VkCommandBuffer commandBuffer,
+                            const VkClearColorValue *pColor,
+                            const VkClearRect *pRects) {
+    if (pColor != nullptr) {
     }
 
-    if(pRects != nullptr)
-    {
+    if (pRects != nullptr) {
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
-    VkCommandBuffer                                 commandBuffer,
-    uint32_t                                    attachmentCount,
-    const VkClearAttachment*                    pAttachments,
-    uint32_t                                    rectCount,
-    const VkClearRect*                          pRects)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdClearAttachments(VkCommandBuffer commandBuffer,
+                          uint32_t attachmentCount,
+                          const VkClearAttachment *pAttachments,
+                          uint32_t rectCount, const VkClearRect *pRects) {
     for (uint32_t i = 0; i < attachmentCount; i++) {
-        PreCmdClearAttachments(commandBuffer, &pAttachments[i].clearValue.color, pRects);
+        PreCmdClearAttachments(commandBuffer, &pAttachments[i].clearValue.color,
+                               pRects);
     }
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearAttachments(
+        commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 }
 
-bool PreCmdResolveImage(
-    VkCommandBuffer commandBuffer,
-    const VkImageResolve* pRegions)
-{
-    if(pRegions != nullptr)
-    {
-    if ((pRegions->srcSubresource.aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdResolveImage parameter, VkImageAspect pRegions->srcSubresource.aspectMask, is an unrecognized enumerator");
-        return false;
-    }
-    if ((pRegions->dstSubresource.aspectMask &
-       (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdResolveImage parameter, VkImageAspect pRegions->dstSubresource.aspectMask, is an unrecognized enumerator");
-        return false;
-    }
+bool PreCmdResolveImage(VkCommandBuffer commandBuffer,
+                        const VkImageResolve *pRegions) {
+    if (pRegions != nullptr) {
+        if ((pRegions->srcSubresource.aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCmdResolveImage parameter, VkImageAspect "
+                    "pRegions->srcSubresource.aspectMask, is an unrecognized "
+                    "enumerator");
+            return false;
+        }
+        if ((pRegions->dstSubresource.aspectMask &
+             (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
+              VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) ==
+            0) {
+            log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCmdResolveImage parameter, VkImageAspect "
+                    "pRegions->dstSubresource.aspectMask, is an unrecognized "
+                    "enumerator");
+            return false;
+        }
     }
 
     return true;
 }
 
-bool PostCmdResolveImage(
-    VkCommandBuffer commandBuffer,
-    VkImage srcImage,
-    VkImageLayout srcImageLayout,
-    VkImage dstImage,
-    VkImageLayout dstImageLayout,
-    uint32_t regionCount)
-{
-
+bool PostCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                         VkImageLayout srcImageLayout, VkImage dstImage,
+                         VkImageLayout dstImageLayout, uint32_t regionCount) {
 
     if (((srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (srcImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdResolveImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
+         (srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)) &&
+        (srcImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdResolveImage parameter, VkImageLayout srcImageLayout, is "
+                "an unrecognized enumerator");
         return false;
     }
 
-
     if (((dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE) ||
-         (dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE))  &&
-        (dstImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR))
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdResolveImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
+         (dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)) &&
+        (dstImageLayout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdResolveImage parameter, VkImageLayout dstImageLayout, is "
+                "an unrecognized enumerator");
         return false;
     }
 
-
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
-    VkCommandBuffer commandBuffer,
-    VkImage srcImage,
-    VkImageLayout srcImageLayout,
-    VkImage dstImage,
-    VkImageLayout dstImageLayout,
-    uint32_t regionCount,
-    const VkImageResolve* pRegions)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                      VkImageLayout srcImageLayout, VkImage dstImage,
+                      VkImageLayout dstImageLayout, uint32_t regionCount,
+                      const VkImageResolve *pRegions) {
     PreCmdResolveImage(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage,
+                          dstImageLayout, regionCount, pRegions);
 
-    PostCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount);
+    PostCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage,
+                        dstImageLayout, regionCount);
 }
 
-bool PostCmdSetEvent(
-    VkCommandBuffer commandBuffer,
-    VkEvent event,
-    VkPipelineStageFlags stageMask)
-{
-
-
+bool PostCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+                     VkPipelineStageFlags stageMask) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
-    VkCommandBuffer commandBuffer,
-    VkEvent event,
-    VkPipelineStageFlags stageMask)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+                  VkPipelineStageFlags stageMask) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdSetEvent(commandBuffer, event, stageMask);
 
     PostCmdSetEvent(commandBuffer, event, stageMask);
 }
 
-bool PostCmdResetEvent(
-    VkCommandBuffer commandBuffer,
-    VkEvent event,
-    VkPipelineStageFlags stageMask)
-{
-
-
+bool PostCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+                       VkPipelineStageFlags stageMask) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
-    VkCommandBuffer commandBuffer,
-    VkEvent event,
-    VkPipelineStageFlags stageMask)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+                    VkPipelineStageFlags stageMask) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdResetEvent(commandBuffer, event, stageMask);
 
     PostCmdResetEvent(commandBuffer, event, stageMask);
 }
 
-bool PreCmdWaitEvents(
-    VkCommandBuffer commandBuffer,
-    const VkEvent* pEvents,
-    uint32_t                     memoryBarrierCount,
-    const VkMemoryBarrier       *pMemoryBarriers,
-    uint32_t                     bufferMemoryBarrierCount,
-    const VkBufferMemoryBarrier *pBufferMemoryBarriers,
-    uint32_t                     imageMemoryBarrierCount,
-    const VkImageMemoryBarrier  *pImageMemoryBarriers)
-{
-    if(pEvents != nullptr)
-    {
+bool PreCmdWaitEvents(VkCommandBuffer commandBuffer, const VkEvent *pEvents,
+                      uint32_t memoryBarrierCount,
+                      const VkMemoryBarrier *pMemoryBarriers,
+                      uint32_t bufferMemoryBarrierCount,
+                      const VkBufferMemoryBarrier *pBufferMemoryBarriers,
+                      uint32_t imageMemoryBarrierCount,
+                      const VkImageMemoryBarrier *pImageMemoryBarriers) {
+    if (pEvents != nullptr) {
     }
 
-    if(pMemoryBarriers != nullptr)
-    {
+    if (pMemoryBarriers != nullptr) {
     }
 
     return true;
 }
 
-bool PostCmdWaitEvents(
-    VkCommandBuffer commandBuffer,
-    uint32_t eventCount,
-    VkPipelineStageFlags srcStageMask,
-    VkPipelineStageFlags dstStageMask,
-    uint32_t memoryBarrierCount)
-{
-
-
-
-
+bool PostCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
+                       VkPipelineStageFlags srcStageMask,
+                       VkPipelineStageFlags dstStageMask,
+                       uint32_t memoryBarrierCount) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
-    VkCommandBuffer              commandBuffer,
-    uint32_t                     eventCount,
-    const VkEvent               *pEvents,
-    VkPipelineStageFlags         srcStageMask,
-    VkPipelineStageFlags         dstStageMask,
-    uint32_t                     memoryBarrierCount,
-    const VkMemoryBarrier       *pMemoryBarriers,
-    uint32_t                     bufferMemoryBarrierCount,
-    const VkBufferMemoryBarrier *pBufferMemoryBarriers,
-    uint32_t                     imageMemoryBarrierCount,
-    const VkImageMemoryBarrier  *pImageMemoryBarriers)
-{
-    PreCmdWaitEvents(commandBuffer, pEvents, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
+                    const VkEvent *pEvents, VkPipelineStageFlags srcStageMask,
+                    VkPipelineStageFlags dstStageMask,
+                    uint32_t memoryBarrierCount,
+                    const VkMemoryBarrier *pMemoryBarriers,
+                    uint32_t bufferMemoryBarrierCount,
+                    const VkBufferMemoryBarrier *pBufferMemoryBarriers,
+                    uint32_t imageMemoryBarrierCount,
+                    const VkImageMemoryBarrier *pImageMemoryBarriers) {
+    PreCmdWaitEvents(commandBuffer, pEvents, memoryBarrierCount,
+                     pMemoryBarriers, bufferMemoryBarrierCount,
+                     pBufferMemoryBarriers, imageMemoryBarrierCount,
+                     pImageMemoryBarriers);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdWaitEvents(
+        commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask,
+        memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+        pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 
-    PostCmdWaitEvents(commandBuffer, eventCount, srcStageMask, dstStageMask, memoryBarrierCount);
+    PostCmdWaitEvents(commandBuffer, eventCount, srcStageMask, dstStageMask,
+                      memoryBarrierCount);
 }
 
-bool PreCmdPipelineBarrier(
-    VkCommandBuffer              commandBuffer,
-    uint32_t                     memoryBarrierCount,
-    const VkMemoryBarrier       *pMemoryBarriers,
-    uint32_t                     bufferMemoryBarrierCount,
-    const VkBufferMemoryBarrier *pBufferMemoryBarriers,
-    uint32_t                     imageMemoryBarrierCount,
-    const VkImageMemoryBarrier  *pImageMemoryBarriers)
-{
-    if(pMemoryBarriers != nullptr)
-    {
+bool PreCmdPipelineBarrier(VkCommandBuffer commandBuffer,
+                           uint32_t memoryBarrierCount,
+                           const VkMemoryBarrier *pMemoryBarriers,
+                           uint32_t bufferMemoryBarrierCount,
+                           const VkBufferMemoryBarrier *pBufferMemoryBarriers,
+                           uint32_t imageMemoryBarrierCount,
+                           const VkImageMemoryBarrier *pImageMemoryBarriers) {
+    if (pMemoryBarriers != nullptr) {
     }
 
     return true;
 }
 
-bool PostCmdPipelineBarrier(
-    VkCommandBuffer commandBuffer,
-    VkPipelineStageFlags srcStageMask,
-    VkPipelineStageFlags dstStageMask,
-    VkDependencyFlags dependencyFlags,
-    uint32_t memoryBarrierCount)
-{
-
-
-
-
+bool PostCmdPipelineBarrier(VkCommandBuffer commandBuffer,
+                            VkPipelineStageFlags srcStageMask,
+                            VkPipelineStageFlags dstStageMask,
+                            VkDependencyFlags dependencyFlags,
+                            uint32_t memoryBarrierCount) {
 
     return true;
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
-    VkCommandBuffer              commandBuffer,
-    VkPipelineStageFlags         srcStageMask,
-    VkPipelineStageFlags         dstStageMask,
-    VkDependencyFlags            dependencyFlags,
-    uint32_t                     memoryBarrierCount,
-    const VkMemoryBarrier       *pMemoryBarriers,
-    uint32_t                     bufferMemoryBarrierCount,
+    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)
-{
-    PreCmdPipelineBarrier(commandBuffer, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+    uint32_t imageMemoryBarrierCount,
+    const VkImageMemoryBarrier *pImageMemoryBarriers) {
+    PreCmdPipelineBarrier(commandBuffer, memoryBarrierCount, pMemoryBarriers,
+                          bufferMemoryBarrierCount, pBufferMemoryBarriers,
+                          imageMemoryBarrierCount, pImageMemoryBarriers);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdPipelineBarrier(
+        commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
+        memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+        pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 
-    PostCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount);
+    PostCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask,
+                           dependencyFlags, memoryBarrierCount);
 }
 
-bool PostCmdBeginQuery(
-    VkCommandBuffer commandBuffer,
-    VkQueryPool queryPool,
-    uint32_t slot,
-    VkQueryControlFlags flags)
-{
-
-
-
+bool PostCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                       uint32_t slot, VkQueryControlFlags flags) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
-    VkCommandBuffer commandBuffer,
-    VkQueryPool queryPool,
-    uint32_t slot,
-    VkQueryControlFlags flags)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                    uint32_t slot, VkQueryControlFlags flags) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
 
     PostCmdBeginQuery(commandBuffer, queryPool, slot, flags);
 }
 
-bool PostCmdEndQuery(
-    VkCommandBuffer commandBuffer,
-    VkQueryPool queryPool,
-    uint32_t slot)
-{
-
-
+bool PostCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                     uint32_t slot) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
-    VkCommandBuffer commandBuffer,
-    VkQueryPool queryPool,
-    uint32_t slot)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdEndQuery(commandBuffer, queryPool, slot);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                  uint32_t slot) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdEndQuery(commandBuffer, queryPool, slot);
 
     PostCmdEndQuery(commandBuffer, queryPool, slot);
 }
 
-bool PostCmdResetQueryPool(
-    VkCommandBuffer commandBuffer,
-    VkQueryPool queryPool,
-    uint32_t firstQuery,
-    uint32_t queryCount)
-{
-
-
-
+bool PostCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                           uint32_t firstQuery, uint32_t queryCount) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
-    VkCommandBuffer commandBuffer,
-    VkQueryPool queryPool,
-    uint32_t firstQuery,
-    uint32_t queryCount)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                        uint32_t firstQuery, uint32_t queryCount) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
 
     PostCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
 }
 
-bool PostCmdWriteTimestamp(
-    VkCommandBuffer commandBuffer,
-    VkPipelineStageFlagBits pipelineStage,
-    VkQueryPool queryPool,
-    uint32_t slot)
-{
+bool PostCmdWriteTimestamp(VkCommandBuffer commandBuffer,
+                           VkPipelineStageFlagBits pipelineStage,
+                           VkQueryPool queryPool, uint32_t slot) {
 
     ValidateEnumerator(pipelineStage);
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
-    VkCommandBuffer commandBuffer,
-    VkPipelineStageFlagBits pipelineStage,
-    VkQueryPool queryPool,
-    uint32_t slot)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
+                        VkPipelineStageFlagBits pipelineStage,
+                        VkQueryPool queryPool, uint32_t slot) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
 
     PostCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
 }
 
-bool PostCmdCopyQueryPoolResults(
-    VkCommandBuffer commandBuffer,
-    VkQueryPool queryPool,
-    uint32_t firstQuery,
-    uint32_t queryCount,
-    VkBuffer dstBuffer,
-    VkDeviceSize dstOffset,
-    VkDeviceSize stride,
-    VkQueryResultFlags flags)
-{
-
-
-
-
-
-
-
+bool PostCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,
+                                 VkQueryPool queryPool, uint32_t firstQuery,
+                                 uint32_t queryCount, VkBuffer dstBuffer,
+                                 VkDeviceSize dstOffset, VkDeviceSize stride,
+                                 VkQueryResultFlags flags) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
-    VkCommandBuffer commandBuffer,
-    VkQueryPool queryPool,
-    uint32_t firstQuery,
-    uint32_t queryCount,
-    VkBuffer dstBuffer,
-    VkDeviceSize dstOffset,
-    VkDeviceSize stride,
-    VkQueryResultFlags flags)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,
+                              VkQueryPool queryPool, uint32_t firstQuery,
+                              uint32_t queryCount, VkBuffer dstBuffer,
+                              VkDeviceSize dstOffset, VkDeviceSize stride,
+                              VkQueryResultFlags flags) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery,
+                                  queryCount, dstBuffer, dstOffset, stride,
+                                  flags);
 
-    PostCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+    PostCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery,
+                                queryCount, dstBuffer, dstOffset, stride,
+                                flags);
 }
 
-bool PreCmdPushConstants(
-    VkCommandBuffer commandBuffer,
-    const void* pValues)
-{
-    if(pValues != nullptr)
-    {
+bool PreCmdPushConstants(VkCommandBuffer commandBuffer, const void *pValues) {
+    if (pValues != nullptr) {
     }
 
     return true;
 }
 
-bool PostCmdPushConstants(
-    VkCommandBuffer commandBuffer,
-    VkPipelineLayout layout,
-    VkShaderStageFlags stageFlags,
-    uint32_t offset,
-    uint32_t size)
-{
-
-
-
-
+bool PostCmdPushConstants(VkCommandBuffer commandBuffer,
+                          VkPipelineLayout layout,
+                          VkShaderStageFlags stageFlags, uint32_t offset,
+                          uint32_t size) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
-    VkCommandBuffer commandBuffer,
-    VkPipelineLayout layout,
-    VkShaderStageFlags stageFlags,
-    uint32_t offset,
-    uint32_t size,
-    const void* pValues)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+                       VkShaderStageFlags stageFlags, uint32_t offset,
+                       uint32_t size, const void *pValues) {
     PreCmdPushConstants(commandBuffer, pValues);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdPushConstants(
+        commandBuffer, layout, stageFlags, offset, size, pValues);
 
     PostCmdPushConstants(commandBuffer, layout, stageFlags, offset, size);
 }
 
-bool PreCmdBeginRenderPass(
-    VkCommandBuffer commandBuffer,
-    const VkRenderPassBeginInfo* pRenderPassBegin)
-{
-    if(pRenderPassBegin != nullptr)
-    {
-    if(pRenderPassBegin->sType != VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdBeginRenderPass parameter, VkStructureType pRenderPassBegin->sType, is an invalid enumerator");
-        return false;
-    }
-    if(pRenderPassBegin->pClearValues != nullptr)
-    {
-    }
+bool PreCmdBeginRenderPass(VkCommandBuffer commandBuffer,
+                           const VkRenderPassBeginInfo *pRenderPassBegin) {
+    if (pRenderPassBegin != nullptr) {
+        if (pRenderPassBegin->sType !=
+            VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO) {
+            log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                    "vkCmdBeginRenderPass parameter, VkStructureType "
+                    "pRenderPassBegin->sType, is an invalid enumerator");
+            return false;
+        }
+        if (pRenderPassBegin->pClearValues != nullptr) {
+        }
     }
 
     return true;
 }
 
-bool PostCmdBeginRenderPass(
-    VkCommandBuffer commandBuffer,
-    VkSubpassContents contents)
-{
+bool PostCmdBeginRenderPass(VkCommandBuffer commandBuffer,
+                            VkSubpassContents contents) {
 
-    if(contents < VK_SUBPASS_CONTENTS_BEGIN_RANGE ||
-        contents > VK_SUBPASS_CONTENTS_END_RANGE)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdBeginRenderPass parameter, VkSubpassContents contents, is an unrecognized enumerator");
+    if (contents < VK_SUBPASS_CONTENTS_BEGIN_RANGE ||
+        contents > VK_SUBPASS_CONTENTS_END_RANGE) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdBeginRenderPass parameter, VkSubpassContents contents, "
+                "is an unrecognized enumerator");
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
-    VkCommandBuffer commandBuffer,
-    const VkRenderPassBeginInfo* pRenderPassBegin,
-    VkSubpassContents contents)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
+                         const VkRenderPassBeginInfo *pRenderPassBegin,
+                         VkSubpassContents contents) {
     PreCmdBeginRenderPass(commandBuffer, pRenderPassBegin);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 
     PostCmdBeginRenderPass(commandBuffer, contents);
 }
 
-bool PostCmdNextSubpass(
-    VkCommandBuffer commandBuffer,
-    VkSubpassContents contents)
-{
+bool PostCmdNextSubpass(VkCommandBuffer commandBuffer,
+                        VkSubpassContents contents) {
 
-    if(contents < VK_SUBPASS_CONTENTS_BEGIN_RANGE ||
-        contents > VK_SUBPASS_CONTENTS_END_RANGE)
-    {
-        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
-        "vkCmdNextSubpass parameter, VkSubpassContents contents, is an unrecognized enumerator");
+    if (contents < VK_SUBPASS_CONTENTS_BEGIN_RANGE ||
+        contents > VK_SUBPASS_CONTENTS_END_RANGE) {
+        log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, "PARAMCHECK",
+                "vkCmdNextSubpass parameter, VkSubpassContents contents, is an "
+                "unrecognized enumerator");
         return false;
     }
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
-    VkCommandBuffer commandBuffer,
-    VkSubpassContents contents)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdNextSubpass(commandBuffer, contents);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdNextSubpass(VkCommandBuffer commandBuffer,
+                     VkSubpassContents contents) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdNextSubpass(commandBuffer, contents);
 
     PostCmdNextSubpass(commandBuffer, contents);
 }
 
-bool PostCmdEndRenderPass(
-    VkCommandBuffer commandBuffer)
-{
+bool PostCmdEndRenderPass(VkCommandBuffer commandBuffer) { return true; }
 
-    return true;
-}
-
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
-    VkCommandBuffer commandBuffer)
-{
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdEndRenderPass(commandBuffer);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+    get_dispatch_table(pc_device_table_map, commandBuffer)
+        ->CmdEndRenderPass(commandBuffer);
 
     PostCmdEndRenderPass(commandBuffer);
 }
 
-bool PreCmdExecuteCommands(
-    VkCommandBuffer commandBuffer,
-    const VkCommandBuffer* pCommandBuffers)
-{
-    if(pCommandBuffers != nullptr)
-    {
+bool PreCmdExecuteCommands(VkCommandBuffer commandBuffer,
+                           const VkCommandBuffer *pCommandBuffers) {
+    if (pCommandBuffers != nullptr) {
     }
 
     return true;
 }
 
-bool PostCmdExecuteCommands(
-    VkCommandBuffer commandBuffer,
-    uint32_t commandBuffersCount)
-{
-
+bool PostCmdExecuteCommands(VkCommandBuffer commandBuffer,
+                            uint32_t commandBuffersCount) {
 
     return true;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
-    VkCommandBuffer commandBuffer,
-    uint32_t commandBuffersCount,
-    const VkCommandBuffer* pCommandBuffers)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdExecuteCommands(VkCommandBuffer commandBuffer,
+                         uint32_t commandBuffersCount,
+                         const VkCommandBuffer *pCommandBuffers) {
     PreCmdExecuteCommands(commandBuffer, pCommandBuffers);
 
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdExecuteCommands(
+        commandBuffer, commandBuffersCount, pCommandBuffers);
 
     PostCmdExecuteCommands(commandBuffer, commandBuffersCount);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char* funcName)
-{
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+    vkGetDeviceProcAddr(VkDevice device, const char *funcName) {
     if (!strcmp(funcName, "vkGetDeviceProcAddr"))
-        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
+        return (PFN_vkVoidFunction)vkGetDeviceProcAddr;
     if (!strcmp(funcName, "vkDestroyDevice"))
-        return (PFN_vkVoidFunction) vkDestroyDevice;
+        return (PFN_vkVoidFunction)vkDestroyDevice;
     if (!strcmp(funcName, "vkGetDeviceQueue"))
-        return (PFN_vkVoidFunction) vkGetDeviceQueue;
+        return (PFN_vkVoidFunction)vkGetDeviceQueue;
     if (!strcmp(funcName, "vkQueueSubmit"))
-        return (PFN_vkVoidFunction) vkQueueSubmit;
+        return (PFN_vkVoidFunction)vkQueueSubmit;
     if (!strcmp(funcName, "vkQueueWaitIdle"))
-        return (PFN_vkVoidFunction) vkQueueWaitIdle;
+        return (PFN_vkVoidFunction)vkQueueWaitIdle;
     if (!strcmp(funcName, "vkDeviceWaitIdle"))
-        return (PFN_vkVoidFunction) vkDeviceWaitIdle;
+        return (PFN_vkVoidFunction)vkDeviceWaitIdle;
     if (!strcmp(funcName, "vkAllocateMemory"))
-        return (PFN_vkVoidFunction) vkAllocateMemory;
+        return (PFN_vkVoidFunction)vkAllocateMemory;
     if (!strcmp(funcName, "vkMapMemory"))
-        return (PFN_vkVoidFunction) vkMapMemory;
+        return (PFN_vkVoidFunction)vkMapMemory;
     if (!strcmp(funcName, "vkFlushMappedMemoryRanges"))
-        return (PFN_vkVoidFunction) vkFlushMappedMemoryRanges;
+        return (PFN_vkVoidFunction)vkFlushMappedMemoryRanges;
     if (!strcmp(funcName, "vkInvalidateMappedMemoryRanges"))
-        return (PFN_vkVoidFunction) vkInvalidateMappedMemoryRanges;
+        return (PFN_vkVoidFunction)vkInvalidateMappedMemoryRanges;
     if (!strcmp(funcName, "vkCreateFence"))
-        return (PFN_vkVoidFunction) vkCreateFence;
+        return (PFN_vkVoidFunction)vkCreateFence;
     if (!strcmp(funcName, "vkResetFences"))
-        return (PFN_vkVoidFunction) vkResetFences;
+        return (PFN_vkVoidFunction)vkResetFences;
     if (!strcmp(funcName, "vkGetFenceStatus"))
-        return (PFN_vkVoidFunction) vkGetFenceStatus;
+        return (PFN_vkVoidFunction)vkGetFenceStatus;
     if (!strcmp(funcName, "vkWaitForFences"))
-        return (PFN_vkVoidFunction) vkWaitForFences;
+        return (PFN_vkVoidFunction)vkWaitForFences;
     if (!strcmp(funcName, "vkCreateSemaphore"))
-        return (PFN_vkVoidFunction) vkCreateSemaphore;
+        return (PFN_vkVoidFunction)vkCreateSemaphore;
     if (!strcmp(funcName, "vkCreateEvent"))
-        return (PFN_vkVoidFunction) vkCreateEvent;
+        return (PFN_vkVoidFunction)vkCreateEvent;
     if (!strcmp(funcName, "vkGetEventStatus"))
-        return (PFN_vkVoidFunction) vkGetEventStatus;
+        return (PFN_vkVoidFunction)vkGetEventStatus;
     if (!strcmp(funcName, "vkSetEvent"))
-        return (PFN_vkVoidFunction) vkSetEvent;
+        return (PFN_vkVoidFunction)vkSetEvent;
     if (!strcmp(funcName, "vkResetEvent"))
-        return (PFN_vkVoidFunction) vkResetEvent;
+        return (PFN_vkVoidFunction)vkResetEvent;
     if (!strcmp(funcName, "vkCreateQueryPool"))
-        return (PFN_vkVoidFunction) vkCreateQueryPool;
+        return (PFN_vkVoidFunction)vkCreateQueryPool;
     if (!strcmp(funcName, "vkGetQueryPoolResults"))
-        return (PFN_vkVoidFunction) vkGetQueryPoolResults;
+        return (PFN_vkVoidFunction)vkGetQueryPoolResults;
     if (!strcmp(funcName, "vkCreateBuffer"))
-        return (PFN_vkVoidFunction) vkCreateBuffer;
+        return (PFN_vkVoidFunction)vkCreateBuffer;
     if (!strcmp(funcName, "vkCreateBufferView"))
-        return (PFN_vkVoidFunction) vkCreateBufferView;
+        return (PFN_vkVoidFunction)vkCreateBufferView;
     if (!strcmp(funcName, "vkCreateImage"))
-        return (PFN_vkVoidFunction) vkCreateImage;
+        return (PFN_vkVoidFunction)vkCreateImage;
     if (!strcmp(funcName, "vkGetImageSubresourceLayout"))
-        return (PFN_vkVoidFunction) vkGetImageSubresourceLayout;
+        return (PFN_vkVoidFunction)vkGetImageSubresourceLayout;
     if (!strcmp(funcName, "vkCreateImageView"))
-        return (PFN_vkVoidFunction) vkCreateImageView;
+        return (PFN_vkVoidFunction)vkCreateImageView;
     if (!strcmp(funcName, "vkCreateShaderModule"))
-        return (PFN_vkVoidFunction) vkCreateShaderModule;
+        return (PFN_vkVoidFunction)vkCreateShaderModule;
     if (!strcmp(funcName, "vkCreateGraphicsPipelines"))
-        return (PFN_vkVoidFunction) vkCreateGraphicsPipelines;
+        return (PFN_vkVoidFunction)vkCreateGraphicsPipelines;
     if (!strcmp(funcName, "vkCreateComputePipelines"))
-        return (PFN_vkVoidFunction) vkCreateComputePipelines;
+        return (PFN_vkVoidFunction)vkCreateComputePipelines;
     if (!strcmp(funcName, "vkCreatePipelineLayout"))
-        return (PFN_vkVoidFunction) vkCreatePipelineLayout;
+        return (PFN_vkVoidFunction)vkCreatePipelineLayout;
     if (!strcmp(funcName, "vkCreateSampler"))
-        return (PFN_vkVoidFunction) vkCreateSampler;
+        return (PFN_vkVoidFunction)vkCreateSampler;
     if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
-        return (PFN_vkVoidFunction) vkCreateDescriptorSetLayout;
+        return (PFN_vkVoidFunction)vkCreateDescriptorSetLayout;
     if (!strcmp(funcName, "vkCreateDescriptorPool"))
-        return (PFN_vkVoidFunction) vkCreateDescriptorPool;
+        return (PFN_vkVoidFunction)vkCreateDescriptorPool;
     if (!strcmp(funcName, "vkResetDescriptorPool"))
-        return (PFN_vkVoidFunction) vkResetDescriptorPool;
+        return (PFN_vkVoidFunction)vkResetDescriptorPool;
     if (!strcmp(funcName, "vkAllocateDescriptorSets"))
-        return (PFN_vkVoidFunction) vkAllocateDescriptorSets;
+        return (PFN_vkVoidFunction)vkAllocateDescriptorSets;
     if (!strcmp(funcName, "vkCmdSetViewport"))
-        return (PFN_vkVoidFunction) vkCmdSetViewport;
+        return (PFN_vkVoidFunction)vkCmdSetViewport;
     if (!strcmp(funcName, "vkCmdSetScissor"))
-        return (PFN_vkVoidFunction) vkCmdSetScissor;
+        return (PFN_vkVoidFunction)vkCmdSetScissor;
     if (!strcmp(funcName, "vkCmdSetLineWidth"))
-        return (PFN_vkVoidFunction) vkCmdSetLineWidth;
+        return (PFN_vkVoidFunction)vkCmdSetLineWidth;
     if (!strcmp(funcName, "vkCmdSetDepthBias"))
-        return (PFN_vkVoidFunction) vkCmdSetDepthBias;
+        return (PFN_vkVoidFunction)vkCmdSetDepthBias;
     if (!strcmp(funcName, "vkCmdSetBlendConstants"))
-        return (PFN_vkVoidFunction) vkCmdSetBlendConstants;
+        return (PFN_vkVoidFunction)vkCmdSetBlendConstants;
     if (!strcmp(funcName, "vkCmdSetDepthBounds"))
-        return (PFN_vkVoidFunction) vkCmdSetDepthBounds;
+        return (PFN_vkVoidFunction)vkCmdSetDepthBounds;
     if (!strcmp(funcName, "vkCmdSetStencilCompareMask"))
-        return (PFN_vkVoidFunction) vkCmdSetStencilCompareMask;
+        return (PFN_vkVoidFunction)vkCmdSetStencilCompareMask;
     if (!strcmp(funcName, "vkCmdSetStencilWriteMask"))
-        return (PFN_vkVoidFunction) vkCmdSetStencilWriteMask;
+        return (PFN_vkVoidFunction)vkCmdSetStencilWriteMask;
     if (!strcmp(funcName, "vkCmdSetStencilReference"))
-        return (PFN_vkVoidFunction) vkCmdSetStencilReference;
+        return (PFN_vkVoidFunction)vkCmdSetStencilReference;
     if (!strcmp(funcName, "vkAllocateCommandBuffers"))
-        return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
+        return (PFN_vkVoidFunction)vkAllocateCommandBuffers;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
-        return (PFN_vkVoidFunction) vkBeginCommandBuffer;
+        return (PFN_vkVoidFunction)vkBeginCommandBuffer;
     if (!strcmp(funcName, "vkEndCommandBuffer"))
-        return (PFN_vkVoidFunction) vkEndCommandBuffer;
+        return (PFN_vkVoidFunction)vkEndCommandBuffer;
     if (!strcmp(funcName, "vkResetCommandBuffer"))
-        return (PFN_vkVoidFunction) vkResetCommandBuffer;
+        return (PFN_vkVoidFunction)vkResetCommandBuffer;
     if (!strcmp(funcName, "vkCmdBindPipeline"))
-        return (PFN_vkVoidFunction) vkCmdBindPipeline;
+        return (PFN_vkVoidFunction)vkCmdBindPipeline;
     if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
-        return (PFN_vkVoidFunction) vkCmdBindDescriptorSets;
+        return (PFN_vkVoidFunction)vkCmdBindDescriptorSets;
     if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
-        return (PFN_vkVoidFunction) vkCmdBindVertexBuffers;
+        return (PFN_vkVoidFunction)vkCmdBindVertexBuffers;
     if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
-        return (PFN_vkVoidFunction) vkCmdBindIndexBuffer;
+        return (PFN_vkVoidFunction)vkCmdBindIndexBuffer;
     if (!strcmp(funcName, "vkCmdDraw"))
-        return (PFN_vkVoidFunction) vkCmdDraw;
+        return (PFN_vkVoidFunction)vkCmdDraw;
     if (!strcmp(funcName, "vkCmdDrawIndexed"))
-        return (PFN_vkVoidFunction) vkCmdDrawIndexed;
+        return (PFN_vkVoidFunction)vkCmdDrawIndexed;
     if (!strcmp(funcName, "vkCmdDrawIndirect"))
-        return (PFN_vkVoidFunction) vkCmdDrawIndirect;
+        return (PFN_vkVoidFunction)vkCmdDrawIndirect;
     if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
-        return (PFN_vkVoidFunction) vkCmdDrawIndexedIndirect;
+        return (PFN_vkVoidFunction)vkCmdDrawIndexedIndirect;
     if (!strcmp(funcName, "vkCmdDispatch"))
-        return (PFN_vkVoidFunction) vkCmdDispatch;
+        return (PFN_vkVoidFunction)vkCmdDispatch;
     if (!strcmp(funcName, "vkCmdDispatchIndirect"))
-        return (PFN_vkVoidFunction) vkCmdDispatchIndirect;
+        return (PFN_vkVoidFunction)vkCmdDispatchIndirect;
     if (!strcmp(funcName, "vkCmdCopyBuffer"))
-        return (PFN_vkVoidFunction) vkCmdCopyBuffer;
+        return (PFN_vkVoidFunction)vkCmdCopyBuffer;
     if (!strcmp(funcName, "vkCmdCopyImage"))
-        return (PFN_vkVoidFunction) vkCmdCopyImage;
+        return (PFN_vkVoidFunction)vkCmdCopyImage;
     if (!strcmp(funcName, "vkCmdBlitImage"))
-        return (PFN_vkVoidFunction) vkCmdBlitImage;
+        return (PFN_vkVoidFunction)vkCmdBlitImage;
     if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
-        return (PFN_vkVoidFunction) vkCmdCopyBufferToImage;
+        return (PFN_vkVoidFunction)vkCmdCopyBufferToImage;
     if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
-        return (PFN_vkVoidFunction) vkCmdCopyImageToBuffer;
+        return (PFN_vkVoidFunction)vkCmdCopyImageToBuffer;
     if (!strcmp(funcName, "vkCmdUpdateBuffer"))
-        return (PFN_vkVoidFunction) vkCmdUpdateBuffer;
+        return (PFN_vkVoidFunction)vkCmdUpdateBuffer;
     if (!strcmp(funcName, "vkCmdFillBuffer"))
-        return (PFN_vkVoidFunction) vkCmdFillBuffer;
+        return (PFN_vkVoidFunction)vkCmdFillBuffer;
     if (!strcmp(funcName, "vkCmdClearColorImage"))
-        return (PFN_vkVoidFunction) vkCmdClearColorImage;
+        return (PFN_vkVoidFunction)vkCmdClearColorImage;
     if (!strcmp(funcName, "vkCmdResolveImage"))
-        return (PFN_vkVoidFunction) vkCmdResolveImage;
+        return (PFN_vkVoidFunction)vkCmdResolveImage;
     if (!strcmp(funcName, "vkCmdSetEvent"))
-        return (PFN_vkVoidFunction) vkCmdSetEvent;
+        return (PFN_vkVoidFunction)vkCmdSetEvent;
     if (!strcmp(funcName, "vkCmdResetEvent"))
-        return (PFN_vkVoidFunction) vkCmdResetEvent;
+        return (PFN_vkVoidFunction)vkCmdResetEvent;
     if (!strcmp(funcName, "vkCmdWaitEvents"))
-        return (PFN_vkVoidFunction) vkCmdWaitEvents;
+        return (PFN_vkVoidFunction)vkCmdWaitEvents;
     if (!strcmp(funcName, "vkCmdPipelineBarrier"))
-        return (PFN_vkVoidFunction) vkCmdPipelineBarrier;
+        return (PFN_vkVoidFunction)vkCmdPipelineBarrier;
     if (!strcmp(funcName, "vkCmdBeginQuery"))
-        return (PFN_vkVoidFunction) vkCmdBeginQuery;
+        return (PFN_vkVoidFunction)vkCmdBeginQuery;
     if (!strcmp(funcName, "vkCmdEndQuery"))
-        return (PFN_vkVoidFunction) vkCmdEndQuery;
+        return (PFN_vkVoidFunction)vkCmdEndQuery;
     if (!strcmp(funcName, "vkCmdResetQueryPool"))
-        return (PFN_vkVoidFunction) vkCmdResetQueryPool;
+        return (PFN_vkVoidFunction)vkCmdResetQueryPool;
     if (!strcmp(funcName, "vkCmdWriteTimestamp"))
-        return (PFN_vkVoidFunction) vkCmdWriteTimestamp;
+        return (PFN_vkVoidFunction)vkCmdWriteTimestamp;
     if (!strcmp(funcName, "vkCmdCopyQueryPoolResults"))
-        return (PFN_vkVoidFunction) vkCmdCopyQueryPoolResults;
+        return (PFN_vkVoidFunction)vkCmdCopyQueryPoolResults;
     if (!strcmp(funcName, "vkCreateFramebuffer"))
-        return (PFN_vkVoidFunction) vkCreateFramebuffer;
+        return (PFN_vkVoidFunction)vkCreateFramebuffer;
     if (!strcmp(funcName, "vkCreateRenderPass"))
-        return (PFN_vkVoidFunction) vkCreateRenderPass;
+        return (PFN_vkVoidFunction)vkCreateRenderPass;
     if (!strcmp(funcName, "vkCmdBeginRenderPass"))
-        return (PFN_vkVoidFunction) vkCmdBeginRenderPass;
+        return (PFN_vkVoidFunction)vkCmdBeginRenderPass;
     if (!strcmp(funcName, "vkCmdNextSubpass"))
-        return (PFN_vkVoidFunction) vkCmdNextSubpass;
+        return (PFN_vkVoidFunction)vkCmdNextSubpass;
 
     if (device == NULL) {
         return NULL;
     }
 
-    if (get_dispatch_table(pc_device_table_map, device)->GetDeviceProcAddr == NULL)
+    if (get_dispatch_table(pc_device_table_map, device)->GetDeviceProcAddr ==
+        NULL)
         return NULL;
-    return get_dispatch_table(pc_device_table_map, device)->GetDeviceProcAddr(device, funcName);
+    return get_dispatch_table(pc_device_table_map, device)
+        ->GetDeviceProcAddr(device, funcName);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
-{
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+    vkGetInstanceProcAddr(VkInstance instance, const char *funcName) {
     if (!strcmp(funcName, "vkGetInstanceProcAddr"))
-        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
+        return (PFN_vkVoidFunction)vkGetInstanceProcAddr;
     if (!strcmp(funcName, "vkCreateInstance"))
-        return (PFN_vkVoidFunction) vkCreateInstance;
+        return (PFN_vkVoidFunction)vkCreateInstance;
     if (!strcmp(funcName, "vkDestroyInstance"))
-        return (PFN_vkVoidFunction) vkDestroyInstance;
+        return (PFN_vkVoidFunction)vkDestroyInstance;
     if (!strcmp(funcName, "vkCreateDevice"))
-        return (PFN_vkVoidFunction) vkCreateDevice;
+        return (PFN_vkVoidFunction)vkCreateDevice;
     if (!strcmp(funcName, "vkEnumeratePhysicalDevices"))
-        return (PFN_vkVoidFunction) vkEnumeratePhysicalDevices;
+        return (PFN_vkVoidFunction)vkEnumeratePhysicalDevices;
     if (!strcmp(funcName, "vkGetPhysicalDeviceProperties"))
-        return (PFN_vkVoidFunction) vkGetPhysicalDeviceProperties;
+        return (PFN_vkVoidFunction)vkGetPhysicalDeviceProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceFeatures"))
-        return (PFN_vkVoidFunction) vkGetPhysicalDeviceFeatures;
+        return (PFN_vkVoidFunction)vkGetPhysicalDeviceFeatures;
     if (!strcmp(funcName, "vkGetPhysicalDeviceFormatProperties"))
-        return (PFN_vkVoidFunction) vkGetPhysicalDeviceFormatProperties;
+        return (PFN_vkVoidFunction)vkGetPhysicalDeviceFormatProperties;
     if (!strcmp(funcName, "vkEnumerateInstanceLayerProperties"))
-        return (PFN_vkVoidFunction) vkEnumerateInstanceLayerProperties;
+        return (PFN_vkVoidFunction)vkEnumerateInstanceLayerProperties;
     if (!strcmp(funcName, "vkEnumerateInstanceExtensionProperties"))
-        return (PFN_vkVoidFunction) vkEnumerateInstanceExtensionProperties;
+        return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties;
     if (!strcmp(funcName, "vkEnumerateDeviceLayerProperties"))
-        return (PFN_vkVoidFunction) vkEnumerateDeviceLayerProperties;
+        return (PFN_vkVoidFunction)vkEnumerateDeviceLayerProperties;
     if (!strcmp(funcName, "vkEnumerateDeviceExtensionProperties"))
-        return (PFN_vkVoidFunction) vkEnumerateDeviceExtensionProperties;
+        return (PFN_vkVoidFunction)vkEnumerateDeviceExtensionProperties;
 
     if (instance == NULL) {
         return NULL;
     }
 
-    layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    PFN_vkVoidFunction fptr = debug_report_get_instance_proc_addr(data->report_data, funcName);
-    if(fptr)
+    layer_data *data =
+        get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+    PFN_vkVoidFunction fptr =
+        debug_report_get_instance_proc_addr(data->report_data, funcName);
+    if (fptr)
         return fptr;
 
-    if (get_dispatch_table(pc_instance_table_map, instance)->GetInstanceProcAddr == NULL)
+    if (get_dispatch_table(pc_instance_table_map, instance)
+            ->GetInstanceProcAddr == NULL)
         return NULL;
-    return get_dispatch_table(pc_instance_table_map, instance)->GetInstanceProcAddr(instance, funcName);
+    return get_dispatch_table(pc_instance_table_map, instance)
+        ->GetInstanceProcAddr(instance, funcName);
 }