From 0b71584853af8d48b5683195c3e9023369c4d527 Mon Sep 17 00:00:00 2001
From: Oleh Kuznetsov <okuznetsov@google.com>
Date: Wed, 28 Jan 2026 16:07:52 +0000
Subject: [PATCH 1/9] Prototype frame looping

---
 framework/application/application.cpp         |   8 +
 framework/application/application.h           |   2 +
 framework/decode/file_processor.cpp           |  74 ++-
 framework/decode/file_processor.h             |  11 +-
 .../decode/vulkan_replay_consumer_base.cpp    | 543 +++++++++++++++++-
 .../decode/vulkan_replay_consumer_base.h      |  28 +
 framework/decode/vulkan_replay_options.h      |   3 +-
 framework/util/file_input_stream.cpp          |  13 +
 framework/util/file_input_stream.h            |   1 +
 tools/replay/android_main.cpp                 |   5 +
 tools/replay/replay_settings.h                |  53 +-
 tools/tool_settings.h                         |   5 +
 12 files changed, 725 insertions(+), 21 deletions(-)

diff --git a/framework/application/application.cpp b/framework/application/application.cpp
index 3e5da8bf12..03b496f38a 100644
--- a/framework/application/application.cpp
+++ b/framework/application/application.cpp
@@ -198,6 +198,14 @@ void Application::SetPaused(bool paused)
     paused_ = paused;
 }
 
+void Application::SetRepeatFrameNTimes(uint32_t repeat_frame_n_times)
+{
+    if (file_processor_)
+    {
+        file_processor_->SetRepeatFrameNTimes(repeat_frame_n_times);
+    }
+}
+
 bool Application::PlaySingleFrame()
 {
     bool success = false;
diff --git a/framework/application/application.h b/framework/application/application.h
index 58776480c6..a0a9b43a52 100644
--- a/framework/application/application.h
+++ b/framework/application/application.h
@@ -73,6 +73,8 @@ class Application final
 
     void SetPauseFrame(uint32_t pause_frame) { pause_frame_ = pause_frame; }
 
+    void SetRepeatFrameNTimes(uint32_t repeat_frame_n_times);
+
     bool PlaySingleFrame();
 
     void ProcessEvents(bool wait_for_input);
diff --git a/framework/decode/file_processor.cpp b/framework/decode/file_processor.cpp
index d309d3c5d5..8826825406 100644
--- a/framework/decode/file_processor.cpp
+++ b/framework/decode/file_processor.cpp
@@ -28,6 +28,13 @@
 #include "util/logging.h"
 
 #include <string>
+#include <limits>
+#if defined(__ANDROID__)
+#include <android/trace.h>
+#else
+#define ATrace_beginSection(name)
+#define ATrace_endSection()
+#endif
 
 GFXRECON_BEGIN_NAMESPACE(gfxrecon)
 GFXRECON_BEGIN_NAMESPACE(decode)
@@ -111,12 +118,58 @@ bool FileProcessor::ProcessNextFrame()
 
 bool FileProcessor::ProcessBlocksOneFrame()
 {
-    for (ApiDecoder* decoder : decoders_)
+    ATrace_beginSection("ProcessBlocksOneFrame");
+    block_parser_->SetDecompressionPolicy(BlockParser::DecompressionPolicy::kAlways);
+    if (current_frame_number_ == kFirstFrame) {
+        // Process initial resources state
+        ATrace_beginSection("InitState");
+        if (!ProcessBlocks())
+        {
+            return false;
+        }
+        ATrace_endSection();
+    }
+
+    int64_t start_offset = 0;
+    bool    do_repeat    = (repeat_frame_n_times_ > 0) && (!file_stack_.empty());
+
+    if (do_repeat)
     {
-        decoder->SetCurrentFrameNumber(current_frame_number_);
+        start_offset = GetCurrentFile().active_file->Tell();
     }
-    block_parser_->SetDecompressionPolicy(BlockParser::DecompressionPolicy::kAlways);
-    return ProcessBlocks();
+
+    uint32_t start_frame = current_frame_number_;
+
+    // Handle limited command counts (e.g. from trim ranges or secondary files)
+    uint32_t remaining_commands_before       = 0;
+
+    remaining_commands_before = GetCurrentFile().remaining_commands;
+
+    for (uint32_t i = 0; i <= repeat_frame_n_times_; ++i)
+    {
+        // Ensure we replay with the same frame number
+        current_frame_number_ = start_frame;
+       
+        for (ApiDecoder* decoder : decoders_)
+        {
+            decoder->SetCurrentFrameNumber(current_frame_number_);
+        }
+        
+        GetCurrentFile().remaining_commands = (i < repeat_frame_n_times_) ? remaining_commands_before + 1 : remaining_commands_before;
+
+        if (!ProcessBlocks())
+        {
+            return false;
+        }
+
+        if (i < repeat_frame_n_times_)
+        {
+            SeekActiveFile(start_offset, util::platform::FileSeekSet);
+        }
+    }
+
+    ATrace_endSection();
+    return true;
 }
 
 bool FileProcessor::DoProcessNextFrame(const std::function<bool()>& block_processor)
@@ -274,6 +327,7 @@ void FileProcessor::DecrementRemainingCommands()
 
 bool FileProcessor::ProcessBlocks()
 {
+    ATrace_beginSection("ProcessBlocks");
     BlockBuffer block_buffer;
     bool        success = true;
 
@@ -330,12 +384,19 @@ bool FileProcessor::ProcessBlocks()
                     }
 
                     // NOTE: Warnings for unknown/invalid blocks are handled in the BlockParser
-
+                    if (process_visitor.IsStateDelimiter())
+                    {
+                        ++block_index_;
+                        DecrementRemainingCommands();
+                        break;
+                    }
                     if (process_visitor.IsFrameDelimiter())
                     {
                         // The ProcessVisitor (pre-dispatch) is not the right place to update the frame state, so do it
                         // here
                         UpdateEndFrameState();
+                        ++block_index_;
+                        DecrementRemainingCommands();
                         break;
                     }
                 }
@@ -348,8 +409,8 @@ bool FileProcessor::ProcessBlocks()
         ++block_index_;
         DecrementRemainingCommands();
     }
+    ATrace_endSection();
 
-    DecrementRemainingCommands();
     return success;
 }
 
@@ -525,7 +586,6 @@ void FileProcessor::UpdateEndFrameState()
 
     // Make sure to increment the frame number on the way out.
     ++current_frame_number_;
-    ++block_index_;
 }
 
 bool FileProcessor::ProcessFrameDelimiter(gfxrecon::format::ApiCallId call_id)
diff --git a/framework/decode/file_processor.h b/framework/decode/file_processor.h
index 4329ff10e7..89073d6306 100644
--- a/framework/decode/file_processor.h
+++ b/framework/decode/file_processor.h
@@ -161,6 +161,8 @@ class FileProcessor
         block_index_to_          = block_index_to;
     }
 
+    void SetRepeatFrameNTimes(uint32_t repeat_frame_n_times) { repeat_frame_n_times_ = repeat_frame_n_times; }
+
     bool IsFrameDelimiter(format::BlockType block_type, format::MarkerType marker_type) const;
     bool IsFrameDelimiter(format::ApiCallId call_id) const;
 
@@ -320,7 +322,6 @@ class FileProcessor
         void operator()(const ExecuteBlocksFromFileArgs& execute_blocks)
         {
             // The block and marker type are implied by the Args type
-            is_frame_delimiter = false;
             success            = file_processor_.ProcessExecuteBlocksFromFile(execute_blocks);
         }
 
@@ -328,7 +329,6 @@ class FileProcessor
         void operator()(const StateBeginMarkerArgs& state_begin)
         {
             // The block and marker type are implied by the Args type
-            is_frame_delimiter = false;
             success            = true;
             file_processor_.ProcessStateBeginMarker(state_begin);
         }
@@ -336,7 +336,7 @@ class FileProcessor
         void operator()(const StateEndMarkerArgs& state_end)
         {
             // The block and marker type are implied by the Args type
-            is_frame_delimiter = false;
+            is_state_delimiter = true;
             success            = true;
             file_processor_.ProcessStateEndMarker(state_end);
         }
@@ -344,7 +344,6 @@ class FileProcessor
         void operator()(const AnnotationArgs& annotation)
         {
             // The block and marker type are implied by the Command type
-            is_frame_delimiter = false;
             success            = true;
             file_processor_.ProcessAnnotation(annotation);
         }
@@ -353,7 +352,6 @@ class FileProcessor
         void operator()(const Args&)
         {
             // The default behavior for a Visit is a successful, non-frame-delimiter
-            is_frame_delimiter = false;
             success            = true;
         }
 
@@ -366,10 +364,12 @@ class FileProcessor
 
         bool IsSuccess() const { return success; }
         bool IsFrameDelimiter() const { return is_frame_delimiter; }
+        bool IsStateDelimiter() const { return is_state_delimiter; }
         ProcessVisitor(FileProcessor& file_processor) : file_processor_(file_processor) {}
 
       private:
         bool           is_frame_delimiter = false;
+        bool           is_state_delimiter = false;
         bool           success            = true;
         FileProcessor& file_processor_;
     };
@@ -420,6 +420,7 @@ class FileProcessor
     int64_t                             block_index_from_{ 0 };
     int64_t                             block_index_to_{ 0 };
     bool                                loading_trimmed_capture_state_;
+    uint32_t                            repeat_frame_n_times_{ 0 };
 
     std::string        absolute_path_;
     format::FileHeader file_header_;
diff --git a/framework/decode/vulkan_replay_consumer_base.cpp b/framework/decode/vulkan_replay_consumer_base.cpp
index 59b637e75b..369debfe87 100644
--- a/framework/decode/vulkan_replay_consumer_base.cpp
+++ b/framework/decode/vulkan_replay_consumer_base.cpp
@@ -53,6 +53,8 @@
 #include "util/platform.h"
 #include "util/logging.h"
 #include "util/callbacks.h"
+#include "decode/mark_injected_commands.h"
+#include "graphics/vulkan_resources_util.h"
 
 #include "spirv_reflect.h"
 
@@ -62,15 +64,42 @@
 #include "Vulkan-Utility-Libraries/vk_format_utils.h"
 
 #include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
 #include <limits>
 #include <numeric>
 #include <unordered_set>
 #include <future>
 #include <span>
+#include <iterator>
+#include <unistd.h>
+
+#if defined(__ANDROID__)
+#include <android/trace.h>
+#else
+#define ATrace_beginSection(name)
+#define ATrace_endSection()
+#endif
 
 GFXRECON_BEGIN_NAMESPACE(gfxrecon)
 GFXRECON_BEGIN_NAMESPACE(decode)
 
+bool frame_first_queue_submit = false;
+
+static uint32_t FindMemoryType(const VkPhysicalDeviceMemoryProperties& memory_properties,
+                               uint32_t                                type_bits,
+                               VkMemoryPropertyFlags                   properties)
+{
+    uint32_t              index = std::numeric_limits<uint32_t>::max();
+    VkMemoryPropertyFlags dummy_flags;
+    if (graphics::FindMemoryTypeIndex(memory_properties, type_bits, properties, &index, &dummy_flags))
+    {
+        return index;
+    }
+    return std::numeric_limits<uint32_t>::max();
+}
+
 const size_t kMaxEventStatusRetries = 16;
 
 const char kUnknownDeviceLabel[]  = "<Unknown>";
@@ -375,6 +404,7 @@ void VulkanReplayConsumerBase::ProcessStateEndMarker(uint64_t frame_number)
     {
         fps_info_->ProcessStateEndMarker(frame_number);
     }
+    frame_first_queue_submit = true;
 
     if (options_.dumping_resources)
     {
@@ -4102,6 +4132,31 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
 
     assert((queue_info != nullptr) && (pSubmits != nullptr));
 
+    if (frame_first_queue_submit) {
+        frame_first_queue_submit = false;
+        static bool first_time = true;
+        if (first_time && wait_before_first_frame_min_ms_ > 0) {
+            ATrace_beginSection("FirstTimeWait");
+            usleep(wait_before_first_frame_min_ms_ * 1000);
+            ATrace_endSection();
+            first_time = false;
+        }
+        if (sleep_around_gpu_frame_ms_ > 0.0) {
+            // WaitDevicesIdle(); // Need to implement or check availability
+            usleep(static_cast<useconds_t>(sleep_around_gpu_frame_ms_ * 1000));
+        }
+
+        if (frame_warm_up_gpu_load_ > 0) {
+            // Add device warm up using dispatch
+            WarmUpDevice(queue_info, frame_warm_up_gpu_load_);        
+        }
+        ATrace_beginSection("GFXRFrame");
+        if (sleep_around_gpu_frame_ms_ > 0.0)
+        {
+            usleep(static_cast<useconds_t>(sleep_around_gpu_frame_ms_ * 1000));
+        }
+    }
+
     VkResult            result       = VK_SUCCESS;
     const VkSubmitInfo* submit_infos = pSubmits->GetPointer();
     assert(submitCount == 0 || submit_infos != nullptr);
@@ -4123,6 +4178,63 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
     GFXRECON_ASSERT(allocator != nullptr);
     allocator->ClearStagingResources();
 
+    auto queue_submit = [&](const VkSubmitInfo* submit_infos_arg, uint32_t submitCount_arg) {
+        VkDevice         device       = device_info->handle;
+        WarmUpResources& resources    = warmup_resources_[device];
+        if(resources.next_semaphore_index < resources.semaphores.size()) {           
+            std::vector<VkSubmitInfo> modified_submit_infos(submit_infos_arg, std::next(submit_infos_arg, submitCount_arg));
+            std::vector<std::vector<VkSemaphore>> new_wait_semaphore_lists(submitCount_arg);
+            std::vector<std::vector<VkPipelineStageFlags>> new_wait_stage_mask_lists(submitCount_arg);
+
+            for (uint32_t i = 0; i < submitCount_arg; ++i)
+            {
+                const VkSubmitInfo& original_submit = submit_infos_arg[i];
+                std::vector<VkSemaphore>& new_list = new_wait_semaphore_lists[i];
+                new_list.reserve(original_submit.waitSemaphoreCount + 1);
+                if (original_submit.waitSemaphoreCount > 0 && original_submit.pWaitSemaphores) {
+                    new_list.assign(original_submit.pWaitSemaphores, 
+                                    original_submit.pWaitSemaphores + original_submit.waitSemaphoreCount);
+                }
+
+                std::vector<VkPipelineStageFlags>& new_stage_list = new_wait_stage_mask_lists[i];
+                new_stage_list.reserve(original_submit.waitSemaphoreCount + 1);
+                if (original_submit.waitSemaphoreCount > 0 && original_submit.pWaitDstStageMask)
+                {
+                    new_stage_list.assign(original_submit.pWaitDstStageMask,
+                                          original_submit.pWaitDstStageMask + original_submit.waitSemaphoreCount);
+                }
+                else {
+                    // Safe default if mask is missing but we're adding a semaphore
+                    VkPipelineStageFlags default_flags = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+                    new_stage_list.assign(new_list.size() + 1, default_flags); 
+                    // Actually we need to match the size.
+                    // If original was 0, we have 1 now.
+                    // If we assigned from original, we have N.
+                    // But we push_back later.
+                    // Let's just rely on the push_back below for the NEW semaphore.
+                    // But if original_submit.pWaitDstStageMask was NULL, we need to fill the previous ones?
+                    // Spec says pWaitDstStageMask must be valid if waitSemaphoreCount > 0.
+                    // So if waitSemaphoreCount was 0, pWaitDstStageMask might be NULL.
+                    // In that case new_stage_list is empty.
+                }
+                
+                if(resources.next_semaphore_index < resources.semaphores.size()) {           
+                    VkSemaphore warm_up_semaphore = resources.semaphores[resources.next_semaphore_index++];
+                    new_list.push_back(warm_up_semaphore);
+                    new_stage_list.push_back(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);                    
+                }
+
+                VkSubmitInfo& modified_submit = modified_submit_infos[i];
+                modified_submit.waitSemaphoreCount = static_cast<uint32_t>(new_list.size());
+                modified_submit.pWaitSemaphores = new_list.data();
+                modified_submit.pWaitDstStageMask = new_stage_list.data();
+            }
+
+            return func(queue_info->handle, submitCount_arg, modified_submit_infos.data(), fence);        
+        } 
+        return func(queue_info->handle, submitCount_arg, submit_infos_arg, fence);
+    };
+
     if (UseAddressReplacement(device_info) && submit_info_data != nullptr)
     {
         const auto& address_tracker  = GetDeviceAddressTracker(device_info);
@@ -4194,7 +4306,7 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
     // tracked.
     if ((!have_imported_semaphores_) && (options_.surface_index == -1) && (!options_.dumping_resources))
     {
-        result = func(queue_info->handle, submitCount, submit_infos, fence);
+        result = queue_submit(submit_infos, submitCount);
     }
     else
     {
@@ -4227,7 +4339,7 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
 
         if (altered_submits.empty() && !options_.dumping_resources)
         {
-            result = func(queue_info->handle, submitCount, submit_infos, fence);
+            result = queue_submit(submit_infos, submitCount);
         }
         else
         {
@@ -4289,10 +4401,7 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
             }
             else
             {
-                result = func(queue_info->handle,
-                              static_cast<uint32_t>(modified_submit_infos.size()),
-                              modified_submit_infos.data(),
-                              fence);
+                result = queue_submit(modified_submit_infos.data(), static_cast<uint32_t>(modified_submit_infos.size()));
             }
         }
     }
@@ -8292,6 +8401,19 @@ VulkanReplayConsumerBase::OverrideQueuePresentKHR(PFN_vkQueuePresentKHR
                                                   const VulkanQueueInfo*                                queue_info,
                                                   const StructPointerDecoder<Decoded_VkPresentInfoKHR>* pPresentInfo)
 {
+    if (!frame_first_queue_submit) {
+        frame_first_queue_submit = true;
+        if (sleep_around_gpu_frame_ms_ > 0.0) {
+             auto device_info = object_info_table_->GetVkDeviceInfo(queue_info->parent_id);
+             if (device_info) {
+                 auto device_table = GetDeviceTable(device_info->handle);
+                 device_table->DeviceWaitIdle(device_info->handle);
+             }
+            usleep(static_cast<useconds_t>(sleep_around_gpu_frame_ms_ * 1000));
+        }
+        ATrace_endSection();
+    }
+
     assert((queue_info != nullptr) && (pPresentInfo != nullptr) && !pPresentInfo->IsNull());
 
     VkResult   result             = VK_SUCCESS;
@@ -10105,6 +10227,8 @@ void VulkanReplayConsumerBase::OverrideCmdBeginRenderPass(
 
     VkCommandBuffer command_buffer = command_buffer_info->handle;
 
+    InsertRenderPassBarrier(command_buffer, command_buffer_info);
+
     func(command_buffer, render_pass_begin_info_decoder->GetPointer(), contents);
 }
 
@@ -10144,9 +10268,40 @@ void VulkanReplayConsumerBase::OverrideCmdBeginRenderPass2(
 
     VkCommandBuffer command_buffer = command_buffer_info->handle;
 
+    InsertRenderPassBarrier(command_buffer, command_buffer_info);
+
     func(command_buffer, render_pass_begin_info_decoder->GetPointer(), subpass_begin_info_decode->GetPointer());
 }
 
+void VulkanReplayConsumerBase::InsertRenderPassBarrier(VkCommandBuffer                command_buffer,
+                                                       const VulkanCommandBufferInfo* command_buffer_info)
+{
+    if (options_.render_pass_barrier)
+    {
+        auto* device_info = GetObjectInfoTable().GetVkDeviceInfo(command_buffer_info->parent_id);
+        GFXRECON_ASSERT(device_info != nullptr);
+
+        VkMemoryBarrier memory_barrier = {
+            VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+            nullptr,
+            VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
+            VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
+        };
+
+        GetDeviceTable(command_buffer)
+            ->CmdPipelineBarrier(command_buffer,
+                                 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                                 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                                 0,
+                                 1,
+                                 &memory_barrier,
+                                 0,
+                                 nullptr,
+                                 0,
+                                 nullptr);
+    }
+}
+
 void VulkanReplayConsumerBase::OverrideCmdTraceRaysKHR(
     PFN_vkCmdTraceRaysKHR                                          func,
     VulkanCommandBufferInfo*                                       command_buffer_info,
@@ -12925,5 +13080,381 @@ void VulkanReplayConsumerBase::OverrideGetDeviceMemoryOpaqueCaptureAddress(
     allocator->GetDeviceMemoryOpaqueCaptureAddress(info, allocator_data);
 }
 
+void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, uint32_t warm_up_load)
+{
+    VulkanDeviceInfo* device_info = object_info_table_->GetVkDeviceInfo(queue_info->parent_id);
+    if (device_info == nullptr)
+    {
+        return;
+    }
+
+    ATrace_beginSection("WarmUpDevice");
+    VkDevice         device       = device_info->handle;
+    auto             device_table = GetDeviceTable(device);
+    WarmUpResources& resources    = warmup_resources_[device];
+
+    VkResult result = VK_SUCCESS;
+
+    if (resources.command_pool == VK_NULL_HANDLE)
+    {
+        VkCommandPoolCreateInfo cmd_pool_info = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
+        cmd_pool_info.queueFamilyIndex        = queue_info->family_index;
+        cmd_pool_info.flags                   = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
+        result = device_table->CreateCommandPool(device, &cmd_pool_info, nullptr, &resources.command_pool);
+        GFXRECON_LOG_WARNING("CreateCommandPool %s.", util::ToString<VkResult>(result).c_str());
+    }
+
+    if (result == VK_SUCCESS && resources.shader_module == VK_NULL_HANDLE)
+    {
+        // Minimal SPIR-V compute shader:
+        // #version 450
+
+        // // Define the size of the workgroup.
+        // // This means 64 invocations of this shader will run in parallel as a single group.
+        // layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
+
+        // // Define a storage buffer that the application will provide.
+        // // It's an array of floating-point numbers that we can both read from and write to.
+        // // 'binding = 0' means it will be bound to the first descriptor slot (index 0).
+        // layout(std430, binding = 0) buffer DataBuffer {
+        //     float data[];
+        // };
+
+        // void main() {
+        //     // Get the unique global ID for this specific shader invocation.
+        //     // This gives us a unique index into our data buffer.
+        //     uint index = gl_GlobalInvocationID.x;
+
+        //     // Read the initial value from the buffer.
+        //     float value = data[index];
+
+        //     // --- DUMMY WORK ---
+        //     // Perform a series of arbitrary calculations in a loop to keep the GPU busy.
+        //     // This is designed to be work that the compiler can't easily optimize away.
+        //     for (int i = 0; i < 1000; i++) {
+        //         value = sin(value) * 0.999 + cos(float(i)) * 0.001;
+        //     }
+
+        //     // Write the final, modified value back into the same position in the buffer.
+        //     data[index] = value;
+        // }        
+        unsigned char spirv[] = {
+        0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x0d, 0x00,
+        0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+        0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00,
+        0x47, 0x4c, 0x53, 0x4c, 0x2e, 0x73, 0x74, 0x64, 0x2e, 0x34, 0x35, 0x30,
+        0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x06, 0x00, 0x05, 0x00, 0x00, 0x00,
+        0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00,
+        0x0b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x06, 0x00, 0x04, 0x00, 0x00, 0x00,
+        0x11, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+        0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x00,
+        0xc2, 0x01, 0x00, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x47, 0x4c, 0x5f, 0x47,
+        0x4f, 0x4f, 0x47, 0x4c, 0x45, 0x5f, 0x63, 0x70, 0x70, 0x5f, 0x73, 0x74,
+        0x79, 0x6c, 0x65, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x64, 0x69, 0x72,
+        0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00,
+        0x47, 0x4c, 0x5f, 0x47, 0x4f, 0x4f, 0x47, 0x4c, 0x45, 0x5f, 0x69, 0x6e,
+        0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74,
+        0x69, 0x76, 0x65, 0x00, 0x05, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00,
+        0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00,
+        0x08, 0x00, 0x00, 0x00, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x00, 0x00, 0x00,
+        0x05, 0x00, 0x08, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x67, 0x6c, 0x5f, 0x47,
+        0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x63, 0x61, 0x74,
+        0x69, 0x6f, 0x6e, 0x49, 0x44, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00,
+        0x12, 0x00, 0x00, 0x00, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x00, 0x00, 0x00,
+        0x05, 0x00, 0x05, 0x00, 0x14, 0x00, 0x00, 0x00, 0x44, 0x61, 0x74, 0x61,
+        0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x00, 0x00, 0x06, 0x00, 0x05, 0x00,
+        0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x61, 0x74, 0x61,
+        0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00, 0x16, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00, 0x1e, 0x00, 0x00, 0x00,
+        0x69, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00,
+        0x0b, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+        0x13, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+        0x47, 0x00, 0x03, 0x00, 0x14, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+        0x48, 0x00, 0x05, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+        0x16, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x47, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x3a, 0x00, 0x00, 0x00,
+        0x0b, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00,
+        0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
+        0x02, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+        0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+        0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+        0x17, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+        0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00,
+        0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+        0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+        0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0d, 0x00, 0x00, 0x00,
+        0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
+        0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+        0x11, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+        0x1d, 0x00, 0x03, 0x00, 0x13, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+        0x1e, 0x00, 0x03, 0x00, 0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+        0x20, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+        0x14, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00,
+        0x16, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
+        0x17, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+        0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00,
+        0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+        0x1d, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+        0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+        0xe8, 0x03, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00, 0x26, 0x00, 0x00, 0x00,
+        0x2b, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00,
+        0x77, 0xbe, 0x7f, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
+        0x2f, 0x00, 0x00, 0x00, 0x6f, 0x12, 0x83, 0x3a, 0x2b, 0x00, 0x04, 0x00,
+        0x17, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+        0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
+        0x40, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+        0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00,
+        0x09, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
+        0x39, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00,
+        0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x03, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
+        0x3b, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+        0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00,
+        0x12, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+        0x1d, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+        0x41, 0x00, 0x05, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+        0x0b, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+        0x06, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+        0x3e, 0x00, 0x03, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+        0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+        0x08, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x1a, 0x00, 0x00, 0x00,
+        0x1b, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+        0x19, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
+        0x1c, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
+        0x12, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
+        0x1e, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00,
+        0x1f, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x1f, 0x00, 0x00, 0x00,
+        0xf6, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x23, 0x00, 0x00, 0x00,
+        0xf8, 0x00, 0x02, 0x00, 0x23, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+        0x17, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+        0xb1, 0x00, 0x05, 0x00, 0x26, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+        0x24, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00,
+        0x27, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+        0xf8, 0x00, 0x02, 0x00, 0x20, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+        0x10, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+        0x0c, 0x00, 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+        0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+        0x85, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00,
+        0x29, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+        0x17, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+        0x6f, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00,
+        0x2c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x10, 0x00, 0x00, 0x00,
+        0x2e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+        0x2d, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00,
+        0x30, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00,
+        0x81, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
+        0x2b, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
+        0x12, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00,
+        0x22, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x22, 0x00, 0x00, 0x00,
+        0x3d, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
+        0x1e, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00,
+        0x34, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
+        0x3e, 0x00, 0x03, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+        0xf9, 0x00, 0x02, 0x00, 0x1f, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00,
+        0x21, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+        0x35, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+        0x10, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+        0x41, 0x00, 0x06, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
+        0x16, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
+        0x3e, 0x00, 0x03, 0x00, 0x37, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
+        0xfd, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00
+        };
+
+        VkShaderModuleCreateInfo sm_create_info = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
+        sm_create_info.codeSize                 = sizeof(spirv);
+        sm_create_info.pCode                    = (uint32_t*)spirv;
+        result = device_table->CreateShaderModule(device, &sm_create_info, nullptr, &resources.shader_module);
+        GFXRECON_LOG_WARNING("CreateShaderModule %s.", util::ToString<VkResult>(result).c_str());
+    }
+    const uint32_t   num_invocations = warm_up_load * 1000 * 64 * 1 * 1; // Dispatch(X,Y,Z) * local_size(X,Y,Z)
+    const VkDeviceSize buffer_size   = sizeof(float) * num_invocations;
+
+    if (result == VK_SUCCESS && resources.buffer == VK_NULL_HANDLE)
+    {
+        VkBufferCreateInfo buffer_info = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+        buffer_info.size               = buffer_size;
+        buffer_info.usage              = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+        buffer_info.sharingMode        = VK_SHARING_MODE_EXCLUSIVE;
+        result = device_table->CreateBuffer(device, &buffer_info, nullptr, &resources.buffer);
+        GFXRECON_LOG_WARNING("CreateBuffer for warm-up %s.", util::ToString<VkResult>(result).c_str());
+
+        if (result == VK_SUCCESS)
+        {
+            VkMemoryRequirements mem_requirements;
+            device_table->GetBufferMemoryRequirements(device, resources.buffer, &mem_requirements);
+
+            VulkanPhysicalDeviceInfo* physical_device_info = object_info_table_->GetVkPhysicalDeviceInfo(device_info->parent_id);
+            VkPhysicalDeviceMemoryProperties* memory_properties = &physical_device_info->capture_memory_properties;
+
+            GFXRECON_ASSERT(physical_device_info != nullptr && physical_device_info->replay_device_info != nullptr &&
+                            physical_device_info->replay_device_info->memory_properties.has_value());
+
+            VkMemoryAllocateInfo alloc_info = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+            alloc_info.allocationSize       = mem_requirements.size;
+            alloc_info.memoryTypeIndex =
+                FindMemoryType(*memory_properties,
+                               mem_requirements.memoryTypeBits,
+                               VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+
+            if (alloc_info.memoryTypeIndex != std::numeric_limits<uint32_t>::max())
+            {
+                result = device_table->AllocateMemory(device, &alloc_info, nullptr, &resources.buffer_memory);
+                GFXRECON_LOG_WARNING("AllocateMemory for warm-up buffer %s.", util::ToString<VkResult>(result).c_str());
+                if (result == VK_SUCCESS)
+                {
+                    result = device_table->BindBufferMemory(device, resources.buffer, resources.buffer_memory, 0);
+                }
+            }
+            else
+            {
+                result = VK_ERROR_INITIALIZATION_FAILED;
+            }
+        }
+    }
+
+    if (result == VK_SUCCESS && resources.descriptor_set_layout == VK_NULL_HANDLE)
+    {
+        VkDescriptorSetLayoutBinding layout_binding = {};
+        layout_binding.binding                      = 0;
+        layout_binding.descriptorType               = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+        layout_binding.descriptorCount              = 1;
+        layout_binding.stageFlags                   = VK_SHADER_STAGE_COMPUTE_BIT;
+
+        VkDescriptorSetLayoutCreateInfo layout_info = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
+        layout_info.bindingCount                    = 1;
+        layout_info.pBindings                       = &layout_binding;
+        result = device_table->CreateDescriptorSetLayout(device, &layout_info, nullptr, &resources.descriptor_set_layout);
+        GFXRECON_LOG_WARNING("CreateDescriptorSetLayout %s.", util::ToString<VkResult>(result).c_str());
+    }    
+
+    if (result == VK_SUCCESS && resources.pipeline_layout == VK_NULL_HANDLE)
+    {
+        VkPipelineLayoutCreateInfo pl_create_info = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
+        pl_create_info.setLayoutCount             = 1;
+        pl_create_info.pSetLayouts                = &resources.descriptor_set_layout; // Link the layout
+        result = device_table->CreatePipelineLayout(device, &pl_create_info, nullptr, &resources.pipeline_layout);
+        GFXRECON_LOG_WARNING("CreatePipelineLayout %s.", util::ToString<VkResult>(result).c_str());
+    }
+
+        if (result == VK_SUCCESS && resources.descriptor_pool == VK_NULL_HANDLE)
+    {
+        VkDescriptorPoolSize pool_size = {};
+        pool_size.type                 = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+        pool_size.descriptorCount      = 1;
+
+        VkDescriptorPoolCreateInfo pool_info = { VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
+        pool_info.poolSizeCount              = 1;
+        pool_info.pPoolSizes                 = &pool_size;
+        pool_info.maxSets                    = 1;
+        result = device_table->CreateDescriptorPool(device, &pool_info, nullptr, &resources.descriptor_pool);
+        GFXRECON_LOG_WARNING("CreateDescriptorPool %s.", util::ToString<VkResult>(result).c_str());
+    }
+
+    if (result == VK_SUCCESS && resources.descriptor_set == VK_NULL_HANDLE)
+    {
+        VkDescriptorSetAllocateInfo alloc_info = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
+        alloc_info.descriptorPool              = resources.descriptor_pool;
+        alloc_info.descriptorSetCount          = 1;
+        alloc_info.pSetLayouts                 = &resources.descriptor_set_layout;
+        result = device_table->AllocateDescriptorSets(device, &alloc_info, &resources.descriptor_set);
+        GFXRECON_LOG_WARNING("AllocateDescriptorSets %s.", util::ToString<VkResult>(result).c_str());
+
+        // NEW: Update the descriptor set to point to our buffer
+        if (result == VK_SUCCESS)
+        {
+            VkDescriptorBufferInfo buffer_info_for_descriptor = {};
+            buffer_info_for_descriptor.buffer                 = resources.buffer;
+            buffer_info_for_descriptor.offset                 = 0;
+            buffer_info_for_descriptor.range                  = buffer_size;
+
+            VkWriteDescriptorSet descriptor_write = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET };
+            descriptor_write.dstSet               = resources.descriptor_set;
+            descriptor_write.dstBinding           = 0;
+            descriptor_write.dstArrayElement      = 0;
+            descriptor_write.descriptorType       = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+            descriptor_write.descriptorCount      = 1;
+            descriptor_write.pBufferInfo          = &buffer_info_for_descriptor;
+            device_table->UpdateDescriptorSets(device, 1, &descriptor_write, 0, nullptr);
+        }
+    }
+    
+    if (result == VK_SUCCESS && resources.pipeline == VK_NULL_HANDLE)
+    {
+        VkComputePipelineCreateInfo cp_create_info = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO };
+        cp_create_info.stage.sType                 = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        cp_create_info.stage.stage                 = VK_SHADER_STAGE_COMPUTE_BIT;
+        cp_create_info.stage.module                = resources.shader_module;
+        cp_create_info.stage.pName                 = "main";
+        cp_create_info.layout                      = resources.pipeline_layout;
+        result =
+            device_table->CreateComputePipelines(device, VK_NULL_HANDLE, 1, &cp_create_info, nullptr, &resources.pipeline);
+        GFXRECON_LOG_WARNING("CreateComputePipelines %s.", util::ToString<VkResult>(result).c_str());
+    }
+
+    if (result == VK_SUCCESS && resources.semaphores.empty())
+    {
+        resources.semaphores.resize(10);
+        VkSemaphoreCreateInfo semaphore_info = { VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
+        for (size_t i = 0; i < resources.semaphores.size(); ++i)
+        {
+            result = device_table->CreateSemaphore(device, &semaphore_info, nullptr, &resources.semaphores[i]);
+            if (result != VK_SUCCESS)
+            {
+                GFXRECON_LOG_WARNING("Failed to create semaphore for warm-up. Error %s.", util::ToString<VkResult>(result).c_str());
+                resources.semaphores.clear();
+                break;
+            }
+        }
+    }
+
+    if (result == VK_SUCCESS && resources.command_buffer == VK_NULL_HANDLE)
+    {
+        VkCommandBufferAllocateInfo cmd_buf_alloc_info = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+        cmd_buf_alloc_info.commandPool                 = resources.command_pool;
+        cmd_buf_alloc_info.level                       = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+        cmd_buf_alloc_info.commandBufferCount          = 1;
+        result = device_table->AllocateCommandBuffers(device, &cmd_buf_alloc_info, &resources.command_buffer);
+        GFXRECON_LOG_WARNING("AllocateCommandBuffers %s.", util::ToString<VkResult>(result).c_str());
+
+        VkCommandBufferBeginInfo begin_info = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
+        begin_info.flags                    = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
+        device_table->BeginCommandBuffer(resources.command_buffer, &begin_info);
+        device_table->CmdBindPipeline(resources.command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, resources.pipeline);
+        device_table->CmdBindDescriptorSets(resources.command_buffer,
+                                    VK_PIPELINE_BIND_POINT_COMPUTE,
+                                    resources.pipeline_layout,
+                                    0,
+                                    1,
+                                    &resources.descriptor_set,
+                                    0,
+                                    nullptr);
+        device_table->CmdDispatch(resources.command_buffer, warm_up_load * 64, 1, 1);
+        device_table->EndCommandBuffer(resources.command_buffer);
+    }
+
+    if (result == VK_SUCCESS)
+    {
+        VkSubmitInfo submit_info       = { VK_STRUCTURE_TYPE_SUBMIT_INFO };
+        submit_info.commandBufferCount = 1;
+        submit_info.pCommandBuffers    = &resources.command_buffer;
+        // next_semaphore_index > 0 means we know how many of them we need from previous frame render
+        submit_info.signalSemaphoreCount = resources.next_semaphore_index > 0 ? resources.next_semaphore_index : static_cast<uint32_t>(resources.semaphores.size());
+        submit_info.pSignalSemaphores    = resources.semaphores.data();
+        device_table->QueueSubmit(queue_info->handle, 1, &submit_info, VK_NULL_HANDLE);
+        resources.next_semaphore_index = 0;
+    }
+
+    if (result != VK_SUCCESS)
+    {
+        GFXRECON_LOG_WARNING("Device warm-up dispatch failed with error %s.", util::ToString<VkResult>(result).c_str());
+    }
+    ATrace_endSection();
+}
 GFXRECON_END_NAMESPACE(decode)
 GFXRECON_END_NAMESPACE(gfxrecon)
diff --git a/framework/decode/vulkan_replay_consumer_base.h b/framework/decode/vulkan_replay_consumer_base.h
index 270f78e65b..a922485e16 100644
--- a/framework/decode/vulkan_replay_consumer_base.h
+++ b/framework/decode/vulkan_replay_consumer_base.h
@@ -1659,6 +1659,11 @@ class VulkanReplayConsumerBase : public VulkanConsumer
     virtual void ClearRecaptureHandleIds() override;
     virtual bool IsRecapture() override { return options_.capture; }
 
+    void SetWaitBeforeFirstFrameMinMs(uint32_t ms) { wait_before_first_frame_min_ms_ = ms; }
+    void SetSleepAroundGpuFrameMs(double ms) { sleep_around_gpu_frame_ms_ = ms; }
+    void SetFrameWarmUpGpuLoad(uint32_t load) { frame_warm_up_gpu_load_ = load; }
+    void WarmUpDevice(const VulkanQueueInfo* queue_info, uint32_t warm_up_load);
+
     //// End recapture members
 
   private:
@@ -1964,6 +1969,29 @@ class VulkanReplayConsumerBase : public VulkanConsumer
 
     std::unordered_map<format::HandleId, std::pair<const VulkanDeviceInfo*, VkPipelineCache>> tracked_pipeline_caches_;
     std::unordered_map<VkPipeline, format::HandleId> pipeline_cache_correspondances_;
+
+    uint32_t wait_before_first_frame_min_ms_{ 0 };
+    double   sleep_around_gpu_frame_ms_{ 0.0 };
+    uint32_t frame_warm_up_gpu_load_{ 0 };
+    struct WarmUpResources
+    {
+        VkDescriptorPool      descriptor_pool{ VK_NULL_HANDLE };
+        VkDescriptorSetLayout descriptor_set_layout{ VK_NULL_HANDLE };
+        VkDescriptorSet       descriptor_set{ VK_NULL_HANDLE };
+        VkPipelineLayout      pipeline_layout{ VK_NULL_HANDLE };
+        VkPipeline            pipeline{ VK_NULL_HANDLE };
+        VkBuffer              buffer{ VK_NULL_HANDLE };
+        VkDeviceMemory        buffer_memory{ VK_NULL_HANDLE };
+        VkShaderModule        shader_module{ VK_NULL_HANDLE };
+        VkCommandPool         command_pool{ VK_NULL_HANDLE };
+        VkCommandBuffer       command_buffer{ VK_NULL_HANDLE };
+        VkFence               fence{ VK_NULL_HANDLE };
+        std::vector<VkSemaphore> semaphores;
+        uint32_t next_semaphore_index{ 0 };
+    };
+    std::unordered_map<VkDevice, WarmUpResources> warmup_resources_;
+
+    void InsertRenderPassBarrier(VkCommandBuffer command_buffer, const VulkanCommandBufferInfo* command_buffer_info);
 };
 
 GFXRECON_END_NAMESPACE(decode)
diff --git a/framework/decode/vulkan_replay_options.h b/framework/decode/vulkan_replay_options.h
index 9b9e6402a1..28485d6765 100644
--- a/framework/decode/vulkan_replay_options.h
+++ b/framework/decode/vulkan_replay_options.h
@@ -164,7 +164,6 @@ struct VulkanReplayOptions : public ReplayOptions
     std::string load_pipeline_cache_filename;
     std::string save_pipeline_cache_filename;
     bool        add_new_pipeline_caches;
-
     // Time of instantiation of this struct.
     std::chrono::high_resolution_clock::time_point start_time{ std::chrono::high_resolution_clock::now() };
 
@@ -172,6 +171,8 @@ struct VulkanReplayOptions : public ReplayOptions
     uint32_t wait_before_first_submit{ 0 };
 
     void MaybeWaitBeforeFirstSubmit() const;
+
+    bool        render_pass_barrier{ false };
 };
 
 GFXRECON_END_NAMESPACE(decode)
diff --git a/framework/util/file_input_stream.cpp b/framework/util/file_input_stream.cpp
index e964a4d38d..0354d1f544 100644
--- a/framework/util/file_input_stream.cpp
+++ b/framework/util/file_input_stream.cpp
@@ -197,6 +197,19 @@ bool FStreamFileInputStream::HasReadAhead() const noexcept
     return read_ahead_bytes_ > 0;
 }
 
+int64_t FStreamFileInputStream::Tell() const
+{
+    if (fd_)
+    {
+        int64_t pos = util::platform::FileTell(fd_);
+        if (pos >= 0)
+        {
+            return pos - static_cast<int64_t>(read_ahead_bytes_);
+        }
+    }
+    return -1;
+}
+
 size_t FStreamFileInputStream::ReadFromReadAheadBuffer(void* buffer, size_t bytes)
 {
     char* dest = static_cast<char*>(buffer);
diff --git a/framework/util/file_input_stream.h b/framework/util/file_input_stream.h
index 04b2be5ce0..3cf921f3ee 100644
--- a/framework/util/file_input_stream.h
+++ b/framework/util/file_input_stream.h
@@ -64,6 +64,7 @@ class FStreamFileInputStream
     bool     Open(const std::string& filename);
     void     Close();
     bool     FileSeek(int64_t offset, util::platform::FileSeekOrigin origin);
+    int64_t  Tell() const;
     bool     ReadBytes(void* buffer, size_t bytes);
     size_t   PeekBytes(void* buffer, size_t bytes);
     bool     ReadOverwriteSpan(const size_t bytes, DataSpan& span);
diff --git a/tools/replay/android_main.cpp b/tools/replay/android_main.cpp
index cf7552430a..04913560cc 100644
--- a/tools/replay/android_main.cpp
+++ b/tools/replay/android_main.cpp
@@ -160,6 +160,7 @@ void android_main(struct android_app* app)
                 gfxrecon::decode::VulkanTrackedObjectInfoTable tracked_object_info_table;
                 gfxrecon::decode::VulkanReplayOptions          replay_options =
                     GetVulkanReplayOptions(arg_parser, filename, &tracked_object_info_table);
+                replay_options.render_pass_barrier = GetRenderPassBarrier(arg_parser);
 
                 gfxrecon::decode::VulkanReplayConsumer vulkan_replay_consumer(application, replay_options);
                 gfxrecon::decode::VulkanDecoder        vulkan_decoder;
@@ -226,6 +227,10 @@ void android_main(struct android_app* app)
                                                       replay_options.block_index_to);
 
                 application->SetPauseFrame(GetPauseFrame(arg_parser));
+                application->SetRepeatFrameNTimes(GetRepeatFrameNTimes(arg_parser));
+                vulkan_replay_consumer.SetWaitBeforeFirstFrameMinMs(GetWaitBeforeFirstFrameMs(arg_parser));
+                vulkan_replay_consumer.SetSleepAroundGpuFrameMs(GetSleepAroundGpuFrameMs(arg_parser));
+                vulkan_replay_consumer.SetFrameWarmUpGpuLoad(GetFrameWarmUpGpuLoad(arg_parser));
 
 #if ENABLE_OPENXR_SUPPORT
                 gfxrecon::decode::OpenXrReplayOptions  openxr_replay_options = {};
diff --git a/tools/replay/replay_settings.h b/tools/replay/replay_settings.h
index a1fabb39eb..53088b5305 100644
--- a/tools/replay/replay_settings.h
+++ b/tools/replay/replay_settings.h
@@ -34,7 +34,7 @@ const char kOptions[] =
     "indices,--dcp,--discard-cached-psos,--use-colorspace-fallback,--use-cached-psos,--dx12-override-object-names,--"
     "dx12-ags-inject-markers,--offscreen-swapchain-frame-boundary,--wait-before-present,--dump-resources-before-draw,"
     "--dump-resources-modifiable-state-only,--pbi-all,--preload-measurement-range,--add-new-pipeline-caches,--"
-    "screenshot-ignore-FrameBoundaryANDROID,--deduplicate-device,--log-timestamps,--capture";
+    "screenshot-ignore-FrameBoundaryANDROID,--deduplicate-device,--log-timestamps,--capture,--render-pass-barrier";
 const char kArguments[] =
     "--log-level,--log-file,--cpu-mask,--gpu,--gpu-group,--pause-frame,--wsi,--surface-index,-m|--memory-translation,"
     "--replace-shaders,--screenshots,--screenshot-interval,--denied-messages,--allowed-messages,--screenshot-format,--"
@@ -42,7 +42,7 @@ const char kArguments[] =
     "force-windowed,--fwo|--force-windowed-origin,--batching-memory-usage,--measurement-file,--swapchain,--sgfs|--skip-"
     "get-fence-status,--sgfr|--skip-get-fence-ranges,--dump-resources,--dump-resources-dir,--dump-resources-image-"
     "format,pbis,--pcj|--pipeline-creation-jobs,--save-pipeline-cache,--load-pipeline-cache,--quit-after-frame,--"
-    "present-mode,--wait-before-first-submit";
+    "present-mode,--wait-before-first-submit,--wait-before-first-frame-ms,--sleep-around-gpu-frame-ms,--frame-warm-up-gpu-load,--frame-repeats";
 
 static void PrintUsage(const char* exe_name)
 {
@@ -387,4 +387,53 @@ static void PrintUsage(const char* exe_name)
 #endif
 }
 
+static uint32_t GetRepeatFrameNTimes(const gfxrecon::util::ArgumentParser& arg_parser)
+{
+    uint32_t repeat_frame_n_times = 0;
+    const auto& value             = arg_parser.GetArgumentValue(kRepeatFrameNTimesArgument);
+    if (!value.empty())
+    {
+        repeat_frame_n_times = static_cast<uint32_t>(std::stoi(value));
+    }
+    return repeat_frame_n_times;
+}
+
+static uint32_t GetWaitBeforeFirstFrameMs(const gfxrecon::util::ArgumentParser& arg_parser)
+{
+    uint32_t wait_before_first_frame_ms = 0;
+    const auto& value                   = arg_parser.GetArgumentValue(kWaitBeforeFirstFrameMsArgument);
+    if (!value.empty())
+    {
+        wait_before_first_frame_ms = static_cast<uint32_t>(std::stoi(value));
+    }
+    return wait_before_first_frame_ms;
+}
+
+static double GetSleepAroundGpuFrameMs(const gfxrecon::util::ArgumentParser& arg_parser)
+{
+    double sleep_around_gpu_frame_ms = 0.0;
+    const auto& value                = arg_parser.GetArgumentValue(kSleepAroundGpuFrameMsArgument);
+    if (!value.empty())
+    {
+        sleep_around_gpu_frame_ms = std::stod(value);
+    }
+    return sleep_around_gpu_frame_ms;
+}
+
+static uint32_t GetFrameWarmUpGpuLoad(const gfxrecon::util::ArgumentParser& arg_parser)
+{
+    uint32_t frame_warm_up_gpu_load = 0;
+    const auto& value               = arg_parser.GetArgumentValue(kFrameWarmUpGpuLoadArgument);
+    if (!value.empty())
+    {
+        frame_warm_up_gpu_load = static_cast<uint32_t>(std::stoi(value));
+    }
+    return frame_warm_up_gpu_load;
+}
+
+static bool GetRenderPassBarrier(const gfxrecon::util::ArgumentParser& arg_parser)
+{
+    return arg_parser.IsOptionSet(kRenderPassBarrierArgument);
+}
+
 #endif // GFXRECON_REPLAY_SETTINGS_H
diff --git a/tools/tool_settings.h b/tools/tool_settings.h
index 69ed7dfd04..c70ae32758 100644
--- a/tools/tool_settings.h
+++ b/tools/tool_settings.h
@@ -148,6 +148,11 @@ const char kLoadPipelineCacheArgument[]           = "--load-pipeline-cache";
 const char kCreateNewPipelineCacheOption[]        = "--add-new-pipeline-caches";
 const char kDeduplicateDevice[]                   = "--deduplicate-device";
 const char kWaitBeforeFirstSubmit[]               = "--wait-before-first-submit";
+const char kRepeatFrameNTimesArgument[]          = "--frame-repeats";
+const char kWaitBeforeFirstFrameMsArgument[]     = "--wait-before-first-frame-ms";
+const char kSleepAroundGpuFrameMsArgument[]      = "--sleep-around-gpu-frame-ms";
+const char kFrameWarmUpGpuLoadArgument[]         = "--frame-warm-up-gpu-load";
+const char kRenderPassBarrierArgument[]          = "--render-pass-barrier";
 
 const char kScreenshotIgnoreFrameBoundaryArgument[] = "--screenshot-ignore-FrameBoundaryANDROID";
 

From 9f8cb7ff06562d77c2f54c8a9ca202b6cc4bf9af Mon Sep 17 00:00:00 2001
From: Oleh Kuznetsov <okuznetsov@google.com>
Date: Fri, 6 Feb 2026 14:16:25 +0000
Subject: [PATCH 2/9] Local build optimizations for debug

---
 android/tools/replay/build.gradle | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/android/tools/replay/build.gradle b/android/tools/replay/build.gradle
index 88a7c31533..ea2266ba04 100644
--- a/android/tools/replay/build.gradle
+++ b/android/tools/replay/build.gradle
@@ -31,6 +31,13 @@ android {
         }
     }
     buildTypes {
+        debug {
+            externalNativeBuild {
+                cmake {
+                    cppFlags "-O2", "-DNDEBUG"
+                }
+            }
+        }
         release {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

From fb267430122a584590b75217c5710252877a7192 Mon Sep 17 00:00:00 2001
From: Oleh Kuznetsov <okuznetsov@google.com>
Date: Fri, 6 Feb 2026 15:13:23 +0000
Subject: [PATCH 3/9] Fix build errors: add FileTell(int) and remove missing
 header

---
 framework/decode/vulkan_replay_consumer_base.cpp | 1 -
 framework/util/file_input_stream.cpp             | 2 +-
 framework/util/platform.h                        | 5 +++++
 3 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/framework/decode/vulkan_replay_consumer_base.cpp b/framework/decode/vulkan_replay_consumer_base.cpp
index 369debfe87..9d38cc26e2 100644
--- a/framework/decode/vulkan_replay_consumer_base.cpp
+++ b/framework/decode/vulkan_replay_consumer_base.cpp
@@ -53,7 +53,6 @@
 #include "util/platform.h"
 #include "util/logging.h"
 #include "util/callbacks.h"
-#include "decode/mark_injected_commands.h"
 #include "graphics/vulkan_resources_util.h"
 
 #include "spirv_reflect.h"
diff --git a/framework/util/file_input_stream.cpp b/framework/util/file_input_stream.cpp
index 0354d1f544..1a4c9139da 100644
--- a/framework/util/file_input_stream.cpp
+++ b/framework/util/file_input_stream.cpp
@@ -199,7 +199,7 @@ bool FStreamFileInputStream::HasReadAhead() const noexcept
 
 int64_t FStreamFileInputStream::Tell() const
 {
-    if (fd_)
+    if (IsOpen())
     {
         int64_t pos = util::platform::FileTell(fd_);
         if (pos >= 0)
diff --git a/framework/util/platform.h b/framework/util/platform.h
index 94b996fabd..790029ac2b 100644
--- a/framework/util/platform.h
+++ b/framework/util/platform.h
@@ -547,6 +547,11 @@ inline int64_t FileTell(FILE* stream)
     return ftello(stream);
 }
 
+inline int64_t FileTell(int fd)
+{
+    return lseek64(fd, 0, SEEK_CUR);
+}
+
 inline bool FileSeek(FILE* stream, int64_t offset, FileSeekOrigin origin)
 {
     int32_t result = fseeko(stream, offset, origin);

From e21eaf3889dd4cbab86dbac3418fba3c00e3bf35 Mon Sep 17 00:00:00 2001
From: Oleh Kuznetsov <okuznetsov@google.com>
Date: Fri, 6 Feb 2026 15:43:26 +0000
Subject: [PATCH 4/9] Format code with clang-format

---
 framework/decode/file_processor.cpp           |  12 +-
 .../decode/vulkan_replay_consumer_base.cpp    | 380 ++++++++----------
 .../decode/vulkan_replay_consumer_base.h      |  24 +-
 framework/decode/vulkan_replay_options.h      |   4 +-
 framework/util/platform.h                     |  10 +-
 tools/replay/replay_settings.h                |  19 +-
 tools/tool_settings.h                         |  10 +-
 7 files changed, 218 insertions(+), 241 deletions(-)

diff --git a/framework/decode/file_processor.cpp b/framework/decode/file_processor.cpp
index 8826825406..af28154ad7 100644
--- a/framework/decode/file_processor.cpp
+++ b/framework/decode/file_processor.cpp
@@ -120,7 +120,8 @@ bool FileProcessor::ProcessBlocksOneFrame()
 {
     ATrace_beginSection("ProcessBlocksOneFrame");
     block_parser_->SetDecompressionPolicy(BlockParser::DecompressionPolicy::kAlways);
-    if (current_frame_number_ == kFirstFrame) {
+    if (current_frame_number_ == kFirstFrame)
+    {
         // Process initial resources state
         ATrace_beginSection("InitState");
         if (!ProcessBlocks())
@@ -141,7 +142,7 @@ bool FileProcessor::ProcessBlocksOneFrame()
     uint32_t start_frame = current_frame_number_;
 
     // Handle limited command counts (e.g. from trim ranges or secondary files)
-    uint32_t remaining_commands_before       = 0;
+    uint32_t remaining_commands_before = 0;
 
     remaining_commands_before = GetCurrentFile().remaining_commands;
 
@@ -149,13 +150,14 @@ bool FileProcessor::ProcessBlocksOneFrame()
     {
         // Ensure we replay with the same frame number
         current_frame_number_ = start_frame;
-       
+
         for (ApiDecoder* decoder : decoders_)
         {
             decoder->SetCurrentFrameNumber(current_frame_number_);
         }
-        
-        GetCurrentFile().remaining_commands = (i < repeat_frame_n_times_) ? remaining_commands_before + 1 : remaining_commands_before;
+
+        GetCurrentFile().remaining_commands =
+            (i < repeat_frame_n_times_) ? remaining_commands_before + 1 : remaining_commands_before;
 
         if (!ProcessBlocks())
         {
diff --git a/framework/decode/vulkan_replay_consumer_base.cpp b/framework/decode/vulkan_replay_consumer_base.cpp
index 9d38cc26e2..0d901197fd 100644
--- a/framework/decode/vulkan_replay_consumer_base.cpp
+++ b/framework/decode/vulkan_replay_consumer_base.cpp
@@ -233,8 +233,7 @@ static uint32_t GetHardwareBufferFormatBpp(uint32_t format)
 
 VulkanReplayConsumerBase::VulkanReplayConsumerBase(std::shared_ptr<application::Application> application,
                                                    const VulkanReplayOptions&                options) :
-    options_(options),
-    loader_handle_(nullptr), get_instance_proc_addr_(nullptr), create_instance_proc_(nullptr),
+    options_(options), loader_handle_(nullptr), get_instance_proc_addr_(nullptr), create_instance_proc_(nullptr),
     application_(application), loading_trim_state_(false), replaying_trimmed_capture_(false), fps_info_(nullptr),
     have_imported_semaphores_(false), omitted_pipeline_cache_data_(false)
 {
@@ -4131,23 +4130,27 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
 
     assert((queue_info != nullptr) && (pSubmits != nullptr));
 
-    if (frame_first_queue_submit) {
+    if (frame_first_queue_submit)
+    {
         frame_first_queue_submit = false;
-        static bool first_time = true;
-        if (first_time && wait_before_first_frame_min_ms_ > 0) {
+        static bool first_time   = true;
+        if (first_time && wait_before_first_frame_min_ms_ > 0)
+        {
             ATrace_beginSection("FirstTimeWait");
             usleep(wait_before_first_frame_min_ms_ * 1000);
             ATrace_endSection();
             first_time = false;
         }
-        if (sleep_around_gpu_frame_ms_ > 0.0) {
+        if (sleep_around_gpu_frame_ms_ > 0.0)
+        {
             // WaitDevicesIdle(); // Need to implement or check availability
             usleep(static_cast<useconds_t>(sleep_around_gpu_frame_ms_ * 1000));
         }
 
-        if (frame_warm_up_gpu_load_ > 0) {
+        if (frame_warm_up_gpu_load_ > 0)
+        {
             // Add device warm up using dispatch
-            WarmUpDevice(queue_info, frame_warm_up_gpu_load_);        
+            WarmUpDevice(queue_info, frame_warm_up_gpu_load_);
         }
         ATrace_beginSection("GFXRFrame");
         if (sleep_around_gpu_frame_ms_ > 0.0)
@@ -4178,20 +4181,23 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
     allocator->ClearStagingResources();
 
     auto queue_submit = [&](const VkSubmitInfo* submit_infos_arg, uint32_t submitCount_arg) {
-        VkDevice         device       = device_info->handle;
-        WarmUpResources& resources    = warmup_resources_[device];
-        if(resources.next_semaphore_index < resources.semaphores.size()) {           
-            std::vector<VkSubmitInfo> modified_submit_infos(submit_infos_arg, std::next(submit_infos_arg, submitCount_arg));
+        VkDevice         device    = device_info->handle;
+        WarmUpResources& resources = warmup_resources_[device];
+        if (resources.next_semaphore_index < resources.semaphores.size())
+        {
+            std::vector<VkSubmitInfo>             modified_submit_infos(submit_infos_arg,
+                                                                        std::next(submit_infos_arg, submitCount_arg));
             std::vector<std::vector<VkSemaphore>> new_wait_semaphore_lists(submitCount_arg);
             std::vector<std::vector<VkPipelineStageFlags>> new_wait_stage_mask_lists(submitCount_arg);
 
             for (uint32_t i = 0; i < submitCount_arg; ++i)
             {
-                const VkSubmitInfo& original_submit = submit_infos_arg[i];
-                std::vector<VkSemaphore>& new_list = new_wait_semaphore_lists[i];
+                const VkSubmitInfo&       original_submit = submit_infos_arg[i];
+                std::vector<VkSemaphore>& new_list        = new_wait_semaphore_lists[i];
                 new_list.reserve(original_submit.waitSemaphoreCount + 1);
-                if (original_submit.waitSemaphoreCount > 0 && original_submit.pWaitSemaphores) {
-                    new_list.assign(original_submit.pWaitSemaphores, 
+                if (original_submit.waitSemaphoreCount > 0 && original_submit.pWaitSemaphores)
+                {
+                    new_list.assign(original_submit.pWaitSemaphores,
                                     original_submit.pWaitSemaphores + original_submit.waitSemaphoreCount);
                 }
 
@@ -4202,10 +4208,11 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
                     new_stage_list.assign(original_submit.pWaitDstStageMask,
                                           original_submit.pWaitDstStageMask + original_submit.waitSemaphoreCount);
                 }
-                else {
+                else
+                {
                     // Safe default if mask is missing but we're adding a semaphore
                     VkPipelineStageFlags default_flags = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
-                    new_stage_list.assign(new_list.size() + 1, default_flags); 
+                    new_stage_list.assign(new_list.size() + 1, default_flags);
                     // Actually we need to match the size.
                     // If original was 0, we have 1 now.
                     // If we assigned from original, we have N.
@@ -4216,21 +4223,22 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
                     // So if waitSemaphoreCount was 0, pWaitDstStageMask might be NULL.
                     // In that case new_stage_list is empty.
                 }
-                
-                if(resources.next_semaphore_index < resources.semaphores.size()) {           
+
+                if (resources.next_semaphore_index < resources.semaphores.size())
+                {
                     VkSemaphore warm_up_semaphore = resources.semaphores[resources.next_semaphore_index++];
                     new_list.push_back(warm_up_semaphore);
-                    new_stage_list.push_back(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);                    
+                    new_stage_list.push_back(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
                 }
 
-                VkSubmitInfo& modified_submit = modified_submit_infos[i];
+                VkSubmitInfo& modified_submit      = modified_submit_infos[i];
                 modified_submit.waitSemaphoreCount = static_cast<uint32_t>(new_list.size());
-                modified_submit.pWaitSemaphores = new_list.data();
-                modified_submit.pWaitDstStageMask = new_stage_list.data();
+                modified_submit.pWaitSemaphores    = new_list.data();
+                modified_submit.pWaitDstStageMask  = new_stage_list.data();
             }
 
-            return func(queue_info->handle, submitCount_arg, modified_submit_infos.data(), fence);        
-        } 
+            return func(queue_info->handle, submitCount_arg, modified_submit_infos.data(), fence);
+        }
         return func(queue_info->handle, submitCount_arg, submit_infos_arg, fence);
     };
 
@@ -4273,7 +4281,7 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
             {
                 VkSubmitInfo& submit_info_mut = pSubmits->GetPointer()[i];
                 auto          wait_semaphores = graphics::StripWaitSemaphores(&submit_info_mut);
-                semaphores[i]                 = address_replacer.UpdateBufferAddresses(cmd_buf_info,
+                semaphores[i] = address_replacer.UpdateBufferAddresses(cmd_buf_info,
                                                                        addresses_to_replace.data(),
                                                                        addresses_to_replace.size(),
                                                                        GetDeviceAddressTracker(device_info),
@@ -4400,7 +4408,8 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
             }
             else
             {
-                result = queue_submit(modified_submit_infos.data(), static_cast<uint32_t>(modified_submit_infos.size()));
+                result =
+                    queue_submit(modified_submit_infos.data(), static_cast<uint32_t>(modified_submit_infos.size()));
             }
         }
     }
@@ -8400,14 +8409,17 @@ VulkanReplayConsumerBase::OverrideQueuePresentKHR(PFN_vkQueuePresentKHR
                                                   const VulkanQueueInfo*                                queue_info,
                                                   const StructPointerDecoder<Decoded_VkPresentInfoKHR>* pPresentInfo)
 {
-    if (!frame_first_queue_submit) {
+    if (!frame_first_queue_submit)
+    {
         frame_first_queue_submit = true;
-        if (sleep_around_gpu_frame_ms_ > 0.0) {
-             auto device_info = object_info_table_->GetVkDeviceInfo(queue_info->parent_id);
-             if (device_info) {
-                 auto device_table = GetDeviceTable(device_info->handle);
-                 device_table->DeviceWaitIdle(device_info->handle);
-             }
+        if (sleep_around_gpu_frame_ms_ > 0.0)
+        {
+            auto device_info = object_info_table_->GetVkDeviceInfo(queue_info->parent_id);
+            if (device_info)
+            {
+                auto device_table = GetDeviceTable(device_info->handle);
+                device_table->DeviceWaitIdle(device_info->handle);
+            }
             usleep(static_cast<useconds_t>(sleep_around_gpu_frame_ms_ * 1000));
         }
         ATrace_endSection();
@@ -8500,14 +8512,14 @@ VulkanReplayConsumerBase::OverrideQueuePresentKHR(PFN_vkQueuePresentKHR
 
                     uint32_t replay_index = 0;
                     result                = swapchain_->AcquireNextImageKHR(original_result,
-                                                             device_table->AcquireNextImageKHR,
-                                                             swapchain_info->device_info,
-                                                             swapchain_info,
-                                                             std::numeric_limits<uint64_t>::max(),
-                                                             VK_NULL_HANDLE,
-                                                             acquire_fence.fence,
-                                                             capture_image_index,
-                                                             &replay_index);
+                                                                            device_table->AcquireNextImageKHR,
+                                                                            swapchain_info->device_info,
+                                                                            swapchain_info,
+                                                                            std::numeric_limits<uint64_t>::max(),
+                                                                            VK_NULL_HANDLE,
+                                                                            acquire_fence.fence,
+                                                                            capture_image_index,
+                                                                            &replay_index);
                     GFXRECON_ASSERT((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR));
 
                     result = device_table->WaitForFences(
@@ -8648,14 +8660,14 @@ VulkanReplayConsumerBase::OverrideQueuePresentKHR(PFN_vkQueuePresentKHR
 
                     uint32_t replay_index = 0;
                     result                = swapchain_->AcquireNextImageKHR(original_result,
-                                                             device_table->AcquireNextImageKHR,
-                                                             swapchain_info->device_info,
-                                                             swapchain_info,
-                                                             std::numeric_limits<uint64_t>::max(),
-                                                             VK_NULL_HANDLE,
-                                                             acquire_fence.fence,
-                                                             capture_image_index,
-                                                             &replay_index);
+                                                                            device_table->AcquireNextImageKHR,
+                                                                            swapchain_info->device_info,
+                                                                            swapchain_info,
+                                                                            std::numeric_limits<uint64_t>::max(),
+                                                                            VK_NULL_HANDLE,
+                                                                            acquire_fence.fence,
+                                                                            capture_image_index,
+                                                                            &replay_index);
                     GFXRECON_ASSERT((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR));
 
                     result = device_table->WaitForFences(
@@ -9477,7 +9489,7 @@ VkResult VulkanReplayConsumerBase::OverrideCreateRayTracingPipelinesKHR(
 
             uint32_t group_info_count = in_pCreateInfos[create_info_i].groupCount;
             bool     has_data         = (device_info->shader_group_handles.find(pipeline_capture_id) !=
-                             device_info->shader_group_handles.end());
+                                         device_info->shader_group_handles.end());
 
             if (has_data)
             {
@@ -12583,8 +12595,8 @@ bool VulkanReplayConsumerBase::CheckPipelineCacheUUID(const VulkanDeviceInfo*
             // compare pipelineCacheUUID for device and blob
             auto* cache_header = reinterpret_cast<const VkPipelineCacheHeaderVersionOne*>(create_info->pInitialData);
             uuid_match         = memcmp(cache_header->pipelineCacheUUID,
-                                physical_device_info->replay_device_info->properties->pipelineCacheUUID,
-                                VK_UUID_SIZE) == 0;
+                                        physical_device_info->replay_device_info->properties->pipelineCacheUUID,
+                                        VK_UUID_SIZE) == 0;
         }
         return uuid_match;
     }
@@ -13136,133 +13148,92 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
 
         //     // Write the final, modified value back into the same position in the buffer.
         //     data[index] = value;
-        // }        
+        // }
         unsigned char spirv[] = {
-        0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x0d, 0x00,
-        0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
-        0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00,
-        0x47, 0x4c, 0x53, 0x4c, 0x2e, 0x73, 0x74, 0x64, 0x2e, 0x34, 0x35, 0x30,
-        0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x06, 0x00, 0x05, 0x00, 0x00, 0x00,
-        0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00,
-        0x0b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x06, 0x00, 0x04, 0x00, 0x00, 0x00,
-        0x11, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-        0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x00,
-        0xc2, 0x01, 0x00, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x47, 0x4c, 0x5f, 0x47,
-        0x4f, 0x4f, 0x47, 0x4c, 0x45, 0x5f, 0x63, 0x70, 0x70, 0x5f, 0x73, 0x74,
-        0x79, 0x6c, 0x65, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x64, 0x69, 0x72,
-        0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00,
-        0x47, 0x4c, 0x5f, 0x47, 0x4f, 0x4f, 0x47, 0x4c, 0x45, 0x5f, 0x69, 0x6e,
-        0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74,
-        0x69, 0x76, 0x65, 0x00, 0x05, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00,
-        0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00,
-        0x08, 0x00, 0x00, 0x00, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x00, 0x00, 0x00,
-        0x05, 0x00, 0x08, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x67, 0x6c, 0x5f, 0x47,
-        0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x63, 0x61, 0x74,
-        0x69, 0x6f, 0x6e, 0x49, 0x44, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00,
-        0x12, 0x00, 0x00, 0x00, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x00, 0x00, 0x00,
-        0x05, 0x00, 0x05, 0x00, 0x14, 0x00, 0x00, 0x00, 0x44, 0x61, 0x74, 0x61,
-        0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x00, 0x00, 0x06, 0x00, 0x05, 0x00,
-        0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x61, 0x74, 0x61,
-        0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00, 0x16, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00, 0x1e, 0x00, 0x00, 0x00,
-        0x69, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00,
-        0x0b, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-        0x13, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-        0x47, 0x00, 0x03, 0x00, 0x14, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-        0x48, 0x00, 0x05, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
-        0x16, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x47, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x3a, 0x00, 0x00, 0x00,
-        0x0b, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00,
-        0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
-        0x02, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
-        0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-        0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-        0x17, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
-        0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00,
-        0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
-        0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-        0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0d, 0x00, 0x00, 0x00,
-        0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
-        0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-        0x11, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-        0x1d, 0x00, 0x03, 0x00, 0x13, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
-        0x1e, 0x00, 0x03, 0x00, 0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
-        0x20, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
-        0x14, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00,
-        0x16, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
-        0x17, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-        0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00,
-        0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
-        0x1d, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
-        0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
-        0xe8, 0x03, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00, 0x26, 0x00, 0x00, 0x00,
-        0x2b, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00,
-        0x77, 0xbe, 0x7f, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
-        0x2f, 0x00, 0x00, 0x00, 0x6f, 0x12, 0x83, 0x3a, 0x2b, 0x00, 0x04, 0x00,
-        0x17, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-        0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
-        0x40, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
-        0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00,
-        0x09, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
-        0x39, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00,
-        0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x03, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
-        0x3b, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
-        0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00,
-        0x12, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
-        0x1d, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
-        0x41, 0x00, 0x05, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
-        0x0b, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
-        0x06, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
-        0x3e, 0x00, 0x03, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
-        0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
-        0x08, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x1a, 0x00, 0x00, 0x00,
-        0x1b, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
-        0x19, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
-        0x1c, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
-        0x12, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
-        0x1e, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00,
-        0x1f, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x1f, 0x00, 0x00, 0x00,
-        0xf6, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x23, 0x00, 0x00, 0x00,
-        0xf8, 0x00, 0x02, 0x00, 0x23, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
-        0x17, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
-        0xb1, 0x00, 0x05, 0x00, 0x26, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
-        0x24, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00,
-        0x27, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
-        0xf8, 0x00, 0x02, 0x00, 0x20, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
-        0x10, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-        0x0c, 0x00, 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
-        0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
-        0x85, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00,
-        0x29, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
-        0x17, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
-        0x6f, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00,
-        0x2c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x10, 0x00, 0x00, 0x00,
-        0x2e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
-        0x2d, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00,
-        0x30, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00,
-        0x81, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
-        0x2b, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
-        0x12, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00,
-        0x22, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x22, 0x00, 0x00, 0x00,
-        0x3d, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
-        0x1e, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00,
-        0x34, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
-        0x3e, 0x00, 0x03, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
-        0xf9, 0x00, 0x02, 0x00, 0x1f, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00,
-        0x21, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
-        0x35, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
-        0x10, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
-        0x41, 0x00, 0x06, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
-        0x16, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
-        0x3e, 0x00, 0x03, 0x00, 0x37, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
-        0xfd, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00
+            0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x0d, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00,
+            0x47, 0x4c, 0x53, 0x4c, 0x2e, 0x73, 0x74, 0x64, 0x2e, 0x34, 0x35, 0x30, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00,
+            0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x06, 0x00, 0x05, 0x00, 0x00, 0x00,
+            0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x10, 0x00,
+            0x06, 0x00, 0x04, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+            0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x00, 0xc2, 0x01, 0x00, 0x00, 0x04, 0x00,
+            0x0a, 0x00, 0x47, 0x4c, 0x5f, 0x47, 0x4f, 0x4f, 0x47, 0x4c, 0x45, 0x5f, 0x63, 0x70, 0x70, 0x5f, 0x73, 0x74,
+            0x79, 0x6c, 0x65, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65,
+            0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x47, 0x4c, 0x5f, 0x47, 0x4f, 0x4f, 0x47, 0x4c, 0x45, 0x5f, 0x69, 0x6e,
+            0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x00, 0x05, 0x00,
+            0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00,
+            0x08, 0x00, 0x00, 0x00, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x00, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00, 0x0b, 0x00,
+            0x00, 0x00, 0x67, 0x6c, 0x5f, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x63, 0x61, 0x74,
+            0x69, 0x6f, 0x6e, 0x49, 0x44, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x76, 0x61,
+            0x6c, 0x75, 0x65, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x14, 0x00, 0x00, 0x00, 0x44, 0x61, 0x74, 0x61,
+            0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x00, 0x00, 0x06, 0x00, 0x05, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x64, 0x61, 0x74, 0x61, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00, 0x16, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x47, 0x00,
+            0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+            0x13, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x14, 0x00,
+            0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00, 0x21, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x19, 0x00,
+            0x00, 0x00, 0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
+            0x02, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+            0x17, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x20, 0x00,
+            0x04, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+            0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x06, 0x00,
+            0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0d, 0x00, 0x00, 0x00,
+            0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00,
+            0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+            0x1d, 0x00, 0x03, 0x00, 0x13, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x03, 0x00, 0x14, 0x00,
+            0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+            0x14, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x02, 0x00,
+            0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+            0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
+            0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+            0x1d, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x17, 0x00,
+            0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00, 0x26, 0x00, 0x00, 0x00,
+            0x2b, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x77, 0xbe, 0x7f, 0x3f, 0x2b, 0x00,
+            0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x6f, 0x12, 0x83, 0x3a, 0x2b, 0x00, 0x04, 0x00,
+            0x17, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x06, 0x00,
+            0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+            0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, 0x09, 0x00, 0x00, 0x00, 0x3a, 0x00,
+            0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00,
+            0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf8, 0x00,
+            0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+            0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x00,
+            0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+            0x41, 0x00, 0x05, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0c, 0x00,
+            0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+            0x3e, 0x00, 0x03, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00,
+            0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x1a, 0x00, 0x00, 0x00,
+            0x1b, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x3d, 0x00,
+            0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
+            0x12, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x18, 0x00,
+            0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x1f, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x1f, 0x00, 0x00, 0x00,
+            0xf6, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00,
+            0x02, 0x00, 0x23, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x23, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+            0x17, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0xb1, 0x00, 0x05, 0x00, 0x26, 0x00,
+            0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00,
+            0x27, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x20, 0x00,
+            0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+            0x0c, 0x00, 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00,
+            0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00,
+            0x29, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x2c, 0x00,
+            0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x6f, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00,
+            0x2c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x01, 0x00,
+            0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00,
+            0x30, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x10, 0x00,
+            0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
+            0x12, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x22, 0x00, 0x00, 0x00, 0xf8, 0x00,
+            0x02, 0x00, 0x22, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
+            0x1e, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x32, 0x00,
+            0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+            0xf9, 0x00, 0x02, 0x00, 0x1f, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x21, 0x00, 0x00, 0x00, 0x3d, 0x00,
+            0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+            0x10, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x41, 0x00, 0x06, 0x00, 0x1a, 0x00,
+            0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
+            0x3e, 0x00, 0x03, 0x00, 0x37, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x01, 0x00, 0x38, 0x00,
+            0x01, 0x00
         };
 
         VkShaderModuleCreateInfo sm_create_info = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
@@ -13271,8 +13242,8 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
         result = device_table->CreateShaderModule(device, &sm_create_info, nullptr, &resources.shader_module);
         GFXRECON_LOG_WARNING("CreateShaderModule %s.", util::ToString<VkResult>(result).c_str());
     }
-    const uint32_t   num_invocations = warm_up_load * 1000 * 64 * 1 * 1; // Dispatch(X,Y,Z) * local_size(X,Y,Z)
-    const VkDeviceSize buffer_size   = sizeof(float) * num_invocations;
+    const uint32_t     num_invocations = warm_up_load * 1000 * 64 * 1 * 1; // Dispatch(X,Y,Z) * local_size(X,Y,Z)
+    const VkDeviceSize buffer_size     = sizeof(float) * num_invocations;
 
     if (result == VK_SUCCESS && resources.buffer == VK_NULL_HANDLE)
     {
@@ -13280,7 +13251,7 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
         buffer_info.size               = buffer_size;
         buffer_info.usage              = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
         buffer_info.sharingMode        = VK_SHARING_MODE_EXCLUSIVE;
-        result = device_table->CreateBuffer(device, &buffer_info, nullptr, &resources.buffer);
+        result                         = device_table->CreateBuffer(device, &buffer_info, nullptr, &resources.buffer);
         GFXRECON_LOG_WARNING("CreateBuffer for warm-up %s.", util::ToString<VkResult>(result).c_str());
 
         if (result == VK_SUCCESS)
@@ -13288,7 +13259,8 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
             VkMemoryRequirements mem_requirements;
             device_table->GetBufferMemoryRequirements(device, resources.buffer, &mem_requirements);
 
-            VulkanPhysicalDeviceInfo* physical_device_info = object_info_table_->GetVkPhysicalDeviceInfo(device_info->parent_id);
+            VulkanPhysicalDeviceInfo* physical_device_info =
+                object_info_table_->GetVkPhysicalDeviceInfo(device_info->parent_id);
             VkPhysicalDeviceMemoryProperties* memory_properties = &physical_device_info->capture_memory_properties;
 
             GFXRECON_ASSERT(physical_device_info != nullptr && physical_device_info->replay_device_info != nullptr &&
@@ -13296,10 +13268,8 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
 
             VkMemoryAllocateInfo alloc_info = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
             alloc_info.allocationSize       = mem_requirements.size;
-            alloc_info.memoryTypeIndex =
-                FindMemoryType(*memory_properties,
-                               mem_requirements.memoryTypeBits,
-                               VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+            alloc_info.memoryTypeIndex      = FindMemoryType(
+                *memory_properties, mem_requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
             if (alloc_info.memoryTypeIndex != std::numeric_limits<uint32_t>::max())
             {
@@ -13328,9 +13298,10 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
         VkDescriptorSetLayoutCreateInfo layout_info = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
         layout_info.bindingCount                    = 1;
         layout_info.pBindings                       = &layout_binding;
-        result = device_table->CreateDescriptorSetLayout(device, &layout_info, nullptr, &resources.descriptor_set_layout);
+        result =
+            device_table->CreateDescriptorSetLayout(device, &layout_info, nullptr, &resources.descriptor_set_layout);
         GFXRECON_LOG_WARNING("CreateDescriptorSetLayout %s.", util::ToString<VkResult>(result).c_str());
-    }    
+    }
 
     if (result == VK_SUCCESS && resources.pipeline_layout == VK_NULL_HANDLE)
     {
@@ -13341,7 +13312,7 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
         GFXRECON_LOG_WARNING("CreatePipelineLayout %s.", util::ToString<VkResult>(result).c_str());
     }
 
-        if (result == VK_SUCCESS && resources.descriptor_pool == VK_NULL_HANDLE)
+    if (result == VK_SUCCESS && resources.descriptor_pool == VK_NULL_HANDLE)
     {
         VkDescriptorPoolSize pool_size = {};
         pool_size.type                 = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
@@ -13382,7 +13353,7 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
             device_table->UpdateDescriptorSets(device, 1, &descriptor_write, 0, nullptr);
         }
     }
-    
+
     if (result == VK_SUCCESS && resources.pipeline == VK_NULL_HANDLE)
     {
         VkComputePipelineCreateInfo cp_create_info = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO };
@@ -13391,8 +13362,8 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
         cp_create_info.stage.module                = resources.shader_module;
         cp_create_info.stage.pName                 = "main";
         cp_create_info.layout                      = resources.pipeline_layout;
-        result =
-            device_table->CreateComputePipelines(device, VK_NULL_HANDLE, 1, &cp_create_info, nullptr, &resources.pipeline);
+        result                                     = device_table->CreateComputePipelines(
+            device, VK_NULL_HANDLE, 1, &cp_create_info, nullptr, &resources.pipeline);
         GFXRECON_LOG_WARNING("CreateComputePipelines %s.", util::ToString<VkResult>(result).c_str());
     }
 
@@ -13405,7 +13376,8 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
             result = device_table->CreateSemaphore(device, &semaphore_info, nullptr, &resources.semaphores[i]);
             if (result != VK_SUCCESS)
             {
-                GFXRECON_LOG_WARNING("Failed to create semaphore for warm-up. Error %s.", util::ToString<VkResult>(result).c_str());
+                GFXRECON_LOG_WARNING("Failed to create semaphore for warm-up. Error %s.",
+                                     util::ToString<VkResult>(result).c_str());
                 resources.semaphores.clear();
                 break;
             }
@@ -13426,13 +13398,13 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
         device_table->BeginCommandBuffer(resources.command_buffer, &begin_info);
         device_table->CmdBindPipeline(resources.command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, resources.pipeline);
         device_table->CmdBindDescriptorSets(resources.command_buffer,
-                                    VK_PIPELINE_BIND_POINT_COMPUTE,
-                                    resources.pipeline_layout,
-                                    0,
-                                    1,
-                                    &resources.descriptor_set,
-                                    0,
-                                    nullptr);
+                                            VK_PIPELINE_BIND_POINT_COMPUTE,
+                                            resources.pipeline_layout,
+                                            0,
+                                            1,
+                                            &resources.descriptor_set,
+                                            0,
+                                            nullptr);
         device_table->CmdDispatch(resources.command_buffer, warm_up_load * 64, 1, 1);
         device_table->EndCommandBuffer(resources.command_buffer);
     }
@@ -13443,7 +13415,9 @@ void VulkanReplayConsumerBase::WarmUpDevice(const VulkanQueueInfo* queue_info, u
         submit_info.commandBufferCount = 1;
         submit_info.pCommandBuffers    = &resources.command_buffer;
         // next_semaphore_index > 0 means we know how many of them we need from previous frame render
-        submit_info.signalSemaphoreCount = resources.next_semaphore_index > 0 ? resources.next_semaphore_index : static_cast<uint32_t>(resources.semaphores.size());
+        submit_info.signalSemaphoreCount = resources.next_semaphore_index > 0
+                                               ? resources.next_semaphore_index
+                                               : static_cast<uint32_t>(resources.semaphores.size());
         submit_info.pSignalSemaphores    = resources.semaphores.data();
         device_table->QueueSubmit(queue_info->handle, 1, &submit_info, VK_NULL_HANDLE);
         resources.next_semaphore_index = 0;
diff --git a/framework/decode/vulkan_replay_consumer_base.h b/framework/decode/vulkan_replay_consumer_base.h
index a922485e16..07a21231e8 100644
--- a/framework/decode/vulkan_replay_consumer_base.h
+++ b/framework/decode/vulkan_replay_consumer_base.h
@@ -1975,19 +1975,19 @@ class VulkanReplayConsumerBase : public VulkanConsumer
     uint32_t frame_warm_up_gpu_load_{ 0 };
     struct WarmUpResources
     {
-        VkDescriptorPool      descriptor_pool{ VK_NULL_HANDLE };
-        VkDescriptorSetLayout descriptor_set_layout{ VK_NULL_HANDLE };
-        VkDescriptorSet       descriptor_set{ VK_NULL_HANDLE };
-        VkPipelineLayout      pipeline_layout{ VK_NULL_HANDLE };
-        VkPipeline            pipeline{ VK_NULL_HANDLE };
-        VkBuffer              buffer{ VK_NULL_HANDLE };
-        VkDeviceMemory        buffer_memory{ VK_NULL_HANDLE };
-        VkShaderModule        shader_module{ VK_NULL_HANDLE };
-        VkCommandPool         command_pool{ VK_NULL_HANDLE };
-        VkCommandBuffer       command_buffer{ VK_NULL_HANDLE };
-        VkFence               fence{ VK_NULL_HANDLE };
+        VkDescriptorPool         descriptor_pool{ VK_NULL_HANDLE };
+        VkDescriptorSetLayout    descriptor_set_layout{ VK_NULL_HANDLE };
+        VkDescriptorSet          descriptor_set{ VK_NULL_HANDLE };
+        VkPipelineLayout         pipeline_layout{ VK_NULL_HANDLE };
+        VkPipeline               pipeline{ VK_NULL_HANDLE };
+        VkBuffer                 buffer{ VK_NULL_HANDLE };
+        VkDeviceMemory           buffer_memory{ VK_NULL_HANDLE };
+        VkShaderModule           shader_module{ VK_NULL_HANDLE };
+        VkCommandPool            command_pool{ VK_NULL_HANDLE };
+        VkCommandBuffer          command_buffer{ VK_NULL_HANDLE };
+        VkFence                  fence{ VK_NULL_HANDLE };
         std::vector<VkSemaphore> semaphores;
-        uint32_t next_semaphore_index{ 0 };
+        uint32_t                 next_semaphore_index{ 0 };
     };
     std::unordered_map<VkDevice, WarmUpResources> warmup_resources_;
 
diff --git a/framework/decode/vulkan_replay_options.h b/framework/decode/vulkan_replay_options.h
index 28485d6765..308753a842 100644
--- a/framework/decode/vulkan_replay_options.h
+++ b/framework/decode/vulkan_replay_options.h
@@ -119,7 +119,7 @@ struct VulkanReplayOptions : public ReplayOptions
     std::vector<util::UintRange> skip_get_fence_ranges;
     bool                         wait_before_present{ false };
     VkFlags                      debug_message_severity{ VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
-                                    VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT };
+                                                         VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT };
 
     // Dumping resources related configurable replay options
     std::vector<BeginCmdBufQueueSubmitPair> BeginCommandBufferQueueSubmit_Indices;
@@ -172,7 +172,7 @@ struct VulkanReplayOptions : public ReplayOptions
 
     void MaybeWaitBeforeFirstSubmit() const;
 
-    bool        render_pass_barrier{ false };
+    bool render_pass_barrier{ false };
 };
 
 GFXRECON_END_NAMESPACE(decode)
diff --git a/framework/util/platform.h b/framework/util/platform.h
index 790029ac2b..d22ab851e5 100644
--- a/framework/util/platform.h
+++ b/framework/util/platform.h
@@ -425,7 +425,7 @@ inline void* GetProcAddress(LibraryHandle handle, const char* name)
 
 inline std::string GetEnv(const char* name)
 {
-    std::string      env_value;
+    std::string env_value;
 
 #if defined(__ANDROID__)
     const prop_info* pi = __system_property_find(name);
@@ -575,7 +575,7 @@ inline bool FileWriteNoLock(const void* buffer, size_t bytes, FILE* stream)
 #else
         write_count = fwrite_unlocked(buffer, bytes, 1, stream);
 #endif
-        err         = ferror(stream);
+        err = ferror(stream);
     } while (write_count < 1 && (err == EWOULDBLOCK || err == EINTR || err == EAGAIN));
     return (write_count == 1 || bytes == 0);
 }
@@ -589,9 +589,9 @@ inline bool FileReadNoLock(void* buffer, size_t bytes, FILE* stream)
 #if defined(__APPLE__) || (defined(__ANDROID__) && (__ANDROID_API__ < 28))
         read_count = fread(buffer, bytes, 1, stream);
 #else
-        read_count  = fread_unlocked(buffer, bytes, 1, stream);
+        read_count = fread_unlocked(buffer, bytes, 1, stream);
 #endif
-        err        = ferror(stream);
+        err = ferror(stream);
     } while (!feof(stream) && read_count < 1 && (err == EWOULDBLOCK || err == EINTR || err == EAGAIN));
     return (read_count == 1 || bytes == 0);
 }
@@ -697,7 +697,7 @@ inline std::string GetCpuAffinity()
     std::string affinity;
 
 #ifdef __linux__
-    cpu_set_t   mask;
+    cpu_set_t mask;
     if (sched_getaffinity(0, sizeof(mask), &mask))
     {
         return affinity;
diff --git a/tools/replay/replay_settings.h b/tools/replay/replay_settings.h
index 53088b5305..596777e305 100644
--- a/tools/replay/replay_settings.h
+++ b/tools/replay/replay_settings.h
@@ -42,7 +42,8 @@ const char kArguments[] =
     "force-windowed,--fwo|--force-windowed-origin,--batching-memory-usage,--measurement-file,--swapchain,--sgfs|--skip-"
     "get-fence-status,--sgfr|--skip-get-fence-ranges,--dump-resources,--dump-resources-dir,--dump-resources-image-"
     "format,pbis,--pcj|--pipeline-creation-jobs,--save-pipeline-cache,--load-pipeline-cache,--quit-after-frame,--"
-    "present-mode,--wait-before-first-submit,--wait-before-first-frame-ms,--sleep-around-gpu-frame-ms,--frame-warm-up-gpu-load,--frame-repeats";
+    "present-mode,--wait-before-first-submit,--wait-before-first-frame-ms,--sleep-around-gpu-frame-ms,--frame-warm-up-"
+    "gpu-load,--frame-repeats";
 
 static void PrintUsage(const char* exe_name)
 {
@@ -389,8 +390,8 @@ static void PrintUsage(const char* exe_name)
 
 static uint32_t GetRepeatFrameNTimes(const gfxrecon::util::ArgumentParser& arg_parser)
 {
-    uint32_t repeat_frame_n_times = 0;
-    const auto& value             = arg_parser.GetArgumentValue(kRepeatFrameNTimesArgument);
+    uint32_t    repeat_frame_n_times = 0;
+    const auto& value                = arg_parser.GetArgumentValue(kRepeatFrameNTimesArgument);
     if (!value.empty())
     {
         repeat_frame_n_times = static_cast<uint32_t>(std::stoi(value));
@@ -400,8 +401,8 @@ static uint32_t GetRepeatFrameNTimes(const gfxrecon::util::ArgumentParser& arg_p
 
 static uint32_t GetWaitBeforeFirstFrameMs(const gfxrecon::util::ArgumentParser& arg_parser)
 {
-    uint32_t wait_before_first_frame_ms = 0;
-    const auto& value                   = arg_parser.GetArgumentValue(kWaitBeforeFirstFrameMsArgument);
+    uint32_t    wait_before_first_frame_ms = 0;
+    const auto& value                      = arg_parser.GetArgumentValue(kWaitBeforeFirstFrameMsArgument);
     if (!value.empty())
     {
         wait_before_first_frame_ms = static_cast<uint32_t>(std::stoi(value));
@@ -411,8 +412,8 @@ static uint32_t GetWaitBeforeFirstFrameMs(const gfxrecon::util::ArgumentParser&
 
 static double GetSleepAroundGpuFrameMs(const gfxrecon::util::ArgumentParser& arg_parser)
 {
-    double sleep_around_gpu_frame_ms = 0.0;
-    const auto& value                = arg_parser.GetArgumentValue(kSleepAroundGpuFrameMsArgument);
+    double      sleep_around_gpu_frame_ms = 0.0;
+    const auto& value                     = arg_parser.GetArgumentValue(kSleepAroundGpuFrameMsArgument);
     if (!value.empty())
     {
         sleep_around_gpu_frame_ms = std::stod(value);
@@ -422,8 +423,8 @@ static double GetSleepAroundGpuFrameMs(const gfxrecon::util::ArgumentParser& arg
 
 static uint32_t GetFrameWarmUpGpuLoad(const gfxrecon::util::ArgumentParser& arg_parser)
 {
-    uint32_t frame_warm_up_gpu_load = 0;
-    const auto& value               = arg_parser.GetArgumentValue(kFrameWarmUpGpuLoadArgument);
+    uint32_t    frame_warm_up_gpu_load = 0;
+    const auto& value                  = arg_parser.GetArgumentValue(kFrameWarmUpGpuLoadArgument);
     if (!value.empty())
     {
         frame_warm_up_gpu_load = static_cast<uint32_t>(std::stoi(value));
diff --git a/tools/tool_settings.h b/tools/tool_settings.h
index c70ae32758..e65d10e16f 100644
--- a/tools/tool_settings.h
+++ b/tools/tool_settings.h
@@ -148,11 +148,11 @@ const char kLoadPipelineCacheArgument[]           = "--load-pipeline-cache";
 const char kCreateNewPipelineCacheOption[]        = "--add-new-pipeline-caches";
 const char kDeduplicateDevice[]                   = "--deduplicate-device";
 const char kWaitBeforeFirstSubmit[]               = "--wait-before-first-submit";
-const char kRepeatFrameNTimesArgument[]          = "--frame-repeats";
-const char kWaitBeforeFirstFrameMsArgument[]     = "--wait-before-first-frame-ms";
-const char kSleepAroundGpuFrameMsArgument[]      = "--sleep-around-gpu-frame-ms";
-const char kFrameWarmUpGpuLoadArgument[]         = "--frame-warm-up-gpu-load";
-const char kRenderPassBarrierArgument[]          = "--render-pass-barrier";
+const char kRepeatFrameNTimesArgument[]           = "--frame-repeats";
+const char kWaitBeforeFirstFrameMsArgument[]      = "--wait-before-first-frame-ms";
+const char kSleepAroundGpuFrameMsArgument[]       = "--sleep-around-gpu-frame-ms";
+const char kFrameWarmUpGpuLoadArgument[]          = "--frame-warm-up-gpu-load";
+const char kRenderPassBarrierArgument[]           = "--render-pass-barrier";
 
 const char kScreenshotIgnoreFrameBoundaryArgument[] = "--screenshot-ignore-FrameBoundaryANDROID";
 

From 7df0216e6a7958a3c22db9552f4947c7a9c79499 Mon Sep 17 00:00:00 2001
From: Oleh Kuznetsov <okuznetsov@google.com>
Date: Fri, 6 Feb 2026 15:58:08 +0000
Subject: [PATCH 5/9] Manual formatting fixes for platform.h as required by CI

---
 framework/util/platform.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/framework/util/platform.h b/framework/util/platform.h
index d22ab851e5..790029ac2b 100644
--- a/framework/util/platform.h
+++ b/framework/util/platform.h
@@ -425,7 +425,7 @@ inline void* GetProcAddress(LibraryHandle handle, const char* name)
 
 inline std::string GetEnv(const char* name)
 {
-    std::string env_value;
+    std::string      env_value;
 
 #if defined(__ANDROID__)
     const prop_info* pi = __system_property_find(name);
@@ -575,7 +575,7 @@ inline bool FileWriteNoLock(const void* buffer, size_t bytes, FILE* stream)
 #else
         write_count = fwrite_unlocked(buffer, bytes, 1, stream);
 #endif
-        err = ferror(stream);
+        err         = ferror(stream);
     } while (write_count < 1 && (err == EWOULDBLOCK || err == EINTR || err == EAGAIN));
     return (write_count == 1 || bytes == 0);
 }
@@ -589,9 +589,9 @@ inline bool FileReadNoLock(void* buffer, size_t bytes, FILE* stream)
 #if defined(__APPLE__) || (defined(__ANDROID__) && (__ANDROID_API__ < 28))
         read_count = fread(buffer, bytes, 1, stream);
 #else
-        read_count = fread_unlocked(buffer, bytes, 1, stream);
+        read_count  = fread_unlocked(buffer, bytes, 1, stream);
 #endif
-        err = ferror(stream);
+        err        = ferror(stream);
     } while (!feof(stream) && read_count < 1 && (err == EWOULDBLOCK || err == EINTR || err == EAGAIN));
     return (read_count == 1 || bytes == 0);
 }
@@ -697,7 +697,7 @@ inline std::string GetCpuAffinity()
     std::string affinity;
 
 #ifdef __linux__
-    cpu_set_t mask;
+    cpu_set_t   mask;
     if (sched_getaffinity(0, sizeof(mask), &mask))
     {
         return affinity;

From ac9049e6fc22b2cebc42fbb0f52743a6dae49b05 Mon Sep 17 00:00:00 2001
From: Oleh Kuznetsov <okuznetsov@google.com>
Date: Fri, 6 Feb 2026 16:11:04 +0000
Subject: [PATCH 6/9] Final formatting pass for C++ files

---
 framework/application/application.cpp |  5 ++---
 framework/application/application.h   |  5 +----
 framework/decode/file_processor.h     | 10 +++++-----
 framework/util/file_input_stream.h    | 11 ++++-------
 tools/replay/android_main.cpp         |  4 ++--
 5 files changed, 14 insertions(+), 21 deletions(-)

diff --git a/framework/application/application.cpp b/framework/application/application.cpp
index 03b496f38a..3ca0ebb850 100644
--- a/framework/application/application.cpp
+++ b/framework/application/application.cpp
@@ -65,8 +65,7 @@ Application::Application(const std::string&     name,
                          decode::FileProcessor* file_processor,
                          const std::string&     cli_wsi_extension,
                          void*                  platform_specific_wsi_data) :
-    name_(name),
-    file_processor_(file_processor), running_(false), paused_(false), pause_frame_(0),
+    name_(name), file_processor_(file_processor), running_(false), paused_(false), pause_frame_(0),
     cli_wsi_extension_(cli_wsi_extension), fps_info_(nullptr)
 {
     if (!cli_wsi_extension_.empty())
@@ -246,7 +245,7 @@ void Application::ProcessEvents(bool wait_for_input)
         bool        activeWsiContext  = wsi_context && !wsi_context->GetWindows().empty();
         auto        pWindowFactory    = wsi_context ? wsi_context->GetWindowFactory() : nullptr;
         bool        androidWsiContext = pWindowFactory && (strcmp(pWindowFactory->GetSurfaceExtensionName(),
-                                                           VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0);
+                                                                  VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0);
         if (activeWsiContext || androidWsiContext)
         {
             wsi_context->ProcessEvents(wait_for_input);
diff --git a/framework/application/application.h b/framework/application/application.h
index a0a9b43a52..00b428f806 100644
--- a/framework/application/application.h
+++ b/framework/application/application.h
@@ -89,10 +89,7 @@ class Application final
 
     void StopRunning() { running_ = false; }
 
-    uint32_t GetCurrentFrameNumber() const
-    {
-        return file_processor_->GetCurrentFrameNumber();
-    }
+    uint32_t GetCurrentFrameNumber() const { return file_processor_->GetCurrentFrameNumber(); }
 
   private:
     // clang-format off
diff --git a/framework/decode/file_processor.h b/framework/decode/file_processor.h
index 89073d6306..2e04fd1144 100644
--- a/framework/decode/file_processor.h
+++ b/framework/decode/file_processor.h
@@ -322,14 +322,14 @@ class FileProcessor
         void operator()(const ExecuteBlocksFromFileArgs& execute_blocks)
         {
             // The block and marker type are implied by the Args type
-            success            = file_processor_.ProcessExecuteBlocksFromFile(execute_blocks);
+            success = file_processor_.ProcessExecuteBlocksFromFile(execute_blocks);
         }
 
         // State Marker control
         void operator()(const StateBeginMarkerArgs& state_begin)
         {
             // The block and marker type are implied by the Args type
-            success            = true;
+            success = true;
             file_processor_.ProcessStateBeginMarker(state_begin);
         }
 
@@ -344,7 +344,7 @@ class FileProcessor
         void operator()(const AnnotationArgs& annotation)
         {
             // The block and marker type are implied by the Command type
-            success            = true;
+            success = true;
             file_processor_.ProcessAnnotation(annotation);
         }
 
@@ -352,7 +352,7 @@ class FileProcessor
         void operator()(const Args&)
         {
             // The default behavior for a Visit is a successful, non-frame-delimiter
-            success            = true;
+            success = true;
         }
 
         // Avoid unpacking the Arg from it's store in the Arg specific overloads
@@ -433,7 +433,7 @@ class FileProcessor
     struct ActiveFileContext
     {
         ActiveFileContext(FileInputStreamPtr&& active_file_, bool execute_til_eof_ = false) :
-            active_file(std::move(active_file_)), execute_till_eof(execute_til_eof_){};
+            active_file(std::move(active_file_)), execute_till_eof(execute_til_eof_) {};
 
         FileInputStreamPtr active_file;
         uint32_t           remaining_commands{ 0 };
diff --git a/framework/util/file_input_stream.h b/framework/util/file_input_stream.h
index 3cf921f3ee..c7ccd0b41c 100644
--- a/framework/util/file_input_stream.h
+++ b/framework/util/file_input_stream.h
@@ -79,25 +79,22 @@ class FStreamFileInputStream
 #if FILE_INPUT_STREAM_USE_FREAD
     constexpr static size_t kReadAheadBufferSize = 1024U;
 #else
-    constexpr static size_t        kReadAheadAlignment  = 4096U;
-    constexpr static size_t        kReadAheadBufferSize = 2U * kReadAheadAlignment;
+    constexpr static size_t kReadAheadAlignment  = 4096U;
+    constexpr static size_t kReadAheadBufferSize = 2U * kReadAheadAlignment;
 #endif
 
     // Design assumes kMaxPeekBytes << kReadAheadBufferSize, as we move data when peeking would
     // exceed the read ahead buffer size, and we want to avoid moving large amounts of data.
     constexpr static size_t kMaxPeekBytes = 32U;
 
-    size_t GetMaxPeekBytes() const noexcept
-    {
-        return kMaxPeekBytes;
-    }
+    size_t GetMaxPeekBytes() const noexcept { return kMaxPeekBytes; }
 
   protected:
     bool   HasReadAhead() const noexcept;
     size_t ReadFromReadAheadBuffer(void* buffer, size_t bytes);
     size_t ReadBytesImpl(void* buffer, size_t bytes);
 
-    std::string   filename_;
+    std::string filename_;
 
 #if FILE_INPUT_STREAM_USE_FREAD
     FILE*                                  fd_{ nullptr };
diff --git a/tools/replay/android_main.cpp b/tools/replay/android_main.cpp
index 04913560cc..cf66ba3757 100644
--- a/tools/replay/android_main.cpp
+++ b/tools/replay/android_main.cpp
@@ -68,8 +68,8 @@ const char kLayerProperty[]      = "debug.vulkan.layers";
 
 const int32_t kSwipeDistance = 200;
 
-void        ProcessAppCmd(struct android_app* app, int32_t cmd);
-int32_t     ProcessInputEvent(struct android_app* app, AInputEvent* event);
+void    ProcessAppCmd(struct android_app* app, int32_t cmd);
+int32_t ProcessInputEvent(struct android_app* app, AInputEvent* event);
 
 static std::unique_ptr<gfxrecon::decode::FileProcessor> file_processor;
 

From 5a3601167f46f812bfb956f3db93692ae3e596b1 Mon Sep 17 00:00:00 2001
From: Oleh Kuznetsov <okuznetsov@google.com>
Date: Mon, 9 Feb 2026 14:41:37 +0000
Subject: [PATCH 7/9] Manual formatting fixes for file_input_stream.h as
 required by CI

---
 framework/util/file_input_stream.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/framework/util/file_input_stream.h b/framework/util/file_input_stream.h
index c7ccd0b41c..53a32d4efe 100644
--- a/framework/util/file_input_stream.h
+++ b/framework/util/file_input_stream.h
@@ -87,7 +87,10 @@ class FStreamFileInputStream
     // exceed the read ahead buffer size, and we want to avoid moving large amounts of data.
     constexpr static size_t kMaxPeekBytes = 32U;
 
-    size_t GetMaxPeekBytes() const noexcept { return kMaxPeekBytes; }
+    size_t GetMaxPeekBytes() const noexcept
+    {
+        return kMaxPeekBytes;
+    }
 
   protected:
     bool   HasReadAhead() const noexcept;

From 915f1778f05228a6e2b8730eabc867ea10dff645 Mon Sep 17 00:00:00 2001
From: Oleh Kuznetsov <okuznetsov@google.com>
Date: Mon, 9 Feb 2026 15:36:34 +0000
Subject: [PATCH 8/9] Fix Windows build: add FileTell(int) overload for WIN32

---
 framework/util/platform.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/framework/util/platform.h b/framework/util/platform.h
index 790029ac2b..29a8523138 100644
--- a/framework/util/platform.h
+++ b/framework/util/platform.h
@@ -246,6 +246,11 @@ inline int64_t FileTell(FILE* stream)
     return _ftelli64(stream);
 }
 
+inline int64_t FileTell(int fd)
+{
+    return _lseeki64(fd, 0, FileSeekCurrent);
+}
+
 inline bool FileSeek(FILE* stream, int64_t offset, FileSeekOrigin origin)
 {
     int32_t result = _fseeki64(stream, offset, origin);

From 1cf552d66228065170e0e1bb2dff4f485ce53d50 Mon Sep 17 00:00:00 2001
From: Oleh Kuznetsov <okuznetsov@google.com>
Date: Mon, 9 Feb 2026 18:39:48 +0000
Subject: [PATCH 9/9] Fix Windows build: replace usleep with
 std::this_thread::sleep_for and remove unistd.h

---
 framework/decode/vulkan_replay_consumer_base.cpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/framework/decode/vulkan_replay_consumer_base.cpp b/framework/decode/vulkan_replay_consumer_base.cpp
index 0d901197fd..570525da38 100644
--- a/framework/decode/vulkan_replay_consumer_base.cpp
+++ b/framework/decode/vulkan_replay_consumer_base.cpp
@@ -72,7 +72,8 @@
 #include <future>
 #include <span>
 #include <iterator>
-#include <unistd.h>
+#include <chrono>
+#include <thread>
 
 #if defined(__ANDROID__)
 #include <android/trace.h>
@@ -4137,14 +4138,14 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
         if (first_time && wait_before_first_frame_min_ms_ > 0)
         {
             ATrace_beginSection("FirstTimeWait");
-            usleep(wait_before_first_frame_min_ms_ * 1000);
+            std::this_thread::sleep_for(std::chrono::milliseconds(wait_before_first_frame_min_ms_));
             ATrace_endSection();
             first_time = false;
         }
         if (sleep_around_gpu_frame_ms_ > 0.0)
         {
             // WaitDevicesIdle(); // Need to implement or check availability
-            usleep(static_cast<useconds_t>(sleep_around_gpu_frame_ms_ * 1000));
+            std::this_thread::sleep_for(std::chrono::microseconds(static_cast<int64_t>(sleep_around_gpu_frame_ms_ * 1000.0)));
         }
 
         if (frame_warm_up_gpu_load_ > 0)
@@ -4155,7 +4156,7 @@ VkResult VulkanReplayConsumerBase::OverrideQueueSubmit(PFN_vkQueueSubmit
         ATrace_beginSection("GFXRFrame");
         if (sleep_around_gpu_frame_ms_ > 0.0)
         {
-            usleep(static_cast<useconds_t>(sleep_around_gpu_frame_ms_ * 1000));
+            std::this_thread::sleep_for(std::chrono::microseconds(static_cast<int64_t>(sleep_around_gpu_frame_ms_ * 1000.0)));
         }
     }
 
@@ -8420,7 +8421,7 @@ VulkanReplayConsumerBase::OverrideQueuePresentKHR(PFN_vkQueuePresentKHR
                 auto device_table = GetDeviceTable(device_info->handle);
                 device_table->DeviceWaitIdle(device_info->handle);
             }
-            usleep(static_cast<useconds_t>(sleep_around_gpu_frame_ms_ * 1000));
+            std::this_thread::sleep_for(std::chrono::microseconds(static_cast<int64_t>(sleep_around_gpu_frame_ms_ * 1000.0)));
         }
         ATrace_endSection();
     }