diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 0da8996..dc3dda4 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -51,15 +51,15 @@
 
 #define MAX_BINDING 0xFFFFFFFF
 
-map<VkCmdBuffer, MT_CB_INFO*>      cbMap;
-map<VkDeviceMemory, MT_MEM_OBJ_INFO*> memObjMap;
-map<VkObject,     MT_OBJ_INFO*>     objectMap;
-map<uint64_t,       MT_FENCE_INFO*>   fenceMap;    // Map fenceId to fence info
-map<VkQueue,      MT_QUEUE_INFO*>   queueMap;
-map<VkSwapChainWSI, MT_SWAP_CHAIN_INFO*>   swapChainMap;
+map<VkCmdBuffer,    MT_CB_INFO*>          cbMap;
+map<VkDeviceMemory, MT_MEM_OBJ_INFO*>     memObjMap;
+map<VkObject,       MT_OBJ_INFO*>         objectMap;
+map<uint64_t,       MT_FENCE_INFO*>       fenceMap;    // Map fenceId to fence info
+map<VkQueue,        MT_QUEUE_INFO*>       queueMap;
+map<VkSwapChainWSI, MT_SWAP_CHAIN_INFO*>  swapChainMap;
 
 // TODO : Add per-device fence completion
-static uint64_t     g_currentFenceId  = 1;
+static uint64_t   g_currentFenceId  = 1;
 static VkDevice   globalDevice      = NULL;
 
 // Add new queue for this device to map container
@@ -71,7 +71,8 @@
     queueMap[queue]        = pInfo;
 }
 
-static void deleteQueueInfoList(void)
+static void deleteQueueInfoList(
+    void)
 {
     // Process queue list, cleaning up each entry before deleting
     for (map<VkQueue, MT_QUEUE_INFO*>::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) {
@@ -80,14 +81,16 @@
     queueMap.clear();
 }
 
-static void addSwapChainInfo(const VkSwapChainWSI swapChain)
+static void addSwapChainInfo(
+    const VkSwapChainWSI swapChain)
 {
     MT_SWAP_CHAIN_INFO* pInfo = new MT_SWAP_CHAIN_INFO;
     swapChainMap[swapChain] = pInfo;
 }
 
 // Add new CBInfo for this cb to map container
-static void addCBInfo(const VkCmdBuffer cb)
+static void addCBInfo(
+    const VkCmdBuffer cb)
 {
     MT_CB_INFO* pInfo = new MT_CB_INFO;
     memset(pInfo, 0, (sizeof(MT_CB_INFO) - sizeof(list<VkDeviceMemory>)));
@@ -96,7 +99,8 @@
 }
 
 // Return ptr to Info in CB map, or NULL if not found
-static MT_CB_INFO* getCBInfo(const VkCmdBuffer cb)
+static MT_CB_INFO* getCBInfo(
+    const VkCmdBuffer cb)
 {
     MT_CB_INFO* pCBInfo = NULL;
     if (cbMap.find(cb) != cbMap.end()) {
@@ -106,7 +110,8 @@
 }
 
 // Return object info for 'object' or return NULL if no info exists
-static MT_OBJ_INFO* getObjectInfo(const VkObject object)
+static MT_OBJ_INFO* getObjectInfo(
+    const VkObject object)
 {
     MT_OBJ_INFO* pObjInfo = NULL;
 
@@ -116,7 +121,12 @@
     return pObjInfo;
 }
 
-static MT_OBJ_INFO* addObjectInfo(VkObject object, VkStructureType sType, const void *pCreateInfo, const int struct_size, const char *name_prefix)
+static MT_OBJ_INFO* addObjectInfo(
+    VkObject         object,
+    VkStructureType  sType,
+    const void      *pCreateInfo,
+    const int        struct_size,
+    const char      *name_prefix)
 {
     MT_OBJ_INFO* pInfo = new MT_OBJ_INFO;
     memset(pInfo, 0, sizeof(MT_OBJ_INFO));
@@ -132,7 +142,9 @@
 }
 
 // Add a fence, creating one if necessary to our list of fences/fenceIds
-static uint64_t addFenceInfo(VkFence fence, VkQueue queue)
+static uint64_t addFenceInfo(
+    VkFence fence,
+    VkQueue queue)
 {
     // Create fence object
     MT_FENCE_INFO* pFenceInfo = new MT_FENCE_INFO;
@@ -169,7 +181,8 @@
 }
 
 // Remove a fenceInfo from our list of fences/fenceIds
-static void deleteFenceInfo(uint64_t fenceId)
+static void deleteFenceInfo(
+    uint64_t fenceId)
 {
     if (fenceId != 0) {
         if (fenceMap.find(fenceId) != fenceMap.end()) {
@@ -188,12 +201,13 @@
 }
 
 // Search through list for this fence, deleting all items before it (with lower IDs) and updating lastRetiredId
-static void updateFenceTracking(VkFence fence)
+static void updateFenceTracking(
+    VkFence fence)
 {
     MT_FENCE_INFO *pCurFenceInfo = NULL;
     uint64_t       fenceId       = 0;
-    VkQueue      queue         = NULL;
-    bool found = false;
+    VkQueue        queue         = NULL;
+    bool           found         = false;
 
     for (map<uint64_t, MT_FENCE_INFO*>::iterator ii=fenceMap.begin(); !found && ii!=fenceMap.end(); ++ii) {
         if ((*ii).second != NULL) {
@@ -209,14 +223,16 @@
             MT_OBJ_INFO* pObjectInfo = getObjectInfo(fence);
             if (pObjectInfo != NULL) {
                 pObjectInfo->create_info.fence_create_info.flags =
-                    static_cast<VkFenceCreateFlags>(pObjectInfo->create_info.fence_create_info.flags | VK_FENCE_CREATE_SIGNALED_BIT);
+                    static_cast<VkFenceCreateFlags>(
+                        pObjectInfo->create_info.fence_create_info.flags | VK_FENCE_CREATE_SIGNALED_BIT);
             }
         }
     }
 }
 
 // Utility function that determines if a fenceId has been retired yet
-static bool32_t fenceRetired(uint64_t fenceId)
+static bool32_t fenceRetired(
+    uint64_t fenceId)
 {
     bool32_t result = VK_FALSE;
     if (fenceMap.find(fenceId) != fenceMap.end()) {
@@ -233,7 +249,8 @@
 }
 
 // Return the fence associated with a fenceId
-static VkFence getFenceFromId(uint64_t fenceId)
+static VkFence getFenceFromId(
+    uint64_t fenceId)
 {
     VkFence fence = NULL;
     if (fenceId != 0) {
@@ -252,7 +269,8 @@
 }
 
 // Helper routine that updates the fence list for a specific queue to all-retired
-static void retireQueueFences(VkQueue queue)
+static void retireQueueFences(
+    VkQueue queue)
 {
     MT_QUEUE_INFO *pQueueInfo = queueMap[queue];
     pQueueInfo->lastRetiredId = pQueueInfo->lastSubmittedId;
@@ -272,7 +290,8 @@
 }
 
 // Helper routine that updates fence list for all queues to all-retired
-static void retireDeviceFences(VkDevice device)
+static void retireDeviceFences(
+    VkDevice device)
 {
     // Process each queue for device
     // TODO: Add multiple device support
@@ -284,7 +303,7 @@
 // Returns True if a memory reference is present in a Queue's memory reference list
 // Queue is validated by caller
 static bool32_t checkMemRef(
-    VkQueue      queue,
+    VkQueue        queue,
     VkDeviceMemory mem)
 {
     bool32_t result = VK_FALSE;
@@ -300,8 +319,8 @@
 }
 
 static bool32_t validateQueueMemRefs(
-    VkQueue             queue,
-    uint32_t              cmdBufferCount,
+    VkQueue            queue,
+    uint32_t           cmdBufferCount,
     const VkCmdBuffer *pCmdBuffers)
 {
     bool32_t result = VK_TRUE;
@@ -319,7 +338,9 @@
             MT_CB_INFO* pCBInfo = getCBInfo(pCmdBuffers[i]);
             if (!pCBInfo) {
                 char str[1024];
-                sprintf(str, "Unable to find info for CB %p in order to check memory references in vkQueueSubmit for queue %p", (void*)pCmdBuffers[i], queue);
+                sprintf(str, "Unable to find info for CB %p in order to check memory references in "
+                             "vkQueueSubmit for queue %p",
+                    (void*)pCmdBuffers[i], queue);
                 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_INVALID_CB, "MEM", str);
                 result = VK_FALSE;
             } else {
@@ -333,7 +354,8 @@
                     }
                     else {
                         char str[1024];
-                        sprintf(str, "Queue %p Memory reference list for Command Buffer %p is missing ref to mem obj %p", queue, pCmdBuffers[i], (*it));
+                        sprintf(str, "Queue %p Memory reference list for Command Buffer %p is missing ref to mem obj %p",
+                            queue, pCmdBuffers[i], (*it));
                         layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCmdBuffers[i], 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
                         result = VK_FALSE;
                     }
@@ -354,7 +376,8 @@
 
 // Return ptr to info in map container containing mem, or NULL if not found
 //  Calls to this function should be wrapped in mutex
-static MT_MEM_OBJ_INFO* getMemObjInfo(const VkDeviceMemory mem)
+static MT_MEM_OBJ_INFO* getMemObjInfo(
+    const VkDeviceMemory mem)
 {
     MT_MEM_OBJ_INFO* pMemObjInfo = NULL;
 
@@ -364,10 +387,12 @@
     return pMemObjInfo;
 }
 
-static void addMemObjInfo(const VkDeviceMemory mem, const VkMemoryAllocInfo* pAllocInfo)
+static void addMemObjInfo(
+    const VkDeviceMemory     mem,
+    const VkMemoryAllocInfo *pAllocInfo)
 {
     MT_MEM_OBJ_INFO* pInfo = new MT_MEM_OBJ_INFO;
-    pInfo->refCount           = 0;
+    pInfo->refCount        = 0;
     memset(&pInfo->allocInfo, 0, sizeof(VkMemoryAllocInfo));
 
     if (pAllocInfo) {  // MEM alloc created by vkCreateSwapChainWSI() doesn't have alloc info struct
@@ -381,14 +406,17 @@
 
 // Find CB Info and add mem binding to list container
 // Find Mem Obj Info and add CB binding to list container
-static bool32_t updateCBBinding(const VkCmdBuffer cb, const VkDeviceMemory mem)
+static bool32_t updateCBBinding(
+    const VkCmdBuffer    cb,
+    const VkDeviceMemory mem)
 {
     bool32_t result = VK_TRUE;
     // First update CB binding in MemObj mini CB list
     MT_MEM_OBJ_INFO* pMemInfo = getMemObjInfo(mem);
     if (!pMemInfo) {
         char str[1024];
-        sprintf(str, "Trying to bind mem obj %p to CB %p but no info for that mem obj.\n    Was it correctly allocated? Did it already get freed?", mem, cb);
+        sprintf(str, "Trying to bind mem obj %p to CB %p but no info for that mem obj.\n    "
+                     "Was it correctly allocated? Did it already get freed?", mem, cb);
         layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
         result = VK_FALSE;
     } else {
@@ -433,7 +461,9 @@
 
 // Clear the CB Binding for mem
 //  Calls to this function should be wrapped in mutex
-static void clearCBBinding(const VkCmdBuffer cb, const VkDeviceMemory mem)
+static void clearCBBinding(
+    const VkCmdBuffer    cb,
+    const VkDeviceMemory mem)
 {
     MT_MEM_OBJ_INFO* pInfo = getMemObjInfo(mem);
     // TODO : Having this check is not ideal, really if memInfo was deleted,
@@ -446,7 +476,8 @@
 }
 
 // Free bindings related to CB
-static bool32_t freeCBBindings(const VkCmdBuffer cb)
+static bool32_t freeCBBindings(
+    const VkCmdBuffer cb)
 {
     bool32_t result = VK_TRUE;
     MT_CB_INFO* pCBInfo = getCBInfo(cb);
@@ -471,7 +502,8 @@
 // Delete CBInfo from list along with all of it's mini MemObjInfo
 //   and also clear mem references to CB
 // TODO : When should this be called?  There's no Destroy of CBs that I see
-static bool32_t deleteCBInfo(const VkCmdBuffer cb)
+static bool32_t deleteCBInfo(
+    const VkCmdBuffer cb)
 {
     bool32_t result = VK_TRUE;
     result = freeCBBindings(cb);
@@ -487,7 +519,8 @@
 }
 
 // Delete the entire CB list
-static bool32_t deleteCBInfoList()
+static bool32_t deleteCBInfoList(
+    void)
 {
     bool32_t result = VK_TRUE;
     for (map<VkCmdBuffer, MT_CB_INFO*>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
@@ -498,14 +531,16 @@
 }
 
 // For given MemObjInfo, report Obj & CB bindings
-static void reportMemReferencesAndCleanUp(MT_MEM_OBJ_INFO* pMemObjInfo)
+static void reportMemReferencesAndCleanUp(
+    MT_MEM_OBJ_INFO* pMemObjInfo)
 {
     size_t cmdBufRefCount = pMemObjInfo->pCmdBufferBindings.size();
     size_t objRefCount    = pMemObjInfo->pObjBindings.size();
 
     if ((pMemObjInfo->pCmdBufferBindings.size() + pMemObjInfo->pObjBindings.size()) != 0) {
         char str[1024];
-        sprintf(str, "Attempting to free memory object %p which still contains %lu references", pMemObjInfo->mem, (cmdBufRefCount + objRefCount));
+        sprintf(str, "Attempting to free memory object %p which still contains %lu references",
+            pMemObjInfo->mem, (cmdBufRefCount + objRefCount));
         layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pMemObjInfo->mem, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
     }
 
@@ -530,7 +565,8 @@
     }
 }
 
-static void deleteMemObjInfo(VkDeviceMemory mem)
+static void deleteMemObjInfo(
+    VkDeviceMemory mem)
 {
     if (memObjMap.find(mem) != memObjMap.end()) {
         MT_MEM_OBJ_INFO* pDelInfo = memObjMap[mem];
@@ -545,7 +581,8 @@
 }
 
 // Check if fence for given CB is completed
-static bool32_t checkCBCompleted(const VkCmdBuffer cb)
+static bool32_t checkCBCompleted(
+    const VkCmdBuffer cb)
 {
     bool32_t result = VK_TRUE;
     MT_CB_INFO* pCBInfo = getCBInfo(cb);
@@ -557,7 +594,8 @@
     } else {
         if (!fenceRetired(pCBInfo->fenceId)) {
             char str[1024];
-            sprintf(str, "FenceId %" PRIx64", fence %p for CB %p has not been checked for completion", pCBInfo->fenceId, getFenceFromId(pCBInfo->fenceId), cb);
+            sprintf(str, "FenceId %" PRIx64", fence %p for CB %p has not been checked for completion",
+                pCBInfo->fenceId, getFenceFromId(pCBInfo->fenceId), cb);
             layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, cb, 0, MEMTRACK_NONE, "MEM", str);
             result = VK_FALSE;
         }
@@ -565,20 +603,24 @@
     return result;
 }
 
-static bool32_t freeMemObjInfo(VkDeviceMemory mem, bool internal)
+static bool32_t freeMemObjInfo(
+    VkDeviceMemory mem,
+    bool           internal)
 {
     bool32_t result = VK_TRUE;
     // Parse global list to find info w/ mem
     MT_MEM_OBJ_INFO* pInfo = getMemObjInfo(mem);
     if (!pInfo) {
         char str[1024];
-        sprintf(str, "Couldn't find mem info object for %p\n    Was %p never allocated or previously freed?", (void*)mem, (void*)mem);
+        sprintf(str, "Couldn't find mem info object for %p\n    Was %p never allocated or previously freed?",
+            (void*)mem, (void*)mem);
         layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
         result = VK_FALSE;
     } else {
         if (pInfo->allocInfo.allocationSize == 0 && !internal) {
             char str[1024];
-            sprintf(str, "Attempting to free memory associated with a Persistent Image, %p, this should not be explicitly freed\n", (void*)mem);
+            sprintf(str, "Attempting to free memory associated with a Persistent Image, %p, "
+                         "this should not be explicitly freed\n", (void*)mem);
             layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
             result = VK_FALSE;
         } else {
@@ -618,13 +660,16 @@
 // 1. Remove ObjectInfo from MemObjInfo list container of obj bindings & free it
 // 2. Decrement refCount for MemObjInfo
 // 3. Clear MemObjInfo ptr from ObjectInfo
-static bool32_t clearObjectBinding(VkObject object)
+static bool32_t clearObjectBinding(
+    VkObject object)
 {
     bool32_t result = VK_FALSE;
     MT_OBJ_INFO* pObjInfo = getObjectInfo(object);
     if (!pObjInfo) {
         char str[1024];
-        sprintf(str, "Attempting to clear mem binding for object %p: devices, queues, command buffers, shaders and memory objects do not have external memory requirements and it is unneccessary to call bind/unbindObjectMemory on them.", object);
+        sprintf(str, "Attempting to clear mem binding for object %p: devices, queues, command buffers, "
+                     "shaders and memory objects do not have external memory requirements and it is "
+                     "unneccessary to call bind/unbindObjectMemory on them.", object);
         layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
     } else {
         if (!pObjInfo->pMemObjInfo) {
@@ -660,7 +705,9 @@
 //  Add reference from objectInfo to memoryInfo
 //  Add reference off of objInfo
 // Return VK_TRUE if addition is successful, VK_FALSE otherwise
-static bool32_t updateObjectBinding(VkObject object, VkDeviceMemory mem)
+static bool32_t updateObjectBinding(
+    VkObject       object,
+    VkDeviceMemory mem)
 {
     bool32_t result = VK_FALSE;
     // Handle NULL case separately, just clear previous binding & decrement reference
@@ -703,7 +750,8 @@
             // For image objects, make sure default memory state is correctly set
             // TODO : What's the best/correct way to handle this?
             if (VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO == pObjInfo->sType) {
-                if (pObjInfo->create_info.image_create_info.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)) {
+                if (pObjInfo->create_info.image_create_info.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                                                                     VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)) {
                     // TODO::  More memory state transition stuff.
                 }
             }
@@ -714,7 +762,8 @@
 }
 
 // Print details of global Obj tracking list
-static void printObjList()
+static void printObjList(
+    void)
 {
     MT_OBJ_INFO* pInfo = NULL;
     char str[1024];
@@ -728,7 +777,8 @@
 }
 
 // For given Object, get 'mem' obj that it's bound to or NULL if no binding
-static VkDeviceMemory getMemBindingFromObject(const VkObject object)
+static VkDeviceMemory getMemBindingFromObject(
+    const VkObject object)
 {
     VkDeviceMemory mem = NULL;
     MT_OBJ_INFO* pObjInfo = getObjectInfo(object);
@@ -753,7 +803,8 @@
 }
 
 // Print details of MemObjInfo list
-static void printMemList()
+static void printMemList(
+    void)
 {
     MT_MEM_OBJ_INFO* pInfo = NULL;
     // Just printing each msg individually for now, may want to package these into single large print
@@ -795,7 +846,8 @@
     }
 }
 
-static void printCBList()
+static void printCBList(
+    void)
 {
     char str[1024] = {0};
     MT_CB_INFO* pCBInfo = NULL;
@@ -817,7 +869,8 @@
     }
 }
 
-static void initMemTracker(void)
+static void initMemTracker(
+    void)
 {
     const char *strOpt;
     // initialize MemTracker options
@@ -827,12 +880,12 @@
     if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
     {
         strOpt = getLayerOption("MemTrackerLogFilename");
-        if (strOpt)
-        {
+        if (strOpt) {
             g_logFile = fopen(strOpt, "w");
         }
-        if (g_logFile == NULL)
+        if (g_logFile == NULL) {
             g_logFile = stdout;
+        }
     }
 
     // initialize Layer dispatch table
@@ -855,7 +908,10 @@
     }
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
+    VkPhysicalDevice          gpu,
+    const VkDeviceCreateInfo *pCreateInfo,
+    VkDevice                 *pDevice)
 {
     pCurObj = (VkBaseLayerObject *) gpu;
     loader_platform_thread_once(&g_initOnce, initMemTracker);
@@ -865,7 +921,8 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(
+    VkDevice device)
 {
     char str[1024];
     sprintf(str, "Printing List details prior to vkDestroyDevice()");
@@ -884,8 +941,8 @@
         pInfo = (*ii).second;
 
         if (pInfo->allocInfo.allocationSize != 0) {
-            sprintf(str, "Mem Object %p has not been freed. You should clean up this memory by calling vkFreeMemory(%p) prior to vkDestroyDevice().",
-                pInfo->mem, pInfo->mem);
+            sprintf(str, "Mem Object %p has not been freed. You should clean up this memory by calling "
+                         "vkFreeMemory(%p) prior to vkDestroyDevice().", pInfo->mem, pInfo->mem);
             layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", str);
         }
     }
@@ -910,32 +967,36 @@
 };
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionInfo(
-                                               VkExtensionInfoType infoType,
-                                               uint32_t extensionIndex,
-                                               size_t*  pDataSize,
-                                               void*    pData)
+    VkExtensionInfoType  infoType,
+    uint32_t             extensionIndex,
+    size_t              *pDataSize,
+    void                *pData)
 {
-    /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
+    // This entrypoint is NOT going to init its own dispatch table since loader calls here early
     VkExtensionProperties *ext_props;
     uint32_t *count;
 
-    if (pDataSize == NULL)
+    if (pDataSize == NULL) {
         return VK_ERROR_INVALID_POINTER;
+    }
 
     switch (infoType) {
         case VK_EXTENSION_INFO_TYPE_COUNT:
             *pDataSize = sizeof(uint32_t);
-            if (pData == NULL)
+            if (pData == NULL) {
                 return VK_SUCCESS;
+            }
             count = (uint32_t *) pData;
             *count = MEM_TRACKER_LAYER_EXT_ARRAY_SIZE;
             break;
         case VK_EXTENSION_INFO_TYPE_PROPERTIES:
             *pDataSize = sizeof(VkExtensionProperties);
-            if (pData == NULL)
+            if (pData == NULL) {
                 return VK_SUCCESS;
-            if (extensionIndex >= MEM_TRACKER_LAYER_EXT_ARRAY_SIZE)
+            }
+            if (extensionIndex >= MEM_TRACKER_LAYER_EXT_ARRAY_SIZE) {
                 return VK_ERROR_INVALID_VALUE;
+            }
             ext_props = (VkExtensionProperties *) pData;
             ext_props->version = mtExts[extensionIndex].version;
             strncpy(ext_props->extName, mtExts[extensionIndex].name,
@@ -949,10 +1010,14 @@
     return VK_SUCCESS;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu,
-    size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(
+    VkPhysicalDevice  gpu,
+    size_t            maxStringSize,
+    size_t           *pLayerCount,
+    char* const      *pOutLayers,
+    void             *pReserved)
 {
-        if (gpu != NULL)
+    if (gpu != NULL)
     {
         pCurObj = (VkBaseLayerObject *)  gpu;
         loader_platform_thread_once(&g_initOnce, initMemTracker);
@@ -961,8 +1026,9 @@
         return result;
     } else
     {
-        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
+        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL) {
             return VK_ERROR_INVALID_POINTER;
+        }
         // This layer compatible with all GPUs
         *pLayerCount = 1;
         strncpy((char *) pOutLayers[0], "MemTracker", maxStringSize);
@@ -970,7 +1036,11 @@
     }
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue)
+VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(
+    VkDevice  device,
+    uint32_t  queueNodeIndex,
+    uint32_t  queueIndex,
+    VkQueue   *pQueue)
 {
     VkResult result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
     if (result == VK_SUCCESS) {
@@ -981,7 +1051,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReferences(VkQueue queue, uint32_t count, const VkDeviceMemory* pMems)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReferences(
+    VkQueue                queue,
+    uint32_t               count,
+    const VkDeviceMemory  *pMems)
 {
     VkResult result = nextTable.QueueAddMemReferences(queue, count, pMems);
     if (result == VK_SUCCESS) {
@@ -997,7 +1070,8 @@
                 if (checkMemRef(queue, pMems[i]) == VK_TRUE) {
                     // Alread in list, just warn
                     char str[1024];
-                    sprintf(str, "Request to add a memory reference (%p) to Queue %p -- ref is already present in the queue's reference list", pMems[i], queue);
+                    sprintf(str, "Request to add a memory reference (%p) to Queue %p -- ref is already "
+                                 "present in the queue's reference list", pMems[i], queue);
                     layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pMems[i], 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
                 } else {
                     // Add to queue's memory reference list
@@ -1010,7 +1084,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReferences(VkQueue queue, uint32_t count, const VkDeviceMemory* pMems)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReferences(
+    VkQueue               queue,
+    uint32_t              count,
+    const VkDeviceMemory *pMems)
 {
     // TODO : Decrement ref count for this memory reference on this queue. Remove if ref count is zero.
     VkResult result = nextTable.QueueRemoveMemReferences(queue, count, pMems);
@@ -1038,8 +1115,8 @@
 
 VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(
     VkQueue             queue,
-    uint32_t              cmdBufferCount,
-    const VkCmdBuffer *pCmdBuffers,
+    uint32_t            cmdBufferCount,
+    const VkCmdBuffer  *pCmdBuffers,
     VkFence             fence)
 {
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1061,7 +1138,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem)
+VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
+    VkDevice                 device,
+    const VkMemoryAllocInfo *pAllocInfo,
+    VkDeviceMemory          *pMem)
 {
     VkResult result = nextTable.AllocMemory(device, pAllocInfo, pMem);
     // TODO : Track allocations and overall size here
@@ -1072,7 +1152,9 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem)
+VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(
+    VkDevice       device,
+    VkDeviceMemory mem)
 {
     /* From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. Before
      * freeing a memory object, an application must ensure the memory object is unbound from
@@ -1092,7 +1174,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority)
+VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(
+    VkDevice         device,
+    VkDeviceMemory   mem,
+    VkMemoryPriority priority)
 {
     // TODO : Update tracking for this alloc
     //  Make sure memory is not pinned, which can't have priority set
@@ -1100,7 +1185,13 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData)
+VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(
+    VkDevice         device,
+    VkDeviceMemory   mem,
+    VkDeviceSize     offset,
+    VkDeviceSize     size,
+    VkFlags          flags,
+    void           **ppData)
 {
     // TODO : Track when memory is mapped
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1115,7 +1206,9 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem)
+VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(
+    VkDevice       device,
+    VkDeviceMemory mem)
 {
     // TODO : Track as memory gets unmapped, do we want to check what changed following map?
     //   Make sure that memory was ever mapped to begin with
@@ -1123,7 +1216,11 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pSysMem, size_t memSize, VkDeviceMemory* pMem)
+VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(
+    VkDevice        device,
+    const void     *pSysMem,
+    size_t          memSize,
+    VkDeviceMemory *pMem)
 {
     // TODO : Track this
     //  Verify that memory is actually pinnable
@@ -1131,28 +1228,41 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedMemory(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem)
+VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedMemory(
+    VkDevice                device,
+    const VkMemoryOpenInfo *pOpenInfo,
+    VkDeviceMemory         *pMem)
 {
     // TODO : Track this
     VkResult result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerMemory(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem)
+VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerMemory(
+    VkDevice                    device,
+    const VkPeerMemoryOpenInfo *pOpenInfo,
+    VkDeviceMemory             *pMem)
 {
     // TODO : Track this
     VkResult result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem)
+VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(
+    VkDevice                   device,
+    const VkPeerImageOpenInfo *pOpenInfo,
+    VkImage                   *pImage,
+    VkDeviceMemory            *pMem)
 {
     // TODO : Track this
     VkResult result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(
+    VkDevice     device,
+    VkObjectType objType,
+    VkObject     object)
 {
     loader_platform_thread_lock_mutex(&globalLock);
 
@@ -1172,9 +1282,12 @@
             }
             else {
                 char str[1024];
-                sprintf(str, "Destroying obj %p that is still bound to memory object %p\nYou should first clear binding by calling vkQueueBindObjectMemory(queue, %p, 0, VK_NULL_HANDLE, 0)", object, (void*)pDelInfo->pMemObjInfo->mem, object);
+                sprintf(str, "Destroying obj %p that is still bound to memory object %p\nYou should first clear binding "
+                             "by calling vkQueueBindObjectMemory(queue, %p, 0, VK_NULL_HANDLE, 0)",
+                             object, (void*)pDelInfo->pMemObjInfo->mem, object);
                 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_DESTROY_OBJECT_ERROR, "MEM", str);
-                // From the spec : If an object has previous memory binding, it is required to unbind memory from an API object before it is destroyed.
+                // From the spec : If an object has previous memory binding, it is required to unbind memory
+                // from an API object before it is destroyed.
                 clearObjectBinding(object);
             }
         }
@@ -1187,16 +1300,29 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(
+    VkDevice          device,
+    VkObjectType      objType,
+    VkObject          object,
+    VkObjectInfoType  infoType,
+    size_t           *pDataSize,
+    void             *pData)
 {
     // TODO : What to track here?
     //   Could potentially save returned mem requirements and validate values passed into QueueBindObjectMemory for this object
-    // From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues, command buffers, shaders and memory objects.
+    // From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues,
+    //             command buffers, shaders and memory objects.
     VkResult result = nextTable.GetObjectInfo(device, objType, object, infoType, pDataSize, pData);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemory(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemory(
+    VkQueue        queue,
+    VkObjectType   objType,
+    VkObject       object,
+    uint32_t       allocationIdx,
+    VkDeviceMemory mem,
+    VkDeviceSize   offset)
 {
     VkResult result = nextTable.QueueBindObjectMemory(queue, objType, object, allocationIdx, mem, offset);
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1212,7 +1338,15 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemoryRange(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemoryRange(
+    VkQueue        queue,
+    VkObjectType   objType,
+    VkObject       object,
+    uint32_t       allocationIdx,
+    VkDeviceSize   rangeOffset,
+    VkDeviceSize   rangeSize,
+    VkDeviceMemory mem,
+    VkDeviceSize   memOffset)
 {
     VkResult result = nextTable.QueueBindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1228,7 +1362,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
+    VkDevice                 device,
+    const VkFenceCreateInfo *pCreateInfo,
+    VkFence                 *pFence)
 {
     VkResult result = nextTable.CreateFence(device, pCreateInfo, pFence);
     if (VK_SUCCESS == result) {
@@ -1239,7 +1376,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, VkFence* pFences)
+VK_LAYER_EXPORT VkResult VKAPI vkResetFences(
+    VkDevice  device,
+    uint32_t  fenceCount,
+    VkFence  *pFences)
 {
     VkResult result = nextTable.ResetFences(device, fenceCount, pFences);
     if (VK_SUCCESS == result) {
@@ -1266,7 +1406,9 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkDevice device, VkFence fence)
+VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(
+    VkDevice device,
+    VkFence  fence)
 {
     VkResult result = nextTable.GetFenceStatus(device, fence);
     if (VK_SUCCESS == result) {
@@ -1277,7 +1419,12 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout)
+VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(
+    VkDevice       device,
+    uint32_t       fenceCount,
+    const VkFence *pFences,
+    bool32_t       waitAll,
+    uint64_t       timeout)
 {
     // Verify fence status of submitted fences
     for(uint32_t i = 0; i < fenceCount; i++) {
@@ -1305,7 +1452,8 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(
+    VkQueue queue)
 {
     VkResult result = nextTable.QueueWaitIdle(queue);
     if (VK_SUCCESS == result) {
@@ -1316,7 +1464,8 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device)
+VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(
+    VkDevice device)
 {
     VkResult result = nextTable.DeviceWaitIdle(device);
     if (VK_SUCCESS == result) {
@@ -1327,7 +1476,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(
+    VkDevice                 device,
+    const VkEventCreateInfo *pCreateInfo,
+    VkEvent                 *pEvent)
 {
     VkResult result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
     if (VK_SUCCESS == result) {
@@ -1338,7 +1490,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(
+    VkDevice                     device,
+    const VkQueryPoolCreateInfo *pCreateInfo,
+    VkQueryPool                 *pQueryPool)
 {
     VkResult result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
     if (VK_SUCCESS == result) {
@@ -1349,7 +1504,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
+    VkDevice                  device,
+    const VkBufferCreateInfo *pCreateInfo,
+    VkBuffer                 *pBuffer)
 {
     VkResult result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
     if (VK_SUCCESS == result) {
@@ -1360,7 +1518,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
+    VkDevice                      device,
+    const VkBufferViewCreateInfo *pCreateInfo,
+    VkBufferView                 *pView)
 {
     VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView);
     if (result == VK_SUCCESS) {
@@ -1371,7 +1532,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
+    VkDevice                 device,
+    const VkImageCreateInfo *pCreateInfo,
+    VkImage                 *pImage)
 {
     VkResult result = nextTable.CreateImage(device, pCreateInfo, pImage);
     if (VK_SUCCESS == result) {
@@ -1382,7 +1546,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
+    VkDevice                     device,
+    const VkImageViewCreateInfo *pCreateInfo,
+    VkImageView                 *pView)
 {
     VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView);
     if (result == VK_SUCCESS) {
@@ -1393,8 +1560,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo,
-    VkColorAttachmentView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(
+    VkDevice                               device,
+    const VkColorAttachmentViewCreateInfo *pCreateInfo,
+    VkColorAttachmentView                 *pView)
 {
     VkResult result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
     if (result == VK_SUCCESS) {
@@ -1405,7 +1574,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(
+    VkDevice                            device,
+    const VkDepthStencilViewCreateInfo *pCreateInfo,
+    VkDepthStencilView                 *pView)
 {
     VkResult result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
     if (result == VK_SUCCESS) {
@@ -1416,13 +1588,19 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
+    VkDevice                  device,
+    const VkShaderCreateInfo *pCreateInfo,
+    VkShader                 *pShader)
 {
     VkResult result = nextTable.CreateShader(device, pCreateInfo, pShader);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(
+    VkDevice                            device,
+    const VkGraphicsPipelineCreateInfo *pCreateInfo,
+    VkPipeline                         *pPipeline)
 {
     VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
     if (result == VK_SUCCESS) {
@@ -1434,10 +1612,10 @@
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(
-        VkDevice device,
-        const VkGraphicsPipelineCreateInfo* pCreateInfo,
-        VkPipeline basePipeline,
-        VkPipeline* pPipeline)
+    VkDevice                            device,
+    const VkGraphicsPipelineCreateInfo *pCreateInfo,
+    VkPipeline                          basePipeline,
+    VkPipeline                         *pPipeline)
 {
     VkResult result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
     if (result == VK_SUCCESS) {
@@ -1448,7 +1626,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(
+    VkDevice                           device,
+    const VkComputePipelineCreateInfo *pCreateInfo,
+    VkPipeline                        *pPipeline)
 {
     VkResult result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
     if (result == VK_SUCCESS) {
@@ -1459,7 +1640,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(
+    VkDevice                   device,
+    const VkSamplerCreateInfo *pCreateInfo,
+    VkSampler                 *pSampler)
 {
     VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
     if (result == VK_SUCCESS) {
@@ -1470,8 +1654,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo,
-    VkDynamicVpState* pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(
+    VkDevice                          device,
+    const VkDynamicVpStateCreateInfo *pCreateInfo,
+    VkDynamicVpState                 *pState)
 {
     VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
     if (result == VK_SUCCESS) {
@@ -1482,8 +1668,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo,
-    VkDynamicRsState* pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(
+    VkDevice                          device,
+    const VkDynamicRsStateCreateInfo *pCreateInfo,
+    VkDynamicRsState                 *pState)
 {
     VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
     if (result == VK_SUCCESS) {
@@ -1494,8 +1682,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo,
-    VkDynamicCbState*  pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(
+    VkDevice                          device,
+    const VkDynamicCbStateCreateInfo *pCreateInfo,
+    VkDynamicCbState                 *pState)
 {
     VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
     if (result == VK_SUCCESS) {
@@ -1506,8 +1696,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo,
-    VkDynamicDsState*    pState)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(
+    VkDevice                          device,
+    const VkDynamicDsStateCreateInfo *pCreateInfo,
+    VkDynamicDsState                 *pState)
 {
     VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
     if (result == VK_SUCCESS) {
@@ -1518,7 +1710,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(
+    VkDevice                     device,
+    const VkCmdBufferCreateInfo *pCreateInfo,
+    VkCmdBuffer                 *pCmdBuffer)
 {
     VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
     // At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer
@@ -1530,7 +1725,9 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
+VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(
+    VkCmdBuffer                 cmdBuffer,
+    const VkCmdBufferBeginInfo *pBeginInfo)
 {
     // This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references
     MT_CB_INFO* pCBInfo = getCBInfo(cmdBuffer);
@@ -1538,7 +1735,8 @@
         bool32_t cbDone = checkCBCompleted(cmdBuffer);
         if (VK_FALSE == cbDone) {
             char str[1024];
-            sprintf(str, "Calling vkBeginCommandBuffer() on active CB %p before it has completed. You must check CB flag before this call.", cmdBuffer);
+            sprintf(str, "Calling vkBeginCommandBuffer() on active CB %p before it has completed. "
+                         "You must check CB flag before this call.", cmdBuffer);
             layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
         }
     }
@@ -1549,14 +1747,16 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(
+    VkCmdBuffer cmdBuffer)
 {
     // TODO : Anything to do here?
     VkResult result = nextTable.EndCommandBuffer(cmdBuffer);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(
+    VkCmdBuffer cmdBuffer)
 {
     // Verify that CB is complete (not in-flight)
     MT_CB_INFO* pCBInfo = getCBInfo(cmdBuffer);
@@ -1564,7 +1764,8 @@
         bool32_t cbDone = checkCBCompleted(cmdBuffer);
         if (VK_FALSE == cbDone) {
             char str[1024];
-            sprintf(str, "Resetting CB %p before it has completed. You must check CB flag before calling vkResetCommandBuffer().", cmdBuffer);
+            sprintf(str, "Resetting CB %p before it has completed. You must check CB flag before "
+                         "calling vkResetCommandBuffer().", cmdBuffer);
             layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
         }
     }
@@ -1577,7 +1778,10 @@
 }
 // TODO : For any vkCmdBind* calls that include an object which has mem bound to it,
 //    need to account for that mem now having binding to given cmdBuffer
-VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(
+    VkCmdBuffer         cmdBuffer,
+    VkPipelineBindPoint pipelineBindPoint,
+    VkPipeline          pipeline)
 {
 #if 0
     // TODO : If memory bound to pipeline, then need to tie that mem to cmdBuffer
@@ -1600,7 +1804,10 @@
     nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state)
+VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(
+    VkCmdBuffer          cmdBuffer,
+    VkStateBindPoint     stateBindPoint,
+    VkDynamicStateObject state)
 {
     MT_OBJ_INFO *pObjInfo;
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1622,34 +1829,43 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
-    VkCmdBuffer                              cmdBuffer,
-    VkPipelineBindPoint                     pipelineBindPoint,
-        uint32_t                            firstSet,
-        uint32_t                            setCount,
-        const VkDescriptorSet*              pDescriptorSets,
-        uint32_t                            dynamicOffsetCount,
-        const uint32_t*                     pDynamicOffsets)
+    VkCmdBuffer            cmdBuffer,
+    VkPipelineBindPoint    pipelineBindPoint,
+    uint32_t               firstSet,
+    uint32_t               setCount,
+    const VkDescriptorSet *pDescriptorSets,
+    uint32_t               dynamicOffsetCount,
+    const uint32_t        *pDynamicOffsets)
 {
     // TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state
     nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
-    VkCmdBuffer                                 cmdBuffer,
-    uint32_t                                    startBinding,
-    uint32_t                                    bindingCount,
-    const VkBuffer*                             pBuffers,
-    const VkDeviceSize*                         pOffsets)
+    VkCmdBuffer         cmdBuffer,
+    uint32_t            startBinding,
+    uint32_t            bindingCount,
+    const VkBuffer     *pBuffers,
+    const VkDeviceSize *pOffsets)
 {
     nextTable.CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(
+    VkCmdBuffer  cmdBuffer,
+    VkBuffer     buffer,
+    VkDeviceSize offset,
+    VkIndexType  indexType)
 {
     nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(
+    VkCmdBuffer   cmdBuffer,
+     VkBuffer     buffer,
+     VkDeviceSize offset,
+     uint32_t     count,
+     uint32_t     stride)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem = getMemBindingFromObject(buffer);
@@ -1662,7 +1878,12 @@
     nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
+    VkCmdBuffer  cmdBuffer,
+    VkBuffer     buffer,
+    VkDeviceSize offset,
+    uint32_t     count,
+    uint32_t     stride)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem = getMemBindingFromObject(buffer);
@@ -1675,7 +1896,10 @@
     nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(
+    VkCmdBuffer  cmdBuffer,
+    VkBuffer     buffer,
+    VkDeviceSize offset)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem = getMemBindingFromObject(buffer);
@@ -1688,8 +1912,12 @@
     nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer,
-    uint32_t regionCount, const VkBufferCopy* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(
+    VkCmdBuffer         cmdBuffer,
+    VkBuffer            srcBuffer,
+    VkBuffer            destBuffer,
+    uint32_t            regionCount,
+    const VkBufferCopy *pRegions)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem = getMemBindingFromObject(srcBuffer);
@@ -1708,28 +1936,39 @@
     nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer,
-                                             VkImage srcImage, VkImageLayout srcImageLayout,
-                                             VkImage destImage, VkImageLayout destImageLayout,
-                                             uint32_t regionCount, const VkImageCopy* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
+    VkCmdBuffer        cmdBuffer,
+    VkImage            srcImage,
+    VkImageLayout      srcImageLayout,
+    VkImage            destImage,
+    VkImageLayout      destImageLayout,
+    uint32_t           regionCount,
+    const VkImageCopy *pRegions)
 {
     // TODO : Each image will have mem mapping so track them
     nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer,
-                                             VkImage srcImage, VkImageLayout srcImageLayout,
-                                             VkImage destImage, VkImageLayout destImageLayout,
-                                             uint32_t regionCount, const VkImageBlit* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
+    VkCmdBuffer        cmdBuffer,
+    VkImage            srcImage,
+    VkImageLayout      srcImageLayout,
+    VkImage            destImage,
+    VkImageLayout      destImageLayout,
+    uint32_t           regionCount,
+    const VkImageBlit *pRegions)
 {
     // TODO : Each image will have mem mapping so track them
     nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer,
-                                                     VkBuffer srcBuffer,
-                                                     VkImage destImage, VkImageLayout destImageLayout,
-                                                     uint32_t regionCount, const VkBufferImageCopy* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
+    VkCmdBuffer              cmdBuffer,
+    VkBuffer                 srcBuffer,
+    VkImage                  destImage,
+    VkImageLayout            destImageLayout,
+    uint32_t                 regionCount,
+    const VkBufferImageCopy *pRegions)
 {
     // TODO : Track this
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1750,10 +1989,13 @@
     nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer,
-                                                     VkImage srcImage, VkImageLayout srcImageLayout,
-                                                     VkBuffer destBuffer,
-                                                     uint32_t regionCount, const VkBufferImageCopy* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
+    VkCmdBuffer              cmdBuffer,
+    VkImage                  srcImage,
+    VkImageLayout            srcImageLayout,
+    VkBuffer                 destBuffer,
+    uint32_t                 regionCount,
+    const VkBufferImageCopy *pRegions)
 {
     // TODO : Track this
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1773,8 +2015,12 @@
     nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
-    VkImage destImage, VkImageLayout destImageLayout)
+VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(
+    VkCmdBuffer   cmdBuffer,
+    VkImage       srcImage,
+    VkImageLayout srcImageLayout,
+    VkImage       destImage,
+    VkImageLayout destImageLayout)
 {
     // TODO : Each image will have mem mapping so track them
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1794,7 +2040,12 @@
     nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
+    VkCmdBuffer     cmdBuffer,
+    VkBuffer        destBuffer,
+    VkDeviceSize    destOffset,
+    VkDeviceSize    dataSize,
+    const uint32_t *pData)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem = getMemBindingFromObject(destBuffer);
@@ -1807,7 +2058,12 @@
     nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
+    VkCmdBuffer  cmdBuffer,
+    VkBuffer     destBuffer,
+    VkDeviceSize destOffset,
+    VkDeviceSize fillSize,
+    uint32_t     data)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem = getMemBindingFromObject(destBuffer);
@@ -1820,10 +2076,13 @@
     nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer,
-                                                   VkImage image, VkImageLayout imageLayout,
-                                                   VkClearColor color,
-                                                   uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
+    VkCmdBuffer                    cmdBuffer,
+    VkImage                        image,
+    VkImageLayout                  imageLayout,
+    VkClearColor                   color,
+    uint32_t                       rangeCount,
+    const VkImageSubresourceRange *pRanges)
 {
     // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1837,10 +2096,14 @@
     nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer,
-                                                     VkImage image, VkImageLayout imageLayout,
-                                                     float depth, uint32_t stencil,
-                                                     uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(
+    VkCmdBuffer                    cmdBuffer,
+    VkImage                        image,
+    VkImageLayout                  imageLayout,
+    float                          depth,
+    uint32_t                       stencil,
+    uint32_t                       rangeCount,
+    const VkImageSubresourceRange *pRanges)
 {
     // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1854,10 +2117,14 @@
     nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer,
-                                                VkImage srcImage, VkImageLayout srcImageLayout,
-                                                VkImage destImage, VkImageLayout destImageLayout,
-                                                uint32_t regionCount, const VkImageResolve* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
+    VkCmdBuffer           cmdBuffer,
+    VkImage               srcImage,
+    VkImageLayout         srcImageLayout,
+    VkImage               destImage,
+    VkImageLayout         destImageLayout,
+    uint32_t              regionCount,
+    const VkImageResolve *pRegions)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem = getMemBindingFromObject(srcImage);
@@ -1876,7 +2143,11 @@
     nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(
+    VkCmdBuffer cmdBuffer,
+    VkQueryPool queryPool,
+    uint32_t    slot,
+    VkFlags     flags)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem = getMemBindingFromObject(queryPool);
@@ -1889,7 +2160,10 @@
     nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(
+    VkCmdBuffer cmdBuffer,
+    VkQueryPool queryPool,
+    uint32_t    slot)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem = getMemBindingFromObject(queryPool);
@@ -1902,7 +2176,11 @@
     nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(
+    VkCmdBuffer cmdBuffer,
+    VkQueryPool queryPool,
+    uint32_t    startQuery,
+    uint32_t    queryCount)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem = getMemBindingFromObject(queryPool);
@@ -1915,7 +2193,10 @@
     nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(
+    VkInstance                    instance,
+    VK_DBG_MSG_CALLBACK_FUNCTION  pfnMsgCallback,
+    void                         *pUserData)
 {
     // This layer intercepts callbacks
     VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE));
@@ -1933,23 +2214,25 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(
+    VkInstance                   instance,
+    VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
 {
     VK_LAYER_DBG_FUNCTION_NODE *pInfo = g_pDbgFunctionHead;
     VK_LAYER_DBG_FUNCTION_NODE *pPrev = pInfo;
     while (pInfo) {
         if (pInfo->pfnMsgCallback == pfnMsgCallback) {
             pPrev->pNext = pInfo->pNext;
-            if (g_pDbgFunctionHead == pInfo)
+            if (g_pDbgFunctionHead == pInfo) {
                 g_pDbgFunctionHead = pInfo->pNext;
+            }
             free(pInfo);
             break;
         }
         pPrev = pInfo;
         pInfo = pInfo->pNext;
     }
-    if (g_pDbgFunctionHead == NULL)
-    {
+    if (g_pDbgFunctionHead == NULL) {
         if (g_actionIsDefault) {
             g_debugAction = VK_DBG_LAYER_ACTION_LOG_MSG;
         } else {
@@ -1960,7 +2243,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(
+    VkDevice                        device,
+    const VkSwapChainCreateInfoWSI *pCreateInfo,
+    VkSwapChainWSI                 *pSwapChain)
 {
     VkResult result = nextTable.CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
 
@@ -1973,7 +2259,8 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkDestroySwapChainWSI(VkSwapChainWSI swapChain)
+VK_LAYER_EXPORT VkResult VKAPI vkDestroySwapChainWSI(
+    VkSwapChainWSI swapChain)
 {
     loader_platform_thread_lock_mutex(&globalLock);
 
@@ -1999,7 +2286,11 @@
     return nextTable.DestroySwapChainWSI(swapChain);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainInfoWSI(VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, size_t* pDataSize, void* pData)
+VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainInfoWSI(
+    VkSwapChainWSI          swapChain,
+    VkSwapChainInfoTypeWSI  infoType,
+    size_t                 *pDataSize,
+    void                   *pData)
 {
     VkResult result = nextTable.GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData);
 
@@ -2037,12 +2328,15 @@
     return result;
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* funcName)
+VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(
+    VkPhysicalDevice  gpu,
+    const char       *funcName)
 {
     VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
 
-    if (gpu == NULL)
+    if (gpu == NULL) {
         return NULL;
+    }
     pCurObj = gpuw;
     loader_platform_thread_once(&g_initOnce, initMemTracker);
 
@@ -2195,8 +2489,9 @@
     if (!strcmp(funcName, "vkGetSwapChainInfoWSI"))
         return (void*) vkGetSwapChainInfoWSI;
     else {
-        if (gpuw->pGPA == NULL)
+        if (gpuw->pGPA == NULL) {
             return NULL;
+        }
         return gpuw->pGPA((VkPhysicalDevice)gpuw->nextObject, funcName);
     }
 }
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index 417da1d..84df08e 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -85,65 +85,65 @@
 
 // Data struct for tracking memory object
 struct MT_MEM_OBJ_INFO {
-    uint32_t                     refCount;           // Count of references (obj bindings or CB use)
-    VkDeviceMemory               mem;
-    VkMemoryAllocInfo        allocInfo;
-    list<VkObject>             pObjBindings;       // list container of objects bound to this memory
-    list<VkCmdBuffer>         pCmdBufferBindings; // list container of cmd buffers that reference this mem object
+    uint32_t                    refCount;           // Count of references (obj bindings or CB use)
+    VkDeviceMemory              mem;
+    VkMemoryAllocInfo           allocInfo;
+    list<VkObject>              pObjBindings;       // list container of objects bound to this memory
+    list<VkCmdBuffer>           pCmdBufferBindings; // list container of cmd buffers that reference this mem object
 };
 
 struct MT_OBJ_INFO {
-    MT_MEM_OBJ_INFO*            pMemObjInfo;
-    VkObject                  object;
-    VkStructureType          sType;
-    uint32_t                    ref_count;
+    MT_MEM_OBJ_INFO*                       pMemObjInfo;
+    VkObject                               object;
+    VkStructureType                        sType;
+    uint32_t                               ref_count;
     // Capture all object types that may have memory bound. From prog guide:
     // The only objects that are guaranteed to have no external memory
-    //   requirements are devices, queues, command buffers, shaders and memory objects.
+    // requirements are devices, queues, command buffers, shaders and memory objects.
     union {
-        VkColorAttachmentViewCreateInfo     color_attachment_view_create_info;
-        VkDepthStencilViewCreateInfo        ds_view_create_info;
-        VkImageViewCreateInfo                image_view_create_info;
-        VkImageCreateInfo                     image_create_info;
-        VkGraphicsPipelineCreateInfo         graphics_pipeline_create_info;
-        VkComputePipelineCreateInfo          compute_pipeline_create_info;
-        VkSamplerCreateInfo                   sampler_create_info;
-        VkFenceCreateInfo                     fence_create_info;
-        VkSwapChainCreateInfoWSI            swap_chain_create_info;
+        VkColorAttachmentViewCreateInfo    color_attachment_view_create_info;
+        VkDepthStencilViewCreateInfo       ds_view_create_info;
+        VkImageViewCreateInfo              image_view_create_info;
+        VkImageCreateInfo                  image_create_info;
+        VkGraphicsPipelineCreateInfo       graphics_pipeline_create_info;
+        VkComputePipelineCreateInfo        compute_pipeline_create_info;
+        VkSamplerCreateInfo                sampler_create_info;
+        VkFenceCreateInfo                  fence_create_info;
+        VkSwapChainCreateInfoWSI           swap_chain_create_info;
     } create_info;
     char object_name[64];
 };
 
 // Track all command buffers
 struct MT_CB_INFO {
-    VkCmdBufferCreateInfo      createInfo;
-    MT_OBJ_INFO*                    pDynamicState[VK_NUM_STATE_BIND_POINT];
-    VkPipeline                    pipelines[VK_NUM_PIPELINE_BIND_POINT];
-    uint32_t                        colorAttachmentCount;
-    VkDepthStencilBindInfo     dsBindInfo;
-    VkCmdBuffer                  cmdBuffer;
-    uint64_t                        fenceId;
+    VkCmdBufferCreateInfo       createInfo;
+    MT_OBJ_INFO*                pDynamicState[VK_NUM_STATE_BIND_POINT];
+    VkPipeline                  pipelines[VK_NUM_PIPELINE_BIND_POINT];
+    uint32_t                    colorAttachmentCount;
+    VkDepthStencilBindInfo      dsBindInfo;
+    VkCmdBuffer                 cmdBuffer;
+    uint64_t                    fenceId;
     // Order dependent, stl containers must be at end of struct
-    list<VkDeviceMemory>            pMemObjList; // List container of Mem objs referenced by this CB
+    list<VkDeviceMemory>        pMemObjList; // List container of Mem objs referenced by this CB
 };
 
 // Associate fenceId with a fence object
 struct MT_FENCE_INFO {
-    VkFence   fence;         // Handle to fence object
-    VkQueue   queue;         // Queue that this fence is submitted against
-    bool32_t    localFence;    // Is fence created by layer?
+    VkFence   fence;            // Handle to fence object
+    VkQueue   queue;            // Queue that this fence is submitted against
+    bool32_t    localFence;     // Is fence created by layer?
 };
 
 // Track Queue information
 struct MT_QUEUE_INFO {
-    uint64_t                      lastRetiredId;
-    uint64_t                      lastSubmittedId;
-    list<VkCmdBuffer>          pQueueCmdBuffers;
-    list<VkDeviceMemory>          pMemRefList;
+    uint64_t                    lastRetiredId;
+    uint64_t                    lastSubmittedId;
+    list<VkCmdBuffer>           pQueueCmdBuffers;
+    list<VkDeviceMemory>        pMemRefList;
 };
 
 struct MT_SWAP_CHAIN_INFO {
-    VkSwapChainCreateInfoWSI createInfo;
+    VkSwapChainCreateInfoWSI             createInfo;
     std::vector<VkSwapChainImageInfoWSI> images;
 };