diff --git a/src/VmaReplay/Common.h b/src/VmaReplay/Common.h
index a78524b..d0548bf 100644
--- a/src/VmaReplay/Common.h
+++ b/src/VmaReplay/Common.h
@@ -35,6 +35,11 @@
 {
     return (x+y-1) / y;
 }
+template <typename T>
+inline T round_div(T x, T y)
+{
+    return (x+y/(T)2) / y;
+}
 
 template <typename T>
 inline T align_up(T val, T align)
diff --git a/src/VmaReplay/Constants.cpp b/src/VmaReplay/Constants.cpp
new file mode 100644
index 0000000..44b4748
--- /dev/null
+++ b/src/VmaReplay/Constants.cpp
@@ -0,0 +1,766 @@
+#include "Common.h"
+#include "Constants.h"
+
+const int RESULT_EXCEPTION          = -1000;
+const int RESULT_ERROR_COMMAND_LINE = -1;
+const int RESULT_ERROR_SOURCE_FILE  = -2;
+const int RESULT_ERROR_FORMAT       = -3;
+const int RESULT_ERROR_VULKAN       = -4;
+
+const char* VMA_FUNCTION_NAMES[] = {
+    "vmaCreatePool",
+    "vmaDestroyPool",
+    "vmaSetAllocationUserData",
+    "vmaCreateBuffer",
+    "vmaDestroyBuffer",
+    "vmaCreateImage",
+    "vmaDestroyImage",
+    "vmaFreeMemory",
+    "vmaFreeMemoryPages",
+    "vmaCreateLostAllocation",
+    "vmaAllocateMemory",
+    "vmaAllocateMemoryPages",
+    "vmaAllocateMemoryForBuffer",
+    "vmaAllocateMemoryForImage",
+    "vmaMapMemory",
+    "vmaUnmapMemory",
+    "vmaFlushAllocation",
+    "vmaInvalidateAllocation",
+    "vmaTouchAllocation",
+    "vmaGetAllocationInfo",
+    "vmaMakePoolAllocationsLost",
+    "vmaResizeAllocation",
+    "vmaDefragmentationBegin",
+    "vmaDefragmentationEnd",
+};
+static_assert(
+    _countof(VMA_FUNCTION_NAMES) == (size_t)VMA_FUNCTION::Count,
+    "VMA_FUNCTION_NAMES array doesn't match VMA_FUNCTION enum.");
+
+const char* VMA_POOL_CREATE_FLAG_NAMES[] = {
+    "VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT",
+    "VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT",
+    "VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT",
+};
+const uint32_t VMA_POOL_CREATE_FLAG_VALUES[] = {
+    VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT,
+    VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT,
+    VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT,
+};
+const size_t VMA_POOL_CREATE_FLAG_COUNT = _countof(VMA_POOL_CREATE_FLAG_NAMES);
+static_assert(
+    _countof(VMA_POOL_CREATE_FLAG_NAMES) == _countof(VMA_POOL_CREATE_FLAG_VALUES),
+    "VMA_POOL_CREATE_FLAG_NAMES array doesn't match VMA_POOL_CREATE_FLAG_VALUES.");
+
+const char* VK_BUFFER_CREATE_FLAG_NAMES[] = {
+    "VK_BUFFER_CREATE_SPARSE_BINDING_BIT",
+    "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT",
+    "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT",
+    "VK_BUFFER_CREATE_PROTECTED_BIT",
+};
+const uint32_t VK_BUFFER_CREATE_FLAG_VALUES[] = {
+    VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
+    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
+    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
+    VK_BUFFER_CREATE_PROTECTED_BIT,
+};
+const size_t VK_BUFFER_CREATE_FLAG_COUNT = _countof(VK_BUFFER_CREATE_FLAG_NAMES);
+static_assert(
+    _countof(VK_BUFFER_CREATE_FLAG_NAMES) == _countof(VK_BUFFER_CREATE_FLAG_VALUES),
+    "VK_BUFFER_CREATE_FLAG_NAMES array doesn't match VK_BUFFER_CREATE_FLAG_VALUES.");
+
+const char* VK_BUFFER_USAGE_FLAG_NAMES[] = {
+    "VK_BUFFER_USAGE_TRANSFER_SRC_BIT",
+    "VK_BUFFER_USAGE_TRANSFER_DST_BIT",
+    "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT",
+    "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT",
+    "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT",
+    "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT",
+    "VK_BUFFER_USAGE_INDEX_BUFFER_BIT",
+    "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT",
+    "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT",
+    "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT",
+    "VK_BUFFER_USAGE_RAYTRACING_BIT_NVX",
+};
+const uint32_t VK_BUFFER_USAGE_FLAG_VALUES[] = {
+    VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+    VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
+    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
+    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
+    VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
+    VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
+    VK_BUFFER_USAGE_RAYTRACING_BIT_NVX,
+};
+const size_t VK_BUFFER_USAGE_FLAG_COUNT = _countof(VK_BUFFER_USAGE_FLAG_NAMES);
+static_assert(
+    _countof(VK_BUFFER_USAGE_FLAG_NAMES) == _countof(VK_BUFFER_USAGE_FLAG_VALUES),
+    "VK_BUFFER_USAGE_FLAG_NAMES array doesn't match VK_BUFFER_USAGE_FLAG_VALUES.");
+
+const char* VK_SHARING_MODE_NAMES[] = {
+    "VK_SHARING_MODE_EXCLUSIVE",
+    "VK_SHARING_MODE_CONCURRENT",
+};
+const size_t VK_SHARING_MODE_COUNT = _countof(VK_SHARING_MODE_NAMES);
+
+const char* VK_IMAGE_CREATE_FLAG_NAMES[] = {
+    "VK_IMAGE_CREATE_SPARSE_BINDING_BIT",
+    "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT",
+    "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT",
+    "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT",
+    "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT",
+    "VK_IMAGE_CREATE_ALIAS_BIT",
+    "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT",
+    "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT",
+    "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT",
+    "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT",
+    "VK_IMAGE_CREATE_PROTECTED_BIT",
+    "VK_IMAGE_CREATE_DISJOINT_BIT",
+    "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV",
+    "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT",
+};
+const uint32_t VK_IMAGE_CREATE_FLAG_VALUES[] = {
+    VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
+    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
+    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
+    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
+    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
+    VK_IMAGE_CREATE_ALIAS_BIT,
+    VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
+    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
+    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
+    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
+    VK_IMAGE_CREATE_PROTECTED_BIT,
+    VK_IMAGE_CREATE_DISJOINT_BIT,
+    VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV,
+    VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT,
+};
+const size_t VK_IMAGE_CREATE_FLAG_COUNT = _countof(VK_IMAGE_CREATE_FLAG_NAMES);
+static_assert(
+    _countof(VK_IMAGE_CREATE_FLAG_NAMES) == _countof(VK_IMAGE_CREATE_FLAG_VALUES),
+    "VK_IMAGE_CREATE_FLAG_NAMES array doesn't match VK_IMAGE_CREATE_FLAG_VALUES.");
+
+const char* VK_IMAGE_TYPE_NAMES[] = {
+    "VK_IMAGE_TYPE_1D",
+    "VK_IMAGE_TYPE_2D",
+    "VK_IMAGE_TYPE_3D",
+};
+const size_t VK_IMAGE_TYPE_COUNT = _countof(VK_IMAGE_TYPE_NAMES);
+
+const char* VK_FORMAT_NAMES[] = {
+    "VK_FORMAT_UNDEFINED",
+    "VK_FORMAT_R4G4_UNORM_PACK8",
+    "VK_FORMAT_R4G4B4A4_UNORM_PACK16",
+    "VK_FORMAT_B4G4R4A4_UNORM_PACK16",
+    "VK_FORMAT_R5G6B5_UNORM_PACK16",
+    "VK_FORMAT_B5G6R5_UNORM_PACK16",
+    "VK_FORMAT_R5G5B5A1_UNORM_PACK16",
+    "VK_FORMAT_B5G5R5A1_UNORM_PACK16",
+    "VK_FORMAT_A1R5G5B5_UNORM_PACK16",
+    "VK_FORMAT_R8_UNORM",
+    "VK_FORMAT_R8_SNORM",
+    "VK_FORMAT_R8_USCALED",
+    "VK_FORMAT_R8_SSCALED",
+    "VK_FORMAT_R8_UINT",
+    "VK_FORMAT_R8_SINT",
+    "VK_FORMAT_R8_SRGB",
+    "VK_FORMAT_R8G8_UNORM",
+    "VK_FORMAT_R8G8_SNORM",
+    "VK_FORMAT_R8G8_USCALED",
+    "VK_FORMAT_R8G8_SSCALED",
+    "VK_FORMAT_R8G8_UINT",
+    "VK_FORMAT_R8G8_SINT",
+    "VK_FORMAT_R8G8_SRGB",
+    "VK_FORMAT_R8G8B8_UNORM",
+    "VK_FORMAT_R8G8B8_SNORM",
+    "VK_FORMAT_R8G8B8_USCALED",
+    "VK_FORMAT_R8G8B8_SSCALED",
+    "VK_FORMAT_R8G8B8_UINT",
+    "VK_FORMAT_R8G8B8_SINT",
+    "VK_FORMAT_R8G8B8_SRGB",
+    "VK_FORMAT_B8G8R8_UNORM",
+    "VK_FORMAT_B8G8R8_SNORM",
+    "VK_FORMAT_B8G8R8_USCALED",
+    "VK_FORMAT_B8G8R8_SSCALED",
+    "VK_FORMAT_B8G8R8_UINT",
+    "VK_FORMAT_B8G8R8_SINT",
+    "VK_FORMAT_B8G8R8_SRGB",
+    "VK_FORMAT_R8G8B8A8_UNORM",
+    "VK_FORMAT_R8G8B8A8_SNORM",
+    "VK_FORMAT_R8G8B8A8_USCALED",
+    "VK_FORMAT_R8G8B8A8_SSCALED",
+    "VK_FORMAT_R8G8B8A8_UINT",
+    "VK_FORMAT_R8G8B8A8_SINT",
+    "VK_FORMAT_R8G8B8A8_SRGB",
+    "VK_FORMAT_B8G8R8A8_UNORM",
+    "VK_FORMAT_B8G8R8A8_SNORM",
+    "VK_FORMAT_B8G8R8A8_USCALED",
+    "VK_FORMAT_B8G8R8A8_SSCALED",
+    "VK_FORMAT_B8G8R8A8_UINT",
+    "VK_FORMAT_B8G8R8A8_SINT",
+    "VK_FORMAT_B8G8R8A8_SRGB",
+    "VK_FORMAT_A8B8G8R8_UNORM_PACK32",
+    "VK_FORMAT_A8B8G8R8_SNORM_PACK32",
+    "VK_FORMAT_A8B8G8R8_USCALED_PACK32",
+    "VK_FORMAT_A8B8G8R8_SSCALED_PACK32",
+    "VK_FORMAT_A8B8G8R8_UINT_PACK32",
+    "VK_FORMAT_A8B8G8R8_SINT_PACK32",
+    "VK_FORMAT_A8B8G8R8_SRGB_PACK32",
+    "VK_FORMAT_A2R10G10B10_UNORM_PACK32",
+    "VK_FORMAT_A2R10G10B10_SNORM_PACK32",
+    "VK_FORMAT_A2R10G10B10_USCALED_PACK32",
+    "VK_FORMAT_A2R10G10B10_SSCALED_PACK32",
+    "VK_FORMAT_A2R10G10B10_UINT_PACK32",
+    "VK_FORMAT_A2R10G10B10_SINT_PACK32",
+    "VK_FORMAT_A2B10G10R10_UNORM_PACK32",
+    "VK_FORMAT_A2B10G10R10_SNORM_PACK32",
+    "VK_FORMAT_A2B10G10R10_USCALED_PACK32",
+    "VK_FORMAT_A2B10G10R10_SSCALED_PACK32",
+    "VK_FORMAT_A2B10G10R10_UINT_PACK32",
+    "VK_FORMAT_A2B10G10R10_SINT_PACK32",
+    "VK_FORMAT_R16_UNORM",
+    "VK_FORMAT_R16_SNORM",
+    "VK_FORMAT_R16_USCALED",
+    "VK_FORMAT_R16_SSCALED",
+    "VK_FORMAT_R16_UINT",
+    "VK_FORMAT_R16_SINT",
+    "VK_FORMAT_R16_SFLOAT",
+    "VK_FORMAT_R16G16_UNORM",
+    "VK_FORMAT_R16G16_SNORM",
+    "VK_FORMAT_R16G16_USCALED",
+    "VK_FORMAT_R16G16_SSCALED",
+    "VK_FORMAT_R16G16_UINT",
+    "VK_FORMAT_R16G16_SINT",
+    "VK_FORMAT_R16G16_SFLOAT",
+    "VK_FORMAT_R16G16B16_UNORM",
+    "VK_FORMAT_R16G16B16_SNORM",
+    "VK_FORMAT_R16G16B16_USCALED",
+    "VK_FORMAT_R16G16B16_SSCALED",
+    "VK_FORMAT_R16G16B16_UINT",
+    "VK_FORMAT_R16G16B16_SINT",
+    "VK_FORMAT_R16G16B16_SFLOAT",
+    "VK_FORMAT_R16G16B16A16_UNORM",
+    "VK_FORMAT_R16G16B16A16_SNORM",
+    "VK_FORMAT_R16G16B16A16_USCALED",
+    "VK_FORMAT_R16G16B16A16_SSCALED",
+    "VK_FORMAT_R16G16B16A16_UINT",
+    "VK_FORMAT_R16G16B16A16_SINT",
+    "VK_FORMAT_R16G16B16A16_SFLOAT",
+    "VK_FORMAT_R32_UINT",
+    "VK_FORMAT_R32_SINT",
+    "VK_FORMAT_R32_SFLOAT",
+    "VK_FORMAT_R32G32_UINT",
+    "VK_FORMAT_R32G32_SINT",
+    "VK_FORMAT_R32G32_SFLOAT",
+    "VK_FORMAT_R32G32B32_UINT",
+    "VK_FORMAT_R32G32B32_SINT",
+    "VK_FORMAT_R32G32B32_SFLOAT",
+    "VK_FORMAT_R32G32B32A32_UINT",
+    "VK_FORMAT_R32G32B32A32_SINT",
+    "VK_FORMAT_R32G32B32A32_SFLOAT",
+    "VK_FORMAT_R64_UINT",
+    "VK_FORMAT_R64_SINT",
+    "VK_FORMAT_R64_SFLOAT",
+    "VK_FORMAT_R64G64_UINT",
+    "VK_FORMAT_R64G64_SINT",
+    "VK_FORMAT_R64G64_SFLOAT",
+    "VK_FORMAT_R64G64B64_UINT",
+    "VK_FORMAT_R64G64B64_SINT",
+    "VK_FORMAT_R64G64B64_SFLOAT",
+    "VK_FORMAT_R64G64B64A64_UINT",
+    "VK_FORMAT_R64G64B64A64_SINT",
+    "VK_FORMAT_R64G64B64A64_SFLOAT",
+    "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+    "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32",
+    "VK_FORMAT_D16_UNORM",
+    "VK_FORMAT_X8_D24_UNORM_PACK32",
+    "VK_FORMAT_D32_SFLOAT",
+    "VK_FORMAT_S8_UINT",
+    "VK_FORMAT_D16_UNORM_S8_UINT",
+    "VK_FORMAT_D24_UNORM_S8_UINT",
+    "VK_FORMAT_D32_SFLOAT_S8_UINT",
+    "VK_FORMAT_BC1_RGB_UNORM_BLOCK",
+    "VK_FORMAT_BC1_RGB_SRGB_BLOCK",
+    "VK_FORMAT_BC1_RGBA_UNORM_BLOCK",
+    "VK_FORMAT_BC1_RGBA_SRGB_BLOCK",
+    "VK_FORMAT_BC2_UNORM_BLOCK",
+    "VK_FORMAT_BC2_SRGB_BLOCK",
+    "VK_FORMAT_BC3_UNORM_BLOCK",
+    "VK_FORMAT_BC3_SRGB_BLOCK",
+    "VK_FORMAT_BC4_UNORM_BLOCK",
+    "VK_FORMAT_BC4_SNORM_BLOCK",
+    "VK_FORMAT_BC5_UNORM_BLOCK",
+    "VK_FORMAT_BC5_SNORM_BLOCK",
+    "VK_FORMAT_BC6H_UFLOAT_BLOCK",
+    "VK_FORMAT_BC6H_SFLOAT_BLOCK",
+    "VK_FORMAT_BC7_UNORM_BLOCK",
+    "VK_FORMAT_BC7_SRGB_BLOCK",
+    "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK",
+    "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK",
+    "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK",
+    "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK",
+    "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK",
+    "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK",
+    "VK_FORMAT_EAC_R11_UNORM_BLOCK",
+    "VK_FORMAT_EAC_R11_SNORM_BLOCK",
+    "VK_FORMAT_EAC_R11G11_UNORM_BLOCK",
+    "VK_FORMAT_EAC_R11G11_SNORM_BLOCK",
+    "VK_FORMAT_ASTC_4x4_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_4x4_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_5x4_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_5x4_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_5x5_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_5x5_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_6x5_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_6x5_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_6x6_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_6x6_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_8x5_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_8x5_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_8x6_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_8x6_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_8x8_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_8x8_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_10x5_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_10x5_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_10x6_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_10x6_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_10x8_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_10x8_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_10x10_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_10x10_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_12x10_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_12x10_SRGB_BLOCK",
+    "VK_FORMAT_ASTC_12x12_UNORM_BLOCK",
+    "VK_FORMAT_ASTC_12x12_SRGB_BLOCK",
+    "VK_FORMAT_G8B8G8R8_422_UNORM",
+    "VK_FORMAT_B8G8R8G8_422_UNORM",
+    "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM",
+    "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM",
+    "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM",
+    "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM",
+    "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM",
+    "VK_FORMAT_R10X6_UNORM_PACK16",
+    "VK_FORMAT_R10X6G10X6_UNORM_2PACK16",
+    "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16",
+    "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16",
+    "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16",
+    "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16",
+    "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16",
+    "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16",
+    "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16",
+    "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16",
+    "VK_FORMAT_R12X4_UNORM_PACK16",
+    "VK_FORMAT_R12X4G12X4_UNORM_2PACK16",
+    "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16",
+    "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16",
+    "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16",
+    "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16",
+    "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16",
+    "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16",
+    "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16",
+    "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16",
+    "VK_FORMAT_G16B16G16R16_422_UNORM",
+    "VK_FORMAT_B16G16R16G16_422_UNORM",
+    "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM",
+    "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM",
+    "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM",
+    "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM",
+    "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM",
+    "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG",
+    "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG",
+    "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG",
+    "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG",
+    "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG",
+    "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG",
+    "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG",
+    "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG",
+};
+const uint32_t VK_FORMAT_VALUES[] = {
+    VK_FORMAT_UNDEFINED,
+    VK_FORMAT_R4G4_UNORM_PACK8,
+    VK_FORMAT_R4G4B4A4_UNORM_PACK16,
+    VK_FORMAT_B4G4R4A4_UNORM_PACK16,
+    VK_FORMAT_R5G6B5_UNORM_PACK16,
+    VK_FORMAT_B5G6R5_UNORM_PACK16,
+    VK_FORMAT_R5G5B5A1_UNORM_PACK16,
+    VK_FORMAT_B5G5R5A1_UNORM_PACK16,
+    VK_FORMAT_A1R5G5B5_UNORM_PACK16,
+    VK_FORMAT_R8_UNORM,
+    VK_FORMAT_R8_SNORM,
+    VK_FORMAT_R8_USCALED,
+    VK_FORMAT_R8_SSCALED,
+    VK_FORMAT_R8_UINT,
+    VK_FORMAT_R8_SINT,
+    VK_FORMAT_R8_SRGB,
+    VK_FORMAT_R8G8_UNORM,
+    VK_FORMAT_R8G8_SNORM,
+    VK_FORMAT_R8G8_USCALED,
+    VK_FORMAT_R8G8_SSCALED,
+    VK_FORMAT_R8G8_UINT,
+    VK_FORMAT_R8G8_SINT,
+    VK_FORMAT_R8G8_SRGB,
+    VK_FORMAT_R8G8B8_UNORM,
+    VK_FORMAT_R8G8B8_SNORM,
+    VK_FORMAT_R8G8B8_USCALED,
+    VK_FORMAT_R8G8B8_SSCALED,
+    VK_FORMAT_R8G8B8_UINT,
+    VK_FORMAT_R8G8B8_SINT,
+    VK_FORMAT_R8G8B8_SRGB,
+    VK_FORMAT_B8G8R8_UNORM,
+    VK_FORMAT_B8G8R8_SNORM,
+    VK_FORMAT_B8G8R8_USCALED,
+    VK_FORMAT_B8G8R8_SSCALED,
+    VK_FORMAT_B8G8R8_UINT,
+    VK_FORMAT_B8G8R8_SINT,
+    VK_FORMAT_B8G8R8_SRGB,
+    VK_FORMAT_R8G8B8A8_UNORM,
+    VK_FORMAT_R8G8B8A8_SNORM,
+    VK_FORMAT_R8G8B8A8_USCALED,
+    VK_FORMAT_R8G8B8A8_SSCALED,
+    VK_FORMAT_R8G8B8A8_UINT,
+    VK_FORMAT_R8G8B8A8_SINT,
+    VK_FORMAT_R8G8B8A8_SRGB,
+    VK_FORMAT_B8G8R8A8_UNORM,
+    VK_FORMAT_B8G8R8A8_SNORM,
+    VK_FORMAT_B8G8R8A8_USCALED,
+    VK_FORMAT_B8G8R8A8_SSCALED,
+    VK_FORMAT_B8G8R8A8_UINT,
+    VK_FORMAT_B8G8R8A8_SINT,
+    VK_FORMAT_B8G8R8A8_SRGB,
+    VK_FORMAT_A8B8G8R8_UNORM_PACK32,
+    VK_FORMAT_A8B8G8R8_SNORM_PACK32,
+    VK_FORMAT_A8B8G8R8_USCALED_PACK32,
+    VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
+    VK_FORMAT_A8B8G8R8_UINT_PACK32,
+    VK_FORMAT_A8B8G8R8_SINT_PACK32,
+    VK_FORMAT_A8B8G8R8_SRGB_PACK32,
+    VK_FORMAT_A2R10G10B10_UNORM_PACK32,
+    VK_FORMAT_A2R10G10B10_SNORM_PACK32,
+    VK_FORMAT_A2R10G10B10_USCALED_PACK32,
+    VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
+    VK_FORMAT_A2R10G10B10_UINT_PACK32,
+    VK_FORMAT_A2R10G10B10_SINT_PACK32,
+    VK_FORMAT_A2B10G10R10_UNORM_PACK32,
+    VK_FORMAT_A2B10G10R10_SNORM_PACK32,
+    VK_FORMAT_A2B10G10R10_USCALED_PACK32,
+    VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
+    VK_FORMAT_A2B10G10R10_UINT_PACK32,
+    VK_FORMAT_A2B10G10R10_SINT_PACK32,
+    VK_FORMAT_R16_UNORM,
+    VK_FORMAT_R16_SNORM,
+    VK_FORMAT_R16_USCALED,
+    VK_FORMAT_R16_SSCALED,
+    VK_FORMAT_R16_UINT,
+    VK_FORMAT_R16_SINT,
+    VK_FORMAT_R16_SFLOAT,
+    VK_FORMAT_R16G16_UNORM,
+    VK_FORMAT_R16G16_SNORM,
+    VK_FORMAT_R16G16_USCALED,
+    VK_FORMAT_R16G16_SSCALED,
+    VK_FORMAT_R16G16_UINT,
+    VK_FORMAT_R16G16_SINT,
+    VK_FORMAT_R16G16_SFLOAT,
+    VK_FORMAT_R16G16B16_UNORM,
+    VK_FORMAT_R16G16B16_SNORM,
+    VK_FORMAT_R16G16B16_USCALED,
+    VK_FORMAT_R16G16B16_SSCALED,
+    VK_FORMAT_R16G16B16_UINT,
+    VK_FORMAT_R16G16B16_SINT,
+    VK_FORMAT_R16G16B16_SFLOAT,
+    VK_FORMAT_R16G16B16A16_UNORM,
+    VK_FORMAT_R16G16B16A16_SNORM,
+    VK_FORMAT_R16G16B16A16_USCALED,
+    VK_FORMAT_R16G16B16A16_SSCALED,
+    VK_FORMAT_R16G16B16A16_UINT,
+    VK_FORMAT_R16G16B16A16_SINT,
+    VK_FORMAT_R16G16B16A16_SFLOAT,
+    VK_FORMAT_R32_UINT,
+    VK_FORMAT_R32_SINT,
+    VK_FORMAT_R32_SFLOAT,
+    VK_FORMAT_R32G32_UINT,
+    VK_FORMAT_R32G32_SINT,
+    VK_FORMAT_R32G32_SFLOAT,
+    VK_FORMAT_R32G32B32_UINT,
+    VK_FORMAT_R32G32B32_SINT,
+    VK_FORMAT_R32G32B32_SFLOAT,
+    VK_FORMAT_R32G32B32A32_UINT,
+    VK_FORMAT_R32G32B32A32_SINT,
+    VK_FORMAT_R32G32B32A32_SFLOAT,
+    VK_FORMAT_R64_UINT,
+    VK_FORMAT_R64_SINT,
+    VK_FORMAT_R64_SFLOAT,
+    VK_FORMAT_R64G64_UINT,
+    VK_FORMAT_R64G64_SINT,
+    VK_FORMAT_R64G64_SFLOAT,
+    VK_FORMAT_R64G64B64_UINT,
+    VK_FORMAT_R64G64B64_SINT,
+    VK_FORMAT_R64G64B64_SFLOAT,
+    VK_FORMAT_R64G64B64A64_UINT,
+    VK_FORMAT_R64G64B64A64_SINT,
+    VK_FORMAT_R64G64B64A64_SFLOAT,
+    VK_FORMAT_B10G11R11_UFLOAT_PACK32,
+    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
+    VK_FORMAT_D16_UNORM,
+    VK_FORMAT_X8_D24_UNORM_PACK32,
+    VK_FORMAT_D32_SFLOAT,
+    VK_FORMAT_S8_UINT,
+    VK_FORMAT_D16_UNORM_S8_UINT,
+    VK_FORMAT_D24_UNORM_S8_UINT,
+    VK_FORMAT_D32_SFLOAT_S8_UINT,
+    VK_FORMAT_BC1_RGB_UNORM_BLOCK,
+    VK_FORMAT_BC1_RGB_SRGB_BLOCK,
+    VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
+    VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
+    VK_FORMAT_BC2_UNORM_BLOCK,
+    VK_FORMAT_BC2_SRGB_BLOCK,
+    VK_FORMAT_BC3_UNORM_BLOCK,
+    VK_FORMAT_BC3_SRGB_BLOCK,
+    VK_FORMAT_BC4_UNORM_BLOCK,
+    VK_FORMAT_BC4_SNORM_BLOCK,
+    VK_FORMAT_BC5_UNORM_BLOCK,
+    VK_FORMAT_BC5_SNORM_BLOCK,
+    VK_FORMAT_BC6H_UFLOAT_BLOCK,
+    VK_FORMAT_BC6H_SFLOAT_BLOCK,
+    VK_FORMAT_BC7_UNORM_BLOCK,
+    VK_FORMAT_BC7_SRGB_BLOCK,
+    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
+    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
+    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
+    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
+    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
+    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
+    VK_FORMAT_EAC_R11_UNORM_BLOCK,
+    VK_FORMAT_EAC_R11_SNORM_BLOCK,
+    VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
+    VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
+    VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
+    VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
+    VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
+    VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
+    VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
+    VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
+    VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
+    VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
+    VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
+    VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
+    VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
+    VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
+    VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
+    VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
+    VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
+    VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
+    VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
+    VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
+    VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
+    VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
+    VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
+    VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
+    VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
+    VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
+    VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
+    VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
+    VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
+    VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
+    VK_FORMAT_G8B8G8R8_422_UNORM,
+    VK_FORMAT_B8G8R8G8_422_UNORM,
+    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
+    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
+    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
+    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
+    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
+    VK_FORMAT_R10X6_UNORM_PACK16,
+    VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
+    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
+    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
+    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
+    VK_FORMAT_R12X4_UNORM_PACK16,
+    VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
+    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
+    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
+    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
+    VK_FORMAT_G16B16G16R16_422_UNORM,
+    VK_FORMAT_B16G16R16G16_422_UNORM,
+    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
+    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
+    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
+    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
+    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
+    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG,
+    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG,
+    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG,
+    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG,
+    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG,
+    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
+    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
+    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
+};
+const size_t VK_FORMAT_COUNT = _countof(VK_FORMAT_NAMES);
+static_assert(
+    _countof(VK_FORMAT_NAMES) == _countof(VK_FORMAT_VALUES),
+    "VK_FORMAT_NAMES array doesn't match VK_FORMAT_VALUES.");
+
+const char* VK_SAMPLE_COUNT_NAMES[] = {
+    "VK_SAMPLE_COUNT_1_BIT",
+    "VK_SAMPLE_COUNT_2_BIT",
+    "VK_SAMPLE_COUNT_4_BIT",
+    "VK_SAMPLE_COUNT_8_BIT",
+    "VK_SAMPLE_COUNT_16_BIT",
+    "VK_SAMPLE_COUNT_32_BIT",
+    "VK_SAMPLE_COUNT_64_BIT",
+};
+const uint32_t VK_SAMPLE_COUNT_VALUES[] = {
+    VK_SAMPLE_COUNT_1_BIT,
+    VK_SAMPLE_COUNT_2_BIT,
+    VK_SAMPLE_COUNT_4_BIT,
+    VK_SAMPLE_COUNT_8_BIT,
+    VK_SAMPLE_COUNT_16_BIT,
+    VK_SAMPLE_COUNT_32_BIT,
+    VK_SAMPLE_COUNT_64_BIT,
+};
+const size_t VK_SAMPLE_COUNT_COUNT = _countof(VK_SAMPLE_COUNT_NAMES);
+static_assert(
+    _countof(VK_SAMPLE_COUNT_NAMES) == _countof(VK_SAMPLE_COUNT_VALUES),
+    "VK_SAMPLE_COUNT_NAMES array doesn't match VK_SAMPLE_COUNT_VALUES.");
+
+const char* VK_IMAGE_TILING_NAMES[] = {
+    "VK_IMAGE_TILING_OPTIMAL",
+    "VK_IMAGE_TILING_LINEAR",
+};
+const size_t VK_IMAGE_TILING_COUNT = _countof(VK_IMAGE_TILING_NAMES);
+
+const char* VK_IMAGE_USAGE_FLAG_NAMES[] = {
+    "VK_IMAGE_USAGE_TRANSFER_SRC_BIT",
+    "VK_IMAGE_USAGE_TRANSFER_DST_BIT",
+    "VK_IMAGE_USAGE_SAMPLED_BIT",
+    "VK_IMAGE_USAGE_STORAGE_BIT",
+    "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT",
+    "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT",
+    "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT",
+    "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT",
+    "VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV",
+};
+const uint32_t VK_IMAGE_USAGE_FLAG_VALUES[] = {
+    VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+    VK_IMAGE_USAGE_TRANSFER_DST_BIT,
+    VK_IMAGE_USAGE_SAMPLED_BIT,
+    VK_IMAGE_USAGE_STORAGE_BIT,
+    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
+    VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV,
+};
+const size_t VK_IMAGE_USAGE_FLAG_COUNT = _countof(VK_IMAGE_USAGE_FLAG_NAMES);
+static_assert(
+    _countof(VK_IMAGE_USAGE_FLAG_NAMES) == _countof(VK_IMAGE_USAGE_FLAG_VALUES),
+    "VK_IMAGE_USAGE_FLAG_NAMES array doesn't match VK_IMAGE_USAGE_FLAG_VALUES.");
+
+const char* VK_IMAGE_LAYOUT_NAMES[] = {
+    "VK_IMAGE_LAYOUT_UNDEFINED",
+    "VK_IMAGE_LAYOUT_GENERAL",
+    "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL",
+    "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL",
+    "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL",
+    "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL",
+    "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL",
+    "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL",
+    "VK_IMAGE_LAYOUT_PREINITIALIZED",
+    "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL",
+    "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL",
+    "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR",
+    "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR",
+    "VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV",
+};
+const uint32_t VK_IMAGE_LAYOUT_VALUES[] = {
+    VK_IMAGE_LAYOUT_UNDEFINED,
+    VK_IMAGE_LAYOUT_GENERAL,
+    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
+    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+    VK_IMAGE_LAYOUT_PREINITIALIZED,
+    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
+    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
+    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+    VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR,
+    VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV,
+};
+const size_t VK_IMAGE_LAYOUT_COUNT = _countof(VK_IMAGE_LAYOUT_NAMES);
+static_assert(
+    _countof(VK_IMAGE_LAYOUT_NAMES) == _countof(VK_IMAGE_LAYOUT_VALUES),
+    "VK_IMAGE_LAYOUT_NAMES array doesn't match VK_IMAGE_LAYOUT_VALUES.");
+
+const char* VMA_ALLOCATION_CREATE_FLAG_NAMES[] = {
+    "VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT",
+    "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT",
+    "VMA_ALLOCATION_CREATE_MAPPED_BIT",
+    "VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT",
+    "VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT",
+    "VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT",
+    "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT",
+    "VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT",
+    "VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT",
+    "VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT",
+};
+const uint32_t VMA_ALLOCATION_CREATE_FLAG_VALUES[] = {
+    VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
+    VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT,
+    VMA_ALLOCATION_CREATE_MAPPED_BIT,
+    VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT,
+    VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT,
+    VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT,
+    VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT,
+    VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT,
+    VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT,
+    VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
+};
+const size_t VMA_ALLOCATION_CREATE_FLAG_COUNT = _countof(VMA_ALLOCATION_CREATE_FLAG_NAMES);
+static_assert(
+    _countof(VMA_ALLOCATION_CREATE_FLAG_NAMES) == _countof(VMA_ALLOCATION_CREATE_FLAG_VALUES),
+    "VMA_ALLOCATION_CREATE_FLAG_NAMES array doesn't match VMA_ALLOCATION_CREATE_FLAG_VALUES.");
+
+const char* VMA_MEMORY_USAGE_NAMES[] = {
+    "VMA_MEMORY_USAGE_UNKNOWN",
+    "VMA_MEMORY_USAGE_GPU_ONLY",
+    "VMA_MEMORY_USAGE_CPU_ONLY",
+    "VMA_MEMORY_USAGE_CPU_TO_GPU",
+    "VMA_MEMORY_USAGE_GPU_TO_CPU",
+};
+const size_t VMA_MEMORY_USAGE_COUNT = _countof(VMA_MEMORY_USAGE_NAMES);
+
+const char* VK_MEMORY_PROPERTY_FLAG_NAMES[] = {
+    "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT",
+    "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT",
+    "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT",
+    "VK_MEMORY_PROPERTY_HOST_CACHED_BIT",
+    "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT",
+    "VK_MEMORY_PROPERTY_PROTECTED_BIT",
+};
+const uint32_t VK_MEMORY_PROPERTY_FLAG_VALUES[] = {
+    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+    VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
+    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT,
+    VK_MEMORY_PROPERTY_PROTECTED_BIT,
+};
+const size_t VK_MEMORY_PROPERTY_FLAG_COUNT = _countof(VK_MEMORY_PROPERTY_FLAG_NAMES);
+static_assert(
+    _countof(VK_MEMORY_PROPERTY_FLAG_NAMES) == _countof(VK_MEMORY_PROPERTY_FLAG_VALUES),
+    "VK_MEMORY_PROPERTY_FLAG_NAMES array doesn't match VK_MEMORY_PROPERTY_FLAG_VALUES.");
diff --git a/src/VmaReplay/Constants.h b/src/VmaReplay/Constants.h
new file mode 100644
index 0000000..2c58f68
--- /dev/null
+++ b/src/VmaReplay/Constants.h
@@ -0,0 +1,125 @@
+#pragma once
+
+extern const int RESULT_EXCEPTION;
+extern const int RESULT_ERROR_COMMAND_LINE;
+extern const int RESULT_ERROR_SOURCE_FILE;
+extern const int RESULT_ERROR_FORMAT;
+extern const int RESULT_ERROR_VULKAN;
+
+enum CMD_LINE_OPT
+{
+    CMD_LINE_OPT_VERBOSITY,
+    CMD_LINE_OPT_ITERATIONS,
+    CMD_LINE_OPT_LINES,
+    CMD_LINE_OPT_PHYSICAL_DEVICE,
+    CMD_LINE_OPT_USER_DATA,
+    CMD_LINE_OPT_VK_KHR_DEDICATED_ALLOCATION,
+    CMD_LINE_OPT_VK_LAYER_LUNARG_STANDARD_VALIDATION,
+    CMD_LINE_OPT_MEM_STATS,
+    CMD_LINE_OPT_DUMP_STATS_AFTER_LINE,
+    CMD_LINE_OPT_DEFRAGMENT_AFTER_LINE,
+    CMD_LINE_OPT_DEFRAGMENTATION_FLAGS,
+    CMD_LINE_OPT_DUMP_DETAILED_STATS_AFTER_LINE,
+};
+
+enum class VERBOSITY
+{
+    MINIMUM = 0,
+    DEFAULT,
+    MAXIMUM,
+    COUNT,
+};
+
+enum class VULKAN_EXTENSION_REQUEST
+{
+    DISABLED,
+    ENABLED,
+    DEFAULT
+};
+
+enum class OBJECT_TYPE { BUFFER, IMAGE };
+
+enum class VMA_FUNCTION
+{
+    CreatePool,
+    DestroyPool,
+    SetAllocationUserData,
+    CreateBuffer,
+    DestroyBuffer,
+    CreateImage,
+    DestroyImage,
+    FreeMemory,
+    FreeMemoryPages,
+    CreateLostAllocation,
+    AllocateMemory,
+    AllocateMemoryPages,
+    AllocateMemoryForBuffer,
+    AllocateMemoryForImage,
+    MapMemory,
+    UnmapMemory,
+    FlushAllocation,
+    InvalidateAllocation,
+    TouchAllocation,
+    GetAllocationInfo,
+    MakePoolAllocationsLost,
+    ResizeAllocation,
+    DefragmentationBegin,
+    DefragmentationEnd,
+    Count
+};
+extern const char* VMA_FUNCTION_NAMES[];
+
+extern const char* VMA_POOL_CREATE_FLAG_NAMES[];
+extern const uint32_t VMA_POOL_CREATE_FLAG_VALUES[];
+extern const size_t VMA_POOL_CREATE_FLAG_COUNT;
+
+extern const char* VK_BUFFER_CREATE_FLAG_NAMES[];
+extern const uint32_t VK_BUFFER_CREATE_FLAG_VALUES[];
+extern const size_t VK_BUFFER_CREATE_FLAG_COUNT;
+
+extern const char* VK_BUFFER_USAGE_FLAG_NAMES[];
+extern const uint32_t VK_BUFFER_USAGE_FLAG_VALUES[];
+extern const size_t VK_BUFFER_USAGE_FLAG_COUNT;
+
+extern const char* VK_SHARING_MODE_NAMES[];
+extern const size_t VK_SHARING_MODE_COUNT;
+
+extern const char* VK_IMAGE_CREATE_FLAG_NAMES[];
+extern const uint32_t VK_IMAGE_CREATE_FLAG_VALUES[];
+extern const size_t VK_IMAGE_CREATE_FLAG_COUNT;
+
+extern const char* VK_IMAGE_TYPE_NAMES[];
+extern const size_t VK_IMAGE_TYPE_COUNT;
+
+extern const char* VK_FORMAT_NAMES[];
+extern const uint32_t VK_FORMAT_VALUES[];
+extern const size_t VK_FORMAT_COUNT;
+
+extern const char* VK_SAMPLE_COUNT_NAMES[];
+extern const uint32_t VK_SAMPLE_COUNT_VALUES[];
+extern const size_t VK_SAMPLE_COUNT_COUNT;
+
+extern const char* VK_IMAGE_TILING_NAMES[];
+extern const size_t VK_IMAGE_TILING_COUNT;
+
+extern const char* VK_IMAGE_USAGE_FLAG_NAMES[];
+extern const uint32_t VK_IMAGE_USAGE_FLAG_VALUES[];
+extern const size_t VK_IMAGE_USAGE_FLAG_COUNT;
+
+extern const char* VK_IMAGE_TILING_NAMES[];
+extern const size_t VK_IMAGE_TILING_COUNT;
+
+extern const char* VK_IMAGE_LAYOUT_NAMES[];
+extern const uint32_t VK_IMAGE_LAYOUT_VALUES[];
+extern const size_t VK_IMAGE_LAYOUT_COUNT;
+
+extern const char* VMA_ALLOCATION_CREATE_FLAG_NAMES[];
+extern const uint32_t VMA_ALLOCATION_CREATE_FLAG_VALUES[];
+extern const size_t VMA_ALLOCATION_CREATE_FLAG_COUNT;
+
+extern const char* VMA_MEMORY_USAGE_NAMES[];
+extern const size_t VMA_MEMORY_USAGE_COUNT;
+
+extern const char* VK_MEMORY_PROPERTY_FLAG_NAMES[];
+extern const uint32_t VK_MEMORY_PROPERTY_FLAG_VALUES[];
+extern const size_t VK_MEMORY_PROPERTY_FLAG_COUNT;
diff --git a/src/VmaReplay/VmaReplay.cpp b/src/VmaReplay/VmaReplay.cpp
index f830176..4228009 100644
--- a/src/VmaReplay/VmaReplay.cpp
+++ b/src/VmaReplay/VmaReplay.cpp
@@ -22,104 +22,634 @@
 
 #include "VmaUsage.h"
 #include "Common.h"
+#include "Constants.h"
 #include <unordered_map>
+#include <map>
+#include <algorithm>
 
-static const int RESULT_EXCEPTION          = -1000;
-static const int RESULT_ERROR_COMMAND_LINE = -1;
-static const int RESULT_ERROR_SOURCE_FILE  = -2;
-static const int RESULT_ERROR_FORMAT       = -3;
-static const int RESULT_ERROR_VULKAN       = -4;
+static VERBOSITY g_Verbosity = VERBOSITY::DEFAULT;
 
-enum CMD_LINE_OPT
+namespace DetailedStats
 {
-    CMD_LINE_OPT_VERBOSITY,
-    CMD_LINE_OPT_ITERATIONS,
-    CMD_LINE_OPT_LINES,
-    CMD_LINE_OPT_PHYSICAL_DEVICE,
-    CMD_LINE_OPT_USER_DATA,
-    CMD_LINE_OPT_VK_KHR_DEDICATED_ALLOCATION,
-    CMD_LINE_OPT_VK_LAYER_LUNARG_STANDARD_VALIDATION,
-    CMD_LINE_OPT_MEM_STATS,
-    CMD_LINE_OPT_DUMP_STATS_AFTER_LINE,
-    CMD_LINE_OPT_DEFRAGMENT_AFTER_LINE,
-    CMD_LINE_OPT_DEFRAGMENTATION_FLAGS,
-    CMD_LINE_OPT_DUMP_DETAILED_STATS_AFTER_LINE,
+    
+struct Flag
+{
+    uint32_t setCount = 0;
+
+    void PostValue(bool v)
+    {
+        if(v)
+        {
+            ++setCount;
+        }
+    }
+
+    void Print(uint32_t totalCount) const
+    {
+        if(setCount)
+        {
+            printf(" %u (%.2f%%)\n", setCount, (double)setCount * 100.0 / (double)totalCount);
+        }
+        else
+        {
+            printf(" 0\n");
+        }
+    }
 };
 
-static enum class VERBOSITY
+struct Enum
 {
-    MINIMUM = 0,
-    DEFAULT,
-    MAXIMUM,
-    COUNT,
-} g_Verbosity = VERBOSITY::DEFAULT;
+    Enum(size_t itemCount, const char* const* itemNames, const uint32_t* itemValues = nullptr) :
+        m_ItemCount(itemCount),
+        m_ItemNames(itemNames),
+        m_ItemValues(itemValues)
+    {
+    }
 
-enum class VULKAN_EXTENSION_REQUEST
-{
-    DISABLED,
-    ENABLED,
-    DEFAULT
+    void PostValue(uint32_t v)
+    {
+        if(v < _countof(m_BaseCount))
+        {
+            ++m_BaseCount[v];
+        }
+        else
+        {
+            auto it = m_ExtendedCount.find(v);
+            if(it != m_ExtendedCount.end())
+            {
+                ++it->second;
+            }
+            else
+            {
+                m_ExtendedCount.insert(std::make_pair(v, 1u));
+            }
+        }
+    }
+
+    void Print(uint32_t totalCount) const
+    {
+        if(totalCount &&
+            (!m_ExtendedCount.empty() || std::count_if(m_BaseCount, m_BaseCount + _countof(m_BaseCount), [](uint32_t v) { return v > 0; })))
+        {
+            printf("\n");
+            
+            for(size_t i = 0; i < _countof(m_BaseCount); ++i)
+            {
+                const uint32_t currCount = m_BaseCount[i];
+                if(currCount)
+                {
+                    PrintItem((uint32_t)i, currCount, totalCount);
+                }
+            }
+
+            for(const auto& it : m_ExtendedCount)
+            {
+                PrintItem(it.first, it.second, totalCount);
+            }
+        }
+        else
+        {
+            printf(" 0\n");
+        }
+    }
+
+private:
+    const size_t m_ItemCount;
+    const char* const* const m_ItemNames;
+    const uint32_t* const m_ItemValues;
+
+    uint32_t m_BaseCount[32] = {};
+    std::map<uint32_t, uint32_t> m_ExtendedCount;
+
+    void PrintItem(uint32_t value, uint32_t count, uint32_t totalCount) const
+    {
+        size_t itemIndex = m_ItemCount;
+        if(m_ItemValues)
+        {
+            for(itemIndex = 0; itemIndex < m_ItemCount; ++itemIndex)
+            {
+                if(m_ItemValues[itemIndex] == value)
+                {
+                    break;
+                }
+            }
+        }
+        else
+        {
+            if(value < m_ItemCount)
+            {
+                itemIndex = value;
+            }
+        }
+
+        if(itemIndex < m_ItemCount)
+        {
+            printf("        %s: ", m_ItemNames[itemIndex]);
+        }
+        else
+        {
+            printf("        0x%X: ", value);
+        }
+
+        printf("%u (%.2f%%)\n", count, (double)count * 100.0 / (double)totalCount);
+    }
 };
 
-enum class OBJECT_TYPE { BUFFER, IMAGE };
-
-enum class VMA_FUNCTION
+struct FlagSet
 {
-    CreatePool,
-    DestroyPool,
-    SetAllocationUserData,
-    CreateBuffer,
-    DestroyBuffer,
-    CreateImage,
-    DestroyImage,
-    FreeMemory,
-    FreeMemoryPages,
-    CreateLostAllocation,
-    AllocateMemory,
-    AllocateMemoryPages,
-    AllocateMemoryForBuffer,
-    AllocateMemoryForImage,
-    MapMemory,
-    UnmapMemory,
-    FlushAllocation,
-    InvalidateAllocation,
-    TouchAllocation,
-    GetAllocationInfo,
-    MakePoolAllocationsLost,
-    ResizeAllocation,
-    DefragmentationBegin,
-    DefragmentationEnd,
-    Count
+    uint32_t count[32] = {};
+
+    FlagSet(size_t count, const char* const* names, const uint32_t* values = nullptr) :
+        m_Count(count),
+        m_Names(names),
+        m_Values(values)
+    {
+    }
+
+    void PostValue(uint32_t v)
+    {
+        for(size_t i = 0; i < 32; ++i)
+        {
+            if((v & (1u << i)) != 0)
+            {
+                ++count[i];
+            }
+        }
+    }
+
+    void Print(uint32_t totalCount) const
+    {
+        if(totalCount &&
+            std::count_if(count, count + _countof(count), [](uint32_t v) { return v > 0; }))
+        {
+            printf("\n");
+            for(uint32_t bitIndex = 0; bitIndex < 32; ++bitIndex)
+            {
+                const uint32_t currCount = count[bitIndex];
+                if(currCount)
+                {
+                    size_t itemIndex = m_Count;
+                    if(m_Values)
+                    {
+                        for(itemIndex = 0; itemIndex < m_Count; ++itemIndex)
+                        {
+                            if(m_Values[itemIndex] == (1u << bitIndex))
+                            {
+                                break;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        if(bitIndex < m_Count)
+                        {
+                            itemIndex = bitIndex;
+                        }
+                    }
+
+                    if(itemIndex < m_Count)
+                    {
+                        printf("        %s: ", m_Names[itemIndex]);
+                    }
+                    else
+                    {
+                        printf("        0x%X: ", 1u << bitIndex);
+                    }
+
+                    printf("%u (%.2f%%)\n", currCount, (double)currCount * 100.0 / (double)totalCount);
+                }
+            }
+        }
+        else
+        {
+            printf(" 0\n");
+        }
+    }
+
+private:
+    const size_t m_Count;
+    const char* const* const m_Names;
+    const uint32_t* const m_Values;
 };
-static const char* VMA_FUNCTION_NAMES[] = {
-    "vmaCreatePool",
-    "vmaDestroyPool",
-    "vmaSetAllocationUserData",
-    "vmaCreateBuffer",
-    "vmaDestroyBuffer",
-    "vmaCreateImage",
-    "vmaDestroyImage",
-    "vmaFreeMemory",
-    "vmaFreeMemoryPages",
-    "vmaCreateLostAllocation",
-    "vmaAllocateMemory",
-    "vmaAllocateMemoryPages",
-    "vmaAllocateMemoryForBuffer",
-    "vmaAllocateMemoryForImage",
-    "vmaMapMemory",
-    "vmaUnmapMemory",
-    "vmaFlushAllocation",
-    "vmaInvalidateAllocation",
-    "vmaTouchAllocation",
-    "vmaGetAllocationInfo",
-    "vmaMakePoolAllocationsLost",
-    "vmaResizeAllocation",
-    "vmaDefragmentationBegin",
-    "vmaDefragmentationEnd",
+
+// T should be unsigned int
+template<typename T>
+struct MinMaxAvg
+{
+    T min = std::numeric_limits<T>::max();
+    T max = 0;
+    T sum = T();
+
+    void PostValue(T v)
+    {
+        this->min = std::min(this->min, v);
+        this->max = std::max(this->max, v);
+        sum += v;
+    }
+
+    void Print(uint32_t totalCount) const
+    {
+        if(totalCount && sum > T())
+        {
+            if(this->min == this->max)
+            {
+                printf(" %llu\n", (uint64_t)this->max);
+            }
+            else
+            {
+                printf("\n        Min: %llu\n        Max: %llu\n        Avg: %llu\n",
+                    (uint64_t)this->min,
+                    (uint64_t)this->max,
+                    round_div<uint64_t>(this->sum, totalCount));
+            }
+        }
+        else
+        {
+            printf(" 0\n");
+        }
+    }
 };
-static_assert(
-    _countof(VMA_FUNCTION_NAMES) == (size_t)VMA_FUNCTION::Count,
-    "VMA_FUNCTION_NAMES array doesn't match VMA_FUNCTION enum.");
+
+template<typename T>
+struct BitMask
+{
+    uint32_t zeroCount = 0;
+    uint32_t maxCount = 0;
+
+    void PostValue(T v)
+    {
+        if(v)
+        {
+            if(v == std::numeric_limits<T>::max())
+            {
+                ++maxCount;
+            }
+        }
+        else
+        {
+            ++zeroCount;
+        }
+    }
+
+    void Print(uint32_t totalCount) const
+    {
+        if(totalCount > 0 && zeroCount < totalCount)
+        {
+            const uint32_t otherCount = totalCount - (zeroCount + maxCount);
+            
+            printf("\n        0: %u (%.2f%%)\n        Max: %u (%.2f%%)\n        Other: %u (%.2f%%)\n",
+                zeroCount,  (double)zeroCount  * 100.0 / (double)totalCount,
+                maxCount,   (double)maxCount   * 100.0 / (double)totalCount,
+                otherCount, (double)otherCount * 100.0 / (double)totalCount);
+        }
+        else
+        {
+            printf(" 0\n");
+        }
+    }
+};
+
+struct CountPerMemType
+{
+    uint32_t count[VK_MAX_MEMORY_TYPES] = {};
+
+    void PostValue(uint32_t v)
+    {
+        for(uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
+        {
+            if((v & (1u << i)) != 0)
+            {
+                ++count[i];
+            }
+        }
+    }
+
+    void Print(uint32_t totalCount) const
+    {
+        if(totalCount)
+        {
+            printf("\n");
+            for(uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
+            {
+                if(count[i])
+                {
+                    printf("        %u: %u (%.2f%%)\n", i, count[i],
+                        (double)count[i] * 100.0 / (double)totalCount);
+                }
+            }
+        }
+        else
+        {
+            printf(" 0\n");
+        }
+    }
+};
+
+struct StructureStats
+{
+    uint32_t totalCount = 0;
+};
+
+#define PRINT_FIELD(name) \
+    printf("    " #name ":"); \
+    (name).Print(totalCount);
+#define PRINT_FIELD_NAMED(name, nameStr) \
+    printf("    " nameStr ":"); \
+    (name).Print(totalCount);
+
+struct VmaPoolCreateInfoStats : public StructureStats
+{
+    CountPerMemType memoryTypeIndex;
+    FlagSet flags;
+    MinMaxAvg<VkDeviceSize> blockSize;
+    MinMaxAvg<size_t> minBlockCount;
+    MinMaxAvg<size_t> maxBlockCount;
+    Flag minMaxBlockCountEqual;
+    MinMaxAvg<uint32_t> frameInUseCount;
+
+    VmaPoolCreateInfoStats() :
+        flags(VMA_POOL_CREATE_FLAG_COUNT, VMA_POOL_CREATE_FLAG_NAMES, VMA_POOL_CREATE_FLAG_VALUES)
+    {
+    }
+
+    void PostValue(const VmaPoolCreateInfo& v)
+    {
+        ++totalCount;
+
+        memoryTypeIndex.PostValue(v.memoryTypeIndex);
+        flags.PostValue(v.flags);
+        blockSize.PostValue(v.blockSize);
+        minBlockCount.PostValue(v.minBlockCount);
+        maxBlockCount.PostValue(v.maxBlockCount);
+        minMaxBlockCountEqual.PostValue(v.minBlockCount == v.maxBlockCount);
+        frameInUseCount.PostValue(v.frameInUseCount);
+    }
+
+    void Print() const
+    {
+        if(totalCount == 0)
+        {
+            return;
+        }
+
+        printf("VmaPoolCreateInfo (%u):\n", totalCount);
+
+        PRINT_FIELD(memoryTypeIndex);
+        PRINT_FIELD(flags);
+        PRINT_FIELD(blockSize);
+        PRINT_FIELD(minBlockCount);
+        PRINT_FIELD(maxBlockCount);
+        PRINT_FIELD_NAMED(minMaxBlockCountEqual, "minBlockCount == maxBlockCount");
+        PRINT_FIELD(frameInUseCount);
+    }
+};
+
+struct VkBufferCreateInfoStats : public StructureStats
+{
+    FlagSet flags;
+    MinMaxAvg<VkDeviceSize> size;
+    FlagSet usage;
+    Enum sharingMode;
+
+    VkBufferCreateInfoStats() :
+        flags(VK_BUFFER_CREATE_FLAG_COUNT, VK_BUFFER_CREATE_FLAG_NAMES, VK_BUFFER_CREATE_FLAG_VALUES),
+        usage(VK_BUFFER_USAGE_FLAG_COUNT, VK_BUFFER_USAGE_FLAG_NAMES, VK_BUFFER_USAGE_FLAG_VALUES),
+        sharingMode(VK_SHARING_MODE_COUNT, VK_SHARING_MODE_NAMES)
+    {
+    }
+
+    void PostValue(const VkBufferCreateInfo& v)
+    {
+        ++totalCount;
+
+        flags.PostValue(v.flags);
+        size.PostValue(v.size);
+        usage.PostValue(v.usage);
+        sharingMode.PostValue(v.sharingMode);
+    }
+
+    void Print() const
+    {
+        if(totalCount == 0)
+        {
+            return;
+        }
+
+        printf("VkBufferCreateInfo (%u):\n", totalCount);
+
+        PRINT_FIELD(flags);
+        PRINT_FIELD(size);
+        PRINT_FIELD(usage);
+        PRINT_FIELD(sharingMode);
+    }
+};
+
+struct VkImageCreateInfoStats : public StructureStats
+{
+    FlagSet flags;
+    Enum imageType;
+    Enum format;
+    MinMaxAvg<uint32_t> width, height, depth, mipLevels, arrayLayers;
+    Flag depthGreaterThanOne, mipLevelsGreaterThanOne, arrayLayersGreaterThanOne;
+    Enum samples;
+    Enum tiling;
+    FlagSet usage;
+    Enum sharingMode;
+    Enum initialLayout;
+
+    VkImageCreateInfoStats() :
+        flags(VK_IMAGE_CREATE_FLAG_COUNT, VK_IMAGE_CREATE_FLAG_NAMES, VK_IMAGE_CREATE_FLAG_VALUES),
+        imageType(VK_IMAGE_TYPE_COUNT, VK_IMAGE_TYPE_NAMES),
+        format(VK_FORMAT_COUNT, VK_FORMAT_NAMES, VK_FORMAT_VALUES),
+        samples(VK_SAMPLE_COUNT_COUNT, VK_SAMPLE_COUNT_NAMES, VK_SAMPLE_COUNT_VALUES),
+        tiling(VK_IMAGE_TILING_COUNT, VK_IMAGE_TILING_NAMES),
+        usage(VK_IMAGE_USAGE_FLAG_COUNT, VK_IMAGE_USAGE_FLAG_NAMES, VK_IMAGE_USAGE_FLAG_VALUES),
+        sharingMode(VK_SHARING_MODE_COUNT, VK_SHARING_MODE_NAMES),
+        initialLayout(VK_IMAGE_LAYOUT_COUNT, VK_IMAGE_LAYOUT_NAMES, VK_IMAGE_LAYOUT_VALUES)
+    {
+    }
+
+    void PostValue(const VkImageCreateInfo& v)
+    {
+        ++totalCount;
+
+        flags.PostValue(v.flags);
+        imageType.PostValue(v.imageType);
+        format.PostValue(v.format);
+        width.PostValue(v.extent.width);
+        height.PostValue(v.extent.height);
+        depth.PostValue(v.extent.depth);
+        mipLevels.PostValue(v.mipLevels);
+        arrayLayers.PostValue(v.arrayLayers);
+        depthGreaterThanOne.PostValue(v.extent.depth > 1);
+        mipLevelsGreaterThanOne.PostValue(v.mipLevels > 1);
+        arrayLayersGreaterThanOne.PostValue(v.arrayLayers > 1);
+        samples.PostValue(v.samples);
+        tiling.PostValue(v.tiling);
+        usage.PostValue(v.usage);
+        sharingMode.PostValue(v.sharingMode);
+        initialLayout.PostValue(v.initialLayout);
+    }
+
+    void Print() const
+    {
+        if(totalCount == 0)
+        {
+            return;
+        }
+
+        printf("VkImageCreateInfo (%u):\n", totalCount);
+
+        PRINT_FIELD(flags);
+        PRINT_FIELD(imageType);
+        PRINT_FIELD(format);
+        PRINT_FIELD(width);
+        PRINT_FIELD(height);
+        PRINT_FIELD(depth);
+        PRINT_FIELD(mipLevels);
+        PRINT_FIELD(arrayLayers);
+        PRINT_FIELD_NAMED(depthGreaterThanOne, "depth > 1");
+        PRINT_FIELD_NAMED(mipLevelsGreaterThanOne, "mipLevels > 1");
+        PRINT_FIELD_NAMED(arrayLayersGreaterThanOne, "arrayLayers > 1");
+        PRINT_FIELD(samples);
+        PRINT_FIELD(tiling);
+        PRINT_FIELD(usage);
+        PRINT_FIELD(sharingMode);
+        PRINT_FIELD(initialLayout);
+    }
+};
+
+struct VmaAllocationCreateInfoStats : public StructureStats
+{
+    FlagSet flags;
+    Enum usage;
+    FlagSet requiredFlags, preferredFlags;
+    Flag requiredFlagsNotZero, preferredFlagsNotZero;
+    BitMask<uint32_t> memoryTypeBits;
+    Flag poolNotNull;
+    Flag userDataNotNull;
+
+    VmaAllocationCreateInfoStats() :
+        flags(VMA_ALLOCATION_CREATE_FLAG_COUNT, VMA_ALLOCATION_CREATE_FLAG_NAMES, VMA_ALLOCATION_CREATE_FLAG_VALUES),
+        usage(VMA_MEMORY_USAGE_COUNT, VMA_MEMORY_USAGE_NAMES),
+        requiredFlags(VK_MEMORY_PROPERTY_FLAG_COUNT, VK_MEMORY_PROPERTY_FLAG_NAMES, VK_MEMORY_PROPERTY_FLAG_VALUES),
+        preferredFlags(VK_MEMORY_PROPERTY_FLAG_COUNT, VK_MEMORY_PROPERTY_FLAG_NAMES, VK_MEMORY_PROPERTY_FLAG_VALUES)
+    {
+    }
+
+    void PostValue(const VmaAllocationCreateInfo& v, size_t count = 1)
+    {
+        totalCount += (uint32_t)count;
+
+        for(size_t i = 0; i < count; ++i)
+        {
+            flags.PostValue(v.flags);
+            usage.PostValue(v.usage);
+            requiredFlags.PostValue(v.requiredFlags);
+            preferredFlags.PostValue(v.preferredFlags);
+            requiredFlagsNotZero.PostValue(v.requiredFlags != 0);
+            preferredFlagsNotZero.PostValue(v.preferredFlags != 0);
+            memoryTypeBits.PostValue(v.memoryTypeBits);
+            poolNotNull.PostValue(v.pool != VK_NULL_HANDLE);
+            userDataNotNull.PostValue(v.pUserData != nullptr);
+        }
+    }
+
+    void Print() const
+    {
+        if(totalCount == 0)
+        {
+            return;
+        }
+
+        printf("VmaAllocationCreateInfo (%u):\n", totalCount);
+
+        PRINT_FIELD(flags);
+        PRINT_FIELD(usage);
+        PRINT_FIELD(requiredFlags);
+        PRINT_FIELD(preferredFlags);
+        PRINT_FIELD_NAMED(requiredFlagsNotZero, "requiredFlags != 0");
+        PRINT_FIELD_NAMED(preferredFlagsNotZero, "preferredFlags != 0");
+        PRINT_FIELD(memoryTypeBits);
+        PRINT_FIELD_NAMED(poolNotNull, "pool != VK_NULL_HANDLE");
+        PRINT_FIELD_NAMED(userDataNotNull, "pUserData != nullptr");
+    }
+};
+
+struct VmaAllocateMemoryPagesStats : public StructureStats
+{
+    MinMaxAvg<size_t> allocationCount;
+
+    void PostValue(size_t allocationCount)
+    {
+        this->allocationCount.PostValue(allocationCount);
+    }
+
+    void Print() const
+    {
+        if(totalCount == 0)
+        {
+            return;
+        }
+
+        printf("vmaAllocateMemoryPages (%u):\n", totalCount);
+
+        PRINT_FIELD(allocationCount);
+    }
+};
+
+struct VmaDefragmentationInfo2Stats : public StructureStats
+{
+    BitMask<VkDeviceSize> maxCpuBytesToMove;
+    BitMask<uint32_t> maxCpuAllocationsToMove;
+    BitMask<VkDeviceSize> maxGpuBytesToMove;
+    BitMask<uint32_t> maxGpuAllocationsToMove;
+    Flag commandBufferNotNull;
+    MinMaxAvg<uint32_t> allocationCount;
+    Flag allocationCountNotZero;
+    MinMaxAvg<uint32_t> poolCount;
+    Flag poolCountNotZero;
+
+    void PostValue(const VmaDefragmentationInfo2& info)
+    {
+        ++totalCount;
+
+        maxCpuBytesToMove.PostValue(info.maxCpuBytesToMove);
+        maxCpuAllocationsToMove.PostValue(info.maxCpuAllocationsToMove);
+        maxGpuBytesToMove.PostValue(info.maxGpuBytesToMove);
+        maxGpuAllocationsToMove.PostValue(info.maxGpuAllocationsToMove);
+        commandBufferNotNull.PostValue(info.commandBuffer != VK_NULL_HANDLE);
+        allocationCount.PostValue(info.allocationCount);
+        allocationCountNotZero.PostValue(info.allocationCount != 0);
+        poolCount.PostValue(info.poolCount);
+        poolCountNotZero.PostValue(info.poolCount != 0);
+    }
+
+    void Print() const
+    {
+        if(totalCount == 0)
+        {
+            return;
+        }
+
+        printf("VmaDefragmentationInfo2 (%u):\n", totalCount);
+
+        PRINT_FIELD(maxCpuBytesToMove);
+        PRINT_FIELD(maxCpuAllocationsToMove);
+        PRINT_FIELD(maxGpuBytesToMove);
+        PRINT_FIELD(maxGpuAllocationsToMove);
+        PRINT_FIELD_NAMED(commandBufferNotNull, "commandBuffer != VK_NULL_HANDLE");
+        PRINT_FIELD(allocationCount);
+        PRINT_FIELD_NAMED(allocationCountNotZero, "allocationCount > 0");
+        PRINT_FIELD(poolCount);
+        PRINT_FIELD_NAMED(poolCountNotZero, "poolCount > 0");
+    }
+};
+
+#undef PRINT_FIELD_NAMED
+#undef PRINT_FIELD
+
+} // namespace DetailedStats
 
 // Set this to false to disable deleting leaked VmaAllocation, VmaPool objects
 // and let VMA report asserts about them.
@@ -196,19 +726,24 @@
     Statistics();
     void Init(uint32_t memHeapCount, uint32_t memTypeCount);
     void PrintMemStats() const;
+    void PrintDetailedStats() const;
 
     const size_t* GetFunctionCallCount() const { return m_FunctionCallCount; }
     size_t GetImageCreationCount(uint32_t imgClass) const { return m_ImageCreationCount[imgClass]; }
     size_t GetLinearImageCreationCount() const { return m_LinearImageCreationCount; }
     size_t GetBufferCreationCount(uint32_t bufClass) const { return m_BufferCreationCount[bufClass]; }
-    size_t GetAllocationCreationCount() const { return m_AllocationCreationCount; }
-    size_t GetPoolCreationCount() const { return m_PoolCreationCount; }
+    size_t GetAllocationCreationCount() const { return (size_t)m_VmaAllocationCreateInfo.totalCount + m_CreateLostAllocationCount; }
+    size_t GetPoolCreationCount() const { return m_VmaPoolCreateInfo.totalCount; }
+    size_t GetBufferCreationCount() const { return (size_t)m_VkBufferCreateInfo.totalCount; }
 
     void RegisterFunctionCall(VMA_FUNCTION func);
-    void RegisterCreateImage(uint32_t usage, uint32_t tiling);
-    void RegisterCreateBuffer(uint32_t usage);
-    void RegisterCreatePool();
-    void RegisterCreateAllocation(size_t allocCount = 1);
+    void RegisterCreateImage(const VkImageCreateInfo& info);
+    void RegisterCreateBuffer(const VkBufferCreateInfo& info);
+    void RegisterCreatePool(const VmaPoolCreateInfo& info);
+    void RegisterCreateAllocation(const VmaAllocationCreateInfo& info, size_t allocCount = 1);
+    void RegisterCreateLostAllocation() { ++m_CreateLostAllocationCount; }
+    void RegisterAllocateMemoryPages(size_t allocCount) { m_VmaAllocateMemoryPages.PostValue(allocCount); }
+    void RegisterDefragmentation(const VmaDefragmentationInfo2& info);
 
     void UpdateMemStats(const VmaStats& currStats);
 
@@ -220,8 +755,6 @@
     size_t m_ImageCreationCount[4] = { };
     size_t m_LinearImageCreationCount = 0;
     size_t m_BufferCreationCount[4] = { };
-    size_t m_AllocationCreationCount = 0; // Also includes buffers and images, and lost allocations.
-    size_t m_PoolCreationCount = 0;
     
     // Structure similar to VmaStatInfo, but not the same.
     struct MemStatInfo
@@ -240,6 +773,14 @@
         MemStatInfo total;
     } m_PeakMemStats;
 
+    DetailedStats::VmaPoolCreateInfoStats m_VmaPoolCreateInfo;
+    DetailedStats::VkBufferCreateInfoStats m_VkBufferCreateInfo;
+    DetailedStats::VkImageCreateInfoStats m_VkImageCreateInfo;
+    DetailedStats::VmaAllocationCreateInfoStats m_VmaAllocationCreateInfo;
+    size_t m_CreateLostAllocationCount = 0;
+    DetailedStats::VmaAllocateMemoryPagesStats m_VmaAllocateMemoryPages;
+    DetailedStats::VmaDefragmentationInfo2Stats m_VmaDefragmentationInfo2;
+
     void UpdateMemStatInfo(MemStatInfo& inoutPeakInfo, const VmaStatInfo& currInfo);
     static void PrintMemStatInfo(const MemStatInfo& info);
 };
@@ -346,40 +887,55 @@
     }
 }
 
+void Statistics::PrintDetailedStats() const
+{
+    m_VmaPoolCreateInfo.Print();
+    m_VmaAllocationCreateInfo.Print();
+    m_VmaAllocateMemoryPages.Print();
+    m_VkBufferCreateInfo.Print();
+    m_VkImageCreateInfo.Print();
+    m_VmaDefragmentationInfo2.Print();
+}
+
 void Statistics::RegisterFunctionCall(VMA_FUNCTION func)
 {
     ++m_FunctionCallCount[(size_t)func];
 }
 
-void Statistics::RegisterCreateImage(uint32_t usage, uint32_t tiling)
+void Statistics::RegisterCreateImage(const VkImageCreateInfo& info)
 {
-    if(tiling == VK_IMAGE_TILING_LINEAR)
+    if(info.tiling == VK_IMAGE_TILING_LINEAR)
         ++m_LinearImageCreationCount;
     else
     {
-        const uint32_t imgClass = ImageUsageToClass(usage);
+        const uint32_t imgClass = ImageUsageToClass(info.usage);
         ++m_ImageCreationCount[imgClass];
     }
 
-    ++m_AllocationCreationCount;
+    m_VkImageCreateInfo.PostValue(info);
 }
 
-void Statistics::RegisterCreateBuffer(uint32_t usage)
+void Statistics::RegisterCreateBuffer(const VkBufferCreateInfo& info)
 {
-    const uint32_t bufClass = BufferUsageToClass(usage);
+    const uint32_t bufClass = BufferUsageToClass(info.usage);
     ++m_BufferCreationCount[bufClass];
 
-    ++m_AllocationCreationCount;
+    m_VkBufferCreateInfo.PostValue(info);
 }
 
-void Statistics::RegisterCreatePool()
+void Statistics::RegisterCreatePool(const VmaPoolCreateInfo& info)
 {
-    ++m_PoolCreationCount;
+    m_VmaPoolCreateInfo.PostValue(info);
 }
 
-void Statistics::RegisterCreateAllocation(size_t allocCount)
+void Statistics::RegisterCreateAllocation(const VmaAllocationCreateInfo& info, size_t allocCount)
 {
-    m_AllocationCreationCount += allocCount;
+    m_VmaAllocationCreateInfo.PostValue(info, allocCount);
+}
+
+void Statistics::RegisterDefragmentation(const VmaDefragmentationInfo2& info)
+{
+    m_VmaDefragmentationInfo2.PostValue(info);
 }
 
 void Statistics::UpdateMemStats(const VmaStats& currStats)
@@ -1885,14 +2441,9 @@
     }
 
     // Buffers
-    const size_t bufferCreationCount =
-        m_Stats.GetBufferCreationCount(0) +
-        m_Stats.GetBufferCreationCount(1) +
-        m_Stats.GetBufferCreationCount(2) +
-        m_Stats.GetBufferCreationCount(3);
-    if(bufferCreationCount > 0)
+    if(m_Stats.GetBufferCreationCount())
     {
-        printf("    Total buffers created: %zu\n", bufferCreationCount);
+        printf("    Total buffers created: %zu\n", m_Stats.GetBufferCreationCount());
         if(g_Verbosity == VERBOSITY::MAXIMUM)
         {
             printf("        Class 0 (indirect/vertex/index): %zu\n", m_Stats.GetBufferCreationCount(0));
@@ -1972,6 +2523,12 @@
         }
     }
 
+    // Detailed stats
+    if(g_Verbosity == VERBOSITY::MAXIMUM)
+    {
+        m_Stats.PrintDetailedStats();
+    }
+
     if(g_MemStatsEnabled)
     {
         m_Stats.PrintMemStats();
@@ -2063,7 +2620,7 @@
             StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 5), poolCreateInfo.frameInUseCount) &&
             StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX + 6), origPtr))
         {
-            m_Stats.RegisterCreatePool();
+            m_Stats.RegisterCreatePool(poolCreateInfo);
 
             Pool poolDesc = {};
             VkResult res = vmaCreatePool(m_Allocator, &poolCreateInfo, &poolDesc.pool);
@@ -2242,9 +2799,6 @@
         {
             FindPool(lineNumber, origPool, allocCreateInfo.pool);
 
-            // Forcing VK_SHARING_MODE_EXCLUSIVE because we use only one queue anyway.
-            bufCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-
             if(csvSplit.GetCount() > FIRST_PARAM_INDEX + 11)
             {
                 PrepareUserData(
@@ -2255,7 +2809,11 @@
                     allocCreateInfo.pUserData);
             }
 
-            m_Stats.RegisterCreateBuffer(bufCreateInfo.usage);
+            m_Stats.RegisterCreateBuffer(bufCreateInfo);
+            m_Stats.RegisterCreateAllocation(allocCreateInfo);
+
+            // Forcing VK_SHARING_MODE_EXCLUSIVE because we use only one queue anyway.
+            bufCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
             Allocation allocDesc = { };
             allocDesc.allocationFlags = allocCreateInfo.flags;
@@ -2379,9 +2937,6 @@
         {
             FindPool(lineNumber, origPool, allocCreateInfo.pool);
 
-            // Forcing VK_SHARING_MODE_EXCLUSIVE because we use only one queue anyway.
-            imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-
             if(csvSplit.GetCount() > FIRST_PARAM_INDEX + 20)
             {
                 PrepareUserData(
@@ -2392,7 +2947,11 @@
                     allocCreateInfo.pUserData);
             }
 
-            m_Stats.RegisterCreateImage(imageCreateInfo.usage, imageCreateInfo.tiling);
+            m_Stats.RegisterCreateImage(imageCreateInfo);
+            m_Stats.RegisterCreateAllocation(allocCreateInfo);
+
+            // Forcing VK_SHARING_MODE_EXCLUSIVE because we use only one queue anyway.
+            imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
             Allocation allocDesc = {};
             allocDesc.allocationFlags = allocCreateInfo.flags;
@@ -2470,7 +3029,7 @@
             Allocation allocDesc = {};
             vmaCreateLostAllocation(m_Allocator, &allocDesc.allocation);
             UpdateMemStats();
-            m_Stats.RegisterCreateAllocation();
+            m_Stats.RegisterCreateLostAllocation();
 
             AddAllocation(lineNumber, origPtr, VK_SUCCESS, "vmaCreateLostAllocation", std::move(allocDesc));
         }
@@ -2519,7 +3078,7 @@
             }
 
             UpdateMemStats();
-            m_Stats.RegisterCreateAllocation();
+            m_Stats.RegisterCreateAllocation(allocCreateInfo);
 
             Allocation allocDesc = {};
             allocDesc.allocationFlags = allocCreateInfo.flags;
@@ -2574,7 +3133,8 @@
                 }
 
                 UpdateMemStats();
-                m_Stats.RegisterCreateAllocation(allocCount);
+                m_Stats.RegisterCreateAllocation(allocCreateInfo, allocCount);
+                m_Stats.RegisterAllocateMemoryPages(allocCount);
 
                 std::vector<VmaAllocation> allocations(allocCount);
 
@@ -2645,6 +3205,9 @@
                     allocCreateInfo.pUserData);
             }
 
+            UpdateMemStats();
+            m_Stats.RegisterCreateAllocation(allocCreateInfo);
+
             if(requiresDedicatedAllocation || prefersDedicatedAllocation)
             {
                 allocCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
@@ -2659,9 +3222,6 @@
                 m_AllocateForBufferImageWarningIssued = true;
             }
 
-            UpdateMemStats();
-            m_Stats.RegisterCreateAllocation();
-
             Allocation allocDesc = {};
             allocDesc.allocationFlags = allocCreateInfo.flags;
             VkResult res = vmaAllocateMemory(m_Allocator, &memReq, &allocCreateInfo, &allocDesc.allocation, nullptr);
@@ -3118,6 +3678,8 @@
                 }
             }
 
+            m_Stats.RegisterDefragmentation(defragInfo);
+
             VmaDefragmentationContext defragCtx = nullptr;
             VkResult res = vmaDefragmentationBegin(m_Allocator, &defragInfo, nullptr, &defragCtx);
 
@@ -3251,7 +3813,6 @@
         "    --DefragmentAfterLine <Line> - Defragment memory after specified source file line and print statistics.\n"
         "        It also prints detailed statistics to files VmaReplay_Line####_Defragment*.json\n"
         "    --DefragmentationFlags <Flags> - Flags to be applied when using DefragmentAfterLine.\n"
-        "        E.g. 1 for FAST algorithm, 2 for OPTIMAL algorithm.\n"
         "    --Lines <Ranges> - Replay only limited set of lines from file\n"
         "        Ranges is comma-separated list of ranges, e.g. \"-10,15,18-25,31-\".\n"
         "    --PhysicalDevice <Index> - Choice of Vulkan physical device. Default: 0.\n"