From b0fd2cbc500576e9b7421f27619562708cb545f0 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 21 Jun 2024 05:20:39 -0500
Subject: [PATCH 001/129] Create a basic outline

---
 CMakeLists.txt                 |   2 +
 include/gui/project/window.hpp | 101 +++++++++++++++++++++++++++++++++
 src/gui/logging/window.cpp     |   1 +
 src/gui/project/window.cpp     |  31 ++++++++++
 4 files changed, 135 insertions(+)
 create mode 100644 include/gui/project/window.hpp
 create mode 100644 src/gui/project/window.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b9ebcc1c..2028e3fc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -60,6 +60,8 @@ file(GLOB TOOLBOX_SRC
     "include/gui/layer/*.hpp"
     "src/gui/pad/*.cpp"
     "include/gui/pad/*.hpp"
+    "src/gui/project/*.cpp"
+    "include/gui/project/*.hpp"
     "src/gui/widget/*.cpp"
     "include/gui/widget/*.hpp"
     "src/image/*.cpp"
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
new file mode 100644
index 00000000..76c280b4
--- /dev/null
+++ b/include/gui/project/window.hpp
@@ -0,0 +1,101 @@
+#pragma once
+
+#include <filesystem>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "core/memory.hpp"
+#include "fsystem.hpp"
+#include "objlib/object.hpp"
+#include "objlib/template.hpp"
+#include "scene/scene.hpp"
+#include "smart_resource.hpp"
+
+#include "core/clipboard.hpp"
+#include "game/task.hpp"
+#include "gui/event/event.hpp"
+#include "gui/image/imagepainter.hpp"
+#include "gui/window.hpp"
+
+#include <imgui.h>
+
+namespace Toolbox::UI {
+
+    class ProjectViewWindow final : public ImWindow {
+    public:
+        ProjectViewWindow(const std::string &name);
+        ~ProjectViewWindow() = default;
+
+    protected:
+        void onRenderMenuBar() override;
+        void onRenderBody(TimeStep delta_time) override;
+
+        void renderProjectTreeView();
+        void renderProjectFolderView();
+        void renderProjectFolderButton();
+        void renderProjectFileButton();
+
+    public:
+        ImGuiWindowFlags flags() const override {
+            return ImWindow::flags() | ImGuiWindowFlags_MenuBar;
+        }
+
+        const ImGuiWindowClass *windowClass() const override {
+            if (parent() && parent()->windowClass()) {
+                return parent()->windowClass();
+            }
+
+            ImGuiWindow *currentWindow           = ImGui::GetCurrentWindow();
+            m_window_class.ClassId               = (ImGuiID)getUUID();
+            m_window_class.ParentViewportId      = currentWindow->ViewportId;
+            m_window_class.DockingAllowUnclassed = true;
+            m_window_class.DockingAlwaysTabBar   = false;
+            return nullptr;
+        }
+
+        std::optional<ImVec2> minSize() const override {
+            return {
+                {600, 400}
+            };
+        }
+
+        [[nodiscard]] std::string context() const override {
+            if (!m_project_root)
+                return "(unknown)";
+            return m_project_root->string();
+        }
+
+        [[nodiscard]] bool unsaved() const override { return false; }
+
+        // Returns the supported file types, empty string is designed for a folder.
+        [[nodiscard]] std::vector<std::string> extensions() const override {
+            return {};
+        }
+
+        [[nodiscard]] bool onLoadData(const std::filesystem::path& path) override {
+            m_project_root = path;
+            return true;
+        }
+        [[nodiscard]] bool onSaveData(std::optional<std::filesystem::path> path) override {
+            return true;
+        }
+
+        void onAttach() override;
+        void onDetach() override;
+        void onImGuiUpdate(TimeStep delta_time) override;
+        void onContextMenuEvent(RefPtr<ContextMenuEvent> ev) override;
+        void onDragEvent(RefPtr<DragEvent> ev) override;
+        void onDropEvent(RefPtr<DropEvent> ev) override;
+
+    private:
+        fs_path m_project_root;
+
+        // TODO: Have filesystem model.
+        std::unordered_map<std::string, ImageHandle> m_icon_map;
+        ImagePainter m_icon_painter;
+    };
+
+}  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/gui/logging/window.cpp b/src/gui/logging/window.cpp
index 261c0003..107fd413 100644
--- a/src/gui/logging/window.cpp
+++ b/src/gui/logging/window.cpp
@@ -2,6 +2,7 @@
 
 #include "gui/font.hpp"
 #include "gui/logging/window.hpp"
+#include "window.hpp"
 
 static std::string s_message_pool;
 
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
new file mode 100644
index 00000000..97152c90
--- /dev/null
+++ b/src/gui/project/window.cpp
@@ -0,0 +1,31 @@
+#include "gui/project/window.hpp"
+
+namespace Toolbox::UI {
+
+    ProjectViewWindow::ProjectViewWindow(const std::string &name) : ImWindow(name) {}
+
+    void ProjectViewWindow::onRenderMenuBar() {}
+
+    void ProjectViewWindow::onRenderBody(TimeStep delta_time) {}
+
+    void ProjectViewWindow::renderProjectTreeView() {}
+
+    void ProjectViewWindow::renderProjectFolderView() {}
+
+    void ProjectViewWindow::renderProjectFolderButton() {}
+
+    void ProjectViewWindow::renderProjectFileButton() {}
+
+    void ProjectViewWindow::onAttach() {}
+
+    void ProjectViewWindow::onDetach() {}
+
+    void ProjectViewWindow::onImGuiUpdate(TimeStep delta_time) {}
+
+    void ProjectViewWindow::onContextMenuEvent(RefPtr<ContextMenuEvent> ev) {}
+
+    void ProjectViewWindow::onDragEvent(RefPtr<DragEvent> ev) {}
+
+    void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {}
+
+} // namespace Toolbox::UI
\ No newline at end of file

From 004a58a76796aa508bd85a7eb79a7dc0f0e5845d Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 21 Jun 2024 05:21:14 -0500
Subject: [PATCH 002/129] Context fix

---
 include/gui/project/window.hpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 76c280b4..f4c9f9ce 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -63,9 +63,7 @@ namespace Toolbox::UI {
         }
 
         [[nodiscard]] std::string context() const override {
-            if (!m_project_root)
-                return "(unknown)";
-            return m_project_root->string();
+            return m_project_root.string();
         }
 
         [[nodiscard]] bool unsaved() const override { return false; }

From 70867eb2218eab92ac882afb289c19f3681b04c4 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 21 Jun 2024 06:53:01 -0500
Subject: [PATCH 003/129] Create filesystem model outline

---
 include/model/fsmodel.hpp | 128 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 include/model/fsmodel.hpp

diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
new file mode 100644
index 00000000..5c7c63e7
--- /dev/null
+++ b/include/model/fsmodel.hpp
@@ -0,0 +1,128 @@
+#pragma once
+
+#include <algorithm>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "core/mimedata/mimedata.hpp"
+#include "fsystem.hpp"
+#include "image/imagehandle.hpp"
+#include "unique.hpp"
+
+namespace Toolbox {
+
+    enum class ModelSortOrder {
+        SORT_ASCENDING,
+        SORT_DESCENDING,
+    };
+
+    class ModelIndex : public IUnique {
+    public:
+        ModelIndex() = default;
+        ModelIndex(int64_t row, int64_t column, UUID64 model_uuid)
+            : m_row(row), m_column(column), m_model_uuid(model_uuid) {}
+
+        bool isValid() const { return m_row >= 0 && m_column >= 0 && m_model_uuid != 0; }
+
+        template <typename T = void *> [[nodiscard]] data() const {
+            return reinterpret_cast<T *>(m_user_data);
+        }
+        void setData(void *data) { m_user_data = data; }
+
+        [[nodiscard]] UUID64 getUUID() const override { return m_uuid; }
+        [[nodiscard]] UUID64 getModelUUID() const { return m_model_uuid; }
+
+    private:
+        UUID64 m_uuid;
+        UUID64 m_model_uuid = 0;
+
+        int64_t m_row    = -1;
+        int64_t m_column = -1;
+
+        void *m_user_data = nullptr;
+    };
+
+    class FileSystemModel {
+    public:
+        enum class Options {
+            DISABLE_WATCHDOG = BIT(0),
+            DISABLE_SYMLINKS = BIT(1),
+        };
+        TOOLBOX_BITWISE_ENUM(Options)
+
+    public:
+        FileSystemModel()  = default;
+        ~FileSystemModel() = default;
+
+        const fs_path &getRoot() const &;
+        void setRoot(const fs_path &path);
+
+        const std::string &getFilter() const &;
+        void setFilter(const std::string &filter);
+
+        Options getOptions() const;
+        void setOptions(Options options);
+
+        bool isReadOnly() const;
+        void setReadOnly();
+
+        bool isDirectory(const ModelIndex &index);
+        bool isFile(const ModelIndex &index);
+        bool isArchive(const ModelIndex &index);
+
+        size_t getFileSize(const ModelIndex &index);
+        size_t getDirSize(const ModelIndex &index, bool recursive);
+
+        const ImageHandle &getIcon(const ModelIndex &index) const &;
+        Filesystem::file_time_type getLastModified(const ModelIndex &index) const;
+        Filesystem::perms getPermissions(const ModelIndex &index) const;
+        const Filesystem::file_status &getStatus(const ModelIndex &index) const &;
+
+        std::string getType(const ModelIndex &index) const &;
+
+        ModelIndex mkdir(const ModelIndex &parent, const std::string &name);
+        ModelIndex touch(const ModelIndex &parent, const std::string &name);
+
+        bool rmdir(const ModelIndex &index);
+        bool remove(const ModelIndex &index);
+
+    public:
+        const ModelIndex &getIndex(const fs_path &path) const &;
+        const ModelIndex &getIndex(int64_t row, int64_t column,
+                                   ModelIndex &parent = ModelIndex()) const &;
+        const fs_path &getPath(const ModelIndex &index) const &;
+
+        const Modelindex &getParent(const ModelIndex &index) const &;
+        const ModelIndex &getSibling(int64_t row, int64_t column, const ModelIndex &index);
+
+        size_t getColumnCount(const ModelIndex &index) const;
+        size_t getRowCount(const ModelIndex &index) const;
+
+        bool hasChildren(const ModelIndex &parent = ModelIndex()) const;
+
+        ScopePtr<MimeData> createMimeData(const std::vector<ModelIndex> &indexes) const;
+        std::vector<std::string> getSupportedMimeTypes() const;
+
+        bool canFetchMore(const ModelIndex &index);
+        void fetchMore(const ModelIndex &index););
+
+        void sort(int64_t column, ModelSortOrder order = ModelSortOrder::SORT_ASCENDING);
+
+    protected:
+        void cacheIndex(ModelIndex &index);
+        void cacheFolder(ModelIndex &index);
+        void cacheFile(ModelIndex &index);
+        void cacheArchive(ModelIndex &index);
+
+        const ModelIndex &getParentArchive(const ModelIndex &index);
+
+    private:
+        fs_path m_root_path;
+    };
+
+}  // namespace Toolbox
\ No newline at end of file

From 87195701ef8f4ac4c0b375c605366b03bf405d3a Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Wed, 10 Jul 2024 00:13:31 -0500
Subject: [PATCH 004/129] Fix path issue for Dolphin integration

---
 src/dolphin/hook.cpp       | 2 +-
 src/gui/logging/window.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/dolphin/hook.cpp b/src/dolphin/hook.cpp
index 709a7ce7..55cb5dae 100644
--- a/src/dolphin/hook.cpp
+++ b/src/dolphin/hook.cpp
@@ -122,7 +122,7 @@ namespace Toolbox::Dolphin {
         }
 
         std::string dolphin_args =
-            std::format("-e {}/sys/main.dol -d -c -a HLE", application.getProjectRoot().string());
+            std::format("-e \"{}/sys/main.dol\" -d -c -a HLE", application.getProjectRoot().string());
 
         auto process_result = Platform::CreateExProcess(settings.m_dolphin_path, dolphin_args);
         if (!process_result) {
diff --git a/src/gui/logging/window.cpp b/src/gui/logging/window.cpp
index 107fd413..8bf21f66 100644
--- a/src/gui/logging/window.cpp
+++ b/src/gui/logging/window.cpp
@@ -2,7 +2,7 @@
 
 #include "gui/font.hpp"
 #include "gui/logging/window.hpp"
-#include "window.hpp"
+#include "gui/window.hpp"
 
 static std::string s_message_pool;
 

From 2868efb627e5b702674b97159300154bfbab9585 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Wed, 4 Sep 2024 23:50:15 -0500
Subject: [PATCH 005/129] Current progress

---
 Templates/KeyChest.json  | 67 ++++++++++++++++++++++++++++++++++++++++
 Templates/KeyFollow.json | 67 ++++++++++++++++++++++++++++++++++++++++
 src/gui/pad/recorder.cpp |  4 ++-
 src/gui/scene/window.cpp | 36 +++++++++++++++------
 4 files changed, 164 insertions(+), 10 deletions(-)
 create mode 100644 Templates/KeyChest.json
 create mode 100644 Templates/KeyFollow.json

diff --git a/Templates/KeyChest.json b/Templates/KeyChest.json
new file mode 100644
index 00000000..c5c5a7a7
--- /dev/null
+++ b/Templates/KeyChest.json
@@ -0,0 +1,67 @@
+{
+    "Key Chest": {
+        "Enums": {},
+        "Structs": {
+            "LightInfo": {
+                "ID": {
+                    "Type": "INT",
+                    "ArraySize": 1
+                },
+                "Name": {
+                    "Type": "STRING",
+                    "ArraySize": 1
+                }
+            }
+        },
+        "Members": {
+            "Transform": {
+                "Type": "TRANSFORM",
+                "ArraySize": 1
+            },
+            "Character": {
+                "Type": "STRING",
+                "ArraySize": 1
+            },
+            "LightCount": {
+                "Type": "U32",
+                "ArraySize": 1
+            },
+            "LightArray": {
+                "Type": "LightInfo",
+                "ArraySize": "LightCount"
+            },
+            "Model": {
+                "Type": "STRING",
+                "ArraySize": 1
+            }
+        },
+        "Wizard": {
+            "Default": {
+                "Transform": [
+                      [
+                          0,
+                          0,
+                          0
+                      ],
+                      [
+                          0,
+                          0,
+                          0
+                      ],
+                      [
+                          1,
+                          1,
+                          1
+                      ]
+                  ],
+                  "Character": "KeyChest キャラ",
+                  "LightCount": 0,
+                  "LightArray": {
+                      "ID": 0,
+                      "Name": "LightX"
+                  },
+                  "Model": "key_chest"
+              }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Templates/KeyFollow.json b/Templates/KeyFollow.json
new file mode 100644
index 00000000..fde51879
--- /dev/null
+++ b/Templates/KeyFollow.json
@@ -0,0 +1,67 @@
+{
+    "Key Chest": {
+        "Enums": {},
+        "Structs": {
+            "LightInfo": {
+                "ID": {
+                    "Type": "INT",
+                    "ArraySize": 1
+                },
+                "Name": {
+                    "Type": "STRING",
+                    "ArraySize": 1
+                }
+            }
+        },
+        "Members": {
+            "Transform": {
+                "Type": "TRANSFORM",
+                "ArraySize": 1
+            },
+            "Character": {
+                "Type": "STRING",
+                "ArraySize": 1
+            },
+            "LightCount": {
+                "Type": "U32",
+                "ArraySize": 1
+            },
+            "LightArray": {
+                "Type": "LightInfo",
+                "ArraySize": "LightCount"
+            },
+            "Model": {
+                "Type": "STRING",
+                "ArraySize": 1
+            }
+        },
+        "Wizard": {
+            "Default": {
+                "Transform": [
+                      [
+                          0,
+                          0,
+                          0
+                      ],
+                      [
+                          0,
+                          0,
+                          0
+                      ],
+                      [
+                          1,
+                          1,
+                          1
+                      ]
+                  ],
+                  "Character": "KeyFollow キャラ",
+                  "LightCount": 0,
+                  "LightArray": {
+                      "ID": 0,
+                      "Name": "LightX"
+                  },
+                  "Model": "key_follow"
+              }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/gui/pad/recorder.cpp b/src/gui/pad/recorder.cpp
index 35773588..3123bac5 100644
--- a/src/gui/pad/recorder.cpp
+++ b/src/gui/pad/recorder.cpp
@@ -333,10 +333,12 @@ namespace Toolbox {
 
         Toolbox::Filesystem::create_directories(folder_path)
             .and_then([&](bool created) {
+                #if 0
                 if (!created) {
                     return make_fs_error<bool>(std::error_code(),
-                                               {"[PAD RECORD] Failed to create folder."});
+                                               {"[PAD RECORD] Folder already exists."});
                 }
+                #endif
                 return saveToFolder_(folder_path);
             })
             .and_then([&](bool success) {
diff --git a/src/gui/scene/window.cpp b/src/gui/scene/window.cpp
index 63f76841..fe0fde19 100644
--- a/src/gui/scene/window.cpp
+++ b/src/gui/scene/window.cpp
@@ -162,6 +162,11 @@ namespace Toolbox::UI {
     bool SceneWindow::onSaveData(std::optional<std::filesystem::path> path) {
         std::filesystem::path root_path;
 
+        if (!m_current_scene) {
+            TOOLBOX_ERROR("(SCENE) Failed to save the scene due to lack of a scene instance.");
+            return false;
+        }
+
         if (!path) {
             auto opt_path = m_current_scene->rootPath();
             if (!opt_path) {
@@ -239,6 +244,10 @@ namespace Toolbox::UI {
             m_is_game_edit_mode = false;
         }
 
+        if (!m_current_scene) {
+            return;
+        }
+
         std::vector<RefPtr<Rail::RailNode>> rendered_nodes;
         for (auto &rail : m_current_scene->getRailData().rails()) {
             if (!m_rail_visible_map[rail->getUUID()])
@@ -369,10 +378,15 @@ namespace Toolbox::UI {
         case SCENE_CREATE_RAIL_EVENT: {
             auto event = std::static_pointer_cast<SceneCreateRailEvent>(ev);
             if (event) {
-                const Rail::Rail &rail = event->getRail();
-                m_current_scene->getRailData().addRail(rail);
-                m_rail_visible_map[rail.getUUID()] = true;
-                ev->accept();
+                if (m_current_scene) {
+                    const Rail::Rail &rail = event->getRail();
+                    m_current_scene->getRailData().addRail(rail);
+                    m_rail_visible_map[rail.getUUID()] = true;
+                    ev->accept();
+                } else {
+                    TOOLBOX_ERROR("Failed to create rail due to lack of a scene instance.");
+                    ev->ignore();
+                }
             }
             break;
         }
@@ -431,8 +445,8 @@ void SceneWindow::renderHierarchy() {
 
         // Render Objects
 
-        if (m_current_scene != nullptr) {
-            auto root = m_current_scene->getObjHierarchy().getRoot();
+        if (m_current_scene) {
+            RefPtr<Object::GroupSceneObject> root = m_current_scene->getObjHierarchy().getRoot();
             renderTree(0, root);
         }
 
@@ -440,8 +454,8 @@ void SceneWindow::renderHierarchy() {
         ImGui::Text("Scene Info");
         ImGui::Separator();
 
-        if (m_current_scene != nullptr) {
-            auto root = m_current_scene->getTableHierarchy().getRoot();
+        if (m_current_scene) {
+            RefPtr<Object::GroupSceneObject> root = m_current_scene->getTableHierarchy().getRoot();
             renderTree(0, root);
         }
     }
@@ -990,6 +1004,10 @@ void SceneWindow::reassignAllActorPtrs(u32 param) {
 }
 
 void SceneWindow::renderRailEditor() {
+    if (!m_current_scene) {
+        return;
+    }
+
     const std::string rail_editor_str = ImWindowComponentTitle(*this, "Rail Editor");
 
     const ImGuiTreeNodeFlags rail_flags = ImGuiTreeNodeFlags_OpenOnArrow |
@@ -1215,7 +1233,7 @@ void SceneWindow::renderScene(TimeStep delta_time) {
     std::vector<J3DLight> lights;
 
     // perhaps find a way to limit this so it only happens when we need to re-render?
-    if (m_current_scene != nullptr) {
+    if (m_current_scene) {
         if (m_update_render_objs || !settings.m_is_rendering_simple) {
             m_renderables.clear();
             auto perform_result = m_current_scene->getObjHierarchy().getRoot()->performScene(

From 8fb0202bd4eb8c4983bfd9b09eee193f38afe27c Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sat, 7 Sep 2024 04:59:47 -0500
Subject: [PATCH 006/129] Migrate work into a ProjectManager

---
 CMakeLists.txt              |  2 ++
 include/fsystem.hpp         |  2 +-
 include/gui/application.hpp | 10 +++---
 include/model/fsmodel.hpp   |  2 +-
 include/project/project.hpp | 35 +++++++++++++++++++
 include/scene/layout.hpp    |  2 +-
 include/scene/scene.hpp     | 24 ++++++++++++-
 src/dolphin/hook.cpp        |  3 +-
 src/gui/application.cpp     | 17 ++--------
 src/objlib/template.cpp     | 52 +++++++++++++++-------------
 src/project/project.cpp     | 46 +++++++++++++++++++++++++
 src/scene/layout.cpp        | 26 +++++++-------
 src/scene/scene.cpp         | 68 ++++++++++++++++++-------------------
 13 files changed, 194 insertions(+), 95 deletions(-)
 create mode 100644 include/project/project.hpp
 create mode 100644 src/project/project.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2028e3fc..3677621b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -72,6 +72,8 @@ file(GLOB TOOLBOX_SRC
     "include/pad/*.hpp"
     "src/platform/*.cpp"
     "include/platform/*.hpp"
+    "src/project/*.cpp"
+    "include/project/*.hpp"
     "src/rail/*.cpp"
     "include/rail/*.hpp"
     "src/rarc/*.cpp"
diff --git a/include/fsystem.hpp b/include/fsystem.hpp
index 1acc8225..3b217a6b 100644
--- a/include/fsystem.hpp
+++ b/include/fsystem.hpp
@@ -380,7 +380,7 @@ namespace Toolbox {
             if (result) {
                 return result;
             }
-            if (ec) {
+            if (ec && ec != std::errc::no_such_file_or_directory) {
                 return make_fs_error<bool>(ec);
             }
             return result;
diff --git a/include/gui/application.hpp b/include/gui/application.hpp
index 4daa078f..bb3d9349 100644
--- a/include/gui/application.hpp
+++ b/include/gui/application.hpp
@@ -22,6 +22,8 @@
 #include "core/clipboard.hpp"
 #include "dolphin/process.hpp"
 
+#include "project/project.hpp"
+
 #include "scene/layout.hpp"
 
 using namespace Toolbox::Dolphin;
@@ -116,7 +118,8 @@ namespace Toolbox {
         DolphinCommunicator &getDolphinCommunicator() { return m_dolphin_communicator; }
         Game::TaskCommunicator &getTaskCommunicator() { return m_task_communicator; }
 
-        std::filesystem::path getProjectRoot() const { return m_project_root; }
+        ProjectManager &getProjectManager() { return m_project_manager; }
+        const ProjectManager &getProjectManager() const { return m_project_manager; }
         
 
         void registerDolphinOverlay(UUID64 scene_uuid, const std::string &name,
@@ -155,12 +158,11 @@ namespace Toolbox {
         TypedDataClipboard<SelectionNodeInfo<Rail::Rail>> m_rail_clipboard;
         TypedDataClipboard<SelectionNodeInfo<Rail::RailNode>> m_rail_node_clipboard;
 
-        std::filesystem::path m_project_root = std::filesystem::current_path();
+        ProjectManager m_project_manager;
+
         std::filesystem::path m_load_path    = std::filesystem::current_path();
         std::filesystem::path m_save_path    = std::filesystem::current_path();
 
-        ScopePtr<Scene::SceneLayoutManager> m_scene_layout_manager;
-
         GLFWwindow *m_render_window;
         std::vector<RefPtr<ImWindow>> m_windows;
 
diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index 5c7c63e7..49d30be7 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -109,7 +109,7 @@ namespace Toolbox {
         std::vector<std::string> getSupportedMimeTypes() const;
 
         bool canFetchMore(const ModelIndex &index);
-        void fetchMore(const ModelIndex &index););
+        void fetchMore(const ModelIndex &index);
 
         void sort(int64_t column, ModelSortOrder order = ModelSortOrder::SORT_ASCENDING);
 
diff --git a/include/project/project.hpp b/include/project/project.hpp
new file mode 100644
index 00000000..90735e3b
--- /dev/null
+++ b/include/project/project.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <string>
+
+#include "fsystem.hpp"
+#include "scene/layout.hpp"
+
+namespace Toolbox {
+
+    class ProjectManager {
+    public:
+        ProjectManager()                       = default;
+        ProjectManager(const ProjectManager &) = delete;
+        ProjectManager(ProjectManager &&)      = default;
+
+        ~ProjectManager() = default;
+
+        bool isInitialized();
+        bool loadProjectFolder(const fs_path &path);
+
+        fs_path getProjectFolder() const;
+        Scene::SceneLayoutManager &getSceneLayoutManager();
+        const Scene::SceneLayoutManager &getSceneLayoutManager() const;
+
+        ProjectManager &operator=(const ProjectManager &) = delete;
+        ProjectManager &operator=(ProjectManager &&)      = default;
+
+    private:
+        bool m_is_initialized;
+        fs_path m_project_folder;
+
+        Scene::SceneLayoutManager m_scene_layout_manager;
+    };
+
+}  // namespace Toolbox
\ No newline at end of file
diff --git a/include/scene/layout.hpp b/include/scene/layout.hpp
index 4e88c97c..ac95a2d1 100644
--- a/include/scene/layout.hpp
+++ b/include/scene/layout.hpp
@@ -38,7 +38,7 @@ namespace Toolbox::Scene {
         bool operator==(const SceneLayoutManager &) const = default;
 
     private:
-        ScopePtr<ObjectHierarchy> m_scene_layout;
+        ObjectHierarchy m_scene_layout;
     };
 
 }  // namespace Toolbox::Scene
\ No newline at end of file
diff --git a/include/scene/scene.hpp b/include/scene/scene.hpp
index ff910de7..b3a2c155 100644
--- a/include/scene/scene.hpp
+++ b/include/scene/scene.hpp
@@ -55,11 +55,33 @@ namespace Toolbox {
         }
 
         Result<void, SerialError> serialize(Serializer &out) const override {
+            if (!m_root) {
+                return make_serial_error<void>(out, "Root object is null");
+            }
             return m_root->serialize(out);
         }
 
         Result<void, SerialError> deserialize(Deserializer &in) override {
-            return m_root->deserialize(in);
+            SerialError err = {};
+            bool error      = false;
+
+            ObjectFactory::create(in)
+                .and_then([&](auto &&obj) {
+                    m_root =
+                        std::static_pointer_cast<GroupSceneObject, ISceneObject>(std::move(obj));
+                    return Result<bool, SerialError>();
+                })
+                .or_else([&](SerialError &&e) {
+                    err   = std::move(e);
+                    error = true;
+                    return Result<bool, SerialError>();
+                });
+
+            if (error) {
+                return std::unexpected(err);
+            }
+
+            return Result<void, SerialError>();
         }
 
         ScopePtr<ISmartResource> clone(bool deep) const override {
diff --git a/src/dolphin/hook.cpp b/src/dolphin/hook.cpp
index 55cb5dae..979a9c29 100644
--- a/src/dolphin/hook.cpp
+++ b/src/dolphin/hook.cpp
@@ -122,7 +122,8 @@ namespace Toolbox::Dolphin {
         }
 
         std::string dolphin_args =
-            std::format("-e \"{}/sys/main.dol\" -d -c -a HLE", application.getProjectRoot().string());
+            std::format("-e \"{}/sys/main.dol\" -d -c -a HLE",
+                        application.getProjectManager().getProjectFolder().string());
 
         auto process_result = Platform::CreateExProcess(settings.m_dolphin_path, dolphin_args);
         if (!process_result) {
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index c157bd81..0cece844 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -429,21 +429,8 @@ namespace Toolbox {
                         }
                     }
                 } else {
-                    auto sys_path   = std::filesystem::path(path) / "sys";
-                    auto files_path = std::filesystem::path(path) / "files";
-
-                    auto sys_result   = Toolbox::Filesystem::is_directory(sys_path);
-                    auto files_result = Toolbox::Filesystem::is_directory(files_path);
-
-                    if ((sys_result && sys_result.value()) &&
-                        (files_result && files_result.value())) {
-                        // TODO: Open project folder view
-                        m_project_root = path;
-
-                        // Process the stageArc.bin
-                        fs_path layout_path = path / "files" / "data" / "stageArc.bin";
-                        m_scene_layout_manager
-                            ->loadFromPath(layout_path);
+                    if (m_project_manager.loadProjectFolder(path)) {
+                        TOOLBOX_INFO_V("Loaded project folder: {}", path.string());
                     }
                 }
             }
diff --git a/src/objlib/template.cpp b/src/objlib/template.cpp
index 15249406..696f30a7 100644
--- a/src/objlib/template.cpp
+++ b/src/objlib/template.cpp
@@ -6,15 +6,17 @@
 
 #include <glm/glm.hpp>
 
-#include "objlib/template.hpp"
 #include "color.hpp"
-#include "gui/settings.hpp"
 #include "jsonlib.hpp"
 #include "magic_enum.hpp"
+#include "core/log.hpp"
+#include "gui/settings.hpp"
 #include "objlib/meta/enum.hpp"
 #include "objlib/meta/member.hpp"
 #include "objlib/meta/struct.hpp"
+#include "objlib/template.hpp"
 #include "objlib/transform.hpp"
+#include "gui/logging/errors.hpp"
 
 namespace Toolbox::Object {
 
@@ -561,30 +563,32 @@ namespace Toolbox::Object {
             }
         }
 
-        auto &cwd                = cwd_result.value();
-        auto blob_path           = cwd / "Templates/.cache/blob.json";
-        auto cache_folder_result = Toolbox::Filesystem::is_directory(blob_path.parent_path());
-        if (!cache_folder_result) {
-            return std::unexpected(cache_folder_result.error());
-        }
-
-        if (!cache_folder_result.value()) {
-            auto result = Toolbox::Filesystem::create_directory(blob_path.parent_path());
-            if (!result) {
-                return std::unexpected(result.error());
-            }
-        }
-
-        std::ofstream file(blob_path, std::ios::out);
-        if (!file.is_open()) {
-            return make_fs_error<void>(std::error_code(),
-                                       {"(TemplateFactory) failed to open cache blob!"});
-        }
+        auto &cwd      = cwd_result.value();
+        auto blob_path = cwd / "Templates/.cache/blob.json";
+        Toolbox::Filesystem::is_directory(blob_path.parent_path())
+            .and_then([&](bool is_dir) {
+                if (!is_dir) {
+                    return Toolbox::Filesystem::create_directory(blob_path.parent_path());
+                }
+                return Result<bool, FSError>();
+            })
+            .and_then([&](bool result) {
+                std::ofstream file(blob_path, std::ios::out);
+                if (!file.is_open()) {
+                    return make_fs_error<bool>(std::error_code(),
+                                               {"(TemplateFactory) failed to open cache blob!"});
+                }
 
-        Serializer out(file.rdbuf());
-        out.stream() << blob_json;
+                Serializer out(file.rdbuf());
+                out.stream() << blob_json;
 
-        file.close();
+                file.close();
+                return Result<bool, FSError>();
+            })
+            .or_else([](const FSError &error) {
+                Toolbox::UI::LogError(error);
+                return Result<bool, FSError>();
+            });
 
         return {};
     }
diff --git a/src/project/project.cpp b/src/project/project.cpp
new file mode 100644
index 00000000..7ae7cd92
--- /dev/null
+++ b/src/project/project.cpp
@@ -0,0 +1,46 @@
+#include "project/project.hpp"
+
+namespace Toolbox {
+
+    bool ProjectManager::isInitialized() { return m_is_initialized; }
+
+    bool ProjectManager::loadProjectFolder(const fs_path &path) {
+        fs_path sys_path   = path / "sys";
+        fs_path files_path = path / "files";
+
+        auto sys_result   = Toolbox::Filesystem::is_directory(sys_path);
+        auto files_result = Toolbox::Filesystem::is_directory(files_path);
+
+        if (!(sys_result && sys_result.value()) || !(files_result && files_result.value())) {
+            TOOLBOX_ERROR_V("Project folder is not valid: {}", path.string());
+            return false;
+        }
+
+        Toolbox::Filesystem::is_directory(path).and_then([&](bool is_dir) {
+            if (is_dir) {
+                m_project_folder = path;
+
+                // Process the stageArc.bin
+                fs_path layout_path = path / "files" / "data" / "stageArc.bin";
+                m_scene_layout_manager.loadFromPath(layout_path);
+
+                m_is_initialized = true;
+            } else {
+                m_is_initialized = false;
+            }
+
+            return Result<bool, FSError>();
+        });
+    }
+
+    fs_path ProjectManager::getProjectFolder() const { return m_project_folder; }
+
+    Scene::SceneLayoutManager &ProjectManager::getSceneLayoutManager() {
+        return m_scene_layout_manager;
+    }
+
+    const Scene::SceneLayoutManager &ProjectManager::getSceneLayoutManager() const {
+        return m_scene_layout_manager;
+    }
+
+}  // namespace Toolbox
\ No newline at end of file
diff --git a/src/scene/layout.cpp b/src/scene/layout.cpp
index f1aa911d..5cf7ad76 100644
--- a/src/scene/layout.cpp
+++ b/src/scene/layout.cpp
@@ -9,7 +9,7 @@ using namespace Toolbox::UI;
 namespace Toolbox::Scene {
 
     size_t SceneLayoutManager::sceneCount() const {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             return 0;
         }
@@ -17,7 +17,7 @@ namespace Toolbox::Scene {
     }
 
     size_t SceneLayoutManager::scenarioCount(size_t scene) const {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             return 0;
         }
@@ -42,7 +42,7 @@ namespace Toolbox::Scene {
                 std::ifstream file(path, std::ios::binary);
                 Deserializer in(file.rdbuf());
 
-                m_scene_layout->deserialize(in).or_else([&](const SerialError &error) {
+                m_scene_layout.deserialize(in).or_else([&](const SerialError &error) {
                     result = false;
                     LogError(error);
                     return Result<void, SerialError>();
@@ -88,7 +88,7 @@ namespace Toolbox::Scene {
                 std::ofstream file(path, std::ios::binary);
                 Serializer out(file.rdbuf());
 
-                m_scene_layout->serialize(out).or_else([&](const SerialError &error) {
+                m_scene_layout.serialize(out).or_else([&](const SerialError &error) {
                     result = false;
                     LogError(error);
                     return Result<void, SerialError>();
@@ -106,7 +106,7 @@ namespace Toolbox::Scene {
     }
 
     std::string SceneLayoutManager::getFileName(size_t scene, size_t scenario) const {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             LogError(make_error<std::string>("SCENE_LAYOUT", "stageArc.bin root doesn't exist!")
                          .error());
@@ -156,7 +156,7 @@ namespace Toolbox::Scene {
 
     bool SceneLayoutManager::setFileName(const std::string &filename, size_t scene,
                                          size_t scenario) {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             LogError(make_error<std::string>("SCENE_LAYOUT", "stageArc.bin root doesn't exist!")
                          .error());
@@ -204,7 +204,7 @@ namespace Toolbox::Scene {
 
     bool SceneLayoutManager::getScenarioForFileName(const std::string &filename, size_t &scene_out,
                                                     size_t &scenario_out) const {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             LogError(make_error<std::string>("SCENE_LAYOUT", "stageArc.bin root doesn't exist!")
                          .error());
@@ -249,7 +249,7 @@ namespace Toolbox::Scene {
 
     std::optional<size_t> SceneLayoutManager::addScenario(const std::string &filename,
                                                           size_t scene) {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             LogError(make_error<std::optional<size_t>>("SCENE_LAYOUT",
                                                        "stageArc.bin root doesn't exist!")
@@ -312,7 +312,7 @@ namespace Toolbox::Scene {
     }
 
     std::optional<size_t> SceneLayoutManager::addScene() {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             LogError(make_error<std::optional<size_t>>("SCENE_LAYOUT",
                                                        "stageArc.bin root doesn't exist!")
@@ -342,7 +342,7 @@ namespace Toolbox::Scene {
     }
 
     bool SceneLayoutManager::moveScene(size_t src_scene, size_t dst_scene) {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             LogError(make_error<std::optional<size_t>>("SCENE_LAYOUT",
                                                        "stageArc.bin root doesn't exist!")
@@ -386,7 +386,7 @@ namespace Toolbox::Scene {
 
     bool SceneLayoutManager::moveScenario(size_t src_scene, size_t src_scenario, size_t dst_scene,
                                           size_t dst_scenario) {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             LogError(make_error<std::optional<size_t>>("SCENE_LAYOUT",
                                                        "stageArc.bin root doesn't exist!")
@@ -453,7 +453,7 @@ namespace Toolbox::Scene {
     }
 
     bool SceneLayoutManager::removeScene(size_t scene) {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             LogError(make_error<std::optional<size_t>>("SCENE_LAYOUT",
                                                        "stageArc.bin root doesn't exist!")
@@ -478,7 +478,7 @@ namespace Toolbox::Scene {
     }
 
     bool SceneLayoutManager::removeScenario(size_t scene, size_t scenario) {
-        RefPtr<GroupSceneObject> root = m_scene_layout->getRoot();
+        RefPtr<GroupSceneObject> root = m_scene_layout.getRoot();
         if (!root) {
             LogError(make_error<std::optional<size_t>>("SCENE_LAYOUT",
                                                        "stageArc.bin root doesn't exist!")
diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp
index d469b0ce..a732bf29 100644
--- a/src/scene/scene.cpp
+++ b/src/scene/scene.cpp
@@ -12,59 +12,59 @@ namespace Toolbox {
 
     Result<ScopePtr<SceneInstance>, SerialError>
     SceneInstance::FromPath(const std::filesystem::path &root) {
-        ScopePtr<SceneInstance> scene         = make_scoped<SceneInstance>();
-        scene->m_root_path = root;
+        ScopePtr<SceneInstance> scene = make_scoped<SceneInstance>();
+        scene->m_root_path            = root;
 
-        auto scene_bin   = root / "map/scene.bin";
-        auto tables_bin  = root / "map/tables.bin";
-        auto rail_bin    = root / "map/scene.ral";
-        auto message_bin = root / "map/message.bmg";
+        scene->m_map_objects   = ObjectHierarchy("Map");
+        scene->m_table_objects = ObjectHierarchy("Table");
 
-        ObjectFactory::create_t map_root_obj;
-        ObjectFactory::create_t table_root_obj;
+        fs_path scene_bin   = root / "map/scene.bin";
+        fs_path tables_bin  = root / "map/tables.bin";
+        fs_path rail_bin    = root / "map/scene.ral";
+        fs_path message_bin = root / "map/message.bmg";
 
+        // Load the scene data
         {
             std::ifstream file(scene_bin, std::ios::in | std::ios::binary);
             Deserializer in(file.rdbuf(), scene_bin.string());
 
-            map_root_obj = ObjectFactory::create(in);
-            if (!map_root_obj) {
-                return std::unexpected(map_root_obj.error());
+            Result<void, SerialError> result = scene->m_map_objects.deserialize(in);
+            if (!result) {
+                return std::unexpected(result.error());
             }
         }
 
+        // Load the table data
         {
             std::ifstream file(tables_bin, std::ios::in | std::ios::binary);
             Deserializer in(file.rdbuf());
 
-            table_root_obj = ObjectFactory::create(in);
-            if (!table_root_obj) {
-                return std::unexpected(table_root_obj.error());
+            Result<void, SerialError> result = scene->m_table_objects.deserialize(in);
+            if (!result) {
+                return std::unexpected(result.error());
             }
         }
 
-        RefPtr<Object::GroupSceneObject> map_root_obj_ptr =
-            std::static_pointer_cast<GroupSceneObject, ISceneObject>(
-                std::move(map_root_obj.value()));
-        RefPtr<Object::GroupSceneObject> table_root_obj_ptr =
-            std::static_pointer_cast<GroupSceneObject, ISceneObject>(
-                std::move(table_root_obj.value()));
-
-        scene->m_map_objects   = ObjectHierarchy("Map", map_root_obj_ptr);
-        scene->m_table_objects = ObjectHierarchy("Table", table_root_obj_ptr);
-
+        // Load the rail data
         {
             std::ifstream file(rail_bin, std::ios::in | std::ios::binary);
             Deserializer in(file.rdbuf());
 
-            scene->m_rail_info.deserialize(in);
+            Result<void, SerialError> result = scene->m_rail_info.deserialize(in);
+            if (!result) {
+                return std::unexpected(result.error());
+            }
         }
 
+        // Load the message data
         {
             std::ifstream file(message_bin, std::ios::in | std::ios::binary);
             Deserializer in(file.rdbuf());
 
-            scene->m_message_data.deserialize(in);
+            Result<void, SerialError> result = scene->m_message_data.deserialize(in);
+            if (!result) {
+                return std::unexpected(result.error());
+            }
         }
 
         return scene;
@@ -88,7 +88,7 @@ namespace Toolbox {
             std::ofstream file(scene_bin, std::ios::out | std::ios::binary);
             Serializer out(file.rdbuf(), scene_bin.string());
 
-            auto result = m_map_objects.getRoot()->serialize(out);
+            auto result = m_map_objects.serialize(out);
             if (!result) {
                 return std::unexpected(result.error());
             }
@@ -98,7 +98,7 @@ namespace Toolbox {
             std::ofstream file(tables_bin, std::ios::out | std::ios::binary);
             Serializer out(file.rdbuf(), scene_bin.string());
 
-            auto result = m_table_objects.getRoot()->serialize(out);
+            auto result = m_table_objects.serialize(out);
             if (!result) {
                 return std::unexpected(result.error());
             }
@@ -144,14 +144,14 @@ namespace Toolbox {
     }
 
     ScopePtr<ISmartResource> SceneInstance::clone(bool deep) const {
-        auto scene_instance = make_scoped<SceneInstance>();
+        auto scene_instance         = make_scoped<SceneInstance>();
         scene_instance->m_root_path = m_root_path;
-        
+
         if (deep) {
-            scene_instance->m_map_objects = *make_deep_clone(m_map_objects);
+            scene_instance->m_map_objects   = *make_deep_clone(m_map_objects);
             scene_instance->m_table_objects = *make_deep_clone(m_table_objects);
-            scene_instance->m_rail_info = *make_deep_clone(m_rail_info);
-            scene_instance->m_message_data = m_message_data;
+            scene_instance->m_rail_info     = *make_deep_clone(m_rail_info);
+            scene_instance->m_message_data  = m_message_data;
             return scene_instance;
         }
 
@@ -162,4 +162,4 @@ namespace Toolbox {
         return scene_instance;
     }
 
-}  // namespace Toolbox::Scene
\ No newline at end of file
+}  // namespace Toolbox
\ No newline at end of file

From 7f7bc56ee9a80c39394f7b5e5ad9594cf8adecc4 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 9 Sep 2024 05:59:46 -0500
Subject: [PATCH 007/129] Much progress with seemingly functional model and
 proxy

---
 CMakeLists.txt                                |    2 +
 Images/Icons/Filesystem/fs_arc.png            |  Bin 0 -> 45443 bytes
 Images/Icons/Filesystem/fs_bas.png            |  Bin 0 -> 13334 bytes
 Images/Icons/Filesystem/fs_bck.png            |  Bin 0 -> 19387 bytes
 Images/Icons/Filesystem/fs_bdl.png            |  Bin 0 -> 9182 bytes
 Images/Icons/Filesystem/fs_blo.png            |  Bin 0 -> 4070 bytes
 Images/Icons/Filesystem/fs_bmd.png            |  Bin 0 -> 9182 bytes
 Images/Icons/Filesystem/fs_bmg.png            |  Bin 0 -> 26898 bytes
 Images/Icons/Filesystem/fs_bmt.png            |  Bin 0 -> 33799 bytes
 Images/Icons/Filesystem/fs_brk.png            |  Bin 0 -> 7100 bytes
 Images/Icons/Filesystem/fs_bti.png            |  Bin 0 -> 2321 bytes
 Images/Icons/Filesystem/fs_btk.png            |  Bin 0 -> 11549 bytes
 Images/Icons/Filesystem/fs_btp.png            |  Bin 0 -> 11118 bytes
 Images/Icons/Filesystem/fs_col.png            |  Bin 0 -> 18452 bytes
 Images/Icons/Filesystem/fs_generic_file.png   |  Bin 0 -> 8419 bytes
 Images/Icons/Filesystem/fs_generic_folder.png |  Bin 0 -> 10982 bytes
 Images/Icons/Filesystem/fs_invalid.png        |  Bin 0 -> 319986 bytes
 Images/Icons/Filesystem/fs_jpa.png            |  Bin 0 -> 57806 bytes
 Images/Icons/Filesystem/fs_map.png            |  Bin 0 -> 61346 bytes
 Images/Icons/Filesystem/fs_me.png             |  Bin 0 -> 6338 bytes
 Images/Icons/Filesystem/fs_prm.png            |  Bin 0 -> 42745 bytes
 Images/Icons/Filesystem/fs_sb.png             |  Bin 0 -> 10068 bytes
 Images/Icons/Filesystem/fs_szs.png            |  Bin 0 -> 27272 bytes
 Images/Icons/Filesystem/fs_thp.png            |  Bin 0 -> 6264 bytes
 Images/Icons/color_picker.png                 |  Bin 0 -> 3641 bytes
 include/gui/project/asset.hpp                 |   45 +
 include/gui/project/window.hpp                |   20 +
 include/model/fsmodel.hpp                     |  214 +++-
 src/gui/application.cpp                       |    7 +
 src/gui/project/asset.cpp                     |   21 +
 src/gui/project/window.cpp                    |   81 +-
 src/model/fsmodel.cpp                         | 1111 +++++++++++++++++
 32 files changed, 1453 insertions(+), 48 deletions(-)
 create mode 100644 Images/Icons/Filesystem/fs_arc.png
 create mode 100644 Images/Icons/Filesystem/fs_bas.png
 create mode 100644 Images/Icons/Filesystem/fs_bck.png
 create mode 100644 Images/Icons/Filesystem/fs_bdl.png
 create mode 100644 Images/Icons/Filesystem/fs_blo.png
 create mode 100644 Images/Icons/Filesystem/fs_bmd.png
 create mode 100644 Images/Icons/Filesystem/fs_bmg.png
 create mode 100644 Images/Icons/Filesystem/fs_bmt.png
 create mode 100644 Images/Icons/Filesystem/fs_brk.png
 create mode 100644 Images/Icons/Filesystem/fs_bti.png
 create mode 100644 Images/Icons/Filesystem/fs_btk.png
 create mode 100644 Images/Icons/Filesystem/fs_btp.png
 create mode 100644 Images/Icons/Filesystem/fs_col.png
 create mode 100644 Images/Icons/Filesystem/fs_generic_file.png
 create mode 100644 Images/Icons/Filesystem/fs_generic_folder.png
 create mode 100644 Images/Icons/Filesystem/fs_invalid.png
 create mode 100644 Images/Icons/Filesystem/fs_jpa.png
 create mode 100644 Images/Icons/Filesystem/fs_map.png
 create mode 100644 Images/Icons/Filesystem/fs_me.png
 create mode 100644 Images/Icons/Filesystem/fs_prm.png
 create mode 100644 Images/Icons/Filesystem/fs_sb.png
 create mode 100644 Images/Icons/Filesystem/fs_szs.png
 create mode 100644 Images/Icons/Filesystem/fs_thp.png
 create mode 100644 Images/Icons/color_picker.png
 create mode 100644 include/gui/project/asset.hpp
 create mode 100644 src/gui/project/asset.cpp
 create mode 100644 src/model/fsmodel.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3677621b..7a281c5b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -66,6 +66,8 @@ file(GLOB TOOLBOX_SRC
     "include/gui/widget/*.hpp"
     "src/image/*.cpp"
     "include/image/*.hpp"
+    "src/model/*.cpp"
+    "include/model/*.hpp"
     "src/objlib/*.cpp"
     "include/objlib/*.hpp"
     "src/pad/*.cpp"
diff --git a/Images/Icons/Filesystem/fs_arc.png b/Images/Icons/Filesystem/fs_arc.png
new file mode 100644
index 0000000000000000000000000000000000000000..d74040ad0c150280e09d8a4d4a7def5f7eec766e
GIT binary patch
literal 45443
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

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_bas.png b/Images/Icons/Filesystem/fs_bas.png
new file mode 100644
index 0000000000000000000000000000000000000000..bfc767dbd864b8321a2cdd7c84c80b1ddc8efcb8
GIT binary patch
literal 13334
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
Gjrd=SO4Kv}

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_bck.png b/Images/Icons/Filesystem/fs_bck.png
new file mode 100644
index 0000000000000000000000000000000000000000..80705973c0fcc9af97b71ddc14917d754ebedd61
GIT binary patch
literal 19387
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
Z6m)84qA1p}>*@A1e!$>PSG!$I{2Owl;8_3w

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_bdl.png b/Images/Icons/Filesystem/fs_bdl.png
new file mode 100644
index 0000000000000000000000000000000000000000..0fe86b160870d1ac8a62c34f5c21fbfda80ef98f
GIT binary patch
literal 9182
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
R8e<u~aPH#Sd`+8&{|6Nz%tinJ

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_blo.png b/Images/Icons/Filesystem/fs_blo.png
new file mode 100644
index 0000000000000000000000000000000000000000..4ef638d38d4c7714d26e8e4ec298c6226179b7d8
GIT binary patch
literal 4070
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

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_bmd.png b/Images/Icons/Filesystem/fs_bmd.png
new file mode 100644
index 0000000000000000000000000000000000000000..0fe86b160870d1ac8a62c34f5c21fbfda80ef98f
GIT binary patch
literal 9182
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
R8e<u~aPH#Sd`+8&{|6Nz%tinJ

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_bmg.png b/Images/Icons/Filesystem/fs_bmg.png
new file mode 100644
index 0000000000000000000000000000000000000000..4543065654701685a7f786404dbcb13bee6aeba4
GIT binary patch
literal 26898
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%0D@<j~@DrTr(Zu!%u{nMXv`_x2
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

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_bmt.png b/Images/Icons/Filesystem/fs_bmt.png
new file mode 100644
index 0000000000000000000000000000000000000000..d11782d130b28be3a11f07a8ce85a3cf87e40545
GIT binary patch
literal 33799
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
JPvh33{{uRjVi*7b

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_brk.png b/Images/Icons/Filesystem/fs_brk.png
new file mode 100644
index 0000000000000000000000000000000000000000..c43bb13307b738af3e910ab4f6d1033004134a5e
GIT binary patch
literal 7100
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

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_bti.png b/Images/Icons/Filesystem/fs_bti.png
new file mode 100644
index 0000000000000000000000000000000000000000..1693cb3bfec725d7d32b5bdb6ca32ef10f9160a0
GIT binary patch
literal 2321
zcmeAS@N?(olHy`uVBq!ia0y~yU;;9k7&zE~)R&4YzZe)83p1Ua12U7785lGsmQJ+w
zJ{%y@c7L1K(QPFc9FHhEi?)k(Ewb=p-5t`tttoW+6SK@#6<%}Apcq#1_NL|+kFGzk
zzYtmwD!}3@Q22@c$5xNd=Vq;9nf^O0`QO{Ve|WE$vED7c?e26Ip34t!mUu<!uJJrr
z{zJf#!|=?BGux&Wbyt4rneV=8S%pVO+}_u_+*Yi(#q)tz;Ji_{^^wm<X6han+T(6>
z=2X$dA1xN=UN#)r?i6lQCmi$XhquA`ba96LFEpoGMZ8Q1d&c%rrSQy!)oV)S3MX&K
zTK7bw|B_U5ug)b8$EGGNvxSEpn>KkGzkcU!R(pEIg!YT~op|TSs7^U4t-jSOHuRL#
zORZX~tfY7UpJ!%Y4vza?!1bcO^zQjWg&q7Ruh#vpezmLDSm6Ux%<SCy)@LT)eXI7a
zJ=)j!g0G<R^0g_<53<B1Dz~NRnJ;C~-M@@cUff{`1J7ON=GXVuME$m?XZm#ei%a=|
zhk^!<UoZCB%Wuz+jDK9d02l|H1s;*b3=I5<Ak4VJet9MX1G}52i(^Q|t+%%~b_pj+
zv|W7fpEk)<GWDX?v{#}W(Kn;CIO1MtRj?j1i>hGkQn;bR{aQ>fM{V*?S><n9W%n%)
zFF8Nk^AnGvAkh4Q1^-vfP<V9u^7-;xm+V#qCa-9A^jJ8%ys)fNO#j~g9z(bJtSMg<
zKTpoz^N-zs+2^T}3_+1x46_#Bytv5kyW?)F?QEJp*K2f6DS6Gz`?uQGf#HeCy&m(2
z>I_Di-qN*ic^N&=`hZik00Tn<(5Ea63<^Msk%57Ofx!XD0w#7mQY0!zm_(H62;~Sj
zVG|?lPM|J?5kx6(V1NaN1H%j$ljv|kxN=B&lu&ddyoC~)4Gad1#HAOg0sn%Mn>w!6
zgx<d7Hn(pfADd$9*BaT}$RqpS^)fOkEbqT>KlMK225|-zu7>Wnu6N?|l5ArBUe#Dq
zw9i(Y;ihf%_nIo5HifB1vi;ZiAAdcWxn@@MM%n7c6HYzeuFj;e`}AG&`~Q}d<d>V9
zo%Sv96|WTq#(smytw`zXzh7%C<p8E=2QmA4wi#1zuD?9LNkQ~|1-?X%!`INPff5n~
zvI~ky4!{(KKX;)hN2I+5phogC9<kXPo5k3~i1LC0(79w;OqA&jK-19!1DhCeK~0uB
zp}r$3fIifls##?CI=Fp)X_43Wxa{`PZQs}!87G{({<0>SZIk3Hf$+njJeMzW1HCoC
c;DP@ihTi%l1JBp4>L90hy85}Sb4q9e0B!4@4FCWD

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_btk.png b/Images/Icons/Filesystem/fs_btk.png
new file mode 100644
index 0000000000000000000000000000000000000000..4324d09facaf6d4ef2f0b3eb05018a81c698f0ea
GIT binary patch
literal 11549
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

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_btp.png b/Images/Icons/Filesystem/fs_btp.png
new file mode 100644
index 0000000000000000000000000000000000000000..b030a61799355b2e453261e7088968c215a9c4bb
GIT binary patch
literal 11118
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

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_col.png b/Images/Icons/Filesystem/fs_col.png
new file mode 100644
index 0000000000000000000000000000000000000000..2a9e2816021102242090237c41581f2147de8f9e
GIT binary patch
literal 18452
zcmd3Og;!MH7w??`q+0=L5D}FWBm|s6TBQV}LsXEGl8zZgN+d+OL8QBD7(fvOq`O0M
zNNI+dd6)0+z5n64mP;2i=iGhv`Ru(v`*Y4EOj}cxnu3)A003%rHKk_&00sXG1<0;|
z{~UUaoC5&F#a2;K+xF#401)`%{zd-D5ACbL^R<sVYTpeg{Nz!*7Q*x?Tlz6clU_*e
z2mOS<lD0v7)Ka&fnUXMvd<a}$8ef17=sWAv5i8TV{3AWBQ43p>3}Uj?s+XbNmET>Q
zbAupMY=UPKh^dAbC*M6b7AjV6^E{<fAQS8D>aC4;4fj6$oS|Bn>!lWIj>0sm<mXRO
z?NQV9-wT)hdGIqysFR^tRj#+&^~>o;>Anr*&$>qjasiB{|4yHX_S-N6==Ixi4-7Xf
zpRZoo=X2>DC@Oa6bop9tSNc~VYKS#3LU2e;;lqbJl370#K2)lUV|JcM`uF5VhYZd?
zqE2PM8T*^<R?TBG{chHcJN^&stab=%w)Vri<|ob+>j?MRei!a~T8Yh4tnX%HggEye
z)HKBr5wt3CqTz!o>4<#4PUGx7JQho|V8_hjUHeK{>N_BW&V_I>!*c+tS)xG9T(L1$
z8Ug(`eW>Kwx=1goa5NYJ<Ende-D24@6WjxGXEh@?0HA$w`4^H8%d-UlZa`g0LC<Sy
zJB`#&Pye`c_vt<Lb#7(4E7>1NDDx|X@6@^v5=tA7=jhG!Oa(0!eyY%8N=q9lHaD~F
z+gh3$J<Qm;jOny(#WESl_;~n|dYcKT-=ArC$ZxyZ%z5u(j}ELET0Q4w%Tnj%PiEZW
zE+O&%;h$Z)R$>6p=h@vEw_S8)l|Mivshnh&2p|RkucWtM$D|{09FIW!0>DGpi%{V5
z=cgn4H;4f`09bh0nekMAXQ}X05yii9{!7%G_T{9b0zFOTV9A>}26_Mv0LTzu-2VnH
zoYI3q0RYZylb*f!7TrmRzxd#BBWINGXEO<F(o*Q<401D=TdV*QbQL@7e-94uxcIH)
z8gGyg#g^PN3cZ|CD-}i$`OlV#|7**@<H{YM=IVn+`m|=(hyQz?S950+-K7aYBp1(r
zQ>MarFW0i*)-2ige?OAPGwH-t<uqE&aE{PketF>{42)YS09+0RpMkvUn&)Ra*<xq;
zmfN>rdF1awFVBC=H_yfV38y3)EX9>8O^1DK5xL8Swzm<4Ai)*h|A^hz{({{O(Kpzx
z5sCkA-cx_FAOEf2Aev>38GlhV#r@xc=a!weCYik-l0lI1j6aEik{j4F$^g2}QzFMx
zU(c4Vod$ajPd<Pi0DN$N{Knk-C*9T_OZ>ME-_H5xHu?RNeqpk^YJLAU|G6mMzDqSg
zOa%c>i^u1?aiN=n9}BT-qBn>#Z7anfKqNW{>z-o<3nsbTKy!}^$u!W*tuOaP0k4UD
zC*j{BB*zRliK+Buo)q2vwXGQd#)&8dY1)~w!RcrU2-wm?>LzHpzeW?2i7u~NWi81s
zw7+Cf9-F0&{Rdo{nDNDZeEECYc*Hv2SwjuSlG6)f<Qo9Vtp+8Y-*>CGu->jmW-h<u
zn`0(}a6^HG*K509*6t6}Bdt})eon~U)&8EXDa;Fi8wjFh^R`^TxCPPj<&J=J({jH{
zn)}PyvTjrTg&m?}B^YzypW`=EDkG->CkEip%Fq-pJ40@aH=vJ3agSEb3(0YMrjh|6
z>2gNk=dC4$9>@7y5Bvjq;?2GIXCMB`VEDoxI#j9^t1NPTHYtw^^oTTLQGXUKF?>li
zmm10q0LH-!E_mcPhaV*|QjMPO_w8a~E~$@|?c5Bm06ZYdVon;?-elWE)=f*cCi)V{
zd34({di!GKfy`cFMCGnu@#iO`a&G`>ytTZ202g#`^N64IG6L8k{f5(}zDueu<7j^0
z*WQz(vhGWFKA5~915CBXit@^?-YIp#KdiO!(8!2vzpMSBlZTvcW*$ROO8o}K9=qqv
zb}9uT6RyGCIMAf&H-DWr7{nBimxRVf%qLa0UoMsignXL!ba;bP<qeadP%=P77@$2o
z-&nM{Xi>+<Dd`}Y;0)ZaX7+t=|D`o$%m}sE13=V>$g`uzm0F!qsN37#0+>A=<v$bj
z9Q7YTOtZrxxr{qa7=qw=N4|9ie@Ow6`>kh9MCL!2b{iJ=x#s`Q5rI1@9q_XPoec>N
z%pr$ZQ-T2hIpp%M**$9$pGGv<!=7i2%t>GoF?FJZxST=AAaDR#obVj10UuIfB8CVu
zh|4H3J+zgQ_GfcW^FKk+{tWDB1UM}OXjb$7@@RU;<fa&FD~_@N$pd6|(sFwlax)m4
zn>`G8Bb-1-2OtkR_XDFo!Ucw4As4_K>R4!Syf_Hd_k9*KKL3!~4lYqUrK;Wa@8C{k
z&op;pqwY={Q1>1U`D?~-Nhr&y!cBAR{jm*fg(9$Oc>{35fw6?l36}tNxg0pa$E`yr
zN1_On8?9MP?i{iH6hijC;Cs&Y@fSBaog{XsYuY(K2TR;ZyV2OmZrd+D2*R5@B1T{y
z^Qz<>bnxL)&&fSv;ILFGm%p0#nPk8kdnqS30N)CKD)x&u3Gp_z`VCzE{b$-evA+Ot
za0Yqi28-bWvbjlHJIT_<LY7I%PxA6Fke@s(o<BEpfy)YWL4k{*<+AK?TFZU&Yd4@%
zP7^X^@?jrZ^otgxz`*j2V+Wki4*2h|YVS_A!@SsCfs5=zybp$zX$R6ZfqN1F>{$gJ
z^49w~ZR6Bwx#Z{|`BBoHk0p>~0GZXZlM<*(+Y=AGsWLb3Li!tk9>NQ7zn2M-O~bqC
zNHn<;1UF9j=z%?jkMP)+H(3`r5=j<H64bZD`A%K+I`rZt*7~22T+GmaD;C`w3L1k&
zGwi~APT|CsH<aXi?oYy$x=T5q8ol5JkjtuG(9_$j(PqQ4N=k5HKFHF=FwS-PCS;*)
z?IWLpk5#MUShjBj4*-B{M~UcFD;<(9r+;mY0$RN>Nq>|0vonbP&mj84E&%i1g>iG3
zydP3h9(zPkn`z>X*Kc&4y?<una(|Xo1`zhV;5&!FQEQJ!s;+(Z*ij4sL~P&i^Uv&7
zBW{gl{Y~{4+Pw{y2@hHFp~$2Q-~>*C3{M<EdG19%SyQ!7*eGEQ%_K&y%DFB5Bcg+n
z0r@A|Gd$Rv#6Xfio(|d?Zo<$;npd(@`Omb##Wm&vxQ9_<JAWBWf+RzxoOv71KUTT{
z<Xl|8#!Q{xh0U(q>?WFaIrB>LHLB3<A_ctW>FD9Wp6EYrD6+;=b4fMq5%&``!pc<H
zSDTcZ!*k!P>M_aq4k_UD?l?!jUuTna?*nuA-+!pwH76h1kEam1>(`@eww%{H)h16l
zZr}Y3EI_JyxxY0Z)tWnT96i_B_4Ox0d)oc&pFJexozLGtA~Y?Y8vom!IV8N!_Ltg{
zit~8$d)J@OLvv4*42*gJNvlB24VWsAnMEadm`i2ravNr)8v0T}0VEw97+59+fR6yQ
zmGK?Q+vNrKR1H@=0CdUS&$_nqdf9X5<4ro?@Eih!UICy$CoMPzAO`C(0Pui0B^3q$
zyZ{9GLrU_u_{rxv*9tNKsZGi}k;$IN@hFqtkkazyn$y;PZedYOoc&u)0EqtG-v={H
z_v(}-eY)Wy9j^d5d@%Cf93UaE*8cuO1OTpK?jv)h&!|hTS7+sTj#aVb(6sX$8Gb=G
z9Skx}OC#p64EOW;`zA;MxHRs@+H<_q-#l-ar#F`A-&<9{;i*e~t6-!~{3#9(A<efr
zc_3a}Z=a|}4j@HqLuXix{Dzi|G{=i0<`>BTV)zYS%df?RFxiaE^yveMJYHE^UkFg2
zTD)ac@iy?5a?7Onh%>Jgn7sx}A(n=-E#H#sJ4rTcI08zt6RCk#_n)p0wQ*CkMrWfg
zln2QdA(wMLA%=g@YNXX3K1TgKEAAJbpaEKMQVE>BTxotn_*(Sn&z}9|*X+Tsq5pDa
zrq5xwCMx^<f760qr`sOI4aUr0{4Q8$>wSAn_y`h@YGr_h_kCic``-R$5~`06bUAl~
z-U@2#a96y<r>*U#kjO;v<@fXfKG8GCIJ0R!z6SS#g$`)FXF{T?AK*TQI56IBqXWp0
zdgMrAuHy+6jrq0qiROojEKC5PCWacHGsGRO+dR56Zkw|E2&4?pgaC$_uW0na%)>RA
zptN%}M(BMXlbkvlAMqOT=}xrnzOT_x#yG+3k!;djlnDVnwlyC?5RO~J91{=`)hDi<
z>#%HnQms!o2~n2EziH^fqG<x<Zp&#y8&sV<7`{ze^VNEd?ND;?Li^qe%C{6i*1MGI
zurlVFMq7y!jy$Ijm_EY4w|zvoHyFqd(ymeF??pVv9sK@E6cTXISba07ED9~~ui+Dr
z-uh+r0;^}LZ{*Y6@jg}-!3~X$B!l1EJz>w^nLB8nm}zMuMZL?Q;{lxAiQ&d;ijF#G
z30<Cf1equ9G*i9?3}6Y%(FORtxDkmyR`Zlr${cmE{KWD1uYzF=yc%hf8eL{q*4(Qx
z>|6Lf*p3QU9Ai@iM%wA%$=4eW<&VbZwP@3i+X4%9k9^c=H;|`KRy0d_k@hmi$p=xv
zE!rqW=I3~?<CV5*=}X%RK-=uyrV944ksjvrJECFZFYHl5H$f(qOopsCM`VoF>Gh!x
zf1AdoSX(F&Bgx>o8^$Pw*^}ey)*n@bOb-(=kvm&^32J_efES$$d4Rm6oUX3R&$okT
z1`m@GJl1HHfEhZ7S}y-WeiAOEK=qjI8ZK)&-l)BI%rXG^9<12iKBq_CPn<{}Kgf_f
z`ZC<m={QOmWgI)%8^8;IgOzF-wbz7vEl}8#;VR9uy%(c3g@XL+dyHog#)cTc7IPHt
ziboZemKuBab-{n7!MK5$UTTZpX9S;re_Puq3D+1s)<G&>zI&=1g!L^$Nj-BN67Fjc
zH|L*-0+6fa%KGjLc+Xr?F28{4sn;vaAQL%F`973h5IHE7J?I~mf9A7=;~C`%#dz|V
z#`?UvLu%>POSW5Njo)lv|D=ifzCv0&Y%=}}AHxno{@ReV{iCGMY{VGIc-}sF4>Q-*
zt_$mO*;a@lLITlz0D~zS^Lw*nR?E5j5l4<$Q;#0eePTMWg&>{J5s7;z+-4cJY5s4#
zQ28Z39&<i%51P4?`~qq;vv)Q>%2uUG&EB|>G4zjUM;kO#qKHxG&)JC)R`1mjd5BCn
zUZC}i2nxSvcK7ax|L&Z53Rn4$sDm5rG#M8FGB`<Kdvaaxz_xgK?3U_k6iO!NfzrA@
z<qbB*uGgnp;Ujy@zdmyApfh}4p}!1XORJ5E<%;$i+#dqyR!`HmIto=+6i4UH_ny&k
zs5k8WD+!r)1Cp1fc=CRlPvL&Ho^N@ichQPQ-vG>2mhAlf$K>?n2{FE441dAEx<F8S
zX#hVzL>i|I>qLl1m#s!{M8&eq%BYR%ODO_K19rcci2Ei^s_G9Cge03e&Hf=gNvzI#
zR!&aoff~BT{h^M}BqL05m{HvBY@Fj5^TcA_+5L9SMGfTuz$@jaoxfEoBGP#M@C~eR
zvuW^UmE7XRqD>cMPXJqXuCh(INZcYNrP7Vs^?$3Olh6`VTH~!CX#@k{+)F<lPyX40
z3p=k%<%-MpD<kEhdPe(O5zr8O+oe8e;0e2F_$6%(EZjtj#0%C-iog^7S)c1x>viWz
zn<6Un?9aBp%^lKHLAZenKESTO#7xzF#hh7bZgyucy7dRl#7UeUSa?J_&tkLT7@Tvk
z!Ge=`UfC&M=ojTZM{{%o?3)4@0rEMFjP`8f{CZcmd7$FZt`RX%uMH$-6*1`CiqX$+
zRK=SfZJ(8$-x!Gk^Up^bu6qunb(<?|ogak>CmMxL8z(~yBoT0vZhd0r`3%q(+~o>K
z#!^*{e?Jp+TfmkB0KN+w9!L6Me!EphVb`<XV3QxKe~E(ZGjFq$^45Qxd~AF+=T3->
zy*MYfS>)R7YGXWQZ0A1O`#}d+EVdh0H)}Y_-z3mHkhpbcw{{{Y01gc%YvrHiFQI4N
z*)=?f(2XPHt!ss#SLTf@FP%XLurZEuBx?D*EqXh1vecC=<VoSZ7@z{c**N@k5ki}0
z^khs$!Yi}}A`Pee?DH0e#Bd?vfCZb%YQl`osMXOw%7ma_EgoMtb!&O=Y+dc8^yV~R
z5ER!+KA3mirX01`#MT5JkP-t9@s#l`C38vc&&T$;9tsG-EY&Vn{B9Z0KkGHx_q7j=
zCE77NSARF#vi6hdGfG%BDErXo#f^HN&BZky<S)a)7R9Y@e-+h-Q^#~+M(q)+q%17F
z$Xqp6DBY2Hm;T*Ucmg*2Zj|qPyE1C9X3+z0I8F46Y4O_;w;RN5EOKfIi{W-JLi*34
z15E7dCt9M0rHu*w#rVY;dPpja4s1%JpV>hp8|w&=io6r~d85e!&-n5mgp9dh1_<&B
znES*O)e;^*NO*YDNqIHH-=ua^b2pw0d{8+Y%zO!gzEY=s#p0EbxV`skAzfF(&LH9q
zF#}{~%O{~MYx518DTbrRFJB&rpd~(Dx+5pZq~%m~9j2AWI$^)hrr%D3>pguEAZ<V&
zL#N*%Vp5`;mi_fckMILwL$NLQxs?Gc?eHT@vP}18)QZPut$crp`G8FwyNEm~6}?x=
zDIGFtOiF3U<>Zb(Po?u=Y&1oj8@&mUB3M9);hSf}$QKnxShIzT3704PVE+a5OP~Id
zenM_iQr17EWxvXGv?h4pS$Ov?G04^+3!0@Yu2x5wrZkp2wC=GUQK*ub;45@M`ZXXs
z{lH_8D|KiuQ1dJ_j~tAPXIG>c4PSH<tXG<4Fx9P`;q&=dJ=RHorTrK*Ro3FQH_n*K
zd|-gTUupGs5%Ru|;P_UG7&!g+iz2@??wZ{gf`3hZuf4-AgbRPGB%syp(>cW4>T@+_
zvgi=iwfRl+c@N$>s@Pp-(`VeKqeG&e1q3^tDDj?oRJ+zmg0!BC4Z+_&9Y3lJd4C4!
zIgFnlun<*Rc-yF9{PN#}hhN|I`i}*0;Lf8%KJ*QY=b$p82Kx}TcPQ$HVF(+|jul=K
z2$K9KIq*Y32)Z-g*{Da5gC|Fb%x=dP)_Gw4HI<*+*q+QE6wVC*Q0`@#mI8FVev8!e
zRXukff#<G6p9Ni*c_*`&f}BP&#y`oJ69Z(7z};$K{q9zxl$DugdZXpUO}14B-#4=F
z>wb&*q(lJDC4ga3o$#|hp8V{>p5O#KrVNBhZMRSy<`k1k5I#R}bLrgH?Se%Aem=D^
zpMI(w{vJ8Wmj+MRe0+4uraLu@YhRzp<Z1y4-Ltm6Q+N913*R_gne`FRT4BexTV1aB
zU+*Qil*-m5`JixOZuzYo4#I^`r_<x4c(p35Jnp2x+Z7!Sg>{=)Wd2?YB~zH<1+s~a
zI=em@4jzj`D+1GFPH5g1pO{{K_&_*vC7p;Kp!*qnj>sfwo2pkd=HF0K5g|Ao`&RXJ
zJ#g6hc5OQw^Zlsw&wk&kM{nZx%2SM+onHEZv&LdRy~6uGSb37>a>Pue5-9EDBrMkq
zBO2cyh+6P|gWUAy7zx6f*T3j%wRqA?D{XR9NK%QI`?dVV`BT02_CK?C<_e7b{+Ue{
zcGkJ#l;$6es_hc);k=s?#d)DfU@sInHKs(irO4d+@@QdnZd!GB4%<Fahq@Ay^U#D0
z8A}Pc44?bN`?KLzGkpX5q6uog^KVNyR)+rIi?W>!5v=+*Y&ht^WJU$)vQgb$NJ(`C
zo3$nN53_t}6QNv8)~NG~#DRQ-nZamPwgCTDV<?3NWn}@&S_ZR_yW~4`r;)_!gy8$W
zdG_5QYy7mmk_^bx7P82YZL!naWoZ|Me^O2Uh3gHN%nwT0!6RmttB-bfJ^Vs8k@a8R
zYiyG8aX%U;2DzI}<;y?A_k(O^Z#o%U_-70lb`cWh2ny#1)Gks?^ho1MF@-6wXHK`K
zHXYU-8|V7oEGh~wb+CqV?GU-)$6g$bSB-Y~rlS|XZmXz0gQ#{m`Ue)WH3dg-_`ReW
zpH7MCvkCtsl0A<*PA`tRh{{2km|*CVj#V!yqWFZ06J_kI_T(OCP)5sa`@yvYF1pc{
z!xbUYv6;I5n|*aC4=VM5oeNILUbmgUe0O;EJWbm5cQjWMCefOsHz}pYbl(=9AR_U8
zT}u^0L(?8gz?K3HywRL4C_{MAVpveh&HgSv<7c&k*crs=+!=AQ>^UjY;_Py~L1=8T
z>NyJfOX@`m?o;7`^{<wO!_Z5AUOm__#{6ZQX7$8#9IpL|kJ{zuB;^ItLjk@!M;kac
zec7(1+ot)`=T9j6>hN5DhNtOl#~uH2=Eb9%uwfkbcB+a>gX@nJ148NelmY9_?WgLU
zbGQFJe|J`a=zb=T{(_yGpJ72PLt8yi1m?pEj_=bIH?D*MbdWB(TK#RM?UCtwcxk<C
zQ9sMRWeyA9rN8T(^LXFDaz(C%gE#Q;)3b0FyqT0>Sm`W=qQ-CJ`%o%D;kI{ec)Ma8
zt|Ned`OcOigJtp{>Oi$7@S!rntNuHG?Z~ua;al9nD!bNK6tQ|0?|F$u#(m76=_!;n
zVRF;=q=ApSH~?9tzT0aef05f~q!NX0<g4{d=?uIX0$VR|9W80CJwThC3=qQWK#mqi
z&P0M-e70TBm5<hhvstiPnU4`b=gOe{13o89TcST1&`RHO(lAG;e-YNAfc%a`?`WL)
zIh<YB4ZNc#jH%b<*c7JVDuPATc>Ponn=9lN5+#mK5@_u_$C&s0$$79i(5#l8FgRM^
zyQX1!tbmQ;lojzBm`Pfhd_2{Kyv0Zo#WaqI>J5))mwOzSDx&~ad(&C`m}}t5a(ce<
z6ESmMe<^al7qaA{1!<AzJyhJswO$XXOBn|q`G)Scb$p1t(}yWm*_AK+SM@$*#d|}>
z-8Uw4Wc0jI4}aC9vC|(?(_aM{Jb7aO^@4Q=XORWVGnU&SY%b51nWykU7$AGEuC~6r
zm23F+*O&x{35rry%3CngM?bb8Z!R@n%JKLtjtFsa=aB^RrBi6M?)UD-hns@9A1}a+
zG(YENbd@tR@qZy;#|x-$C%sDW7fc@_o;{9W+P>+UmDN*sroSPJ%^0uX%X8BH=a#ZT
z24_?cSjzpn`g86x-s>>qwH9W&Ixpo8#5n`c{(7ICbF9<nEzvduq?}A0nPd|)XI@cH
zz$}r!hZ#>HvZDu{-h6Xs+%bH9x0nfCrn2K<b=E|Z_pVqcdyLuHH#;-`jdDoW(8LKA
zcQfC^U*Fh+AU5^oPwm`eom0A=zIjn)g{c>0-2PvJu5=F9ybRDs$iJwt6~DGqE0MZn
z^mxK9FqrhAZ{_k6tyDencl&H{P^Y_{L7g{#op~1CiHJKytNOz>1(q*v9-rIf6_j8E
zcL~Nqub38Z-g9GY`xQA=VT%b~oyADjjagW1mY_OxW!36%@zgJd0p1W2&Rv;Izh97V
z2l0+#eA9RPE4O)|1w}`WZ%$%#&#(oMxH`>acg@!^7C%sgFXsmV;X;B#Yvulo+v3EQ
z^ud5B(&!dkc4#9$uC}1KMk`tKwwNIIW3tpnJEKnBjD|;ME!*WaWn9hy2}hIud?>zR
zDoTgk=zb%g6rK$udoGZLzgt&SsQE+6z<4qAM5q31C2V{53W*YM!2nTnJ*Td5q&V4n
zvwtW&v^|$#?VBvZ=q;_?El)SxB9SjL-ZiT!;OpD}RkkCQ#wr6-s{%Av8e3r1T#Dax
z1uE3+3Ob?k994i%?YZ3j(&1}I*$?saj;k!8U^dvJu3O(03&&>UaQveZf)2^g$(zOu
zll_{nqxC!1%extF9%|aqpSa%aNE5FIYkeM*S)Y|Q^Csv(w=9q7rm9wg%=8bBP_#>D
zQ^@Nzr+Om@JpfYyl0%`*#puX#uTP#B4-pMFV)(n=!9ByWi+`#i5#1(J{wEG1@@pyK
zbfB=oU-7&dq;>Ei_3^(gnAnJV@ytfV-4mbJnm{7dO7aO_b9Bu^Upz994AkKapsilL
zT7ns?nzxN_W!6C9ubhTNJutX2oXu%|AEwHeR1V+lsWC<#qgm;H*km|3hoCOxDN}2D
z*qMKxgiE3WlouHf*S<2D7?#v+A2yUIfP#+ST_Bkb;)y8>7fN4+xi{S~wQ|xSdC88;
zFtT50p4Bua9Gl;Ir(F?g?z`IY06(+tvljAR9J;wciaHSP`wWPR$9Pmuv@4%C@7S+a
zTy`5Ri~v8z;r-mXk=!WbyJ>>+dsK%CQT)n^%C8+M{&Tb=?SA(;lzh!;%om|M^gGtm
zPhB~{w`m7o7Vmy-W;OIvyY<Zcs-0iT7*-W{MMVK=pxaIyFB&OZHOMeAeb*gk8<<T&
zPMu#&A&>hN+gu^?*>t>Vt17>ITCm}b*7#{W7qiu6-zD9DTjnqHn#?|{ZQr~<#`bEE
zhJ1{Ayvd6xP+d>vf%b~FVwqA{@_pwSO+BV~gIe>s5<I*;$MlWRzK-ovrZvxuKYU~K
zJh#R^?N(S*Hjud)n3sRwCgZyH8P{Xq=GiH%gt|9RI9BQiPw1HDfB=7f9B&$q+tUy9
z2d$x=le4EMw;cW`b>n(4D`UBHV`Zk%qszl?WNJ=)r29+Am5~-LHCext(rlxv_!@k3
zYvn+5kSxp1O}m+BBJEu-&QXgz6S<XJhhnLlOPDWS-l0}H<{lmQvF1#vQhVic>4hWO
zaVIUhF6*<9nic47vyJ%uKTf)kz4%I#V*AvG<F`wsg<UVVg9$i0$GD-~E4`+kkCCfo
z0ctzSp-U}72T!aoR%y*1y9U!a+Pjw_bR0(0#rZTbvTCx)b*6||<weS)HI(F$^VcIh
zJ#alRA*N?A(z^hk{I(&f-~(|{KIut2=rQc+m%ATSaoFS-%Q1?#>r8a6cT!^@2%Vxn
zS@Y}zsgnZYwRvU4R3Axl>+EL$ITj9lmB9ve@E?!JZ-;+GnJNn{drVhqHTv(jULVA*
zJ#0*u^*M<3@HfZ3`=<kOU-uuPF-ulMsW_p8cIHR0h#1)^l+<0m#abR@&hi6gg#6q6
z5e=qOz+djQsYsKcLx!$P$NO(pJL=4-pdR|)T>$jXNeX*<eMH!*-%cz|lT>CczD#QF
z``hcwPW30~Jp9Fk>s?<vHovLhm#@gc6OuQb4$smp$|pW1`P_1Gp>g>Eoi@;`LoAL?
zy9s;Yn@490VNougcjGX{?;d-k7CzR3&C2%8<4kS63A)pNFW$2ykhQ9GT0dW}#KEaY
zI}c$B<3)I`uyC@^9NOhO-|3m%!<4aSJKmJ*J^Di!r|z?D$9uH%e?VH`J9Z1Bm2x1U
zp`ZJH>Y@F#SL!9LhMNlZ4qA8`8*GP8Rp0ZU%rje^L#Vu(m{IlDhh=8tn(Y33$$R_`
z54njxco(sPi*l;EY(OPW7ldo-2^JXhqkT>~NVfR^N9xwVXBh<M^zVF>z;xqjM`(hR
z<t_WLDv#YFz0u#_;x=({If^h7Zyr12t1Ztb&9*v0k849vH*M>^$+$OI2$^X7t3j&p
zBNs=^7mN|c?WZz{&(Yn0!+f#XyCbFP-YQk8u6bUq%MkYo6a%e=Iao9L=H<q7W1iJ^
zJf|7<@RnEZ?4i4CK?ho0TE1^R-$`c42v{e9?76M!PVHO7qx+{4Xi`S>&)p5Dw`Eq?
z@iyNd6vwzPn7dt7UPN#9y9w2bDo$^uUgZ>lw(^3^zQe<8J8b{XN3uC8*Ull@rhtoq
zz3vxoHlK>Qw7;AL-I1}Zb`5~(Bp;l#OC$Vk9<)~;NQoQ2{X6;@0D9Kv&d^8WPZxOu
znSI6AnR<Swh^>XuXkFmCDj`J{1@!w?<QEIERO!Wqn(`V23cI{lXWwtzA`CXtj~M3q
zX4b8~+#{xgjp5HRPhNYbAp?)ZT7DmS(AFJo)ooUM6W-RLXIW}otMf3nh(h08%fHRw
z6r!<x+dX+c7eyF6Ki~`(s&1J>40rzdPtQ=26Erx^+txUEPsVg~kEN-wd@YYQ!d<2L
zq1f_Dbl{!ygZ|eX51-jb%4uXDoS4@mUf!~ERddk7HYH2lqX&FG+I|N3II0S0%bS#|
zE)=-dP@Jf_-{?=_SBlA>8$@#WJU>Lq_iaX3B&cORF1hYg)IyZ;)w+f4otAU<nuVS6
z;`GtlYbF!XBRs-pW8#u8BdJb?oCYH+Q?!UH@|k}y@xv^47&&&5-A@bCuMs}yR&5LF
zmppEiFB(g&N>EyJDy`y5CCtUAp%;D3+sMFUi$>3fPZ09<735W~*7>-S^it`hvwJtr
z`WS};zopCC>&x1tAE~L>hR772#{P&q$5ES_c)G<M^{LLc_j^(H_zx;DFoXb0ov0Li
zvi+nS$-e8)fJUx=M+y18tJH1D>-uLudMxB$Jxb8qZQ`$f6u0eG^lTcn9O0Q}5Oc{Z
zGjd^ERcBu7j%<!U?uD<l{^w_vtF8Ha8}TU(qanFwcQgd*!e86WqE1o5yK?W~XFHT!
z#ZSXds2sF!2Idx3imP~ao(*H2?iv`o<68q2h%=Qt=QI&XOPeMp5`*ODiG;;(*eo!-
zpIr6({&FubC9<&?TX-B|Q_~!x{cY@BMoH>7<uOlkuf~x1cm0!}d$g)2+DWHs(T{(4
zUy4$|pU+SS?PEr0-uX=LzkfvCFHsM@{Cvhp`qNN%;)gGEvfb0>^^2n9%)mVdkGcHw
zWYiGm_6>3NSGmE1Cf<dIxTD4n{(tUeiN*5|NULgch+3NK^Vbqi%s8*_XRtj^IrsdM
z`n~Yg2}W<rtIBxZPd(2ofwwTpxlfWAD|UpRZ||M+3R7T+2?1jI7PWCl$**;(hdS{>
zC*i%LR}6@yVxunp6v$9wBfE8K=CYr4Ky_+-T5mk&a7BC0y$)c53Q%wrz$_{!J|x-M
zF%aVOHvCwi<!X}rAcJ3U-%ji;v{*B8`1LbL>(>;U442p=%Ob<3ND<V(VxPtz;;`O`
zRbno$LPe3$fRbk%h}hTO=6{bGX8z$j^ZuL#y0bv{gstaV{!q<+t?oL#Z#}0(7V4_j
zSweeg?$z7AQ#k$ztnTy67t|;5BBL2UglfyRWeK({tPo%)3Ys{Pw{7eDwc_2kK3gd<
zQq1}ZTq)K61$gp!$33!Yrdyw7%0!fS!I9p%Xy-du31X(_8DrB1&f@Q=J2csL`4`?U
z-9^vpIUCjDX^^<i|EoZp;*1c$XvSKWA~VgDws$6HxZUN2VhW1jf3$Wp-lTy^@df}l
zryaez?cHs~m=?>$q~8|y`a_f5*Ndn8h?i_Ezf9)P1t$a<YZU<b^le2m0d_Tn^7vQp
zA10{H%V6tCTPo`bhg|{{?#v`y=pv`L@;9g&SLh%K8)dga)RI4uN=Z^8N`7}Sk$X0g
ze(V{ygDdOoo%_fKCy44e-4gH}#n1@RFsBxG{F)a#Qdufex4Bgl9euNtRtSSjDQIaj
zbZ8sFW`t#h0Z2d9SI>j0<Q@C@h<WdrtX(uNUSyH<A!J`8wh-*Wpn;xBtwiUT45pOz
zGDE(cnqqx?4=q{r-*G#B0W1ifj$SfgkEzz+AjObfcmg6`mz?x)onE|ezIG0+el9y|
zMVTu&;(oawbK%hD0yN&rgxGQ;R$9G`n$k3QS&Q7jc#d$t@x<a|5{h=Y2LCtLi#Ge~
zcU%TIotIvCgn{UhHHncf0`+`)P`WqE2ir^Z;mXt;R*Kgyv4e?8dzTBG+2euoR0RvY
zrJLQtA0I^^C)nGC^o~<4P;~Tt=*%e#R#raKy}~jD1NYj3-qIEFuwvq;w$MF1@;l^N
zaMJO3=Mvsx;KTOoUa%%0EPag^t_neYURon1Pw*$h8MP!wUQ`hPKv06Dk6LIMI%Ef0
z(bFUKEPZ`S3Qk~L;x_=K0Q`;^hWLU)oT$3-1QCyyYqz3=6*e}4Iu?+j3~A9mW~Q_f
zqeqUtl-+k~-oY7IS%VrW<8o$#;S7PNWAVeVm^eJ#mtbAnXBjTkT$V<l`tOk{kit0J
z=*8PXUT#u*B8llUr?M?(Tmuw@7(l;QUMcH@&fx7~$-Mb=#H4EpuYn>EE@wvaaA1hH
zJ|;mVr?G@IyxeaqN_{d{H~@FOy5NXAy4CZiyo;=LwPHK<*7_VFD)Bl5i2j^JuWjc-
zuuenHzpzHC_!3?otvzHiNd#@tqoM|HLvWE87Hnxvr+oYlVSR_6Jz6vDDKQPof<S<X
zFywUHtUELq#PKgnTcn0)m5aj|7GZvZw`lK00?6F@$$$7i)vYaw*B916@F&W2yWTah
zdIJYqSF?eBOqr^n<e=u4Agbuk+pf*Ia|GUADv*cGQT`AH?I98qAHdRPe1jnzD@eXh
zyWJ1I0<s$^ioLkX47x5}KH!+~pmY#LVEu0pIsa|jiVhr?DZ8*Vn|NT9FQIO;e_OD2
zPxuHA+FB9@O*9V#(}I*8{Q!-9AZ;3f=KLTk-Xv=dJh03h<!$97nlioB+IxkYhwdVj
zeq56Iw~yfo9`@ftYMqN#a25va!Ym(>+Eh`5Z-;C9OePbV0_Q|zfSSV91$mr%$clB>
zvnw!{k`<iR2#R2JX_Xqu*Q46LCA^jZ4f6%3cp$A0!P>N?)r!*M*)A6y5Zx`%s@09J
zMqw%>yk^c)d<eCS2cfwTDDX@ex-(|MW#V8pzU17tV#q4@*~q0TuLIXV25MVk;$RK9
zA~iLKW`exvrQ+Pe(GF+a5URV!q(}q>9F!rwc2-fw4!l}lP*iiTvO$AJQG|}f>vVu6
z<Mc4}&jSeQOY1%DU4kjjJM<6Jp(M?J<5VF`>tz^F+oO)ZLi?g=V${9yWY^Lf#LolK
z-%o4D$)&l(14(@dx`%7EOeS6-J_K-&->E>Xz$LVX856(zImJD3miKKACL<1hQXP)$
zyo5*XvtHXPlZn^vR|)M9cxJH#I&sj-dmy8Fza0L9r0JzK-2@h9jNr7d2y#W~ND+aK
zsSrSJ_&=?i>5VgFCARVnb%+6zUB@M+o?4BOm!I)IsE{^whFV`yKq171(J38FEdzZB
z)=PxEdO%_MoCC~lQMT{7J1(7SurCLIH>-G|JNn1t<e3BHYOPPP7;6_ozs}_@EJ!+(
zt=i<0tiH5%cG*QBaNeaW&($u7z#~9miao7MhG+U3oy`h2NqhxT{rnSJGQjz+l+hfa
z3*4I*iPud*^R*B(brbEb+ZWfbTn?0^*o&w{3y_N_INultQ=QUN5Dm^vWTNWY^TrPC
z#f;88@mH9S@Ohj45YUz3m#zeS6!&ppA9-CokTMml6o{ae=Ux5~VjwgODp#;o#^}re
zj&TlO!4cyA`@Zed>SjU@=t7dj>-Rt#R1lmmD}tWAM%-6`13-=(#a>t?S`&DZ^&vrd
zM*~c@!AW2wFf<rB*$eIv>Otdwg98V!QdK%0H52V}n>cV^_*5Z}uMR`oeEYz*t1c~3
z3UY~!oNy%R(YPv8iYSKIH2gbHM4~N1(k4qz5ru$*r^n^nnPtPgmTbLLw(B_1<7<X*
zgJzh(Pi(S*vj4*T%Qr*bYeRwCuH#?bcL}nW!Li36WjIHW0khz|rFA)IzXgKRvLfjF
z)S2!fDYz{S0<8?MVJ~(m1gV)SKtsqGK|`AFKzkoR<_#}>D9ZXIFldh8cwUv!!8Dh7
z8OW`e2^tsk5@k4ZFV*dLcrc}a*(&-6c&lsA@9M&J+)-r*|G7ZCX3)qzFg0=gZ;Z%<
zd6x}%QOME>90b~LOi(p)Xw&QF^CSVyND*kY>Bc{R=#hQYvy>IveLjm7xkMrWdyz|0
zT3b)}2JS%K3+p$EyYqjGwj3&g8m7+XgD(?gKsYo}zpu1<hAK<{P07Lhqe-paCeBNL
zUfh9lj#)^4%>WnE{3`2yB2OU=(+Pog7K<RijE;+^4{}Lpe)bN0xa16o_zot!A?JA_
zaDhiU$hugZJGAu2&;az3Mc9sD!LAR^k^9qbWC`C7W*YXeq^#?gnw=Y1D_e&92zHl=
z9N8$)>iQbCxcOL+I>iMKc?}cW<^S)42xU;pv;5M*PXi7%{q#MHyf?PF1cb=_S&%MV
zVy66dZQi!ocV)O#FBSFSWxatJzkLn83^(`>9VGK%!k+>iFlDoqOGvcp^<W8<|0Uf4
ziCV@SVPP8Pt?(oskox%kM{SCSruA7^=>R}O6|9i%FDqh{uXMG0Sk1lq4}h88rd+%C
zCzlAHevsH$Sr4EPH?DYs<oOop)yPY)4m1nEgDTO<^DBl^Cw=IqN((+ahW||IQ34mT
zKoqXA1y+H2`X^Xc-CbD!5<Vm65*vVV$o7)Fwef;S;$#8}p}RZ3Dysdx(qe`Jyp5V3
z0c|crTZ2h6$1rBJ>}hQ?VdH;}ofbvqhj!pHp0Nv`3RxfP?}BkL-)}`3UVVW6FW+W5
z>L9Om2V{>)3vRQmIb}Ztlla@V0T3Z-5oBPz2$oO$3;<CMv$D0Y-1#m9W<iU_69Sp_
zrS~?=)99q1ha-hVtMYsa)0qAq!MaD9<e;_B*h#!}5U4j`6Gg%Pq{b&@BmM+Ywu3`_
zOlsSH_3}ft%exC-$y_z{tF6}Ub3xz(I+v?xTTM`emxpU#K(()+Zl9%ba{OBbdgGHz
zDBz_}_V;D5q%!0wCvw{z+BJ8~Uk7F;iA`KxQmHx{Hz3#MrVgW3Cab<KF0@A)jwNWg
z)Gs*nZWYYs7M!3_9ZU~L`Uo^svv&WMP1^TG+W0&`=~|q3A@L*Kfab5z_mdij9u>wv
zJPO8Y!JqPk|4GaWzHT_p*oUser@m>p=BjGEd-}C){|4Z9lemlaO&Xb(^xP9J>w++j
zL%h@AcDX~jUvD)!x&sHx@+FA8T-Er<968?so?m$LM9WFEmcx50P~ff`6FWpDDa-QQ
zpzAN6_+V7y3Jrb>3R&cRToAZYW@MH+J!Hb~YU|Uw%ImpWsvXkhJrX_Gyg5V<J0f7H
zUpfFJ5e(FDGKr`nz1c$hTInpXl3cZBn!J?sPAVqa{kAVQaCODw8O|3@Rx!PgXpp|&
zAT@E_)yuZ`U`W0;W47WUk9%?BxrPqE_}CxzZ{O}dTf2=7^ZqLKF5Cw%?avDgQ0?TO
zEPQU`)A)oeILF)t5m})8>zbkQRco>IbTH6A?ciX+Nhv~rGae*7S!8PI269(;2KZ|4
zmM48|-AOc3+C`LCTI^=bME?;tb)xB;PZK5PzRT)t6hkLE6J{&<3EG^`QB6KP&04m5
zZCBqMSz{Kp{Syt-*|l(do1F2(F%$s8AHikizOt29ljp5Vv6;Qq0a#S*Qee5;=bUxl
z?9*Zj%3MBnFj456X_76RDuWkI<hv{F^j?eJQ6S^{**dr%3V&!&_I%GTC3ueO396B8
zI?Q{x;AEcrM~5^a+nH3D8EVP+K)FiaT=2;UGPOuDzK_806%0#W-8H5Y#2XMiroCI;
z%uNMT^=V*!2J?_G6^dRluG$6P5`<}RAVUWGL_-c7m5^BycX`3v!clbjs9-U$e4$-9
z?-{k;=tGxPW+ZwRm2vWm|C&FIcfQDIIA>=N3kxmOx!?DA`+|sq4$ufgexzGxr|t-X
zNAU41U_+5D0l5zrWI>G=>?JH|>YGISWO|nHgxs{wyNPEu;I*O98yfZ4i}q;NJ=}BC
z2jC6OY>3u4IYjI%=JzPEJtg^u#{F9F)Vo5vgs7=t*}a_l?7T)aUTzj_YUW@KT<DM3
z6*~9ytnnz|O$nLwLwag8Zf;h%(Tk&l2N1~wO36i@c%(b&aPcnMY0=6D_s9oF{&{(q
zfOC=KBtuH75(Qjm>Wb$l{uhThAbNWAFohh}$rM5vxk&!|&40;d+KMv6UiIGKTIBpJ
z3eRez+o@H?1&OBN;YKP2z#oyFT2E!RJimF4xzh8;wCC#=v9)=f(Q7s_>}JkQ2cED=
z7Yi=kTT7=Yw83^nMeV++blUH4{pkk<^sq@H;oJakJ&UUhL#V_4qj6!-OL>m>JK9}L
z5ZAdphpdjqSe^`LJEA{_w|fdStyEZytnJCtQVL8)5)!_pm7QPP`Dnlkjh6Ib>htba
zB4S?=6pge%Z}2{{p*(%z51EdeE*<G>B-K(jP8%<^t@m^~{GuFkmwXW)ti%t-XS4!O
z`8RrKLq+j`$QdMilT=`3{{^H<6Im#w$lKwNWymTyJ5hULHr3#_bfa^3=h4G2SJ+{T
zc*!<npuqiJjnuat@&{q(5bHOsD?gyWF_e4^#3}4dbf1lGT_(YX^C?*NZlI?(Yw-#G
z59$Hfje!inowIy+l^vbB>7T{dd3haDkeGc%&ORWwxV)$|Jn7f{4p(uhJ>s08cTcf*
z5AwHzKe^$96VF-KGK@uYUq6-L-mm&iOLxzW`-?!m#BJVzMBO+qjd)C1c?Z9WU6Wj5
z_Dc<X9A9grIoK8=syZ+ywGVd|)4d=#1_%o)VdqZY{xIeilv{?CyF36n-a|26y6$n`
zv*mt>Bpf_5|NGq(Oj&&dah*Q&BO&WlF37@lo&^D$wO8PFpR2p65dZaEFiv!b&Q(q*
zwd^!#Etl4PaKTG*wBMLoywKI7MOOs*Y%*bV)cY)Ga{YEQ+Z`Kb>4Eeto5j?!r9osF
zBZ9xYcuzZu3^HAGW>%`)8aZ=x+ueh7qkmYiwp`(N|KfV`$g-AnfJ`53Q!vvH6j(8X
z$hM;pl23~I&w`L6_LgJhr$sB)Zx`Qc-Tqo~iE4($NSH;=vebx7fRY>Q3x^I8J_eGz
zfjU)@{@U>S3X1>UHF_6*u?>8y$uQy}_4-x#XPT;s-ioO!{k4lMUlB)643;{lez-Ga
z2S&nx3&Xi&&grfmVD^<AO%D<ODHG5|HUe>0b&`k{Bz_!7ANTFU+cK^_(-<-}KGyqp
zh)wNITpitXH~y@8q12`Q;+vW^G)u!PVg7E7;o#jiRKPV){6BU?(3CRuor@SYIX6%M
zxCi=l4bxW<P5wuZGM|e(zz{xtQCsg^(NSvr>hs#pTSmsCu|J#sGj)69FC^7H@EKuS
zN6Q!BEif^8$~CIUglm23N&qoG#p4voH%&{^(qrUr+-bc$U!&*H)us_jU1%kB*0r*C
zEia8Tnk>m$I|hLRGlS=+3Fi>uj7N!dkg%-x-<DralnV3ZL@nO*PwijlimDm;_**Qo
zu+FW%%H;F5457|Ggs&u7Kdinebodq&C}Dyg*rP%{@Q=DFq`;HN?aQME8~ZOVfG1dJ
z2rAK&r6(|*XysnIl;XH^f%$L%DH)DTW1xowlN3)*6f;`-CQoY2{1LMHbcE|EIB{Y}
zH{1Fzwztjv0$WoZ3GQ@((}>K<cB_xb+7k6K6T6Bq9LQyFG<;1N#Y(NjIzIn^jq=b&
zFfE<FK03d?rV1eC!N8v^4dCJ75x=4*&$FQ7VDO<SQr4@g55e}@vx4h~UP7w9?svcM
zLD-C6`#m4{;EVK-*>4w*3DOf()UnpedXdYU=a5n@hLP<*Bc1OW@%xrfG!BQc8Ku+L
zdpJ_X=#Qg4^avgs4Jj@GMp*&keOmb$WWXyW;;q9c65M*2i}0$BxN9EMQ&3QR!hU0d
zG>fwB&~p`TjblAu3ajw8MY#lk4QtOg2szKdH~zZX;_~uGk4lYR3AAXo5`i*WTvM%r
zL;r8Ik!;C#VOg7`$P8z+7brJo(uvNiV<<=P4amy&;Fqz!-4rQwD5Eb9lutk{r9}l~
zw>I_mh@H#!#@E<kQGC1lt>%G@W9hg^=f1(uv3v#P*#;d@TBG9Gt8uxoW;BFxe|sGS
z_S&}V5p%6+=T+Y%9`%4MSC2WZqSzd5l*_!fD?_$;id2$l<<3mD{Lr&BA12VcrNUn0
zIGuFGp_IY1<Y7ok${Tdcu$oM%A$7TcpYPE9x;EHhMQSwU#c=d;0!bElN1I!gRU0vt
zi9CmR{;az=l~j4n4_ol*!J?;5FvM4bPO7&qsCDo8#rLj(eZs5fWCGr=gLc)<&)&R7
zyhuEk^ff}rzpe;7_G$XFR=3L6gU!h0m`tTgGcll#MBjmz&4)x2ufyoezn+<2oBQ#X
zbSpaa%3o=S)GZ2rC3toM2yM^Y0)Jhey%VO41aS~Q;)gZf(;+AV<I$QEsK21}-w%4l
zWVl?oGHw5McfJ5yF-kC`w%)V^l}Ofy(G7H>^^Ao1UX76tY$p=mOF04wYO5&M+^3Di
zV}tZnH&;XyT7}EX1IdZ*e?f)}g~Kh47G-08!do6I1|Vw(@1J8#!Zj`)hkw?22<n_&
z-I8EKtsz^B&e{LGqxbCB8Nvl`u?R*ol8#I%t}6Vjp|sdJ;wn!xH%B<t>>F<acy_xG
zWm732CqRuNywkuw`Fvn;=NJBah3>L?fb7AsA^_wIQLgzVu~XAMgJlLtv>M-6a7<CP
z_l-MVFR9yj*f7fvHnK!h4XE_s1JOvdQtV2^@_fZQ`J5M=29RK(7M<sZaerZX!^C>e
zo|-K5%0wx@SIHbrl@}*}*`k6!^{Q|EiBk;TVH}ITsoXggyPTl-y~@-Piv#A~!ij-o
zA>z&8D^@+952OYG$PtmGu?1XKw`$2U0QKR4W5sXqZqLJ>HPO-Kx-mWscGsl7cc|s{
zQ%uqPawm8l9Wee8ALMqR-&|atc@B~6p|B{Z%Mj$melad*UmKhw1a-ef5xl1sHEP#S
zS3Y7j&deDuz=r7d`WcNT74^kELGC-OnP4ILrfW$lUgA)>@)AAhCZ(e@p(j_3qOdAt
zq>Ot0tn&<uK;Li@enT<BQ%#YDp=8(X|I+{V8+C7Go3D}F9A@N~{dkW#WorP6fW{na
z+GYvZcJIS(?X=}wmSk>f`u7pt6qJh%J~YiGg8*2mu0sZfuZmZq)^%8Y2-r)}Iq!RZ
zr%3;q?77j;Geyc5OyHX^#9MkWR_%EGZx0$w=;RXEsnr-DLgtRzgxS02gpBV9x!*$-
ztND$#?`^ymJStH6L$9`h>BeSZQ~);=7#Mm3=Y?f{Eq>GLc4Uq}E18J8O>1hqFReAs
zy9{4M5p?5lJ_N_#Not=DdR*}O@0|=wXhA{XF^^?Fl?n$${EB3<<is<c%zjT$XGxxa
zRUxIUBb~o>OCs48ajoP6@mdD26op7xncn~PzV?F;u{~e#mH*0FO>VdW+tcV&zWV1*
zPig`!rh47XGSRhlUJlF~+vaStwaLVW2GSe+;U3;*vOj+$({WSdY#%KM(I3G(MuzX0
zddWF4sa^XEAV))yMjrKUg4K$0ybB)m(WzXPtNynr$b=l1*coBTqZgbtUJg=ZDC)PB
z&4g9WyS-ZH-eJ;r88%5NMTvpuVm&mJrCgRu$m>ijrIO-;nf?1>xT8W1T~{f`cGQ$u
z%OF)}#>{fU%Ek3H@TT5E&>Q5LB*?o)iAj`+ldD>gzu$4SjcS4<3$fflue^BS!@Hp2
za{<0J!hP^46HL9)qgTELA)jf)UK?9G4#S^|8^{Pf9nh>SzutG*uYrf|^{T{Fno2|r
z^vEUcxJ~-saSYVj>b#i&IHb!yqUxH#6f4N!9RE09xaPY&&xg#PtPDZHR}?iQxWy!*
zo$(Cg%=w<0U~VojH7lB#_;`>Y(-(Dl3Vv!vhAmjs27oJKm%kT)4+K{M*IpHw8WZ%~
zbZ5wd%lUPQ=o8sqn-pif6<P5o8lD+Y)<f3QImaG+KAQw}5evsXmD2octjWi>ipIIz
z?TSui6b=0PRz5y`L<7`+N)K|2442it1=6}VwQwuL)?OwrQ>Q#vecfLgQ!WANBL|*8
z(;)I-F#;SOvPRQE6|NcPDZ_1W_V9`7HcvgXN=wqxH!0vroKxFAQ4UQoDD8k}WUt+t
z>^iyf*_c8F6fl$*Iduv3pKiB}7<OG-yWlvI=mYgi!0{?H(v|65WN^+Xt!NL4$Qng$
z*!a<L^xWg0>@E>inPdAW-#lRT%-~yKR3OQ{%-b)sm>@MpSxHK5eLLnKPGw3>Q)Ki;
z28WhGS0V57Xg6(|yJlwsJb*cACvCeW8Ss-q>uRb~fTp<x!0i~TYEX1Zh`~q&hD4wq
z_vWo97n=>oXq1S!9hF8N)!;sHfbA&&+*5lN(8{}gLHdHeoI*a}@)cy{_{Ua{Fjgoz
z3oBC3Wo+S}VCtn7WBSxJ0Ey2k6fC;J1C-o)*avenQ>S`~GytF7EC^*dgHXEaTVlc5
zxH3xI<_Nx(2paknWFG|@Blm`{F!q7J0YExnPZoSY1}_vQBAc4e-&GEbFsPq5Jlg(n
z2?3;P5b_(lxTE$nqZj4s0tMr+{JkespcDv14OKb!E!5K)#<Ea|9uc+Xv0Qdoeph6G
z1y7!Gb)y%1Nz0^QhFGwO$)jdvVcO&V&3MZ0U*duXvoWy5YnkUIVHsd9SX5id{W?f~
zViw#%a80cA(7@$KtzjbfUbRDvp0Zt~0pE)R^{S^lbZTVpe`e^wz!xSLu603xH^FpX
z1)H5yHee?`WciUDQWqoF$K{^>e|GREvj9+5IQ?(P3yn~T6|!O-SAC`Q&vvaicTwP2
zVfSNxtz$nKfl1)oBF1OC_3RZCSv*9}SXk6GgxQ-hTyRpHAi(_5#j%ami1TSRNZrg1
zj({)=XP3FGQ{J;?$R5#U3{qj56fUiEdR5?D39${_wsj1^kh<N%a84fRwlWDOh7HOr
z^Zfq!)j4zl`vRbC`ix2sepHw|SPhKu2dfgc>@r!c)_#)-xCazC#PGwJ<4uYZljX(-
zms&onOI`3$%2GZ3g$d{h0pCxX4m*l!T(vJ-w#EQxjS>UHzfKO8f6>AB&i?U<eCTVL
zeZ5QI94Leyc=qW=iTvK#5uoGpm%-VkHd*HXnX9X_cQ`X#0&aC+knCZb@&3s##(mn_
zF`^O6wnff6f0qFm6$hp}DePRcA>ZKguY!LJz=&-*u$<A|^1Mpj_b(e7B%i+z-ys|>
zs{m~OGdxfNrX9<3HR}A_BJHa}`aRZ_1GmBgBW=OQ3}Ba9;(5Ge&$V?G`enBi`s5Fk
zf^-xqCYZhb0qit00XIqX-B_sA@tNI$0l0srrQsyMfs#Y@Wi8|A16Pk+xqj^9{-AG@
z4_{?2PzUb0=TNi+*7kw{vqS^uE>`?5lQK1G%{I+D(^j)KFfcH1Uj&X<cv$@Jxz4{L
z!21fYySBrMp$M4j9kvOqh%K{t{FNEv7mwAzv4wf^8x%gKr$s2_Zitd+U;^ea_w$D=
zt&g=HSo9>35#obCiY(jK$A?)=z07w0&dNENwV;qF&_4N-QFEodK=9|@$Mq?>oR@zw
z*f4EoVA!M0)MtKQdcE0=Lz&H@uUJi2e9&0K33A!Yiws+}_Ozemmk5#UnHAu0%`LSx
zyX3f?wdSV%2Y>qU{;5;A#{5CA=PBb49$`U`KRIoz>t1j5IXmO-!|C-0B<vgX71$XL
zv<m`bz<kzxUlD~_YsJ{F9SK_{^*j=^F}Q(0;$Hps^T)s6D>4FZDIT0)!kPcf@)4#n
T?AJC-2D#AF)z4*}Q$iB}j&8S8

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_generic_file.png b/Images/Icons/Filesystem/fs_generic_file.png
new file mode 100644
index 0000000000000000000000000000000000000000..ee0ab965e3482bfc050ff22a1a30fe294c961bd0
GIT binary patch
literal 8419
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
JlA~=M^grs-`#b;u

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_generic_folder.png b/Images/Icons/Filesystem/fs_generic_folder.png
new file mode 100644
index 0000000000000000000000000000000000000000..8ba89266bb905c68ed19a6fb30417c7d7861a06b
GIT binary patch
literal 10982
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
XXUsk?4|FWUHtU@=`ls}?!`=S^d1)+v

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_invalid.png b/Images/Icons/Filesystem/fs_invalid.png
new file mode 100644
index 0000000000000000000000000000000000000000..3015026d851d7d3b6897ea737218897e13ef4a7d
GIT binary patch
literal 319986
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

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_jpa.png b/Images/Icons/Filesystem/fs_jpa.png
new file mode 100644
index 0000000000000000000000000000000000000000..4f541644c9c3ba6e4dd64e0ad9fb7e1ca32d628e
GIT binary patch
literal 57806
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%0A8!Af1d%9NOVL
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
HP2~RoXR?7a

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_map.png b/Images/Icons/Filesystem/fs_map.png
new file mode 100644
index 0000000000000000000000000000000000000000..79c8304add6585361c6d44da107327199c5b69a9
GIT binary patch
literal 61346
zcma(2by!qi)CLTn8HSQ>q#Kkj0g0hIR1^tmkd%~;8KhAfLAph0>1OCsP>_ZprMqL8
zdHFrh^ZoZ-*Zcl4*O|HIoW0Ll``&A>xL5QuT{WTybPoUkAkt7*egOdB`>$XC59j`J
z=KJ>s06;DdN=nZhtgQinC($cWS_?~oGQ6`_O_}{s9jV3-70QngWd%OY4^JEum5(NE
zBm`OGZ6y>wR9INE8b&?ocz_9M_)zhIh37-mXDH$|yJfpI7(eN!NC0&7XY<c2(B+${
z!P))7gb|vGL1#k~W3xXpuJ2b%=p{m$EHh94q|@>bTw)2lI#eosy&I&XrpM+$zq~`9
zBcxr%Bf}}v_*{(Y5bu&c-B<C-P||(~6z-Z*`TF{md&_WcOogEh-9l+es*6Q?NbIN2
z6ij5q>ouH(-b`K;t|FbZpP%wf#Os6^b=z;H7;<YRCj4!)nOcyz*)+*xVNybK+48v;
z4Mj=tIBK+T6@OLM8%`@O_rT<qWYaO1d0$54ul2dhMIdT%KbsC*OSxwaKdO`MdDU?s
zsIHrAUT`>7k085hSYB<Z+`e^dCc@HtyAXrXcqg*>ow6-g=}_csQQ^{2yln2NT|DW0
z3U^C*s1j}JT}Qq7T({lzq7hlu{Q}^-sT+9$00H@bAJF(>FbV)z01ah@m%ej*?f7+k
zM&4B32eE_4wjI}Z`KA8fN-<h@tt}=yrAaMeI0*?L{5B!Ox5D+GIM_M(7qr0CIQiHk
z7V?9%PBn=MkU{XL1k$9$E~kg0gQ|)Jtsn)T*JY(<M40I+%o6J4-$-EkL$c{h<=&u&
z4<A~;wRx+&F<W0_hGt-AKadT`^&FGMh0C*$;z7V6|6ebPx?Kf1l#0I}vi<j%C4Sd7
z<^Mhp{=bp%f&U$B1TR|`6hcZoA-3O{@%7KpmoC3zPc4>bkpI1}n?a!!_@9aM@PPlB
zJ?s_m4<Hp$o4IjG8fgEr8PGG8-{S#%=#V%NEil`?%PGobylfHcl-`rkJ#8(h)cM=2
z=h;DPZJjurw^q-`D^wsg<fkKwo(R?(KTTY}dG3N8!UlvjThsN_e!J9t>{h@u0OJmN
zM{b>aap%6tzJ2}RrqUrEHs@JJs=T8x&FU;Ax>aA>A>f{yw!xq)(vJs;0Z7#)wYL|s
z{aUXiwoYpT_c;dgm_D+H3mtmS9qM_+)ygy``%WbXW5n)%bxf%GMxpR2K`iSJ9Axs^
z+9Zgct3F&7v-zU>iQ{^qPK(JXC)6*{W#L3QX?Gv?tFDvx*UXo+K~7R0u)HDOaR5=;
z5<x6MxWH=r$0$V`*3yDFrxz#jF?2tNN3zl`Gq@Tp&8*oqQX=H<RmM8~rQgZ;ZvcLn
z%orK?KS8@eqSf5zb=2obTebwF$<r@XA^aJ%o9Wt`Y;bupp!<aqS%QeS!zW|`Qu@0>
zZb=g!g`|5`CRe0YdR}E3MuJPWs+N|X63v|eu<#8mueP}zW~b1ukq^DKT<>W>g#UZW
z@hde~m0{U>g4{keH&glS+B|u^ZPd}36z>$m4<dbw!#6JSJu&ApAen2(FS)Kp;3_HN
z@3>9#Z6QnYo&t&1H$wlrA}!+Dn}wnR?q7aHk4ZmA{!sW25((1Uwe^nA4|R55;RL-N
zpML8{s8M>W!^Sioj42PE=E!}>^&mMezGx};t+O^oJqxLb`*=Z4(OY>)w<COxi30Cl
z>Hq&>s0AASzrWak|Ao0a@PB{@{U7Eb|BF8e`TyGu;1J+wd#vN;STE?Hp82b&!u_1H
z0KrZ8B5gKPcY%9g;DyP}*JFased5-=b2n|{3k3F6t>9wot?c`Vd#tkt{HIz%HMLD<
zik~-}Z7{A3R2_GpJk6``D80C!i)i|(b9t(xNVBWu#oVG=)%)Q&06grz70X=$cxG<T
z?Q8!Drcf-UBn%ZIni6<&%iFZi<BjY3M&fHi>2g`;6><@#VV86-*1e1m;Gv<RCfdC1
zyX2Tb&!9)Z92VSXUKfHO84<O(#Bn9e{oRXe9(d3^_Ggy!UL)i{Sex(7KuL9L`}f@3
zTnXH-lI~G3*`xZ1vqQnkXMo{a&-h)*T+Ig%m^BNx@%DCFke+s~;^2?TfG_NBO27Z(
z<-xeh{VVf=Si>SVj<?qLw9%$Y^CPsP8UX1=-0kJzbm?R%@f+9h#Evu+*}F#oli35I
zVw`1X^$WAr*F6SarBB*dKr{jUa)j?^s!Jz9=v#@lO<B_xwtGV}dsIsLc_$RNA-a5u
z&eiK|BZuwc(%JrAKc{_NT?$IXPpQ>V5wx)KMJ(UHsbG1z$i|uyO%;}F6EfV@4xg${
z64SSHxHYyJtJj;kt`o2B%~!ZjrL*+wn@Qe^;}8IfhtvYYg#@#*v){2EUlQ#;BZul~
z-dKZ|6=%%a`%&wMG8XueSM0bh>VCYBaQtP<Fc4(b`R<e&^yciLsT4Tm8AQha%)Y{)
z>{U_hotkOI^=Ad;N@e-QHp$sV<U%snEE`Dv%R^*))65!Ue=`zxs=4&->+#iH)?yzA
zLd%jH;&E_(6xs7KYPqY7ssA$iOGsR9z{Cucj&?3`Z}TkY_(#BH+_ob*UYHDsy;Sk<
zG=m-NsK*qE5?mcz@Myz4xUqK6)w`F0jF^PP)l=h^`p7()3A0hud+0Uu9FRG{yLFv8
zqO=MG0*0WZR=#`+Sm>|EH=8=47&~9{s+cmG1Eg#buQm%QwaQJ#*LPAjqaCef6|j-0
zU)F2hzg;PE{}TXPS5I%rj@B5v>A0$B0LFW8t^j8FRPqXvXZML%FHu=JEbtp=1kCG6
z@SEwO2$wp`u>}k#(UrvN9dBrMCu+rxY2p<(DW0cWX$J6l{!=FNq2sT^iz|U;8o-h`
zu{+=%xi!6OwY7F#HB(I%(242k!>2o9jK^w;ok~rH_@v7y%_6!Cg>_fIwxGkMkoc=`
zDgma8Pj|UkztIdxX2NCRXb?Cgfz!=2_w&fuY7o)#?$f|KL0tZK5%>T!g@pwqKM29a
z-Spv9aKV3j7sY`VY~h;uG{hW|gSp>RCHN4aLy_QGo~z${SN3fd2M_Q;(ZNvz1noJJ
z37%iT2qzms9ra$0F6G&R!68DAgpxZAOfc2UtA&inD@$s{pAOjYZvEYRT<ViUw>J2>
zX3SH1F;p5+&=^!Q9>9kiNXZJIm>GG1z+KeaVFgz%LzgDoj^lQVj7|&8*WhdDxXb;(
zq`0ig+ec?-wgU+@cCG%Wt}3$}IKue9SR=|E-=KCE_kS&MV8a!_@Pv#jaUB`{XteaL
z|7oLNuGa4PDdm!r`qzU&62F;-<vmT}Rr1IhwVnP%D8W_m#HrlI!@b8S*XZZ&meDo?
zrG5v8bhj{L^tBkW%IMC#;3*aa+@*AbT3<&wy$PtBoTP)nj78oGyFT`cr)zXsY|*|m
z3Y+8#9<3n3CtmtJJvGpfVMvCo!J~a?i8XRK&wgyKx!SpBa^$Ur;N{jv(zuloSDXE-
z{<>!VWSki|^qbzlTX+4Y4tS<Lm=WSen3(6eazdd$1?^|978lWIpJ7;g_~o?LYVJaN
zK%*M_M|ne8i-+$W(t^|a45ebu*6^fwsE4hP%J-tv#*dBWtfZcc7@`_4HGeHJi#2_a
zSra<Zd-_dV17+ItA(?mk+#Juh<kw1d*{lZqa*Xi=`3=vvz!H(H<Jb8!uTs=r^ZBzs
zG88>N3|r^BLT@?+RTzFE=yILWYn#HgTw80$)~<9_uuK_Oe$*uz_W=F(F#7x8y_HLa
zU+L)vFV&N9%q(r&|N5KTHU0ot3cX+UACgj1epQdIT*+8E+DfW0)6?lE9e?b?Njr1J
zCP*>GA(p`)S5w2Is~4gA8mQFy1zc=|G))qMpIaeb<6&&rQi_#Dl?x)^U!Y^El$hrD
zNTu8F=EIr5_3~Q#6Fag_cAme~7xbZ{$s4LHF0{8x0_H+)V~6q2li9$Qes1sI-w-MK
z-&As5C-SyCm=qUj#XRq2SWl_`B9RENgz^6E>6!nqZ7vvn-t+pVpP5NNtpj&Yfv-P#
zTX`51)(hh_x|`ud`^-PhGItl^_rA+kzbcs_{YLa#VgR?4k{3=@Jv{>UE~af-bYsKP
z@taSv0v5e~)pi_m!+z>7A9%8@gjw*-hT$9Q90lWU5bY6PxIbE>7(K>6Eha(UnL8+x
z<Ms7+9nVT=6~0PqI18vcJOBOoTk?aDJPvtkJI{ysfFe+B<LY1$oLs$p_quqak&9J&
z#8#Yw>+<H+H%v9}vVxXB%5-2&g5%h8Df2mybqO%N`9uI`@qefO%QX3eMe9^#NyZDj
z6b4qf6xNLTV5@dWH=qT445P5vn_-cmwDUJB<o&V2ie^z4wh#fq`sK#nyf?o=ctYh1
zQ{)Gww{wHp?e-$9t9o-2k-^TNU>WN2-`+jA{#ojG9Mn3W2}=@wa&JW7Yiny>1Xs+s
zT`oMUm*#<F^1cyNGW|*9Tk<tl0Tx|GV;^ugaoPfmLe>Ntm%5aYVc@*UG^=8w-w!!*
z3CA-V!sYcJe8@H?ajA0uHgcOur4xhY&4_<wcNfVh{eU&qt(&J{ntk*+LlN!P;MiT+
zfdoUl+u<n5_`SP$5>i+=5l?{Qvj9VrY1~Lm1goa9!PO}7?V~>ONB7PrX#jkW_EHni
z>!BncB)X%R6(Mj-?D(qPj9XSkd0B7&a3>UXTd*Ty=oPju$ML)oO1O{+8xc+k#0zG3
zCIj5Y?HqY=i6M?8InEx^FREWnS~T`2=~X6-O?CHb#aO>g#AhP)o2B2&#Uq7H1fkAp
z<c=0dChWOLH%O%O^$-N(-a&W8Q-Phs+vzw)_#mbi0tpaAj1pcxGgB@MYF*$_Tm|!7
zP$4-*-<j3;#AZhN{^2$q;lkXBD*4}1ZQq@~R3gNdS8MqjKR5b9-Wc*LIzymO9^Z%Z
zY&jYy@@;sR?&tUz(36|iBwfP9WvNa>8q!>7h&b_4^F9(SeKI;Gy%}-0qjh<Jg2cLk
zEx#hshjs8fYBl)Bs{75liF(4S!6`>=&HR-L%(o>8!G}*WwGEWOCam(#>(5=khz<S1
zo27SE@U_gP(71_wM}TahRbQ>rJPZ<R7K{b9=tjxm<N#lO<S#2cx?DjAaK;NlXM=$1
z*PADTq3s!zSYA&qq}=<SbZ59l!B02Fuq;5_<fjzfkLlUG{co#A)~-}G-Fh+C-R+xb
z)>vOKE0!MS=&Wo#3)LjOXqHlhNtC2deogkfS{*1y0&;S<0i*SlosA_`1C<kzL}uDI
zTF>bRF0M!f`F-`tF)Ow@{)c=1(o02%2>Ez{>>OYM51uz2zzd{`bBn-7AgwPTdw*#c
zo>{SUy-;~Wi3nh-hx2IdIe0*4D0{LX`A@0oZgW3lZp3eW2(FH4<gON=g+}r$MLoyI
z$7#lSL5icr()aGni-oKlWk7i@>Jzs7q&;lp;G%y?Hv>=y=PgT0%H0`h04;4Xol4|T
z0y^hf7ED<Pe0q$?ckM5H!c511e}bY@0vzH6#I+8+d{28FpkaKsk#`=%i8JMvp0^O$
zF3!~lG-8l$Y53ZDxC$fFPAr2x60-5%55<D2M7z>{_IwzE{>;Pk(OSznzNz}Y6Z+{G
zis{D9x#Rdn2xg^KQ&YQy*u(nLvyPM_CCs%~WqdblYWP24cgE|mfVGw6)zF0#68Q$J
z)n<RllN+BBXZyG=xIEDpf5Z-YrW}u1Kigc7GEVmCG$x0V&^I{@F74Jwgx>}vT`eW_
zcEaL@f^6+Cy>3nT$g*Y9Al>Khp99O}2utqt%iI)H4@5qJ7QxXSdjfdx{2ZlkTD17h
zQ~PHuHeCie^e_dw()pIHUli}D_sZ?Ueiypa?gL{p&GEchAbQkE%mfeOps%a9RAmBR
zl#zI9eEP9)Pdy7bnlJx$dHiLJQGFG<Lw9tcVm>EB@YtBB;|K@gV#*DYKO)2Y*&Z9=
zZD2nPE-$RuwKV$ve14vb6-Iatb<RA}ore!(lfNO-obHA4qnx(4&e^W5+49t-;3|ls
zPwanqg!4REC!65Eh5?sp+68CLG=-Ru3={J&3PQ~Rol72#`a7)nl*lD}<DSa_#$9zW
zmgQ^HM>y*%^L_F-7O2tq#a16}(Wq)oNm<#&6yiR?CW>O@pG;;QYpwCQ1Rj&U>?-w}
zCfS?kKKDii$NRYUG??OsE3#y&^{80SzFJ>P0HD;Q!-xMPG-1p|f3i3VmhzWli|(Wp
zCuMJc@kIB@^H4_7o27T@M^oV--0a8iiE^$J$Uw#6&jAZc7F`S9G~9wH7&&MeHzuS-
zz(Oe|gx-nJMM83++aIggUW-%(z2kRS|E!8ixKm=w6GcXGUN0RKkd82;aej3!h$$_}
z?I<u(F;uk}SuC8WHTUNJfSk%O|MHdB;mzMfg}Q9~%tl#_o7dy5QafLcnieA?)2QDN
zPOY!?@I0Op^$RW`5`-Fs$BgPT3gW|y&#uPMl@_b)+K9!t4zp<X+M@MCDu6BQ>QHMH
zR>CQZcEPSB{DmACGi<=-{~)q`Ed30yV3Pms6CQq9%Y~8@em2QJQ%d^+qAvV<-A(^~
zAzWv5*C?`*`TA05p{e_5w4F>yA&I^@xVvU~`RWX6)v<SPUy;!G@fdiMvV3YalRAt=
z12YU)dxsTQg>&Ni>On}%{(gYxgQL^mm4Rm)oPmE_sKl~4<qXJyk<DXF)7e$$i?~lE
zPv=y{<7QR`tX`Z9tjfB!_QL*_$@}ElrY@v~p(cO$(}S<u16GD4qS&?MBLDo_f2)GC
z_mck+<O@Fp+1Zt!l7v!HitE@+DRK3q6UWz^RDI9T9o*>CY*p164_jaWS$6myHk17R
z$xb<{@l?)Fg%0;uHiM6V?BZo_7?_2~GJ+GF^CrXXxA?Mx6A&*AZc(Mcp-$>p+rQms
z4jwfg`at92vvQs7xGsD}5pzuXc;h;4aR!N&_$2I<v7}_kcMQvApfMMW9MB~_#tqNA
zhd*?-?lx`!vyl!W5#;sAa};H!dkzK~0V}1v95NJr(jMWmC)4b-6jlq!gla^Wq4#mv
zq0wfD7Qo~3l8to=Tb`Vxltd^=xu`+dxNrnVqk!lts5E9peKo1Nm1=c6a7*qzdbPcE
zY{HpiJ?(7Fjef7?c8vR}adLRHy|6WCIa|+kdmoyRgSHG{VWg$d4e)x@vKaV?mn+>U
zxZi&$EWW*j#7AP}N1}mi8D-tndDnJwKtKRV?UiiUH3h~zA>t|?p!ikEfiBwB(`ZQI
zWfKF}^a<R0AcjM3zP|iUV$3O|;_#LU_5x%f`fO|nv_;po$)fQkOVG`RUCR1Te#{g2
zeg>R-DhtwGGVN!P&k8*bFkk!U$6loHBB?kc53Cn#xf%lsEY1|-K?WWpJ<SzGQxb4z
zSc5?l!elLF;(jmXe#)o-5tmDeMVJH5%ER5?jgI4SPg#Q#-E>GckIdR}&2Pe9is{_V
zeOG4#NOi~om6tUoFm3d;i<Gvb>GYajM$oWT6m#JE%ALho`I3x;^D68TjO+aHC7WiF
zO^Z=N2aP3BNQ^vMArWMko`>7&Mcg<IAZsg!=v(CsS`j24sVN;apj)!wBz!zCo`BGx
zI#K@1+|HYOy?4gG<+rSSa<X-1J`DQ)_;iI@?trmSW7yqXTIt~f_$lwgLvi>m4bDOu
z7*RL%Pp7u$ee(M8GDF*96I>8h1D5uB*Bi`12I2r>ifuYIa;^^3*o*(3b6#?i0emZY
zje#U=$AvHYxMW@H-)|qM?XSz75!>lxu=SNAROJncsu!6tzx)X9N~o|DbE4`!n7ykB
zkLf~NGc#VIR_bYLSYR8+$|<ablzwEJ2NCQzEu$m7(7+X>CoJl%h$VHkk1PmfaG5Kv
zabx`VnGPNP7X!RA9T4vL2+WO@u_O*(Z9gWfkxDA<!}Pg6*^l?+2hKS?X`LmYb8`Ax
zdUrNBM4k-i;?MSB>h#H>rP@MeYqp@%$!q0RP8dh<o6I@r=a~AwmErOaqnk?i;U;_}
zgdH$$e-DP!*o#RgQZMNIjyx9$y?nQ<6Ut5BRdi_1MQV_xkZ!d)&^Aqlbpeij@7r-$
zOtNsNFV>2$A8<QR0_EbqVoq7pBVh|VnrSSWyzRA73WUt;uIF>y4ZNd3wpn-tPyLIH
z$J=#af6!!er6MtZ6y7S%lV+HAO6n~~$K{ePq7JNkTjb`TRsD*q&7_litBN0fGqcj#
zy}m4t?hwR1=-59NrTtRxR6k6^uo2(=xhO4?rtlsh)Hizc53AGg&vF*OA4PM8+DVAd
zlwot@_z&g!r6j_KQe6#WxKW?ST+a5hK(D&Dq|MuWHY4r(DPAO?VS<>zw2bb@z06Nv
z|0O8-1nHgCKf5?I&uer=v{r!LoK0J>yq|X$sc;?xjegH?>7rRW=#IQ7P4s5Nt4IIy
z)UGvKoSz+bIiUDD(6zlyBTOI{d&zk$>h&X3{RIb$7`4*P@TuA=j7JvzS`X*wqM0MO
z>@CclY3edL&yJWLER3<M{YL?;B{Q^AUs%@mFK-j!=xO}=w%4uReyjnjs&ag`HE?8c
zLel#81tDQB`Cez>ai|ZP%m~y?yPcaA^fBu%v>Y94gwlwTQ3rf~DUJuig~-J?wsSAS
zbgo<*`6ag;$5RdV!a9tSIMG+JG5CT|sf6y%6olNTf(QF{t}ZSIdUQc7HiV4_XY>Nc
z@o%<@-r3xRZRD~ju>EBXUKpKDTXzk4L?_CPHu^6w@ks-&me%3fBeVVw)5-z1SeKbG
ziG-BDzHzHPaOMs4PwshZ3+|5pk@UQkT(z>wL?tTv&-At4oeOM<;s>c<=NZbgQ!&-D
zkFj8_wkmCEtAw$2hOjQcT@i8C7N;jkgwkIbPAGyoAf)-Xj~gLx2um#tGurK-TCLQa
zfXm<8BU`-(O^crdL3=d!o0Gc2K3>n#CqO>{)zn`2`P0BfUUx$qTh3L_o~Pl=(!30g
zYs3nwzVTFJb-)b+G!BkNU)ga2Oj;+<Cc<O1Qpd;Be~i|;G>Uu1Gm)~7aGv4ivDh0#
zL_GT_T;xtQ`bKSl>+;7g{U7s?zE9EZT^-!tEM)F>aOK>X523fiPF%0p-neA?x_O)k
z6Qj(_23m6zWi{GP^YGw!w1?44RsOkyU4Btcx0^UJdtZ(Yuw6m~%**EdNISt?=W?_5
zU9USz9?-wy{~^l)N{Cl5larOLNdJ)SwZ3e?>6uKNmzU;1#`ra56Y3Vt+?e0yy+fJP
zB$CnKcuu^`=7%;@`2=2WVTMONQ)DtQc?(+3MbSQ-;UQX9#ad3+ac1kzFU9>BVz?sJ
z<u_rKTJl%YmQ51+?<*xX4s9#ZNJ}-gsNkgrAz!3y?`^!EUZ*_8-gMjN>w>5DT;lAh
zhq4;|*Ivo|*Ti;_e*mT|lcQ12(9t}$KK{o23mFaAUnG80YdF|~=rO()kPH|KG06oQ
zPJ3mGR=oeSqI0WVlTz}s*Y~A@WiUtZh!%>U;^yt?+}dT5{T~_F;g7;gj8FmV?=J|l
zGIpR%72YcTyISLqF5~j(SDZr!k!QbpQAQKs0$yU(e-hVeMIYX$Z~uDaW=>jnK70~5
zO7sZlEVx9Nc5n9ed2w3KRzmnA;%yTD#iz)smyhSEk8ZOeD|baksQdGrCGa6aY;yAf
zE#6OV@}uRS@J0bh*4eWsDM}+JqiHD4kX>-jQfpZJVr6j-#_JRuP#1J`F*TLR0c`wF
z<j!RofNFav-#{36A@~D0O6u%%GheERxilDoH~!m?)d$IzF*WJ-ZTP;rN7YL;d3Ke4
ze)E+-<zeJ@)XoNkO+Rps_EO)zW-Z_D3E4VdsK8TlRH1!saXe3|){jRoF=qg0?cR-S
z#wz$JaV*?Z(>vmG*f6-WPQlI1O+Su59)NZFEm^28w;t~({`o6@3JvDz3uZIA@p+mf
zUHa^j2VW8@6_;eH4H}k<Gfl64$2#s@PQ{*X`gnWGNpJh?ihWAXpLE<G6z(k#xps*Z
zKeu?Rr;Ao7+RTRR2p+5qbj2`1r*>esZ-|}C-nyz;3Uxliw1p`58HEk#;gLZZbSsBX
zaE`7i^kYC12ZmRB)S>fEqaPiMp9?R)<D=Xt*0cFOdD~a*n@DzIx?>nOJhq%Gidw4t
zv4mdVgkr>yf|sQmYH}wX`Yq$v)u9b(vO**#<M>^Yfrh5vn|`7+zIrCW8NT$mqbjv-
z4$U4&?yk0c5!jDhGZju0JQ-Lr-vB?heaE__2WG*EXEI&*UB|0ay6_set@+8aCGtt;
z<GNM7x$bA3+vLy#wMD3s@UvRk;J|lN0nbk%lgE12LqoaALU@uibXjIAItbnYu(uQV
zVhXa5Xtk`G-FzFLe4aA6a~8qxek0-CWR=H?nc3IzskrlzyPh2j{-GoD=^W~Ph!i&6
zzFt0FyU-bJZTOe$eYD@PQB-<ae<hrx3gM`@%vY9Qdhd+Yv032SMW1v=GG|zjHcNF=
zU4?(qI@ntA_X?QuN^P2Zgb$Zm-rCw43i<lE$u_X2@ZCOy-#)zJnp^mbrS0RyD_jqR
z)z%I=9Q$$%QiuDh6|RR=d@cHVfbR>cdBBs(O0lp0g%v`h^Jzzt^PE>N!kfrh0dBRt
zk#X9>VP)~+i$RS|PxWD%)v|`0H1z@D1?H~vc40F(P1f%H-AQ<>56QNsUHpAAs^lhX
zcYzKi?SLgwD09^0^q9@r+Bjs^r~Pgu<UTB*VDc$a-xiYGwnzAFKh3YgizDCQcWA?<
zs(A7Qcf)c=1Gs_*TxoqZqR_rA37QIAGE}-CJJGZ2?H*(vBAULsO|6#Jv~)r?nh?(2
z#jG6<e7?5{*T0m)+<fp6nE57iJksM5nW|9@=_J+DZ|uwG`f7yEudoBVo?tm^gi9w1
zu|2G#x6PQSIKi1o8Ol(*5jE$iYB#mBF2VFeZ~s<dZn%%oc_q1R|63x+L852D^fS=3
zCr1Y6^o{1oVDh)}CqG~W@5j~UXLc#KNq(zp4s0D4Cs?I+brs8ye>D%dP5n}ZE6ac6
zJM9HJAGZ?uG8EY28|Zz(M`4w1bmVhmd>X16R>qWimNrA`e_%bXsW<#rjgbK9I201p
zwcPf)15JKthF0Oa{gsR&Q@8_oenO?$!y0S2EKG^pO^66`97V3D$*{b?)}&VaiF(ZT
zKIn}>^*~sBExcp6^-coqV;PMhJ51x<%NA_&+=N%U$S`GR%l-<lmJM{k1lJUb=UyiH
zkgrCSk`D!1^Dhse{QiGj0EfD~L$0&)qHg<hNZUjbQzvDG8snZ_!C1w!F}`euSc0p2
zD;>D4UoRZMbU9I~dP}7rTGd+Le2s$-$9H#g3s#%>WJ+*#=~KUv#v^T~{At6%;5Iz+
zO8P5)q=!5-p%-%@75P!Y!I>F0qx|Nj$U+-eRwpx%h(W=n1>Ky+4OEgG7i&yt4ktm6
zGm?M4o=&3wE_7m7xfx|<k}%kQA@D0|4F7vt2+1L_8AgF?W~mlNB5GEg6(V1<`EXIp
zRek>Qb&LNgFE?ilnJaW9pndUCXxm-RHYuj7_<h`56MIybkzQz0rcMi?)U&JkT~30I
z^$V&%`znthkq^BupV<`6xpp=+HeNf#0NSc3pNF+MVB#hIXiVAUP@g!N5{K|pzVo@y
zZqb+*Xp+lfWLhsqo*bq{-ie)qKEf||Wa>fl^)O&l0+Po+nBn~))rc)X73WDAAn`w$
z>R$Qw^-q)j%G(~6M9?1OMoFw3cOYk0p|aUGQj0%pWVuNCwqu(0={thkF7n$mtueWP
zj?(D~0eu(5!~s5r!nFO^%P3Lh<u@qL>p3T0p^wb_2gRtR^s@_QQ@qSGz1D@rmd*Eq
zrd-{Mtqleu%m28Enp$7Aa77D&mSLYDh_GIg7QZy3z4@Y@J4SYH@wXL@8NZ>#M{z5@
zsKYmgN4h4Vr@V_?!Ec=E$6YFhzXOAhH7&RmH9>CPDjZo7!qu<(=KfL3u=XJYRB?(N
zD|ctc#TEt)S(!5N)DH;3ax_##c$rBH5?nsGt|)xgna#a4A4iM_RSdDENbb;#+TN1$
zkEJDkag2OQGP&K#45Z;hIPFx<I~w8f$X-Fl0s<Vhv^R1aDOEMSCrOk!$-g{sJ8tft
zE;!m3(y$bae`Ns)ksU9AbOKXCuVfi3uFn;)<OFgaHvAKeyLuOo(ey`c3LIZ%6;a7y
zTW<WA(Yr6dibI|rkRNY6$6L1PGR68LAC(B&)2n`-$Q0Z5E+urJWEGyrrpRWgRHBR>
zWjGiR=!YwT>l)Z?wVHS*e~a2Q^WQG+5-~05>FMEy2nIc*IGS91v1X#Sn3*`2AV<MN
zPNtku(}A3}dY3E^aaG(1v#;8=?qVXY$k{m9Ga@qX#zXwNd5GG$6t`%n%XX)Kulkq+
zSPj7!XkqP8bi2wBa0+JVCg)dn`(j(P?x0L!fbjsxVJ7H9ZE{TTNK&am=o;@LvY=a*
z2~%W~E&&osMTivRAsVfr@PRbtCO;ai3*)bGrUalId&7%{?s}10PrND3Le31ehA^XK
z6|AHvpet~R=GoluTPlgz=}sa(7d0$7|HIi_n@?0C?Sus9XSW-!K4V>Ktv5G5McF<I
z7)^Sjqg)y3StGO1vXBJtXEUwOh+DMh)QDe4EGpQ3cglp!YB8+&Oqm?fFTKV!{fOLG
z0b6{iPV1{%5=h_r*lK*5x!+G_wtAieA!7tnOhah&(6lWs=Q`3w=Tqq*T*mU@ucn=B
zW#T8cG=QWOQ!^N0oIi)#7f;BtEj<DWaQeE~?_1Hk2Mg$fn>)vUet*v0t}BG2tj+;H
z2G%yOQL>(x`E)n4yVds1;3Ad_7t^`cC2rV6fS})LD_1=QTN015BgjHc{uZE-E$<Rs
zMu&6U2}GXCwT`ap=>zsg@C%(yu$+G(mf%7q@kiDlHp-^Lg28bFyA;yW(w7>5uf^+%
zaokSxQS_#Naet%PApupFQIE#pQnL`BM_yrfeRSs`DW-6wh7y!<Cnp$U%L<&dp>vA?
z$t~ZfVDbmtI6^(01w?%amso|`y>+6LW_>3F{r=0{-WXEtctf?PIX2wtU+|ik>}0a;
z?ki_kGt8d2SId0?KEXVCn^&(`A7^sgEgj62m<k?`sRA6V<gBv(@X8RU+wM5HTpOv|
z+(fag&FGYz-*Yiy-haoq*_*1fVQDUx%c0Vr|AO=0W?^tN(48{-?tD6|d8enR`$z=p
z2~L0VeTn`F>^XjHd;mtH+nDby^$LsJZh8_5yUp(jyhm5XA65TT79CFX7vG0NyOo_~
z<fJyN&sS1%sRbu=gka%M{=5l6CKWt81Jp<#s7z=9&c`#NwiZYvIP|6X)7vKlUg8C(
zTvmm_*;r%a=?L2bzRd^Wqca$(gf4D#{r}YyZMK$wO#81y!{?&=VE^dqOz(K&bgsAo
zZC8WZD?&D5ys|^8tE3L5)lBYVngK>)HPc1ilT*9nDv|5?-j7tkzlU!G9SCIOy60!q
z;+ZP8|Lyn;;kPeN(l6~C61m3wsqkW77bMSNqt<@LZAzirdS6^ZCSwKZ5C<~_XnrIG
zse68M9}v-r!>XiM6@mX)?YEj`!@9UoC=WJB?KPITuP#}(4i^c@SJ|V^6>vtDZf0v%
zOO9t|>OS;^j&^HJwIqf#piZ$4LP^X~%ZnIWrp<$UdWqoE&dKqXn|_#tRsgG&Zf+?~
zRBwDbs%hQt_m90NNW1ZQ*UR+mEkdjF?puv$pVnY}^K)cU7S`Oii6I_vf*9&t*28yF
zy6u?1)JE{5l>1L5ZNBj}oBZU}Ca1y7`>bt;66)^63zYkru2&Q_<Qt^vB4r%9*Y`pN
z$2tCw#c!s(L0+lE5D{v|B&)o~ee$uhtprnSj)W{L0V?no*J9F-v_zy+O%hH#B_LJ$
z$#2t)Ti(e9haP>1t`al9^EgraS-bx-7HYLJ=HnBXGK<UkT3O8Dmi;bSP)5(@iz!d4
z<m>9S^=OVe9|4`Ft<U?4vb3uMVRErm21`kQPZ0v&Z13}48t>cRQjzg9I1Ona;&pW~
zEetlr#IC{Yz6~U^eJX*-kfVTnw(TLC=^@zk;?UEG{qs(DIrv(cxYSm2U|exVl-~tv
zg267sI{nPYno9l?@Fo##n7$={UjyXYKJe~=SI|Z3d?I|=g|sAH&)$(SWGMRKJ?s*O
zPko?|XE3OyA$-&jxPtkon_wPzjOBwl2rI%shsGS5aPOAh*L%qgQO4~2rty<gM1~^e
zVj4c?*jDXAYc6-4E>L3S+YRDXbk&d}n!UOe-kkFJz&`RB!zZD5^7#<N%Fs3@;<IOq
z@hOQvEF=x}xdu1hsu8z{mc(2|qJ%aAO~QH1{KiTPDVKFl?>4(hk=<fT2As0MAawNQ
zIKEOWp+7Vc=a!$)DMg9BJcze_@OhmD4aCY+hQ9AsMjorLUC0g%OVZTWdR6Hu6&1k(
z=g47+CgB;3*Y#cJYVfjNr|;nbR97Aa(_xyglu2Eh_%qG>eT*KWCR12Yz-HqTzzps5
zXgFB$*bF5gXbFAr=8SRtb!K7InZ7TE=Z%*gE<(-qRZmrNm16-N%(nI}jVK#a&pkCA
zZ=eV;Fy*3B7#zQS=tRdzM21eZPEVUi=icJ+uuMRm$xU)d<aX$i;Do-X?*Y61_1@gi
zk4HlRbq_+Lhgd&3f;T@vfM}52$V(-1jOt|d2-)FZ$-Te-I<?k3k-Xrx9Jef%qXW_?
z`fh*q#oIi(Cla`~7>$k#s`&%F<50oCqh|A$V~kl@cbwNVrkB#44TTj|I$j-Y>fGP|
z44j4`(c4t2vi#fI^e4eaNpiS7@3m4rHP<uy<I=<^I#5G$GL8DgQ~>)2Z9)}$uixlj
zt*x0DnUB^(Uc~UTE12#m&tB4ziJ)I{ETIi7pM?4PW7Kcz_?N$b5}$W^S|a8*u_Qk;
z!KS}~{uPa-q3+CREXDJ^56?J{88j4p$9cP?-<2!!STw%vjuqe2LF}U;U*xwK1r{cn
zkROh4#C}e<Oz9<Qw=bQ}$V;*TU^xQlz({Po)>xpr9GcaHkhThXdC@aK;`BKtLrAc(
z?)+D|M^`;5tA#?~j{Fj3gI#=(CX<)81D0@GRnMe+BYS~k2_%P|4Koz7*4)cyZ%{|(
zVuiny$?5S3Adc6CnZ-?c`5AN+lvOw&jd%msEu!I@ZQs#sMq32jKi#M6CJ)dK%*J<L
z&t#&nHW`ChPPltxaVfD3Wr=+j+a|jogv~Vn4$Gzs<)&Mh)p_>t)$IaZk_dq?*-tMP
zA&)!{g1@OsVv2_ABl8WW)nUcavXb9rZpp4^nT6}zZ<GH;RI{+=DZ_J}_t<1#H+kK&
z3YylZrt|F_FZ?bZu(RELQm5IqPVs-yn`*6+p^0ZBYW#NSGvFo@?5>3j`Y}R(GpMbP
zg#Xi5vU+*^k@Vzs5p&T8;U9+;sUX*!%N48NDUX{Pl8o;BC>j6aCy;XC>>XrKtL|kb
z)m#cf+Pt~?<Y&W7bZ{i5B%NO`jD`okKL|Lam&>$j<hh`=u+`O+Vevo=q&=hp1u)kb
z9>s;Gt39(2laNouAbP!m>Vm%fw(DAp;|MB*L|9nc4m<ck*YMyBxH<uwBTeoErO!pR
z$Px%ZZoYvhm;c6Y!PmRcnaK=W=<#jRRV4D8>!SJ9zn4)1f-?91zCX%UV-?!&ArrjN
zTKZ#>@l2oUaOkQiziU!Gl8ihGRIlwe?qxiPbR{T(DoloP(-XSn(|+@3!;*{F#s?k5
z0R5{(r{Y5*k;{_|O`}qHY<koO+hw*9<yt+yr`ZAvVI8>lL2{$idz_Xwsn5FmaUa+J
zjr9z7`-f|7MyRw|InVs$qWdv8;pXOXL!n(Qn5cxgW2|^?n^@x9bm>$6f|mJ`K}CI)
z8O(dxK1qk5x5L_&5?dap^+yHbtatu=SW}C7_p_a;%#b%rDAv!b7eI~%EFf#9cucCF
z|5*Oc70R8dI|^R{ow_^{qac=K5}`q{0p@l!7B4P3xrh9N=qwb?%W&Py{cjE%e!TI+
zuf(yPpM8!jW?U`Nc;dO-Je3YF9c9_Zp`uDxG%>85TbeucLF?pWBUb**n&WbH7{s+?
zG9tgljafVqVJ+zY7qwZXXu$gT;_BXg-w)BRX*5a0DIl)v&ovje)}uBCvuHoUaZA7F
zkA-^rwJvo(#p2ql#5W;qgJsXFM55NTRdNV<pJG(VzA;MSxy!UU9gI>}=l>wtfp%Nm
zbPHnj%+|)^C&vpUUP-+tGWEZ@@iM1i-GG+7HUkDtW{EMi_yl4`BsspT(Ymbn?|3|P
zISge^gId-0WK7D>uFa|y{yoB*{rLPk+h)%yIj2$Zo@_W5Igl+b^?lddplr@WW9aR5
ztkv&&R+~pS)zheAj_wgpxWpJXswBpehOUK?4d=a{hC7-3&!03zq|P&JvwB-mF*$pZ
zcSF(9(Mu3t9(?9gR^qv)&w6R`4v6b&YA6}niXC9UsXjOW)Y-x11zaE|hV0-*2EQd%
z*nx3mYcKQ5HIuNkrC82<_+utUsnyG|TaN;g<v%J^mE}6$_h!{!V6!e2D0xzVzB2=?
z0j`8;c$(gQLlP!nxjQ^3LO|w^#SzjAM`C)$P#HnFcCEaic43*5J4|vEGsiJvqJSOK
z1|nF<c8g|3Yf&8JT3^a$336@=2?yvfclOlrOr_JjJd-Q`?AXOYGAn@LdkHWwW}}{W
z-7^f?8^`~}YR>$8wtk2?HUR6naWFsQS*3Y$+{tfu(ev>EVQ<8p=D~BzFspC2vHDP;
zdoN^n#k3G|Yo}|2pvH32wOMYbXK<NH_S@Iw!<)7~&B&-`<X2#0vByW;x|TP`Tdm($
zH9I}y<}ckyU_%awwNzmm<(uaBjyq42!Ep1BngspxV>HG9Lv|KQfpsQ+IWD7eiYL^r
zV%z^P7-)*WQmG5{;ffR22JelK1n<A}N7>0ru?h{@dKMYL{zSv5b!5p^UQ=J)^VwCR
zLgFZ~s&YfyG!9i_LNZ?vwlxl|r0d{hzQXLPB}b+YI2?0L*{+0JM=@XSbuK3LE;TGa
zH%UG%vf&o?d^}_V&<pG(P0^7w?4Ex8rj3p08XB4w=?XSOvv5V5<Bp*XU&TzEd|wcX
zXJ-3b)v4-X-V(XB4@18s$28+m&qKyLMigp3u{{aHj+b9x#&D_Pj6zT*k8pDA;qCQD
z+d2ZV*UuonWObiu&GmV)1MV!J1L58z&fNpr!P+(qw6+0OzO9)rsA1?39k^r1C;eEW
z`6;!0mwGhfU}_3FlnqGA$pz1X(U_H}eS0GQqUnCxmFlQI;uUFyU{-hzY{?@E^NItl
zg%i=7F5NIF+C|-EQk@36C&p3}jz(DBXVwxVK)LTdagd!u%jsUkPC4B!&uxCPsV_NU
z_$ZW6VC2)ZB0<-Rj+Z3bwd|CH@QZ$G9nCr9CrW^mdUqXX-pNIzU!;9UA0J*=SQzlZ
zAy>g8t#|B0a3bSH<e!GN)XR~@-cFXo+}k$jq+e+y6O17F*1sCY77jRn&~;gTK?X~>
zVkbS}z^Rn6T29l#k(q_~z76dOctR@%mI->LQC%J$fcC}IVU3SStaO}REj7#6_)J}R
z=?(>|L@Z(fgfri80y@5a>1@wbzxRWf<Uns=YLdOo->rPrIV{#Ad#deK4MoD{$fLY&
ze()dCmv9mGe$Dz6SiZM0UOGU<hTa7YJMgmPOIj`e66KQ&D~<vo8%Os?!+CJrcD9Y(
zA{tGb)Srrz%qu<>=aR9<Z(>MUWW+kC<ji{<q=GwFQ}3Y{7kQ&N7;N?5$@Acz(|6O?
z*Qe@gF((@(?fkA+1h+xt%ny}%Xmcfs34LJkO#$=t?RjI%(ajHz;F(13_$or-^2gV_
zSXy@go=V6gNd_+|25;=Z4SB>@(-_+2bbbNskcsD2hugnBe^YrEci-|85DSVskZ6rR
ziL2bFNX0b~$2s@#Z8n-v8?Nm@{Qv_)%zTA@?>(k=PU=}r2%@+!Ea}qZ#Fp&Hjz+D|
zD}MVu7l7Q|7J1y$rj1Tc^PWe1ZQx$$jwKmh-^T}lWO0;URS~Tuxm&9P!quNSRB)!h
zG;F46Fw95LjT!p(cz1ffYjDC`*U(A~B*gQ8wBfw=tr;Oi$nyX!?~kUtZzo8C0cqT<
zu#MRpn$Li>L=R$JZiVBr-F+(3M?gFCO8D>C%uWSNXYFn*12xOg!1!Ij`T4vWepny@
zSdFmG-}b7J1iQ_nNcBl$uD;3#^<4o8F|NG)_y+%zk3g&8OGK*t^;P4-%pxkinE-$!
zVSL3)zpU)wW4NE!8E)$gVlGUATBVmvO2FDP)k=<Sd5hOyIR`X`U<O5PQ8HSOC$$Zk
z!0=toA~P^cc^oiPUR=HADaj@KD+Eskg(gC=B0I^R9i&|w_SVP-?`g=o-RJRX34eNR
z?;k7DV{BP4O<X*ulpu)W3O?M!$lzv9>uspGX>Ib94jy$#^8z-@i(&Hq?i7A{GF;i7
zd#&Lno$2`Q)9Q`2WG|?xLOVZL7sd53qyk~mkL>Z`)r2gq4K3f&aGwcoH$VN#p~k*5
z^{<Sv!`nwPW}y8pKk~4Ajleu9Z)ZJH6{SfIz4u(qX^*C)B0FZQ%@L`+h%xD77bL&`
zq|fMXfK*{H5XN}~c93$i4QXpMv+}055U2i-wVv0DXz_DrVRqzK288<gSbHN6a*6yE
z!(4Aqea;xqDIXeAUz9vqdFGG0<h+L3Z@W2&?Ux6i2WK#xvZD+B>X3iv$F}rqgVBxf
zI#pN}md4_DH^n4gOlYH;7qj<sO<zJRQda%m-{f9iep~1q=>VxQo?QqpR4EM@ra^l5
zX+&{S&>0C?cK_TrgUa&SgH^4=sv%%_b?LMj!uZiFfItEKy?@N|fG8=JF$!ckW?&x_
zh%Uk<ndfZUlJ12q@`Q5rDylcz+i21y-uE9VCNe(V12>t`cV4+aha0i~07%KwF<rg?
zAVP7iSiWoJAX%+WCREDEXXX<@#e5c#tT0;^*d9opKj8K0+-^CEjwwkwjDic?%fOKP
zl3w2s{Ne}St5xtGj;xo|P8p{vj!Yz5Ay0(*y+R@2{Jd%kfETB{86VC!DxA4Vy&F~~
zy1Tl{+?xm^&Hr0;F5v!Av56qeRKXoIdz+3A(8>I_3PZQ%rsc1TM9WW|Wsdy_fc`HI
z#5YTn8ff;!5BcNYhnd^IlJM+7u@v=cQmZa@)E?%rtwWxXQ7I-Wuz7!G%`=M8+dZAL
ze8uzaZ9}k%+;Ovt8ekQia|-1~L5&BSIMjmM#qeTDNx8W1I5tK1#2u8CncBGLxHJtT
z@BmAyDp@Yz1fZF<OUB9;zL*FwF~K+*3_S5NVpBoq4K7U&=9#VjE{ETNowsWD=vbT*
zDU^R39b(2>g=&-S@0-YYngEva(xckEhqc(xeAloJ1f)Ef1|+DC;};%s!=%A1m`NUo
zXOoX^VRWvrS3~Bp+{RE&%4|IQhZg5>uCmf|%i8Y1_*(S<iK_f0LtvrJuhv|29%gX&
zjZDQUmZ{C0^Q9KUPDcIT$C4k{TbdG39Jx?lVFf12kOYRhWLxnNY2a}SwyiARR;M9Z
zg5f=Gah^spQwDd}X7v!w*V@lLh*B~VO|3~E5$iqV+$^77{aDkH`%*=VNFy2^*8QOg
zCLW@d)`XR}A!^3gHE2&ugE4fwf_bn4Z0TIfcD~a>k52}sH8)=1!)07cO!{k@C1E^a
znmmss3q7XF@Ie9M@7Vl!w*S3$b$)kuoBkk0dqMOGIw5UOn5^2sIF1vplGvd>6CqXc
zjHg=!sJNp@RR9v;rm}|JHP?b6;t?t~L$;(K+PjiR{kIKH9%of)fMW}fGbM{tJQUxE
z`%bq3j0{(0qRdCESLqWYG|hZQ2@M6g+mAG;aXeUnN|I5lXc=)AHINvOLxEee1zCRZ
zd3Maq+QmsSt_llf2;r7YIr(qr-G%#{iq@I&=949bBu&8C#l`Gz#YfD-?6<*wn;5EN
zGv{!_mA5|x^1d9}MMlT66pY1OePm-9^d*lWEVcfTQQ%s_MJ^?9p9}msHdE|`)BD9C
zMYA(0tSKzsrnCjeww*Q_p6q{@?7xmaB)DO4Rc6r|7Z|>IdQYzZ(+(T9HR7jD+M6mm
zDbvkEPyPJZ`77*rt(hDM**hRl{YPMX^?c&tOR*9TH!~GPoypC(|D?haO@ldXa=O!<
zIFUw$hs}Q5(JOqZp%n`*?D_@zL2aQk)gu1l;sTl7Z2BuqGPEtY6X0>5sT6VO6($pc
ziLw!_=HjF*tFrKM(-uAjc=0W}bhAwlQ<N0)vX)p_5sFQsFfxEy==8ox<{gOva>tue
zew~eS<GjO;>_AUx%d+a63o9w(tG1(}J3Am2`C9Mn{%DFAWn<h_(YJI2xt0BqeEe}r
zt!<rzZ2j;q$uV8Qh=w4WF!)9GJv&!!Iv|tlMt(QE>%I|^XSJ!=7CzbI-xuaT>j0<e
z#b4ltP+Okp|F_wHYoAI+p+e;rZn3>86--5`Rc|yJrZ~@UxH)e**x-ZE<pr$!9@PhQ
zpgi~1Bt%r>Xp%dJ`LmZ6tN9N8Qz8XzFu_tzu1+_hG!A*FR6sP8zw2hHHEKVkj9B5`
z0(KPwVUsn6nXjnFAv_tM===N3m*!`$Je#Qj1tw#L=&AQa8MY-HM|>MfzYU&tPUoav
zwOd&+71$o+c!dxqtM<Lb!-lYfs*?<>wx&(*l4gu{=eRzCtjo=5K?o~3!#m$r(HA<A
zHC$F{B;)>9&uvm85be2%G-Cl%9HtO5`1FUV7x*d=&Z<hLrXtThu)UxEKcVRmOEMc7
z*U@xCK&)3~-8kHM<jDUIEzx&}Q3He+1sh+NfX4GIvEJNQo>_eOUQFxSeQ><6**Fur
z)-tRT0o}_MT=?g_sgc#NVaUw<e1N^f-fR=e8j`f-*06ou8CzTHBDg?zPMaHlTQ7s2
z^ukYrd29mC4;D&~Y0xK&QAKk)+O~U4Gh{AVLgc&1|GaS!7{s5jJI+UoSMB~(jgSRN
zrZlq>H9v8;m%E2i|LwWzgYGz9o(xhNOT(7|$O2_xFo8Tq9cLJa+yG1c!VvhjCu)#N
z8xJv(Bl}%vd?ms=O$I<`0}ji=a1W8HBcdS3r;%@)ald{p=WsJVl!~(`99+tkr1kzN
zUCCofac;sh4^0>5B(+~4Kj8(!+A&aV21slyYi<<t{QT_AsG>6PMNflcrAjqj!L-HW
z3$3;BtS`zPva^J}%z5k=Fz&~G%@$2Ohb_-T_Y%w!efx?$5bXWf*d`1fd9<|<@Acrb
zwRo?}JceBv(zP6<FJzwwSg`$7($o6su7!{8?J^?e&^eNdqH;R{)FGtmb>t_`-!uN%
z&;<P{MsiaFjg1Y+b&DYF#Lfrj0l2LX?nHBkzo%BK6o@+q3#lZ%nd8HVefY3*v^kMS
zj;8{iO`xjL`|^#@^xJF0B0JZA>%JwrU`pYg?vpXd%6pu@&5tk@I#g&<w)vs7qOX8u
zh~wwBM~a{UzUZmRZhvfx#+^6sagO(4Ra$>(9)XwdK=+KUTTPVW8!(SkXtcg{@&S{2
z%PS!V1=bfBf{P+J1jzSgVvU`h3}KZ;zI71WU^L;JzB3Uue%E#7p3eqoz=~*M$u~fF
zkr<Vh-+=~2(i*Agx;zMC`*}hC<1nx)2(Qee0^51A?kujR*7ji2b<a8Y^$Htsd>^l5
zT8?<AiVZV7_OFS78%+`5-IkZ1lGgB`mHvc2{}xnd^9(;c8u;yNDvUQ1H3LFe{4m0#
zKY+_^W{bNYJ84*9?WkGn!lR$VANVv3*r=o2Z%=A3ZVG#Q|8~cGQeBo}wbtaxxYV=u
z4zFyqX^PcEVcRuJAs@k|@Auadk4&iS&VWA!*gad>&cOcvq3Nvun*91Oes6>Wq#Nm$
zMnD=ycQd+?ZV-?j-O?c<jUXi@Asy1)0@5WN()H~7!}AC1wcR`CKA*a-_qku<UH_}_
z8Q7jYU^-6_+l@;ugP_m`eJRteB6xqKhz_SkOJ@_Q1E$>fpM|kaGQdPVoIm`)sV{{U
ztjRX8X@}`^c`ygZh7Oo|yN~nF|E~oIjeDJMOAD{2#foX=d%wJ4k{v6yn#%I_q5HBH
zm2ai7j*&g7%55C+Lh|YFwoR&$;c5|tDq6&<7eRnoh~bxmwol#n*I6|`fBRDR4}K@m
z0d5?~F`ii>BOlH_#k}9<GOX<lotN4e2*gXs#q}W&v&f(30KjNYk{nKD@Gn2#+WlM8
zbvbl?G+Rdoc6Zjvj2@PwNTN<3+FG?zXyG17S*IyD&-A&CED_YPbN#W}zw2K@nZd5v
z8+c67a2T#1m~49sOpV=RVGpXVtMkakIPja~GK_gZX?Z)BjS_?=rjx>ife)&qo{_-~
z#AR&sCYGLz#~tG|&}AU#p&OY`=j?W*zz2m&G62@JKwoPhw@J;>Prm9?dgP(q#$f@4
zDKsF+GFQg$Mg~&MIbHi=Cr;gyPf~*xsNZU$T@e?mU+g^gYDosKWjW&6np_q;5Mp5l
zB-$r$y{=G8@#9uBEW9cU1INR<?afNYjv!Y0hLgsC5#ggb4W2?k{=L7-?nH(3^{`1q
zHD7d$V{kP5eGWth7Zf%d1u7-#?Dh_I6{^?Z=QJ@_eyEhh04OERx<xT0n84luuafHH
zyZA`_Ad~n2qF*szZ%1GRL^C*1>I4&-v-^N|S7n9|byqBjMrWt5gNxriF*+-7w|(xw
zSNA9yJrEb4^Qp3Iryi52i!vxDy4<$tCmSuiyX-#<!MW!blnUKxCs14r4uK+ou&!Wl
zBjzg_;=G3$x{5Cqvj~|<(%DCp%n$wsOBG2AgCHo-Xj*{PG6g`bhAG_VkV7&)eIek!
zlj_;&lKmtV?b#ny3(0wA>%Ode`XfV3llmaX9J8yY051oPC@hv4%nJh1ho^7QfgSEC
zHs$Rb%H>jbJyy(I11nA+%8me1NNOBQJ~LvUK6F+N9x&`$WYiO`pbl&dh|7x(E_oT(
zHL4LfwG${*uuVIo?^nw*#{hZoSr+Jm((j>Y6_3&Rin$UAy;Y45ATxyRv@)|&tr`+3
ze%P!1C;rc3^1M%igNg|2R7tg9Fjvrd38Zu1=-{)1W8C$I;_~m4>NN{*@9VT~4EQU4
z=Xz4&d;1BDXYBY+-?XI@u1X8z8@6aZhh!7$sS+WCt6j=+rpZ2y7Fc12CxzwmpC#Wi
z`69#N>+Zlxt5Y&2p<rTTJbFrsRrQRlC>o88%;NCzS)n<@rs4pP^(SWKfls0q0WEpP
z1Pry=G4PSm(jZKF+XufvDwp_V)Jx3{E->}?6kk~PqaF`pDnoOEKrPrqL`R;!x2&*Z
zulKgff@_HZ9oHLE?3-DZjf6}5w?hUr98I}q7m`iodv+6KtTf}yN%F>Mjyiu1Dr>Zh
z3>pn`r<!iQC@}y9>1UV;*W;qyKwGmcsW4iU5&m!9e%br`I)=dWYKRY2A-%dT2t3F7
zusBUD7Fbt63zj5VT3Xswq654d8=mZ@?E^xe-8!zvk;1xk;&*cfx<AIx-R@u``nv=Y
z$T;bbWR_rR48{)$5cw1WQ$0{8NgZ3?-IIcukH|AMEUYWYNNO@ufi9*1IO|A>W2M>6
zlZBR>yQmBvj-tP!doH*M<2fq~OGvDMbN*N!fG@tT*56j2Z3$=iO|Jng{!IUK!y-Qf
zF^8c5>>#!disXpWZp@Zs_KU=CjSp=<w_!LVi0YOk;*ot74L=8ML#A-VtWufBdJ)vj
zLXB8}i-noj;A*^uQb=irELvJ5PP_N(Jm-dVU4U2G;XSLFe5~pAW2mrs1B>r*G~50H
zk>_%`&JlJHtB+n-Yb-#PqvRZE)KB>3PYmZ|e1EIjhWO!;V@K<I@LJ#4j+z3}W4!rz
z`9-hD)=4}#wJGoJ_ts^9$Q=mhT=|LY5~LS=z-Cs5=NuNJzTjouJd>_=%$#X5cKt<o
z87)r<l&CxIoHP3{aFD=Xi!4bgG5Kv)LR1p4O$@>nxF6MK6S#H4akVD%(piHy%;KIg
z;Q^`I3ImmpHD0xhRS<49%={a9cPnOe_~F-v`6r|?>AI18oj2|d3n`Sk3%$8>)QJ+L
zU~kX_9zgTmD<opa9jWno))R@$YIjv9%IS&&rBaqB58?uIN`oBS>1Hr_wDhIF@lQ`}
z4K?A9o*&ogl={lWN|Ui7?g=*X6;L<;2>(W<{<~p@>mtvLrvGzaf9Hb&SY}|BdwNy+
z_NqVX5ydsgolB#fO3(7K&ocz?s+3LRJ=ewnJp~r52m}K+G@(Ni{n!nk3B1)df8Eg7
z?rVqA8UJN87nSkp{aSOhfcedgPJkdSV6u@TJ)*pS`5nC!(FmWnOrZso0^@&q-rn`T
zrO*+40S`~<fUke5X#u~fOB4kqw~8s)iXFH<*P<h#*WsO`<CP3kf^d?{r*M5K3l}fA
z^V#$mmYAlbp5(O;2vG@FOk?QDo>6j9aG4%QtnfiI*ziQd^OE9k#Syi|qi8Ji27>q?
z9%3LnGKDVZC8Mm`zOT&6(Cw=DCu_M*wp1#^Gbh*oKBH@{=n14#jn<<5NbV;gB&Z_*
zu*nK857J$T;oc1JaGc-PDy$;Sqx&}{G=Yo!YSbfLrBfn?cL%YmEXM%z!I_^}+pvVn
z!9xt_zPOke@LO8ypniUc=Q>f5#vx5dCPG>GN9px&b5qg!6fL^Lz)Bs~5&n{$CZThg
zfGi6k?dYo#0#wa@VS9NuwA&HV0(3dgd}n@?*oN4@D+MtL5Z?Dd&74`G=lZRViimV+
zfJSYiRPNUlQp+qa>zFei7E}p1V{+7n#3?Xw`!?#&<$b-z@G;pGIZ_ZgvxE45Dt}?G
z?G~RXSEv{dPd5QO>iizK<S3)aT9Rei;a;Tsh2Psmy-*6IHo-DeGJAz{z4Xndt~oA#
ziaR0EZ)v1zV!|2P+s_wuJZZknn0>TFsq67D1~*kDu}2Iki2gOE>`d{ujOWDk8D(KI
zn>BAlX0%iq$mfAx1o&vog%N<x{2Ou9gw?>E;Dd};1(%!zT^Ex~bZXRZQKuH%M+#)f
zLap9P+Yb{4Czdp;`n(<v2;i19p5?+zJeK6I)G>UzZBN4m_`SUX74%NWAIS->U6iqw
zt7?}CRWf_=^^iZ6i-cNTOIFhnvm@c0BY#N-G7N!E*B4L%aTILO<O(8L&()O$!pNM5
zU*o)sTElldsjF~hz6dlIec;_1E^U0=LdqO_MH7jLVy$>)C2!w-P=e-Dz{E;CypDDZ
zt3+zStwASmx@5y83f~bWKQP4;yrV(Zu{%oAT7pSp_0vaBZ4&{Pco;<jcz|76tvG1H
zgXn<4$a1||S9e-_JC=o>7p?2N#Re{-@Xmn-0O_wXA0oH+^}}+78;%0fPyqZzweQh$
z<0gL3?VLoo5=f4i6&L<>i}XdG-!H8d++z~R0Et};Tfgp0#DHOp`u@vgcoxwrLbHde
zqXQfsRR&Qa-(S|$;k)(;yke;PQkH&zFTi@9d&$lAc@j~;h~Qac#>sv+c6nCv%KxO~
z?O8XQ9J+a3l?^~1G%2YwTHo#D7>*!SON(6qQ+O`v(Sha3+qqjJ|9z(lFp+4q;t*>H
zu;Ra`N&9MF-T343yN(H<r^9voBD&1;HJ~^`O{WGyacZXBLQ74l9l-@?P~duHZ^kjG
zs_585e(hN{jn%d=x@SNH)W(-Ol&D7!2G{T)7neAE`$*OG^F$YuWX|~1cz`~R-H0WL
z{qM4^;qH<@tGUIHsC(zjpRh7kD1!39q;9vrjZ8!#C1#(>=;5ww0PHQ_<$Se$R3YlS
z%3+#84?e$ZEL+BEBZz)L%%M%i4-g^BKpuhuL<5o>1G#qq8(%e;+V^>z!N5B^_V4n_
zidaU_;!1z3d4Q)-=+vV<18Olj$qnxo)zzKCB9Ouztvk<vz~P9*$;b-69!4(_I%=v^
zaBn`aKImpUxJLZ-asD(^$>I?(*QvFRQ5?7GcwAtQlNXyB<2-lP+ZxwgFJe%EdP0wW
z1aCBkgeEZE2svtLbcY5FpgNqWj1tRZ|MrvYr`|xX;$|?D%AC@<kHXyDX1gT}85ARL
z;LWfFB1`*fVgRvIuR$_Xz+ikR*l+)ZrK=VMP`Y!Ga4#4^Z8~M>?->|^XrJ7Al&H75
z?n|~yw?o~V-j+``e2ucUb?))B@w*Uq*ttzGXzvwg?UHbucRl#^kjaktiP8khQcvZM
z?_VD(4us=u*Q2=VPqM{I3j>)avWTR)HPiFxqQ$09{$?e9=phTtZhs`Y@6j#!L=PcX
zUr0-QL8GXrN`0;UzW@Gv(M$fhQ6e-rcXaB;FsTPJywBPcPvGFxhX`4Po+_bMb{C!)
z3ISva({+~lhVggFJSQU=K#9_J;d|kKgrJ3Q3_;ZHO~Z)J$}KVj;z?)}GYJuDprUzi
z7n@jG;E8ivY$IU^rSz|6aGJHZ$aHd$(T&*trNoJGv0|XUk+33|ev1JNm2$g<hwts*
zxtlCCqXS)f9p(*jy)XJB_&}~qooo$$R_nKFS*OIZPZuIr#ayla|FWliXh!}d{?uS5
z^BqQkEq~K68DriwLPWEp%4eOi#N2bgCy5sbR~;fIAGKxr&>;$*l+>B%2dy0M>#uz=
ze^=yR;xJzPlXbCc3mUU+WiPCjI`1b3*g)C;&aaASx<3!x!Y3{elpf^zcwsX&05u}*
z3%Zil8dEv5gpR{wx%0c;OL`>RYtWb<z+`O04~0?jk2K%_L-^FlOPLC}*9lCE@wG))
zeS~2FT5(ZuE{`eiHk=0!pIJH(SM+{2{_z*HB~2jpM>_#1tvNYp?)zt}_AVBj4jx>J
zDY^6hrA~KeW(da%)p?HPhE4XNjd<oH9O~}eU%MJBW9|hmf?g;XpxYx{4C<$kG%n|t
z6n3BA`a0cUe{b{J#5h?Nq(&H7MbHLK+nn3>c`c!8E_29P*0gHEe_tQwX5YBs(XN{g
zETwV#kNx{XOaT7SQ(;U1y3zHqc`9bWLz4cd4<`e$Gbs;~svU_%T*zernGQi!MW898
zjT6OJv&mzFo$pb5(w>x$cFdk(1AlcoZ!rKyN(=9zhK7~6&#md4GqoDlhykU-p!kpn
zF|A<q^qrZ|RR3UPP}0rhX2<)s$2@NQcmKFG;f+=6Q9vt<HwGQ2YrL}pgh(?vNyxpM
z+rFB*k$O;{uxh<uUu3N3N&hALLS~HH8&us`_sE3(Q7t#kJE$>ZPcY8U>ggg<7_?@j
z{NB3m>Y?uLm=|o3)*3+XOSmDI5JXm(aPkW=VPtXUh3@tQED;b=D?7;x#(%aV%03FN
z&H!s?J}U|_hz_4!`H{pEjQt|6;9Bm;gFu0YEtl|Ys3T@vG~6!jigqwJ@#9TW(d4Gw
zRKI6^MVsgkkvy`-QX`O6>lvpkB?%!h?TPreNB4eo%#3Y9Z(>nvzeo88;`2Fv@`UHC
zv*sSlm2G()xG{~0%L_BVUYhTJN-eag>1KBkGr7$b;qR3ZGK^2bpWk^bfIhf_PMw#|
z9#Y8srnBPY5$3lLT??cP3^wj%D>E1N`f~*#>8D$;AkOfM*01t=wy!7~NJRvQPn&wy
z4r3(xJN*IFxX291)q>;EDgt%33dMz!oF{yiI<SKONUm<{rEj2CI>*-ZxTv@sPq$5|
zIlsbmNDaHk*YSH>BErd{3uGX>I(|C}TPbEntjn#Ogyk@woG$5**yXZSPaSK&*wHNL
z_(*^c^k4`IH~2*K@sX<{-zlg<yv}QS;aPm^k1-w~v6X&Wpsl283isyNU^1A?d8Xg`
zK6m|X?s>1bTcNn&JpU)9UP_R4dRPTABnFQ!c-Z|-M!k7dhC2#G!ZHzY>PH52`%pE#
zd`%+KWOn*5LW^YJxqSkAL=fRO46HG4Fgdn8P(%L0Npwmgi;>9mc5ASMvj87-QN5!!
z7_f<7?t;~LZfxDuE{^fNd^ZN9<Z-O~&wK^`<_@s~PI7zAYJx9_5e8US71Q601fcYi
zGG>#NVbH4@JAcIzFRT9&<H{3pA+cKnpKCNC+H`41iX-etv+q+K?K2GLMfYVH?3bAK
zv@xCGh7C_uM^yosq!@Zmb-K<0CL~lBgwUf}%T@Uhfj;;X0L+YM<y_*v_f3%<HmC$2
z+@I%<E%^+%Exel&%C$p&x@+i<A%U6~nprHcCj1ihaF{FF&qW5sonCaZeawd#gTLe3
zykzQ4KnwUFy#Matl9l;V44YFMMy8z;vZz6A#_N`tjA|oQE77=2PE~UGTp++;AA9CT
zyq4sUTivc)>d_rB*6A}|8y<4%rmL=RYbxDx_a6sulmK-4Mfdr(!9sgbHBCZ>C*S3)
zIa!?HhF)vNnBPAlIzS+QM`G-vonxgG9)nz378;Yu#{C|NnT5;H9EX1H+?71cAGaeY
z;F%>n!2K?oOCa&%NXqEsfwNB<JYj|)S9C5%zs2tO8T<S=Aq9Y(JyasEqw&`3rI2#=
z(uzEng7E%PSPUM7Z=Pt(UUA$@Vf&cKen?tr*jI9;paGb4;lU*XIO;#TWKzy5`XPvv
zeUc2y;gq5%q%)lObop5C?>S{fCkj;L5$E%~i?|?11MVxTJ2dzWyoK)W>g+g}S6qej
z@Bp9Fp%lgkD+E%)gXnT;ws+sR_SR4K^zL^BO3~|c+%FoEz;k-NIVU(xKz<fALkZ_b
zJmn79O1KfuvE716-V@ji8wPk87i8b|rS8-W>%Ho%?aM%y2bvcC{JHzxQ#h?QfPdkb
zI6sc0nk}@xK(>JAMH-<UCdfWm!eCC5K74T<dFvK**qP=39H_Iws)oZwM%Xzl26-*2
zOlx))LLIyJvcxK9c|^4SMHz><5Mx=N98rVXLP3baXQnDbxGvWMZKssZG85Qckof!q
zmxwH%)2!YG8o$y8Y%7KSpXt^E=pjJ<pFn=K0TttzNc;P4yIA_?R;eTS-cKv3qo3=}
z@gN2;vz_aig_*&*PKzWYwoWZzUQE<c*wbP{?8p7@C8q5DND7B{V=M_l@8sYl-bM^_
z;*ZU`&nz;)1M$Q)Htt1MJi08P?9+WI@0rGMd*3snu|>r|5`%}PZq7^3_Cp0#%3hSt
zG^PQ9ygy1<y%ZUuWv9N4uC5Yn(Svo3zK_D?avyf}Z|MD@=FHpnir?to*k+t?U%>^U
zEPFv{obwC+B2ldltK(<g^W$7<5RUW{j!5)Ff;q$2$};>Ald#>~E#aLS4$;^X_1xdE
zw#q-zd;@kW4+TEsijdN;Ix9xOS;tqjIP|D71QL0}yrvs+rD5$}K}}1xCJk%a=m1Z?
z=+r{Bwhv{0bWVBf=QVDT`~`PXl+M4f0Y7&Ux(hNCvnpa=tCvfsV-BxYdATsi#I9vg
zPB~+Oga3X=S*X=3EQOlqHH1vPUH`qvR4+r(C@R2Ff?09<yTqY|{h89#%?zZ}I?|(W
zf1mrh;MS=a1+bZGoFAPN-?Kj$FA<gcOz1DJV`b4y|J=0IsZY;n&0QnpvC@~3=E_!k
z1hZHZVljKEgsr8WM*_~<v*h|-bb@_RX!(ZKMcgikRQQfM;oDBcolKPIIh7@4z_;+P
zRfmU%{yI5jUIe$Xi8#Z)X$cvQ*;3u6Qzr)h@T8Nk^Fzek%FWHsUsgGd78tA^B5%1f
zOuVL9WB;=3{)!QeWCvaO{&U-4WNKLEr~v&thxyZpj{`~d3fP?4y<$e^M{3o5xtAQ6
z%Ryc<H3g!6xGWHtfPIhek5UMWmmsuZ$O~BluP$BqT<z|Y{ttXrGBow?Fyzp!kg(iq
zuAt>xL)j-y3&3TWy&+5kRPkDUCuN=h!jn_a?)DP`*p(iVll^E2+NXJtiPb)7a8cs&
z%jmk#0^(yV;h8Nc)Q+Tv6i;+VpU&AYE_V^u#&PwyNzFbqrdQ6l3#Fin!9o}89VNs`
zT%%99<SE<1Z6vOh6Q~h8z2?II%k{|V6K3^de7+)fhKMIhs|F73=`Vzw=}BC)xd7k&
zH<b{hzV*euI8*EZjVzsi`S{wmC()}9l4XSuC@n5LNN^4*F|;pJ{Fdnt_`jlB8=0Ox
zDDJyM%fY>UyeUJ*ZO1FBdGz{RpIOQIl~N#CoY8T^bXl|1ql~wSS)H(RP@by4T;<_d
zb6zG$?DxYQa{O{?WoyH?oViXD9UJZy`4#24ZWQ>~Z<lhi%I9lE(`WSwG-66l!e?I$
zXWn5|8|d3m94L8LEkSq`!YgAJWvaqbT&lwQ)DlYz&a}xrVv#(eR;NHya+Zef5)kT1
z6TlIPiCcectqNky9M)in`9sH@Li4){ySlvl`qw}Qhl99q$8v2Hg4QGPwtc6%p`G+g
zaVMrOwkXj-Z!<me`LPveP^%lNt1D^ttm(hR;{D@d=~0%Ywf3d2H?90}=cQ4k40od|
z_a!XwL1{c8A_1M6tUbeB;M(wGB_d=^b#A%l;ekRM?oeJpjJmD7#V&^&I^=QT%#s&L
zsjvH_oJc^K;Uzq=MIHL=FG^Y72}HZTp+U<l!xBz#>(}FTiCE;t&KJrx?y7Ep!mx?P
z!w&nXWPlBdl#ffo$S%f~?tU3e5#15*PYkIT!HhL3H{()Aq)y|@rc9tjoU+Ui@xcQ9
zt~gsz0Begzz3m%?C4C%BF}x1+;@b=SFc)gn%11w#?|L^72K^@z0CBa;>kailLH9fI
zAOcb2k|_t0d=m0F(wZN5=4J}O+Qo6szgo<%!3xHurRHQ_ehYQ^Q7nr#n^CRAGZyne
zoUh)K{E}U59ZmUAYb9`^_Z&Ykc~!gKa}z9!MNCGx*Q^noC6?7TrYZeGo;fZTdmo8Q
z)s<MZU+mjQe>*hqMTd<aHu}QWLthIve<AfrlDI^pxGNr`Ku2vQbg2>$<t7t>A-m#J
z<QJBAv;d+VUtZ>y;{Vb6MQ=3Ih&WehLR!sUFfp+eb9as_D#4U0#*a|I1G(&ui={Jf
zZ++ocQitrp^Sl>k3EkpXo_Se)kJ1RCN_lw}f`|T?XKC~JmI;>P(=XH`kE@>F*0M)y
zj9#v`eW~P3F4?=V6G>Qq1EgG+ScViaP}iwfv01&clzFdLjGc1F<%24v7V|JWms+$+
z%KTnZ8j1@^m;9cxKBR@;y+Xzk!4Qcys4=O-&(ghYOCK{tH!rr1DY_}LfaP*7VAFNQ
zKIn!ziso-?W_Mc3Lm64`f1UJBgW6S0vdQ%3+j!fZ3o{tUYYJ&V+%~6DH-bq}2^>v3
zYd7m)L=SCR&BwccIJkEUHF+nW?h}u?U>I$SX=abeyu<ie^5%G6Z&8V_>QrLG$zGWs
z+}pJs==)sNJ#(<3u|XZN+a4TB*n5XH8=lquP_ITF!%c^mcY$8Q-+KLD01l<%wi|`P
zRkek>MZ!GBbbJ5clwm{M;oK2ortH?|k9ZXOelp0v$Nb!r<~uS=;o`cTE_&bEp+fid
zj=k7b0o^#y8aA!3N`j2SD*HKUAE+Af83$@&>-hR9yxKPV`Y-2qF)n`)S(YdO%I>G<
zMK1G*350y+1#J@B!Hr)m`M2nB{*#pjyJUkZR=qA)xlUda?;K2V&v(P9EV@t_S+AiC
z#@nKD4&-{mJ)}ILrEfy`HoAYklSeFH?X&e+WVUG^O`m12DJgST7}EJm!tWimbJBG@
zQoFki_zDThW-#~fotv577rwd2$l;s0!^fh{R>$T5Rz$q#?t0KIUDF*$#pRKs;#zlG
zw@{f2>8V$LG{nCA5t_Hn_{D^@(4izm2%W=;3gG+BMHcoJ%_BkkNn^_4OaI3dkzYC;
z^qo4th(m41SMEs|fB22GTzwk%|0)3n4y8LelY%ItQccLcWa};f%~rc)&*%F5{OS`}
z3P_YqJ3;;do1+`%xd2$>`(LvmkI)XHSunn$5&kza8Hgtk816z|k%d$34PyJWK~Pl}
zK7aG)s@h`Jhm)elz(UN+c5?4C8TlO^=uw>8F^b%Ny!HLB;g0HoO-^MR>SyVT9CreM
ztr}bF?Uwk_LE4L|sMV!xxwKl9mM_fCf5Z+OWn;3@An$R9!L*&7^euN`e=%2FP5C)6
z%wjEE1dUuuiThV;T~Z9w-*nomdj5$Cuq{j`I#%F$wrRT#((E@sKe2LkeZ7Vx{C6za
zc$xuwlRqIe35EF^HEy0sXf#~o_lbT=kO3#G>Bz|N_)g4v+&96>MAm(-!y`wMdSHqE
zB<M*aI7hI8x72{ZZ}+SSoPpf=kj<JcH$-E1d!Eou=B%>V^`6v0#mpsC!LjBOQfL}t
zd`%nI{5k~VjTsi8+FR;muAdk*B`Fq@c~=!IJ=I8fY4&i>$Q?H{ta$Lq6wR!hBG0cz
z1AUj<Q3{xN6MzZ5h4aZ?JRw)x^~;$oQXZhNBUSuYAiK!5A6)FCmB`4Fh1WHT4#^Vk
zWGgePs;{vuef$DS!-U=18H~jfjc<mZ;@7D^<8QtgSq>OBgw?2zuXeO2nAgi?jNOqs
zXLKQ#<sF6Nn+m+WZ8i?`7Atp?9KdE%D=I%4Bs^sb`K06OuwTD*LgB!Y@0Bz0p~g!>
z;Fm-8K}d9f?dKJ@i-gnV_>pf-1?sq4RMv$%q)*tj;wi@kF;e62Tm^B0KRObu|J*G+
z`!?R{6^RVz`6>qEH+<ysPPqN3bMb-1Vf&Uvl}0vt^*zs5H;cAS#w+u_3Ik57_Enw(
zb-l!esQa-BwbhC+c-~b*v)s6o#<C|X)<(zV=0Dl0R2+H9WrhAJ5gDk)z-rapu5Vd_
zaS1a1L+boVrP~Rg&ivb+x_kLQ(lH(cI`J-)A@4Q)KJ^WD#=s+uS!>)brxp-N3UP2O
zmBGxyz%1T>H6x{lBme)k0ILBAXG~SAABGw4q*@cUp1=IlewKMtjomINt|Y|j=+W=s
zFKg(WH&2mUh%uI|l-(0f)+wUfki6I3?bwYULyS)ntFO{qfeA#zAEeOC2>LU5qi8OY
zchY4q4{f7|2-U|?j(Vf_odt)B!Lu&_C#Z=h{IAY%ugB^!w$yCmJ30K=gur(+S*MF*
zQ>2Op`}}(($*Fq84Hx}u#(z)$ERl)^h**fG^;8?K(I(v+1Iu*C$ghr2_ZTWK&jlvm
zsXW=|trhWCnEw)MdEIN4{Q)U`X6IuoLI2<saFI<vfioqCa#$ph!OLxq6J50RTLOmx
z`62A&C}TbMAkgAdIAm7uX&)%P3=jry3ejgAYbxtRFqeDmsU%xFo_Sf3WncaBY}7e9
z*~C?FTHfZx0}$#jE5BpWq?~?N$CH`tFpR#!&soYTZ9=Zm9S1~mUD2~VVALXr^JAu`
zp!qX0#DHp4s`6a_!&CY|Mkh^C0(vP0vVho(DwvQ(2f0ebiQ%PW8;m=spwm{?q%YTC
zRre1ijQ3oqP#knS&ZD&YPe!%&>DY&nW}_yzWw;IIbR#^IsRaZ3+(CyQ1m3!ws=e<Z
zQFjUnzbCh*<S+l7{Omb}XR^j>6Yy-lq%T!>@b6V&|1KeOHoI7B&%$~5U^t(ckL`0%
z%`f<$&`wOPa^~RE=r&#o&c~JKiq>9DtcsGdxk%x7ERN!UpRRM)lVZk=7{r5P#&~{d
zm(A~TmI}xdCfZqEJKD^zx%x8nsW$#))v`x1hQgV|ZigI9Wx$<+f5kO;5}h|+d=zSA
z@OE-5d?UJ!rUt8HZDdAOE$ydZ3jR79t14gXAJ?ntZ$s37^jJ|;8H9n7zHcrW90naH
zuhJ?n=1a3FeCfG(HDC7<m$McdZd^I;8b#&(O4MHXixliE=YWBLFkabh%v$AXev<r@
z;xqhgaRq;Iz(=>Z9-1=WMTTn>LDHzg21O=M&$;EoKb0fq{^;I_>}u(KuSP+c`(*CZ
zNLHrlKkDWR%_nn7?b$S9Grz%L(iy*$AM=ws340Odi2%0Z2^H*<lvdB^y-BetP<=DV
z#{E>@#)t8+DtJ;|9Q5e9xF1X#%uG*!Z~wR`Ty^w#RW+a+?j0i8_asD7r{{Yf`1S4X
zWzbl}(#_AlY6DZf6C4*x89mzKTr(TeA8{h6<5S<nOF|`1`NsF}WZA{(jk9n<x-`81
zT~~9xh+~KysVD*<m!&e*C6S?uN03ekaEy%8J`z)kQOe=EN|yc?hOb-+LsbnN|4APx
zm_W@u3sR(~=6e|79e$AxVeHi3di9P0`70qrV?Rf_(_IDy2Z;c%5YdIpko-k#$tRAe
z3q@$%QA&%p`+AL<orn<wYU>hxPeVJ3XpYR;*P^Aw!YPp*8g0g(vgcllg!vt@D5B{|
zmT3+kGX{!<<F)QDfGv4zFGb0rwq|aY-Ul8j10nt6H03v>-BnJ>r^N`QM3!}VL6mJe
zkJGOX{g`0-m7rxT01q@wOt|M)0A9$Dl|g#Y2-Z&uN`x?vR%f=<BFW#C;o@_|{~P%$
zxkUGI82QR>PLheG;LXn3mOS#>y3tj58=KaAe^BHp$*Kc4QtUHk`1grQvLouVd8ILv
z%_c75WHHqueEx6PE+2x5$gMlQA-N*I26=UAaQYgVV-y%A!N~*`=eC-ZXm9@NRMMO4
z4x#BGs-!Vvf}<6#59%9hY%-k{LZCACs+$(Bza$q4l+6kOc5P3cg4Xe}s>zhoh@*G{
z?;9lA_T9Qs*qMw0_YCEpt2;vh0#R3|wn3NsbXZPR0)a+df9ELc>y8GLz=aT7Y+24c
z^w;H=0oqed?Fq7$W>`HJZ1l@p9cC*yo)cnb-!q(K!ZvzDU@jyaaRj00wvbhCF4F_E
zB+GL(I<R!N!WjCgAKJ7W%8dW34`g^gjd)`rz4dYTz?vJ2i>cG5)+~PAm3EJ#O3oU4
zQy(59Y+UkR@d07a`q~t{B+H=w5qE6P^Q1|HS=3{<&+NHzs71W_91I2S=`iaq@tvI7
za<nghi}#tJ;<!$j&(rYAblW>oVPIZMF{bMxhb488;jDxaxvbL!olz0ap_dI2&)L!q
z=4tKHY801e`}DGP2}0GvIel35CA~C2$czItua{siM4e(D9j-r-sEP$huvit|?Nm2F
z7E6QqS|GA|nWBeh6?ope5}o?7q%_I8NbkpzrpXpu4oJc{Z8-N^cMO2#h2IaKdN!x2
zs7RyCVFbOUEUTr1!Zxb3d1Z6nf1Oz+PsG`TSF8K3M|qyT!{|q&5`)PIWN^4+$ThJD
zj+dUZXT!|!$t}q^>D{qANMhi5q36zY7HB~jG9Voumb@sk!ceb4^CT5*v#iUYv@O4N
zA-Xb~0k&xIn8P+NT01;5vW={HFOjs>#573emdDuL*%fb;6cGa$T?1Y3!$4|{hNeY(
ziqSL$cHV*W=7kr%*2yj?|Dtn?1Y7CbrI(dnQ_05;aeivvdT|E9=+_PC5q6|WiA6SI
zk(&$IM3-n<(kQ6MI_7>pfXJ{1{=19v%jfz4Kzpi&WqfHLGv#haB3WY<S6jT7$_;ik
zb}#6bl;%TBJFJPUyaDyR@7~GD8m=IE*>9No*O0zrhfIR9&b2MzL`-Qt$FcP$Qy`S$
zwmMr~TxPDqyYn7a>zxp^aAq~AA+g@nM9&nYX`vpn!Mhu1JrBF#;J|2NU#P~3p&(R$
z6q0S2Y`z$&pGv77n}%iejLSxD88;>~6A@|^`|k3kH;=!qeqEk+7Y=8TJsB_Kp+iUp
zY&9r7`<c7U<%~X8<{hnDHzi!~<vuJs1ZC3#+$MSABJl_Jy2teW_IhQEUh1NIrAKs%
zg6J7htp``;G-uWHX+>zZ5)NxGyXX7bRvl23QI9{0C>7mT@lJ*+e+lINvaVmBNJF6Z
zl7vPhn70}1Ci=GZ;65XCU2`j~=Eie1&+<~3T;f(oVgF!PAye*B;S=HE7#z_$Z>$Q>
z>8N(|(DvQg8C$#Dl?N6m+iz+ke4bo5f5h7-Mmqg`tUTfp*XemPdk@Shj(JGXu=0`c
z5@q`{^)l<<p$UE*V4|5U^#v(N15YZ`IVlq7IL{+^5T=)31djN3UH!v~iNR4~9^I!5
zYE|$KQVo*kuu((*vCn>6oK)@d=h$>^MAH(Un&vfo2Zw(u2^)S1mpj47c55a=p!r7p
z!4yWmpz5}^$6Txgwa4Luu^dy&%vl#-NN@{+C=2#&3vfX*k@4C?u@(90o3mXm#DM2}
zWuZt*h!z%#$GYO)VY1n6SpWbYCcD_I%Bk)XYEzNf$pD(01yttcy>q1GeP54);ciz5
zGz~{?O4swYk~E!3_3l+lpm^+H^qQaxmvwyl<_m|h)r8%XUIb9@=&%xE+4~%HwSsJ$
zyd{L~r$75R9yAhge0<0^e>{TK1b9X83L=|dK&D>~NhH10B<Rsqr_p#TV_>dNv&i^5
zlEFZ%luKo);B^FMxH44%Gn~sRhQPaqwi*m|C8nkZ`;D(H{}J>$e%?PG+8x>-JJ$Vf
zVr_MK>HQqE-PdtJ^=DRJ|I<mp$(_k3&EIwa{2;!;{NSK@YR)e@Kz`$VuGmJPCxMN|
ze_M5)qUVp3h%+IsQVaT*Qtida;DI;V+?bmzTiV5Bk3T=K5b>rrQM1IEZ^rO3K}99U
zJ|4;1zK(n)8p2&AjVKvEFW9gJTv#1k|0pSPUQ`s{y0#QQ$KN78W#oBNh)ROux0fyZ
z>6v0WMsQZwkIdX%yaq7C=v*IR0+Ia+^1xhkxCWdnJn`?@4s@k3jc%=vh<smM4Y;qU
zkZVfX;A0s3#!m0Dz>a^^P}6AE)?y0AR-sE%&5LhzZj*HDQzn<FE0}8SbJ*d^EgTL;
zfh(|xXXxH7EVOCtH$pIS8J^w%T{~0(qG>9o?bBAruU;6g(i6V>CYgDGR1j8VzMc5F
zc%F1|#jg7jMy@&YEok=_XWLn$JvLNmrOgk!{i7dGSbVyug6AI*gUr_7H>k*Lm(0O-
zYVe}nbG3;_^@;Tj_t{Fr;I%pqhU0+OgX8_^%+9uHE+8YF7U7R!Brk76(V?7{)f{Gv
zCUL%pdf(wk5c@VTqgp4kua@0AXg6DPFB3PhGjx>2k6L#vYP)ZmURI9vgAHG>*1ZL8
zl&!>yA?ej|_uzI<C99tUkoa*nUd5LGg|gz?oPtk3R?K2JuJqdKSH$Vxk|)>i#uVQR
zV8DX`ZmAB*mPwY%Hw;{G1|1%7nBAWV>1dkD>yHt>GnT`x;PfAy7~J;F!#TZEf|$d;
z+S{gc!PB#2t;$4Bm!->0R$I5MP0bO_<6b`mWvjwUUNYK<A)CE5iu|X$$G_g`Jd)eu
zFal~@itUkMtDB|N^neB!Z`0=QnARjix48q2kE)7uxm~3q4sm<;(_INV>x@q~E`A2&
z_T|XroEc=yTE1ibE|1~7jl4^c>D~B~KsGfh)Or#_-Rp@7MZ5MZG*J!w&r4{zK=e%=
zuvVO5+L82Bm+5B~GPi{+ib{}~`Q@DX0%xXzd?rJCSEj;o;yUo9y0q0c9998mnS&OE
zjT0}E50xNp$RiX>|G=`p)$XhO3XmV_h=GYJ%{{9R&4R$zf+Bfe=>_Jr$}gQ?{X&*@
ze(%|Uw>)}E>d-zd@QqAEtfnw%P5X&@(Y)fW<ui-J$V7*Nd&bTqjdl{5RqRT^db<Uq
z32MwkvzRtkVY9Lgi@BJU*)MR)5J4ft9h}Q$Ud;IYpYfcmro+9j;~6x8A=;x!Tq;;`
z>=pF~6zijvv^8H$1(h;)s$`DlRTKC@c}^?G8(RqVrYGp(?+ozt>kAfehskd-<!5;K
zP6pRC!F~EVkN%@WF6=M5_l3a&j;o+DAzbrVMcbD9FmIF{3H-b3qoT6~Mxtojc&%Tl
zn}q0BD<`Fwg%8TIO9FGeYS(>s2|mt5#N>sV^xpGKA>|H25Vq6TMou{+dn8^Wz*-L+
zSPW;y`*5<<h6NXyRDlhIc!R+fFo*ZzddA(_OpGs49XArWLf&`eUmv|UE(N*g5K&fx
zVG=)VbVK33%A+W2xW^Yo)RA8tigt*%N^ysir21M8ei8`uNn>ObYae|8%!pld>7JJj
z-crsxK+P3BBr6m%-o%qrAYphugoWs$4Xkcoc@HMParx=8vRQEculeSyJJ+ocS7L@4
zCV0Q*vM{tx>xqBVCrXhGJw>Yy9n8r0XX)VSCNRa1%=ON~n-SD`p<Bh4-qts>^)^ge
zR12ieOxW|#_p&%8ZG!##pVV_Sf2W{HkPuE8{&7<)xRCa-QoFkTsBUJ@)~LIx3c0ku
zDD}8r@#!ljwCHVT^0npMI1#!>F0yTNt^w<{!7YXZbHjT%_P<1qBF_&O_?*+Z3P80>
z;YGZ|Xo_DzjNB%??K>`J^8HIgGcN%MWWZucwAdmosHhvO{)9_w_%kb8E-Zmzs5H?`
zdk3x4LRa*itz`~Dj#8#}K1h~%hxcbI=4EL=SI;cBOHReJZLb%?ErdK`O8ZV<Y@W-q
z@&_<~VySv7=Qvu2=WR}9?38_{b}jnh!N!{&aAgrX_hTTJwY*(*8MY9O8A_9v_i9e<
zwc*D~pD86=iFIzoj>!Deb}gJn?k3F4XA&HO@4r)J6sl4C%mC%0Dd_e+gm(?EFdE-|
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
C<nT!V

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_me.png b/Images/Icons/Filesystem/fs_me.png
new file mode 100644
index 0000000000000000000000000000000000000000..e811d0e1f35aea5fb9a61c744343d05a8644dfb9
GIT binary patch
literal 6338
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
W7v9Js9<m1T@0iI+<LtwBxBm+bJPM-#

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_prm.png b/Images/Icons/Filesystem/fs_prm.png
new file mode 100644
index 0000000000000000000000000000000000000000..d8563bca21c56d3e26eadda068f828dfa4dd2434
GIT binary patch
literal 42745
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
K+HW+S;{FE&eWD8h

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_sb.png b/Images/Icons/Filesystem/fs_sb.png
new file mode 100644
index 0000000000000000000000000000000000000000..8d39c3edaeeae27cd015aa2ae5da99e47beb8698
GIT binary patch
literal 10068
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

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_szs.png b/Images/Icons/Filesystem/fs_szs.png
new file mode 100644
index 0000000000000000000000000000000000000000..db13dbc47e2378f2cb1b2fd139c0dee91d5c7bb4
GIT binary patch
literal 27272
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

literal 0
HcmV?d00001

diff --git a/Images/Icons/Filesystem/fs_thp.png b/Images/Icons/Filesystem/fs_thp.png
new file mode 100644
index 0000000000000000000000000000000000000000..e0a32e37b5bdea9b03bc9516c510fe1f375a7d63
GIT binary patch
literal 6264
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
Oa`Kqz(Sjom5q||J<&Vk$

literal 0
HcmV?d00001

diff --git a/Images/Icons/color_picker.png b/Images/Icons/color_picker.png
new file mode 100644
index 0000000000000000000000000000000000000000..d00e01749bd2cc08ca242649534ea74730195721
GIT binary patch
literal 3641
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

literal 0
HcmV?d00001

diff --git a/include/gui/project/asset.hpp b/include/gui/project/asset.hpp
new file mode 100644
index 00000000..cb4d306d
--- /dev/null
+++ b/include/gui/project/asset.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include "fsystem.hpp"
+#include "gui/widget/widget.hpp"
+#include "model/fsmodel.hpp"
+#include "gui/image/imagepainter.hpp"
+
+namespace Toolbox::UI {
+
+    class ProjectAsset : public ImWidget {
+    public:
+        ProjectAsset() : ImWidget("Project Asset") {}
+        ~ProjectAsset() = default;
+
+        [[nodiscard]] virtual std::optional<ImVec2> defaultSize() const {
+            return {
+                {180, 180}
+            };
+        }
+        [[nodiscard]] virtual std::optional<ImVec2> minSize() const {
+            return {
+                {180, 180}
+            };
+        }
+        [[nodiscard]] virtual std::optional<ImVec2> maxSize() const {
+            return {
+                {180, 180}
+            };
+        }
+
+
+
+        void setModelIndex(const ModelIndex &index) { m_index = index; }
+        void setModel(RefPtr<FileSystemModel> model) { m_model = model; }
+
+    protected:
+        virtual void onRenderBody(TimeStep delta_time);
+
+    private:
+        ModelIndex m_index;
+        RefPtr<FileSystemModel> m_model;
+        ImagePainter m_painter;
+    };
+
+}  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index f4c9f9ce..34c76a19 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -19,6 +19,9 @@
 #include "gui/event/event.hpp"
 #include "gui/image/imagepainter.hpp"
 #include "gui/window.hpp"
+#include "gui/project/asset.hpp"
+
+#include "model/fsmodel.hpp"
 
 #include <imgui.h>
 
@@ -38,6 +41,9 @@ namespace Toolbox::UI {
         void renderProjectFolderButton();
         void renderProjectFileButton();
 
+        void renderFolderTree(const ModelIndex &index);
+        void initFolderAssets(const ModelIndex &index);
+
     public:
         ImGuiWindowFlags flags() const override {
             return ImWindow::flags() | ImGuiWindowFlags_MenuBar;
@@ -75,6 +81,12 @@ namespace Toolbox::UI {
 
         [[nodiscard]] bool onLoadData(const std::filesystem::path& path) override {
             m_project_root = path;
+            m_file_system_model = make_referable<FileSystemModel>();
+            m_file_system_model->setRoot(m_project_root);
+            m_tree_proxy.setSourceModel(m_file_system_model);
+            m_tree_proxy.setDirsOnly(true);
+            m_view_proxy.setSourceModel(m_file_system_model);
+            m_view_index = m_view_proxy.getIndex(0, 0);
             return true;
         }
         [[nodiscard]] bool onSaveData(std::optional<std::filesystem::path> path) override {
@@ -92,6 +104,14 @@ namespace Toolbox::UI {
         fs_path m_project_root;
 
         // TODO: Have filesystem model.
+        FileSystemModelSortFilterProxy m_tree_proxy;
+        FileSystemModelSortFilterProxy m_view_proxy;
+        RefPtr<FileSystemModel> m_file_system_model;
+
+        std::vector<ModelIndex> m_selected_indices;
+        std::vector<ProjectAsset> m_view_assets;
+        ModelIndex m_view_index;
+
         std::unordered_map<std::string, ImageHandle> m_icon_map;
         ImagePainter m_icon_painter;
     };
diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index 49d30be7..ae3dbefc 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "core/mimedata/mimedata.hpp"
+#include "core/types.hpp"
 #include "fsystem.hpp"
 #include "image/imagehandle.hpp"
 #include "unique.hpp"
@@ -21,15 +22,24 @@ namespace Toolbox {
         SORT_DESCENDING,
     };
 
+    enum class ModelSortRole {
+        SORT_ROLE_NONE,
+        SORT_ROLE_NAME,
+        SORT_ROLE_SIZE,
+        SORT_ROLE_DATE,
+    };
+
     class ModelIndex : public IUnique {
     public:
         ModelIndex() = default;
-        ModelIndex(int64_t row, int64_t column, UUID64 model_uuid)
-            : m_row(row), m_column(column), m_model_uuid(model_uuid) {}
+        ModelIndex(UUID64 model_uuid) : m_model_uuid(model_uuid) {}
+        ModelIndex(const ModelIndex &other)
+            : m_uuid(other.m_uuid), m_model_uuid(other.m_model_uuid),
+              m_user_data(other.m_user_data) {}
 
-        bool isValid() const { return m_row >= 0 && m_column >= 0 && m_model_uuid != 0; }
+        bool isValid() const { return m_model_uuid != 0; }
 
-        template <typename T = void *> [[nodiscard]] data() const {
+        template <typename T = void> [[nodiscard]] T *data() const {
             return reinterpret_cast<T *>(m_user_data);
         }
         void setData(void *data) { m_user_data = data; }
@@ -37,53 +47,69 @@ namespace Toolbox {
         [[nodiscard]] UUID64 getUUID() const override { return m_uuid; }
         [[nodiscard]] UUID64 getModelUUID() const { return m_model_uuid; }
 
+        operator bool() const { return isValid(); }
+
+        ModelIndex &operator=(const ModelIndex &other) {
+            m_uuid       = other.m_uuid;
+            m_model_uuid = other.m_model_uuid;
+            m_user_data  = other.m_user_data;
+            return *this;
+        }
+
+        [[nodiscard]] bool operator==(const ModelIndex &other) const {
+            return m_uuid == other.m_uuid && m_model_uuid == other.m_model_uuid;
+        }
+
     private:
         UUID64 m_uuid;
         UUID64 m_model_uuid = 0;
 
-        int64_t m_row    = -1;
-        int64_t m_column = -1;
-
         void *m_user_data = nullptr;
     };
 
-    class FileSystemModel {
+    enum class FileSystemModelOptions {
+        NONE             = 0,
+        DISABLE_WATCHDOG = BIT(0),
+        DISABLE_SYMLINKS = BIT(1),
+    };
+    TOOLBOX_BITWISE_ENUM(FileSystemModelOptions)
+
+    class FileSystemModel : public IUnique {
     public:
-        enum class Options {
-            DISABLE_WATCHDOG = BIT(0),
-            DISABLE_SYMLINKS = BIT(1),
+        struct FSTypeInfo {
+            std::string m_name;
+            ImageHandle m_icon;
         };
-        TOOLBOX_BITWISE_ENUM(Options)
 
     public:
         FileSystemModel()  = default;
         ~FileSystemModel() = default;
 
-        const fs_path &getRoot() const &;
-        void setRoot(const fs_path &path);
+        [[nodiscard]] UUID64 getUUID() const override { return m_uuid; }
 
-        const std::string &getFilter() const &;
-        void setFilter(const std::string &filter);
+        [[nodiscard]] bool validateIndex(const ModelIndex &index) const;
+
+        [[nodiscard]] const fs_path &getRoot() const &;
+        void setRoot(const fs_path &path);
 
-        Options getOptions() const;
-        void setOptions(Options options);
+        [[nodiscard]] FileSystemModelOptions getOptions() const;
+        void setOptions(FileSystemModelOptions options);
 
-        bool isReadOnly() const;
-        void setReadOnly();
+        [[nodiscard]] bool isReadOnly() const;
+        void setReadOnly(bool read_only);
 
-        bool isDirectory(const ModelIndex &index);
-        bool isFile(const ModelIndex &index);
-        bool isArchive(const ModelIndex &index);
+        [[nodiscard]] bool isDirectory(const ModelIndex &index) const;
+        [[nodiscard]] bool isFile(const ModelIndex &index) const;
+        [[nodiscard]] bool isArchive(const ModelIndex &index) const;
 
-        size_t getFileSize(const ModelIndex &index);
-        size_t getDirSize(const ModelIndex &index, bool recursive);
+        [[nodiscard]] size_t getFileSize(const ModelIndex &index);
+        [[nodiscard]] size_t getDirSize(const ModelIndex &index, bool recursive);
 
-        const ImageHandle &getIcon(const ModelIndex &index) const &;
-        Filesystem::file_time_type getLastModified(const ModelIndex &index) const;
-        Filesystem::perms getPermissions(const ModelIndex &index) const;
-        const Filesystem::file_status &getStatus(const ModelIndex &index) const &;
+        [[nodiscard]] const ImageHandle &getIcon(const ModelIndex &index) const &;
+        [[nodiscard]] Filesystem::file_time_type getLastModified(const ModelIndex &index) const;
+        [[nodiscard]] Filesystem::file_status getStatus(const ModelIndex &index) const;
 
-        std::string getType(const ModelIndex &index) const &;
+        [[nodiscard]] std::string getType(const ModelIndex &index) const &;
 
         ModelIndex mkdir(const ModelIndex &parent, const std::string &name);
         ModelIndex touch(const ModelIndex &parent, const std::string &name);
@@ -92,37 +118,137 @@ namespace Toolbox {
         bool remove(const ModelIndex &index);
 
     public:
-        const ModelIndex &getIndex(const fs_path &path) const &;
-        const ModelIndex &getIndex(int64_t row, int64_t column,
-                                   ModelIndex &parent = ModelIndex()) const &;
-        const fs_path &getPath(const ModelIndex &index) const &;
+        [[nodiscard]] ModelIndex getIndex(const fs_path &path) const;
+        [[nodiscard]] ModelIndex getIndex(const UUID64 &path) const;
+        [[nodiscard]] ModelIndex getIndex(int64_t row, int64_t column,
+                                          const ModelIndex &parent = ModelIndex()) const;
+        [[nodiscard]] fs_path getPath(const ModelIndex &index) const;
 
-        const Modelindex &getParent(const ModelIndex &index) const &;
-        const ModelIndex &getSibling(int64_t row, int64_t column, const ModelIndex &index);
+        [[nodiscard]] ModelIndex getParent(const ModelIndex &index) const;
+        [[nodiscard]] ModelIndex getSibling(int64_t row, int64_t column,
+                                            const ModelIndex &index) const;
 
-        size_t getColumnCount(const ModelIndex &index) const;
-        size_t getRowCount(const ModelIndex &index) const;
+        [[nodiscard]] size_t getColumnCount(const ModelIndex &index) const;
+        [[nodiscard]] size_t getRowCount(const ModelIndex &index) const;
 
-        bool hasChildren(const ModelIndex &parent = ModelIndex()) const;
+        [[nodiscard]] bool hasChildren(const ModelIndex &parent = ModelIndex()) const;
 
-        ScopePtr<MimeData> createMimeData(const std::vector<ModelIndex> &indexes) const;
-        std::vector<std::string> getSupportedMimeTypes() const;
+        [[nodiscard]] ScopePtr<MimeData>
+        createMimeData(const std::vector<ModelIndex> &indexes) const;
+        [[nodiscard]] std::vector<std::string> getSupportedMimeTypes() const;
 
-        bool canFetchMore(const ModelIndex &index);
+        [[nodiscard]] bool canFetchMore(const ModelIndex &index);
         void fetchMore(const ModelIndex &index);
 
-        void sort(int64_t column, ModelSortOrder order = ModelSortOrder::SORT_ASCENDING);
+        static const ImageHandle &InvalidIcon();
+        static const std::unordered_map<std::string, FSTypeInfo> &TypeMap();
 
     protected:
+        ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent);
+
         void cacheIndex(ModelIndex &index);
         void cacheFolder(ModelIndex &index);
         void cacheFile(ModelIndex &index);
         void cacheArchive(ModelIndex &index);
 
-        const ModelIndex &getParentArchive(const ModelIndex &index);
+        ModelIndex getParentArchive(const ModelIndex &index) const;
+
+        size_t pollChildren(const ModelIndex &index) const;
 
     private:
+        UUID64 m_uuid;
+
         fs_path m_root_path;
+
+        FileSystemModelOptions m_options = FileSystemModelOptions::NONE;
+        bool m_read_only                 = false;
+
+        UUID64 m_root_index;
+
+        mutable std::unordered_map<UUID64, ModelIndex> m_index_map;
+    };
+
+    class FileSystemModelSortFilterProxy : public IUnique {
+    public:
+        FileSystemModelSortFilterProxy()  = default;
+        ~FileSystemModelSortFilterProxy() = default;
+
+        [[nodiscard]] UUID64 getUUID() const override { return m_uuid; }
+
+        [[nodiscard]] bool validateIndex(const ModelIndex &index) const;
+
+        [[nodiscard]] bool isDirsOnly() const { return m_dirs_only; }
+        void setDirsOnly(bool dirs_only) { m_dirs_only = true; }
+
+        [[nodiscard]] RefPtr<FileSystemModel> getSourceModel() const;
+        void setSourceModel(RefPtr<FileSystemModel> model);
+
+        [[nodiscard]] ModelSortOrder getSortOrder() const;
+        void setSortOrder(ModelSortOrder order);
+
+        [[nodiscard]] ModelSortRole getSortRole() const;
+        void setSortRole(ModelSortRole role);
+
+        [[nodiscard]] const std::string &getFilter() const &;
+        void setFilter(const std::string &filter);
+
+        [[nodiscard]] bool isReadOnly() const;
+        void setReadOnly(bool read_only);
+
+        [[nodiscard]] bool isDirectory(const ModelIndex &index) const;
+        [[nodiscard]] bool isFile(const ModelIndex &index) const;
+        [[nodiscard]] bool isArchive(const ModelIndex &index) const;
+
+        [[nodiscard]] size_t getFileSize(const ModelIndex &index);
+        [[nodiscard]] size_t getDirSize(const ModelIndex &index, bool recursive);
+
+        [[nodiscard]] const ImageHandle &getIcon(const ModelIndex &index) const &;
+        [[nodiscard]] Filesystem::file_time_type getLastModified(const ModelIndex &index) const;
+        [[nodiscard]] Filesystem::file_status getStatus(const ModelIndex &index) const;
+
+        [[nodiscard]] std::string getType(const ModelIndex &index) const &;
+
+        ModelIndex mkdir(const ModelIndex &parent, const std::string &name);
+        ModelIndex touch(const ModelIndex &parent, const std::string &name);
+
+        bool rmdir(const ModelIndex &index);
+        bool remove(const ModelIndex &index);
+
+        [[nodiscard]] ModelIndex getIndex(const fs_path &path) const;
+        [[nodiscard]] ModelIndex getIndex(const UUID64 &path) const;
+        [[nodiscard]] ModelIndex getIndex(int64_t row, int64_t column,
+                                          const ModelIndex &parent = ModelIndex()) const;
+        [[nodiscard]] fs_path getPath(const ModelIndex &index) const;
+
+        [[nodiscard]] ModelIndex getParent(const ModelIndex &index) const;
+        [[nodiscard]] ModelIndex getSibling(int64_t row, int64_t column,
+                                            const ModelIndex &index) const;
+
+        [[nodiscard]] size_t getColumnCount(const ModelIndex &index) const;
+        [[nodiscard]] size_t getRowCount(const ModelIndex &index) const;
+
+        [[nodiscard]] bool hasChildren(const ModelIndex &parent = ModelIndex()) const;
+
+        [[nodiscard]] ScopePtr<MimeData>
+        createMimeData(const std::vector<ModelIndex> &indexes) const;
+        [[nodiscard]] std::vector<std::string> getSupportedMimeTypes() const;
+
+        [[nodiscard]] bool canFetchMore(const ModelIndex &index);
+        void fetchMore(const ModelIndex &index);
+
+    protected:
+        [[nodiscard]] ModelIndex toSourceIndex(const ModelIndex &index) const;
+        [[nodiscard]] ModelIndex toProxyIndex(const ModelIndex &index) const;
+
+    private:
+        UUID64 m_uuid;
+
+        RefPtr<FileSystemModel> m_source_model = nullptr;
+        ModelSortOrder m_sort_order            = ModelSortOrder::SORT_ASCENDING;
+        ModelSortRole m_sort_role              = ModelSortRole::SORT_ROLE_NONE;
+        std::string m_filter                   = "";
+
+        bool m_dirs_only = false;
     };
 
 }  // namespace Toolbox
\ No newline at end of file
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 0cece844..f39a8937 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -26,6 +26,7 @@
 #include "gui/logging/errors.hpp"
 #include "gui/logging/window.hpp"
 #include "gui/pad/window.hpp"
+#include "gui/project/window.hpp"
 #include "gui/scene/ImGuizmo.h"
 #include "gui/scene/window.hpp"
 #include "gui/settings/window.hpp"
@@ -431,6 +432,12 @@ namespace Toolbox {
                 } else {
                     if (m_project_manager.loadProjectFolder(path)) {
                         TOOLBOX_INFO_V("Loaded project folder: {}", path.string());
+                        RefPtr<ProjectViewWindow> project_window =
+                            createWindow<ProjectViewWindow>("Project View");
+                        if (!project_window->onLoadData(path)) {
+                            TOOLBOX_ERROR("Failed to open project folder view!");
+                            project_window->close();
+                        }
                     }
                 }
             }
diff --git a/src/gui/project/asset.cpp b/src/gui/project/asset.cpp
new file mode 100644
index 00000000..b991fa93
--- /dev/null
+++ b/src/gui/project/asset.cpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "fsystem.hpp"
+#include "gui/project/asset.hpp"
+#include "model/fsmodel.hpp"
+
+namespace Toolbox::UI {
+
+    void ProjectAsset::onRenderBody(TimeStep delta_time) {
+        // Draw the asset icon
+        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {3, 3});
+
+        if (m_model) {
+            m_painter.render(m_model->getIcon(m_index));
+            ImGui::Text("%s", m_model->getPath(m_index).c_str());
+        }
+
+        ImGui::PopStyleVar();
+    }
+
+}  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 97152c90..12df64b7 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -1,4 +1,7 @@
 #include "gui/project/window.hpp"
+#include "model/fsmodel.hpp"
+
+#include <imgui/imgui.h>
 
 namespace Toolbox::UI {
 
@@ -6,11 +9,56 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::onRenderMenuBar() {}
 
-    void ProjectViewWindow::onRenderBody(TimeStep delta_time) {}
+    void ProjectViewWindow::onRenderBody(TimeStep delta_time) {
+        renderProjectTreeView();
+        ImGui::SameLine();
+        ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
+        ImGui::SameLine();
+        renderProjectFolderView();
+        renderProjectFolderButton();
+        renderProjectFileButton();
+    }
+
+    void ProjectViewWindow::renderProjectTreeView() {
+        if (ImGui::BeginChild("Tree View", {160, 0}, true,
+                              ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
+            ModelIndex index = m_tree_proxy.getIndex(0, 0);
+            renderFolderTree(index);
+        }
+        ImGui::EndChild();
+    }
+
+    void ProjectViewWindow::renderProjectFolderView() {
+        if (!m_view_index.isValid()) {
+            return;
+        }
 
-    void ProjectViewWindow::renderProjectTreeView() {}
+        if (ImGui::BeginChild("Folder View", { 400, 0 }, true,
+                              ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
+            if (m_view_proxy.hasChildren(m_view_index)) {
+                if (m_view_proxy.canFetchMore(m_view_index)) {
+                    m_view_proxy.fetchMore(m_view_index);
+                }
+                for (size_t i = 0; i < m_view_proxy.getRowCount(m_view_index); ++i) {
+                    ModelIndex child_index = m_view_proxy.getIndex(i, 0, m_view_index);
 
-    void ProjectViewWindow::renderProjectFolderView() {}
+                    if (ImGui::BeginChild(child_index.getUUID(), {160, 180}, true,
+                                          ImGuiWindowFlags_ChildWindow |
+                                              ImGuiWindowFlags_NoDecoration)) {
+                        const ImageHandle &icon = m_view_proxy.getIcon(child_index);
+                        m_icon_painter.render(icon, {140, 140});
+
+                        ImGui::RenderTextEllipsis(
+                            ImGui::GetWindowDrawList(), {10, 150}, {130, 170}, 120.0f, 150.0f,
+                            m_view_proxy.getPath(child_index).filename().string().c_str(), nullptr,
+                            nullptr);
+                    }
+                    ImGui::EndChild();
+                }
+            }
+        }
+        ImGui::EndChild();
+    }
 
     void ProjectViewWindow::renderProjectFolderButton() {}
 
@@ -28,4 +76,29 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {}
 
-} // namespace Toolbox::UI
\ No newline at end of file
+    void ProjectViewWindow::renderFolderTree(const ModelIndex &index) {
+        bool is_open = false;
+        if (m_tree_proxy.hasChildren(index)) {
+            if (m_tree_proxy.canFetchMore(index)) {
+                m_tree_proxy.fetchMore(index);
+            }
+            is_open = ImGui::TreeNodeEx(m_tree_proxy.getPath(index).filename().string().c_str(),
+                                        ImGuiTreeNodeFlags_OpenOnArrow);
+            if (is_open) {
+                for (size_t i = 0; i < m_tree_proxy.getRowCount(index); ++i) {
+                    ModelIndex child_index = m_tree_proxy.getIndex(i, 0, index);
+                    renderFolderTree(child_index);
+                }
+                ImGui::TreePop();
+            }
+        } else {
+            if (ImGui::TreeNodeEx(m_tree_proxy.getPath(index).filename().string().c_str(),
+                                  ImGuiTreeNodeFlags_Leaf)) {
+                ImGui::TreePop();
+            }
+        }
+    }
+
+    void ProjectViewWindow::initFolderAssets(const ModelIndex &index) {}
+
+}  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
new file mode 100644
index 00000000..fe1ba839
--- /dev/null
+++ b/src/model/fsmodel.cpp
@@ -0,0 +1,1111 @@
+#include <algorithm>
+#include <compare>
+#include <set>
+
+#include "model/fsmodel.hpp"
+
+namespace Toolbox {
+
+    struct _FileSystemIndexData {
+        enum class Type {
+            FILE,
+            DIRECTORY,
+            ARCHIVE,
+            UNKNOWN,
+        };
+
+        UUID64 m_parent                = 0;
+        std::vector<UUID64> m_children = {};
+
+        Type m_type = Type::UNKNOWN;
+        fs_path m_path;
+        size_t m_size = 0;
+        Filesystem::file_time_type m_date;
+
+        bool hasChild(UUID64 uuid) const {
+            return std::find(m_children.begin(), m_children.end(), uuid) != m_children.end();
+        }
+
+        std::strong_ordering operator<=>(const _FileSystemIndexData &rhs) const {
+            return m_path <=> rhs.m_path;
+        }
+    };
+
+    static bool _FileSystemIndexDataIsDirLike(const _FileSystemIndexData &data) {
+        return data.m_type == _FileSystemIndexData::Type::DIRECTORY ||
+               data.m_type == _FileSystemIndexData::Type::ARCHIVE;
+    }
+
+    static bool _FileSystemIndexDataCompareByName(const _FileSystemIndexData &lhs,
+                                                  const _FileSystemIndexData &rhs,
+                                                  ModelSortOrder order) {
+        const bool is_lhs_dir = _FileSystemIndexDataIsDirLike(lhs);
+        const bool is_rhs_dir = _FileSystemIndexDataIsDirLike(rhs);
+
+        // Folders come first
+        if (is_lhs_dir && !is_rhs_dir) {
+            return true;
+        }
+
+        if (!is_lhs_dir && is_rhs_dir) {
+            return false;
+        }
+
+        // Sort by name
+        if (order == ModelSortOrder::SORT_ASCENDING) {
+            return lhs.m_path < rhs.m_path;
+        } else {
+            return lhs.m_path > rhs.m_path;
+        }
+    }
+
+    static bool _FileSystemIndexDataCompareBySize(const _FileSystemIndexData &lhs,
+                                                  const _FileSystemIndexData &rhs,
+                                                  ModelSortOrder order) {
+        const bool is_lhs_dir = _FileSystemIndexDataIsDirLike(lhs);
+        const bool is_rhs_dir = _FileSystemIndexDataIsDirLike(rhs);
+
+        // Folders come first
+        if (is_lhs_dir && !is_rhs_dir) {
+            return true;
+        }
+
+        if (!is_lhs_dir && is_rhs_dir) {
+            return false;
+        }
+
+        // Sort by size
+        if (order == ModelSortOrder::SORT_ASCENDING) {
+            return lhs.m_size < rhs.m_size;
+        } else {
+            return lhs.m_size > rhs.m_size;
+        }
+    }
+
+    static bool _FileSystemIndexDataCompareByDate(const _FileSystemIndexData &lhs,
+                                                  const _FileSystemIndexData &rhs,
+                                                  ModelSortOrder order) {
+        const bool is_lhs_dir = _FileSystemIndexDataIsDirLike(lhs);
+        const bool is_rhs_dir = _FileSystemIndexDataIsDirLike(rhs);
+
+        // Folders come first
+        if (is_lhs_dir && !is_rhs_dir) {
+            return true;
+        }
+
+        if (!is_lhs_dir && is_rhs_dir) {
+            return false;
+        }
+
+        // Sort by date
+        if (order == ModelSortOrder::SORT_ASCENDING) {
+            return lhs.m_date < rhs.m_date;
+        } else {
+            return lhs.m_date > rhs.m_date;
+        }
+    }
+
+    const fs_path &FileSystemModel::getRoot() const & { return m_root_path; }
+
+    void FileSystemModel::setRoot(const fs_path &path) {
+        if (m_root_path == path) {
+            return;
+        }
+
+        m_index_map.clear();
+
+        m_root_path  = path;
+        m_root_index = makeIndex(path, 0, ModelIndex()).getUUID();
+    }
+
+    FileSystemModelOptions FileSystemModel::getOptions() const { return m_options; }
+
+    void FileSystemModel::setOptions(FileSystemModelOptions options) { m_options = options; }
+
+    bool FileSystemModel::isReadOnly() const { return m_read_only; }
+
+    void FileSystemModel::setReadOnly(bool read_only) { m_read_only = read_only; }
+
+    bool FileSystemModel::isDirectory(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return false;
+        }
+        return index.data<_FileSystemIndexData>()->m_type == _FileSystemIndexData::Type::DIRECTORY;
+    }
+
+    bool FileSystemModel::isFile(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return false;
+        }
+        return index.data<_FileSystemIndexData>()->m_type == _FileSystemIndexData::Type::FILE;
+    }
+
+    bool FileSystemModel::isArchive(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return false;
+        }
+        return index.data<_FileSystemIndexData>()->m_type == _FileSystemIndexData::Type::ARCHIVE;
+    }
+
+    size_t FileSystemModel::getFileSize(const ModelIndex &index) {
+        if (!isFile(index)) {
+            return 0;
+        }
+        return index.data<_FileSystemIndexData>()->m_size;
+    }
+
+    size_t FileSystemModel::getDirSize(const ModelIndex &index, bool recursive) {
+        if (!(isDirectory(index) || isArchive(index))) {
+            return 0;
+        }
+        return index.data<_FileSystemIndexData>()->m_size;
+    }
+
+    const ImageHandle &FileSystemModel::getIcon(const ModelIndex &index) const & {
+        if (!validateIndex(index)) {
+            return TypeMap().at("_Invalid").m_icon;
+        }
+
+        if (isDirectory(index)) {
+            return TypeMap().at("_Folder").m_icon;
+        }
+
+        if (isArchive(index)) {
+            return TypeMap().at("_Archive").m_icon;
+        }
+
+        std::string ext = index.data<_FileSystemIndexData>()->m_path.extension().string();
+        if (ext.empty()) {
+            return TypeMap().at("_Folder").m_icon;
+        }
+
+        if (TypeMap().find(ext) == TypeMap().end()) {
+            return TypeMap().at("_File").m_icon;
+        }
+
+        return TypeMap().at(ext).m_icon;
+    }
+
+    Filesystem::file_time_type FileSystemModel::getLastModified(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return Filesystem::file_time_type();
+        }
+
+        Filesystem::file_time_type result = Filesystem::file_time_type();
+
+        Filesystem::last_write_time(index.data<_FileSystemIndexData>()->m_path)
+            .and_then([&](Filesystem::file_time_type &&time) {
+                result = std::move(time);
+                return Result<Filesystem::file_time_type, FSError>();
+            })
+            .or_else([&](const FSError &error) {
+                TOOLBOX_ERROR_V("[FileSystemModel] Failed to get last write time: {}",
+                                error.m_message[0]);
+                return Result<Filesystem::file_time_type, FSError>();
+            });
+
+        return result;
+    }
+
+    Filesystem::file_status FileSystemModel::getStatus(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return Filesystem::file_status();
+        }
+
+        Filesystem::file_status result = Filesystem::file_status();
+
+        Filesystem::status(index.data<_FileSystemIndexData>()->m_path)
+            .and_then([&](Filesystem::file_status &&status) {
+                result = std::move(status);
+                return Result<Filesystem::file_status, FSError>();
+            })
+            .or_else([&](const FSError &error) {
+                TOOLBOX_ERROR_V("[FileSystemModel] Failed to get last write status: {}",
+                                error.m_message[0]);
+                return Result<Filesystem::file_status, FSError>();
+            });
+
+        return result;
+    }
+
+    std::string FileSystemModel::getType(const ModelIndex &index) const & {
+        if (!validateIndex(index)) {
+            return TypeMap().at("_Invalid").m_name;
+        }
+
+        if (isDirectory(index)) {
+            return TypeMap().at("_Folder").m_name;
+        }
+
+        if (isArchive(index)) {
+            return TypeMap().at("_Archive").m_name;
+        }
+
+        std::string ext = index.data<_FileSystemIndexData>()->m_path.extension().string();
+        if (ext.empty()) {
+            return TypeMap().at("_Folder").m_name;
+        }
+
+        if (TypeMap().find(ext) == TypeMap().end()) {
+            return TypeMap().at("_File").m_name;
+        }
+
+        return TypeMap().at(ext).m_name;
+    }
+
+    ModelIndex FileSystemModel::mkdir(const ModelIndex &parent, const std::string &name) {
+        if (!validateIndex(parent)) {
+            return ModelIndex();
+        }
+
+        bool result = false;
+
+        if (isDirectory(parent)) {
+            fs_path path = parent.data<_FileSystemIndexData>()->m_path / name;
+            Filesystem::create_directory(path)
+                .and_then([&](bool created) {
+                    if (!created) {
+                        TOOLBOX_ERROR_V("[FileSystemModel] Failed to create directory: {}",
+                                        path.string());
+                        return Result<bool, FSError>();
+                    }
+                    result = true;
+                    return Result<bool, FSError>();
+                })
+                .or_else([&](const FSError &error) {
+                    TOOLBOX_ERROR_V("[FileSystemModel] Failed to create directory: {}",
+                                    error.m_message[0]);
+                    return Result<bool, FSError>();
+                });
+        } else if (isArchive(parent)) {
+            TOOLBOX_ERROR("[FileSystemModel] Archive creation is unimplemented!");
+        } else {
+            TOOLBOX_ERROR("[FileSystemModel] Parent index is not a directory!");
+        }
+
+        if (!result) {
+            return ModelIndex();
+        }
+
+        return makeIndex(parent.data<_FileSystemIndexData>()->m_path / name, getRowCount(parent),
+                         parent);
+    }
+
+    ModelIndex FileSystemModel::touch(const ModelIndex &parent, const std::string &name) {
+        if (!validateIndex(parent)) {
+            return ModelIndex();
+        }
+
+        bool result = false;
+
+        if (isDirectory(parent)) {
+            fs_path path = parent.data<_FileSystemIndexData>()->m_path / name;
+            std::ofstream file(path);
+            if (!file.is_open()) {
+                TOOLBOX_ERROR_V("[FileSystemModel] Failed to create file: {}", path.string());
+                return ModelIndex();
+            }
+            file.close();
+            result = true;
+        } else if (isArchive(parent)) {
+            TOOLBOX_ERROR("[FileSystemModel] Archive creation is unimplemented!");
+        } else {
+            TOOLBOX_ERROR("[FileSystemModel] Parent index is not a directory!");
+        }
+
+        if (!result) {
+            return ModelIndex();
+        }
+
+        return makeIndex(parent.data<_FileSystemIndexData>()->m_path / name, getRowCount(parent),
+                         parent);
+    }
+
+    bool FileSystemModel::rmdir(const ModelIndex &index) {
+        if (!validateIndex(index)) {
+            return false;
+        }
+
+        bool result = false;
+
+        if (isDirectory(index)) {
+            Filesystem::remove_all(index.data<_FileSystemIndexData>()->m_path)
+                .and_then([&](bool removed) {
+                    if (!removed) {
+                        TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove directory: {}",
+                                        index.data<_FileSystemIndexData>()->m_path.string());
+                        return Result<bool, FSError>();
+                    }
+                    result = true;
+                    return Result<bool, FSError>();
+                })
+                .or_else([&](const FSError &error) {
+                    TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove directory: {}",
+                                    error.m_message[0]);
+                    return Result<bool, FSError>();
+                });
+        } else if (isArchive(index)) {
+            Filesystem::remove(index.data<_FileSystemIndexData>()->m_path)
+                .and_then([&](bool removed) {
+                    if (!removed) {
+                        TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove archive: {}",
+                                        index.data<_FileSystemIndexData>()->m_path.string());
+                        return Result<bool, FSError>();
+                    }
+                    result = true;
+                    return Result<bool, FSError>();
+                })
+                .or_else([&](const FSError &error) {
+                    TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove archive: {}",
+                                    error.m_message[0]);
+                    return Result<bool, FSError>();
+                });
+        } else {
+            TOOLBOX_ERROR("[FileSystemModel] Index is not a directory!");
+        }
+
+        if (result) {
+            ModelIndex parent = getParent(index);
+            if (validateIndex(parent)) {
+                _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
+                parent_data->m_children.erase(std::remove(parent_data->m_children.begin(),
+                                                          parent_data->m_children.end(),
+                                                          index.getUUID()),
+                                              parent_data->m_children.end());
+                m_index_map.erase(index.getUUID());
+            }
+        }
+
+        return result;
+    }
+
+    bool FileSystemModel::remove(const ModelIndex &index) {
+        if (!validateIndex(index)) {
+            return false;
+        }
+
+        bool result = false;
+
+        if (isFile(index)) {
+            Filesystem::remove(index.data<_FileSystemIndexData>()->m_path)
+                .and_then([&](bool removed) {
+                    if (!removed) {
+                        TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove file: {}",
+                                        index.data<_FileSystemIndexData>()->m_path.string());
+                        return Result<bool, FSError>();
+                    }
+                    result = true;
+                    return Result<bool, FSError>();
+                })
+                .or_else([&](const FSError &error) {
+                    TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove file: {}",
+                                    error.m_message[0]);
+                    return Result<bool, FSError>();
+                });
+        } else if (isArchive(index)) {
+            TOOLBOX_ERROR("[FileSystemModel] Index is not a file!");
+        } else {
+            TOOLBOX_ERROR("[FileSystemModel] Index is not a file!");
+        }
+
+        if (result) {
+            ModelIndex parent = getParent(index);
+            if (validateIndex(parent)) {
+                _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
+                parent_data->m_children.erase(std::remove(parent_data->m_children.begin(),
+                                                          parent_data->m_children.end(),
+                                                          index.getUUID()),
+                                              parent_data->m_children.end());
+                m_index_map.erase(index.getUUID());
+            }
+        }
+
+        return result;
+    }
+
+    ModelIndex FileSystemModel::getIndex(const fs_path &path) const {
+        if (m_index_map.empty()) {
+            return ModelIndex();
+        }
+
+        for (const auto &[uuid, index] : m_index_map) {
+            if (index.data<_FileSystemIndexData>()->m_path == path) {
+                return index;
+            }
+        }
+
+        return ModelIndex();
+    }
+
+    ModelIndex FileSystemModel::getIndex(const UUID64 &uuid) const { return m_index_map.at(uuid); }
+
+    ModelIndex FileSystemModel::getIndex(int64_t row, int64_t column,
+                                         const ModelIndex &parent) const {
+        if (!validateIndex(parent)) {
+            if (m_root_index != 0 && row == 0 && column == 0) {
+                return m_index_map.at(m_root_index);
+            }
+            return ModelIndex();
+        }
+
+        _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
+        if (row < 0 || (size_t)row >= parent_data->m_children.size()) {
+            return ModelIndex();
+        }
+
+        return m_index_map.at(parent_data->m_children[row]);
+    }
+
+    fs_path FileSystemModel::getPath(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return fs_path();
+        }
+
+        return index.data<_FileSystemIndexData>()->m_path;
+    }
+
+    ModelIndex FileSystemModel::getParent(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return ModelIndex();
+        }
+
+        const UUID64 &id = index.data<_FileSystemIndexData>()->m_parent;
+        if (id == 0) {
+            return ModelIndex();
+        }
+
+        return m_index_map.at(id);
+    }
+
+    ModelIndex FileSystemModel::getSibling(int64_t row, int64_t column,
+                                           const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return ModelIndex();
+        }
+
+        const ModelIndex &parent = getParent(index);
+        if (!validateIndex(parent)) {
+            return ModelIndex();
+        }
+
+        return getIndex(row, column, parent);
+    }
+
+    size_t FileSystemModel::getColumnCount(const ModelIndex &index) const { return 1; }
+
+    size_t FileSystemModel::getRowCount(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return 0;
+        }
+
+        return index.data<_FileSystemIndexData>()->m_children.size();
+    }
+
+    bool FileSystemModel::hasChildren(const ModelIndex &parent) const {
+        return pollChildren(parent) > 0;
+    }
+
+    ScopePtr<MimeData>
+    FileSystemModel::createMimeData(const std::vector<ModelIndex> &indexes) const {
+        TOOLBOX_ERROR("[FileSystemModel] Mimedata unimplemented!");
+        return ScopePtr<MimeData>();
+    }
+
+    std::vector<std::string> FileSystemModel::getSupportedMimeTypes() const {
+        return std::vector<std::string>();
+    }
+
+    bool FileSystemModel::canFetchMore(const ModelIndex &index) {
+        if (!validateIndex(index)) {
+            return false;
+        }
+
+        if (!isDirectory(index) && !isArchive(index)) {
+            return false;
+        }
+
+        return index.data<_FileSystemIndexData>()->m_children.empty();
+    }
+
+    void FileSystemModel::fetchMore(const ModelIndex &index) {
+        if (!validateIndex(index)) {
+            return;
+        }
+
+        if (isDirectory(index)) {
+            fs_path path = index.data<_FileSystemIndexData>()->m_path;
+
+            size_t i = 0;
+            for (const auto &entry : Filesystem::directory_iterator(path)) {
+                makeIndex(entry.path(), i++, index);
+            }
+        }
+    }
+
+    const ImageHandle &FileSystemModel::InvalidIcon() {
+        static ImageHandle s_invalid_fs_icon = ImageHandle("Images/Icons/fs_invalid.png");
+        return s_invalid_fs_icon;
+    }
+
+    const std::unordered_map<std::string, FileSystemModel::FSTypeInfo> &FileSystemModel::TypeMap() {
+        // clang-format off
+        static std::unordered_map<std::string, FileSystemModel::FSTypeInfo> s_type_map = {
+            {"_Invalid", FSTypeInfo("Invalid",                  ImageHandle("Images/Icons/Filesystem/fs_invalid.png"))},
+            {"_Folder",  FSTypeInfo("Folder",                   ImageHandle("Images/Icons/Filesystem/fs_generic_folder.png")) },
+            {"_Archive", FSTypeInfo("Archive",                  ImageHandle("Images/Icons/Filesystem/fs_arc.png"))},
+            {"_File",    FSTypeInfo("File",                     ImageHandle("Images/Icons/Filesystem/fs_generic_file.png"))   },
+            {".txt",     FSTypeInfo("Text",                     ImageHandle("Images/Icons/Filesystem/fs_txt.png"))    },
+            {".md",      FSTypeInfo("Markdown",                 ImageHandle("Images/Icons/Filesystem/fs_md.png"))     },
+            {".c",       FSTypeInfo("C",                        ImageHandle("Images/Icons/Filesystem/fs_c.png"))      },
+            {".h",       FSTypeInfo("Header",                   ImageHandle("Images/Icons/Filesystem/fs_h.png"))      },
+            {".cpp",     FSTypeInfo("C++",                      ImageHandle("Images/Icons/Filesystem/fs_cpp.png"))    },
+            {".hpp",     FSTypeInfo("Header",                   ImageHandle("Images/Icons/Filesystem/fs_hpp.png"))    },
+            {".cxx",     FSTypeInfo("C++",                      ImageHandle("Images/Icons/Filesystem/fs_cpp.png"))    },
+            {".hxx",     FSTypeInfo("Header",                   ImageHandle("Images/Icons/Filesystem/fs_hpp.png"))    },
+            {".c++",     FSTypeInfo("C++",                      ImageHandle("Images/Icons/Filesystem/fs_cpp.png"))    },
+            {".h++",     FSTypeInfo("Header",                   ImageHandle("Images/Icons/Filesystem/fs_hpp.png"))    },
+            {".cc",      FSTypeInfo("C++",                      ImageHandle("Images/Icons/Filesystem/fs_cpp.png"))    },
+            {".hh",      FSTypeInfo("Header",                   ImageHandle("Images/Icons/Filesystem/fs_hpp.png"))    },
+            {".arc",     FSTypeInfo("Archive",                  ImageHandle("Images/Icons/Filesystem/fs_arc.png"))    },
+            {".bas",     FSTypeInfo("JAudio Sequence",          ImageHandle("Images/Icons/Filesystem/fs_bas.png"))    },
+            {".bck",     FSTypeInfo("J3D Bone Animation",       ImageHandle("Images/Icons/Filesystem/fs_bck.png"))    },
+            {".bdl",     FSTypeInfo("J3D Model Data",           ImageHandle("Images/Icons/Filesystem/fs_bdl.png"))    },
+            {".blo",     FSTypeInfo("J2D Screen Layout",        ImageHandle("Images/Icons/Filesystem/fs_blo.png"))    },
+            {".bmd",     FSTypeInfo("J3D Model Data",           ImageHandle("Images/Icons/Filesystem/fs_bmd.png"))    },
+            {".bmg",     FSTypeInfo("Message Data",             ImageHandle("Images/Icons/Filesystem/fs_bmg.png"))    },
+            {".bmt",     FSTypeInfo("J3D Material Table",       ImageHandle("Images/Icons/Filesystem/fs_bmt.png"))    },
+            {".brk",     FSTypeInfo("J3D Color Register Anim",  ImageHandle("Images/Icons/Filesystem/fs_brk.png"))    },
+            {".bti",     FSTypeInfo("J2D Texture Image",        ImageHandle("Images/Icons/Filesystem/fs_bti.png"))    },
+            {".btk",     FSTypeInfo("J2D Texture Animation",    ImageHandle("Images/Icons/Filesystem/fs_btk.png"))    },
+            {".btp",     FSTypeInfo("J2D Texture Pattern Anim", ImageHandle("Images/Icons/Filesystem/fs_btp.png"))    },
+            {".col",     FSTypeInfo("SMS Collision Data",       ImageHandle("Images/Icons/Filesystem/fs_col.png"))    },
+            {".jpa",     FSTypeInfo("JParticle Data",           ImageHandle("Images/Icons/Filesystem/fs_jpa.png"))    },
+            {".map",     FSTypeInfo("Executable Symbol Map",    ImageHandle("Images/Icons/Filesystem/fs_map.png"))    },
+            {".me",      FSTypeInfo("Marked For Delete",        ImageHandle("Images/Icons/Filesystem/fs_me.png"))     },
+            {".prm",     FSTypeInfo("SMS Parameter Data",       ImageHandle("Images/Icons/Filesystem/fs_prm.png"))    },
+            {".sb",      FSTypeInfo("Sunscript",                ImageHandle("Images/Icons/Filesystem/fs_sb.png"))     },
+            {".szs",     FSTypeInfo("Yaz0 Compressed Data",     ImageHandle("Images/Icons/Filesystem/fs_szs.png"))    },
+            {".thp",     FSTypeInfo("DolphinOS Movie Data",     ImageHandle("Images/Icons/Filesystem/fs_thp.png"))    },
+        };
+        // clang-format on
+        return s_type_map;
+    }
+
+    bool FileSystemModel::validateIndex(const ModelIndex &index) const {
+        return index.isValid() && index.getModelUUID() == getUUID();
+    }
+
+    ModelIndex FileSystemModel::makeIndex(const fs_path &path, int64_t row,
+                                          const ModelIndex &parent) {
+        _FileSystemIndexData *parent_data = nullptr;
+
+        if (!validateIndex(parent)) {
+            if (row != 0) {
+                TOOLBOX_ERROR("[FileSystemModel] Invalid row index!");
+                return ModelIndex();
+            }
+        } else {
+            parent_data = parent.data<_FileSystemIndexData>();
+            if (row < 0 || (size_t)row > parent_data->m_children.size()) {
+                TOOLBOX_ERROR("[FileSystemModel] Invalid row index!");
+                return ModelIndex();
+            }
+        }
+
+        _FileSystemIndexData *data = new _FileSystemIndexData;
+        data->m_path               = path;
+        data->m_size               = 0;
+
+        if (Filesystem::is_directory(path).value_or(false)) {
+            data->m_type = _FileSystemIndexData::Type::DIRECTORY;
+        } else if (Filesystem::is_regular_file(path).value_or(false)) {
+            if (false) {
+                data->m_type = _FileSystemIndexData::Type::ARCHIVE;
+            } else {
+                data->m_type = _FileSystemIndexData::Type::FILE;
+            }
+        } else {
+            TOOLBOX_ERROR_V("[FileSystemModel] Invalid path: {}", path.string());
+            return ModelIndex();
+        }
+
+        Filesystem::last_write_time(data->m_path)
+            .and_then([&](Filesystem::file_time_type &&time) {
+                data->m_date = std::move(time);
+                return Result<Filesystem::file_time_type, FSError>();
+            })
+            .or_else([&](const FSError &error) {
+                TOOLBOX_ERROR_V("[FileSystemModel] Failed to get last write time: {}",
+                                error.m_message[0]);
+                return Result<Filesystem::file_time_type, FSError>();
+            });
+
+        ModelIndex index = ModelIndex(getUUID());
+
+        if (!validateIndex(parent)) {
+            index.setData(data);
+            m_index_map[index.getUUID()] = std::move(index);
+        } else {
+            data->m_parent = parent.getUUID();
+            index.setData(data);
+
+            if (parent_data) {
+                parent_data->m_children.insert(parent_data->m_children.begin() + row,
+                                               index.getUUID());
+            }
+
+            m_index_map[index.getUUID()] = std::move(index);
+        }
+
+        return index;
+    }
+
+    void FileSystemModel::cacheIndex(ModelIndex &index) {}
+    void FileSystemModel::cacheFolder(ModelIndex &index) {}
+    void FileSystemModel::cacheFile(ModelIndex &index) {}
+    void FileSystemModel::cacheArchive(ModelIndex &index) {}
+
+    ModelIndex FileSystemModel::getParentArchive(const ModelIndex &index) const {
+        ModelIndex parent = getParent(index);
+        do {
+            if (isArchive(parent)) {
+                return parent;
+            }
+            parent = getParent(parent);
+        } while (validateIndex(parent));
+
+        return ModelIndex();
+    }
+
+    size_t FileSystemModel::pollChildren(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return 0;
+        }
+
+        size_t count = 0;
+
+        if (isDirectory(index)) {
+            // Count the children in the filesystem
+            for (const auto &entry :
+                 Filesystem::directory_iterator(index.data<_FileSystemIndexData>()->m_path)) {
+                count += 1;
+            }
+        } else if (isArchive(index)) {
+            // Count the children in the archive
+            TOOLBOX_ERROR("[FileSystemModel] Archive polling unimplemented!");
+        } else if (isFile(index)) {
+            // Files have no children
+            count = 0;
+        } else {
+            // Invalid index
+            count = 0;
+        }
+
+        return count;
+    }
+
+    RefPtr<FileSystemModel> FileSystemModelSortFilterProxy::getSourceModel() const {
+        return m_source_model;
+    }
+
+    void FileSystemModelSortFilterProxy::setSourceModel(RefPtr<FileSystemModel> model) {
+        m_source_model = model;
+    }
+
+    ModelSortOrder FileSystemModelSortFilterProxy::getSortOrder() const { return m_sort_order; }
+    void FileSystemModelSortFilterProxy::setSortOrder(ModelSortOrder order) {
+        m_sort_order = order;
+    }
+
+    ModelSortRole FileSystemModelSortFilterProxy::getSortRole() const { return m_sort_role; }
+    void FileSystemModelSortFilterProxy::setSortRole(ModelSortRole role) { m_sort_role = role; }
+
+    const std::string &FileSystemModelSortFilterProxy::getFilter() const & { return m_filter; }
+    void FileSystemModelSortFilterProxy::setFilter(const std::string &filter) { m_filter = filter; }
+
+    bool FileSystemModelSortFilterProxy::isReadOnly() const {
+        if (!m_source_model) {
+            return true;
+        }
+        return m_source_model->isReadOnly();
+    }
+
+    void FileSystemModelSortFilterProxy::setReadOnly(bool read_only) {
+        if (!m_source_model) {
+            return;
+        }
+        m_source_model->setReadOnly(read_only);
+    }
+
+    bool FileSystemModelSortFilterProxy::isDirectory(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return false;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->isDirectory(source_index);
+    }
+
+    bool FileSystemModelSortFilterProxy::isFile(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return false;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->isFile(source_index);
+    }
+
+    bool FileSystemModelSortFilterProxy::isArchive(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return false;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->isArchive(source_index);
+    }
+
+    size_t FileSystemModelSortFilterProxy::getFileSize(const ModelIndex &index) {
+        if (!m_source_model) {
+            return 0;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->getFileSize(source_index);
+    }
+
+    size_t FileSystemModelSortFilterProxy::getDirSize(const ModelIndex &index, bool recursive) {
+        if (!m_source_model) {
+            return 0;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->getDirSize(source_index, recursive);
+    }
+
+    const ImageHandle &FileSystemModelSortFilterProxy::getIcon(const ModelIndex &index) const & {
+        if (!m_source_model) {
+            return FileSystemModel::InvalidIcon();
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->getIcon(source_index);
+    }
+
+    Filesystem::file_time_type
+    FileSystemModelSortFilterProxy::getLastModified(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return Filesystem::file_time_type();
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->getLastModified(source_index);
+    }
+
+    Filesystem::file_status
+    FileSystemModelSortFilterProxy::getStatus(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return Filesystem::file_status();
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->getStatus(source_index);
+    }
+
+    std::string FileSystemModelSortFilterProxy::getType(const ModelIndex &index) const & {
+        if (!m_source_model) {
+            return "Invalid";
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->getType(source_index);
+    }
+
+    ModelIndex FileSystemModelSortFilterProxy::mkdir(const ModelIndex &parent,
+                                                     const std::string &name) {
+        if (!m_source_model) {
+            return ModelIndex();
+        }
+
+        ModelIndex &&source_index = toSourceIndex(parent);
+        return m_source_model->mkdir(source_index, name);
+    }
+
+    ModelIndex FileSystemModelSortFilterProxy::touch(const ModelIndex &parent,
+                                                     const std::string &name) {
+        if (!m_source_model) {
+            return ModelIndex();
+        }
+
+        ModelIndex &&source_index = toSourceIndex(parent);
+        return m_source_model->touch(source_index, name);
+    }
+
+    bool FileSystemModelSortFilterProxy::rmdir(const ModelIndex &index) {
+        if (!m_source_model) {
+            return false;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->rmdir(source_index);
+    }
+
+    bool FileSystemModelSortFilterProxy::remove(const ModelIndex &index) {
+        if (!m_source_model) {
+            return false;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->remove(source_index);
+    }
+
+    ModelIndex FileSystemModelSortFilterProxy::getIndex(const fs_path &path) const {
+        ModelIndex index = m_source_model->getIndex(path);
+        if (!index.isValid()) {
+            return ModelIndex();
+        }
+
+        return toProxyIndex(index);
+    }
+
+    ModelIndex FileSystemModelSortFilterProxy::getIndex(const UUID64 &uuid) const {
+        ModelIndex index = m_source_model->getIndex(uuid);
+        if (!index.isValid()) {
+            return ModelIndex();
+        }
+
+        return toProxyIndex(index);
+    }
+
+    ModelIndex FileSystemModelSortFilterProxy::getIndex(int64_t row, int64_t column,
+                                                        const ModelIndex &parent) const {
+        ModelIndex parent_src = toSourceIndex(parent);
+
+        ModelIndex index = m_source_model->getIndex(row, column, parent_src);
+        if (!index.isValid()) {
+            return ModelIndex();
+        }
+
+        return toProxyIndex(index);
+    }
+
+    fs_path FileSystemModelSortFilterProxy::getPath(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return fs_path();
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        if (!source_index.isValid()) {
+            return fs_path();
+        }
+
+        return m_source_model->getPath(source_index);
+    }
+
+    ModelIndex FileSystemModelSortFilterProxy::getParent(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return ModelIndex();
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        if (!source_index.isValid()) {
+            return ModelIndex();
+        }
+
+        return toProxyIndex(m_source_model->getParent(source_index));
+    }
+
+    ModelIndex FileSystemModelSortFilterProxy::getSibling(int64_t row, int64_t column,
+                                                          const ModelIndex &index) const {
+        if (!m_source_model) {
+            return ModelIndex();
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        if (!source_index.isValid()) {
+            return ModelIndex();
+        }
+
+        return toProxyIndex(m_source_model->getSibling(row, column, source_index));
+    }
+
+    size_t FileSystemModelSortFilterProxy::getColumnCount(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return 0;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        if (!source_index.isValid()) {
+            return 0;
+        }
+
+        return m_source_model->getColumnCount(source_index);
+    }
+
+    size_t FileSystemModelSortFilterProxy::getRowCount(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return 0;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        if (!source_index.isValid()) {
+            return 0;
+        }
+
+        return m_source_model->getRowCount(source_index);
+    }
+
+    bool FileSystemModelSortFilterProxy::hasChildren(const ModelIndex &parent) const {
+        if (!m_source_model) {
+            return false;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(parent);
+        if (!source_index.isValid()) {
+            return false;
+        }
+
+        return m_source_model->hasChildren(source_index);
+    }
+
+    ScopePtr<MimeData>
+    FileSystemModelSortFilterProxy::createMimeData(const std::vector<ModelIndex> &indexes) const {
+        if (!m_source_model) {
+            return ScopePtr<MimeData>();
+        }
+
+        std::vector<ModelIndex> indexes_copy = indexes;
+        std::transform(indexes.begin(), indexes.end(), indexes_copy.begin(),
+                       [&](const ModelIndex &index) { return toSourceIndex(index); });
+
+        return m_source_model->createMimeData(indexes);
+    }
+
+    std::vector<std::string> FileSystemModelSortFilterProxy::getSupportedMimeTypes() const {
+        if (!m_source_model) {
+            return std::vector<std::string>();
+        }
+        return m_source_model->getSupportedMimeTypes();
+    }
+
+    bool FileSystemModelSortFilterProxy::canFetchMore(const ModelIndex &index) {
+        if (!m_source_model) {
+            return false;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        if (!source_index.isValid()) {
+            return false;
+        }
+
+        return m_source_model->canFetchMore(source_index);
+    }
+
+    void FileSystemModelSortFilterProxy::fetchMore(const ModelIndex &index) {
+        if (!m_source_model) {
+            return;
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        if (!source_index.isValid()) {
+            return;
+        }
+
+        m_source_model->fetchMore(source_index);
+    }
+
+    bool FileSystemModelSortFilterProxy::validateIndex(const ModelIndex &index) const {
+        return index.isValid() && index.getModelUUID() == getUUID();
+    }
+
+    ModelIndex FileSystemModelSortFilterProxy::toSourceIndex(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return ModelIndex();
+        }
+
+        if (m_source_model->validateIndex(index)) {
+            return index;
+        }
+
+        if (!validateIndex(index)) {
+            return ModelIndex();
+        }
+
+        return m_source_model->getIndex(index.data<_FileSystemIndexData>()->m_path);
+    }
+
+    ModelIndex FileSystemModelSortFilterProxy::toProxyIndex(const ModelIndex &index) const {
+        if (!m_source_model) {
+            return ModelIndex();
+        }
+
+        if (validateIndex(index)) {
+            return index;
+        }
+
+        if (!m_source_model->validateIndex(index)) {
+            return ModelIndex();
+        }
+
+        const ModelIndex &parent = m_source_model->getParent(index);
+        if (!m_source_model->validateIndex(parent)) {
+            ModelIndex proxy_index = ModelIndex(getUUID());
+            proxy_index.setData(index.data<_FileSystemIndexData>());
+            return proxy_index;
+        }
+
+        std::vector<UUID64> children = parent.data<_FileSystemIndexData>()->m_children;
+        std::copy_if(children.begin(), children.end(), children.begin(), [&](const UUID64 &uuid) {
+            ModelIndex child_index = m_source_model->getIndex(uuid);
+            if (!child_index.isValid()) {
+                return false;
+            }
+
+            if (m_dirs_only && m_source_model->isFile(child_index)) {
+                return false;
+            }
+
+            fs_path path = child_index.data<_FileSystemIndexData>()->m_path;
+            return path.filename().string().starts_with(m_filter);
+        });
+
+        switch (m_sort_role) {
+        case ModelSortRole::SORT_ROLE_NAME: {
+            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
+                return _FileSystemIndexDataCompareByName(
+                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
+            });
+            break;
+        }
+        case ModelSortRole::SORT_ROLE_SIZE: {
+            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
+                return _FileSystemIndexDataCompareBySize(
+                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
+            });
+            break;
+        }
+        case ModelSortRole::SORT_ROLE_DATE:
+            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
+                return _FileSystemIndexDataCompareByDate(
+                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
+            });
+            break;
+        default:
+            break;
+        }
+
+        for (size_t i = 0; i < children.size(); i++) {
+            if (children[i] == index.getUUID()) {
+                ModelIndex proxy_index = ModelIndex(getUUID());
+                proxy_index.setData(index.data<_FileSystemIndexData>());
+                return proxy_index;
+            }
+        }
+
+        // Should never reach here
+        return ModelIndex();
+    }
+
+}  // namespace Toolbox
\ No newline at end of file

From 714f99f2a56b67889e9cda4ccbd091372b65af69 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Tue, 10 Sep 2024 08:02:19 -0500
Subject: [PATCH 008/129] Push more progress

---
 include/model/fsmodel.hpp  | 122 +++++++-----------
 include/model/model.hpp    | 118 ++++++++++++++++++
 src/gui/project/asset.cpp  |   4 +-
 src/gui/project/window.cpp |  11 +-
 src/model/fsmodel.cpp      | 248 ++++++++++++++++++++-----------------
 5 files changed, 309 insertions(+), 194 deletions(-)
 create mode 100644 include/model/model.hpp

diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index ae3dbefc..99b4d069 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -13,60 +13,18 @@
 #include "core/types.hpp"
 #include "fsystem.hpp"
 #include "image/imagehandle.hpp"
+#include "model/model.hpp"
 #include "unique.hpp"
 
 namespace Toolbox {
 
-    enum class ModelSortOrder {
-        SORT_ASCENDING,
-        SORT_DESCENDING,
-    };
-
-    enum class ModelSortRole {
+    enum class FileSystemModelSortRole {
         SORT_ROLE_NONE,
         SORT_ROLE_NAME,
         SORT_ROLE_SIZE,
         SORT_ROLE_DATE,
     };
 
-    class ModelIndex : public IUnique {
-    public:
-        ModelIndex() = default;
-        ModelIndex(UUID64 model_uuid) : m_model_uuid(model_uuid) {}
-        ModelIndex(const ModelIndex &other)
-            : m_uuid(other.m_uuid), m_model_uuid(other.m_model_uuid),
-              m_user_data(other.m_user_data) {}
-
-        bool isValid() const { return m_model_uuid != 0; }
-
-        template <typename T = void> [[nodiscard]] T *data() const {
-            return reinterpret_cast<T *>(m_user_data);
-        }
-        void setData(void *data) { m_user_data = data; }
-
-        [[nodiscard]] UUID64 getUUID() const override { return m_uuid; }
-        [[nodiscard]] UUID64 getModelUUID() const { return m_model_uuid; }
-
-        operator bool() const { return isValid(); }
-
-        ModelIndex &operator=(const ModelIndex &other) {
-            m_uuid       = other.m_uuid;
-            m_model_uuid = other.m_model_uuid;
-            m_user_data  = other.m_user_data;
-            return *this;
-        }
-
-        [[nodiscard]] bool operator==(const ModelIndex &other) const {
-            return m_uuid == other.m_uuid && m_model_uuid == other.m_model_uuid;
-        }
-
-    private:
-        UUID64 m_uuid;
-        UUID64 m_model_uuid = 0;
-
-        void *m_user_data = nullptr;
-    };
-
     enum class FileSystemModelOptions {
         NONE             = 0,
         DISABLE_WATCHDOG = BIT(0),
@@ -74,7 +32,13 @@ namespace Toolbox {
     };
     TOOLBOX_BITWISE_ENUM(FileSystemModelOptions)
 
-    class FileSystemModel : public IUnique {
+    enum FileSystemDataRole {
+        FS_DATA_ROLE_DATE = ModelDataRole::DATA_ROLE_USER,
+        FS_DATA_ROLE_STATUS,
+        FS_DATA_ROLE_TYPE,
+    };
+
+    class FileSystemModel : public IDataModel {
     public:
         struct FSTypeInfo {
             std::string m_name;
@@ -87,8 +51,6 @@ namespace Toolbox {
 
         [[nodiscard]] UUID64 getUUID() const override { return m_uuid; }
 
-        [[nodiscard]] bool validateIndex(const ModelIndex &index) const;
-
         [[nodiscard]] const fs_path &getRoot() const &;
         void setRoot(const fs_path &path);
 
@@ -102,14 +64,24 @@ namespace Toolbox {
         [[nodiscard]] bool isFile(const ModelIndex &index) const;
         [[nodiscard]] bool isArchive(const ModelIndex &index) const;
 
-        [[nodiscard]] size_t getFileSize(const ModelIndex &index);
-        [[nodiscard]] size_t getDirSize(const ModelIndex &index, bool recursive);
+        [[nodiscard]] size_t getFileSize(const ModelIndex &index) const;
+        [[nodiscard]] size_t getDirSize(const ModelIndex &index, bool recursive) const;
 
-        [[nodiscard]] const ImageHandle &getIcon(const ModelIndex &index) const &;
-        [[nodiscard]] Filesystem::file_time_type getLastModified(const ModelIndex &index) const;
-        [[nodiscard]] Filesystem::file_status getStatus(const ModelIndex &index) const;
+        [[nodiscard]] Filesystem::file_time_type getLastModified(const ModelIndex &index) const {
+            return std::any_cast<Filesystem::file_time_type>(
+                getData(index, FileSystemDataRole::FS_DATA_ROLE_DATE));
+        }
+        [[nodiscard]] Filesystem::file_status getStatus(const ModelIndex &index) const {
+            return std::any_cast<Filesystem::file_status>(
+                getData(index, FileSystemDataRole::FS_DATA_ROLE_STATUS));
+        }
 
-        [[nodiscard]] std::string getType(const ModelIndex &index) const &;
+        [[nodiscard]] std::string getType(const ModelIndex &index) const {
+            return std::any_cast<std::string>(
+                getData(index, FileSystemDataRole::FS_DATA_ROLE_TYPE));
+        }
+
+        [[nodiscard]] std::any getData(const ModelIndex &index, int role) const override;
 
         ModelIndex mkdir(const ModelIndex &parent, const std::string &name);
         ModelIndex touch(const ModelIndex &parent, const std::string &name);
@@ -119,32 +91,32 @@ namespace Toolbox {
 
     public:
         [[nodiscard]] ModelIndex getIndex(const fs_path &path) const;
-        [[nodiscard]] ModelIndex getIndex(const UUID64 &path) const;
+        [[nodiscard]] ModelIndex getIndex(const UUID64 &path) const override;
         [[nodiscard]] ModelIndex getIndex(int64_t row, int64_t column,
-                                          const ModelIndex &parent = ModelIndex()) const;
+                                          const ModelIndex &parent = ModelIndex()) const override;
         [[nodiscard]] fs_path getPath(const ModelIndex &index) const;
 
-        [[nodiscard]] ModelIndex getParent(const ModelIndex &index) const;
+        [[nodiscard]] ModelIndex getParent(const ModelIndex &index) const override;
         [[nodiscard]] ModelIndex getSibling(int64_t row, int64_t column,
-                                            const ModelIndex &index) const;
+                                            const ModelIndex &index) const override;
 
-        [[nodiscard]] size_t getColumnCount(const ModelIndex &index) const;
-        [[nodiscard]] size_t getRowCount(const ModelIndex &index) const;
+        [[nodiscard]] size_t getColumnCount(const ModelIndex &index) const override;
+        [[nodiscard]] size_t getRowCount(const ModelIndex &index) const override;
 
-        [[nodiscard]] bool hasChildren(const ModelIndex &parent = ModelIndex()) const;
+        [[nodiscard]] bool hasChildren(const ModelIndex &parent = ModelIndex()) const override;
 
         [[nodiscard]] ScopePtr<MimeData>
-        createMimeData(const std::vector<ModelIndex> &indexes) const;
-        [[nodiscard]] std::vector<std::string> getSupportedMimeTypes() const;
+        createMimeData(const std::vector<ModelIndex> &indexes) const override;
+        [[nodiscard]] std::vector<std::string> getSupportedMimeTypes() const override;
 
-        [[nodiscard]] bool canFetchMore(const ModelIndex &index);
-        void fetchMore(const ModelIndex &index);
+        [[nodiscard]] bool canFetchMore(const ModelIndex &index) override;
+        void fetchMore(const ModelIndex &index) override;
 
         static const ImageHandle &InvalidIcon();
         static const std::unordered_map<std::string, FSTypeInfo> &TypeMap();
 
     protected:
-        ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent);
+        ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent) override;
 
         void cacheIndex(ModelIndex &index);
         void cacheFolder(ModelIndex &index);
@@ -168,17 +140,15 @@ namespace Toolbox {
         mutable std::unordered_map<UUID64, ModelIndex> m_index_map;
     };
 
-    class FileSystemModelSortFilterProxy : public IUnique {
+    class FileSystemModelSortFilterProxy : public IDataModel {
     public:
         FileSystemModelSortFilterProxy()  = default;
         ~FileSystemModelSortFilterProxy() = default;
 
         [[nodiscard]] UUID64 getUUID() const override { return m_uuid; }
 
-        [[nodiscard]] bool validateIndex(const ModelIndex &index) const;
-
         [[nodiscard]] bool isDirsOnly() const { return m_dirs_only; }
-        void setDirsOnly(bool dirs_only) { m_dirs_only = true; }
+        void setDirsOnly(bool dirs_only) { m_dirs_only = dirs_only; }
 
         [[nodiscard]] RefPtr<FileSystemModel> getSourceModel() const;
         void setSourceModel(RefPtr<FileSystemModel> model);
@@ -186,8 +156,8 @@ namespace Toolbox {
         [[nodiscard]] ModelSortOrder getSortOrder() const;
         void setSortOrder(ModelSortOrder order);
 
-        [[nodiscard]] ModelSortRole getSortRole() const;
-        void setSortRole(ModelSortRole role);
+        [[nodiscard]] FileSystemModelSortRole getSortRole() const;
+        void setSortRole(FileSystemModelSortRole role);
 
         [[nodiscard]] const std::string &getFilter() const &;
         void setFilter(const std::string &filter);
@@ -202,11 +172,11 @@ namespace Toolbox {
         [[nodiscard]] size_t getFileSize(const ModelIndex &index);
         [[nodiscard]] size_t getDirSize(const ModelIndex &index, bool recursive);
 
-        [[nodiscard]] const ImageHandle &getIcon(const ModelIndex &index) const &;
         [[nodiscard]] Filesystem::file_time_type getLastModified(const ModelIndex &index) const;
         [[nodiscard]] Filesystem::file_status getStatus(const ModelIndex &index) const;
 
-        [[nodiscard]] std::string getType(const ModelIndex &index) const &;
+        [[nodiscard]] std::string getType(const ModelIndex &index) const;
+        [[nodiscard]] std::any getData(const ModelIndex &index, int role) const override;
 
         ModelIndex mkdir(const ModelIndex &parent, const std::string &name);
         ModelIndex touch(const ModelIndex &parent, const std::string &name);
@@ -240,12 +210,16 @@ namespace Toolbox {
         [[nodiscard]] ModelIndex toSourceIndex(const ModelIndex &index) const;
         [[nodiscard]] ModelIndex toProxyIndex(const ModelIndex &index) const;
 
+        ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent) {
+            return ModelIndex();
+        }
+
     private:
         UUID64 m_uuid;
 
         RefPtr<FileSystemModel> m_source_model = nullptr;
         ModelSortOrder m_sort_order            = ModelSortOrder::SORT_ASCENDING;
-        ModelSortRole m_sort_role              = ModelSortRole::SORT_ROLE_NONE;
+        FileSystemModelSortRole m_sort_role    = FileSystemModelSortRole::SORT_ROLE_NONE;
         std::string m_filter                   = "";
 
         bool m_dirs_only = false;
diff --git a/include/model/model.hpp b/include/model/model.hpp
new file mode 100644
index 00000000..c5d71059
--- /dev/null
+++ b/include/model/model.hpp
@@ -0,0 +1,118 @@
+#pragma once
+
+#include <algorithm>
+#include <any>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "core/mimedata/mimedata.hpp"
+#include "core/types.hpp"
+#include "fsystem.hpp"
+#include "image/imagehandle.hpp"
+#include "unique.hpp"
+
+namespace Toolbox {
+
+    enum ModelSortOrder {
+        SORT_ASCENDING,
+        SORT_DESCENDING,
+    };
+
+    enum ModelDataRole {
+        DATA_ROLE_NONE,
+        DATA_ROLE_DISPLAY,
+        DATA_ROLE_TOOLTIP,
+        DATA_ROLE_DECORATION,
+        DATA_ROLE_USER,
+    };
+
+    class ModelIndex final : public IUnique {
+    public:
+        ModelIndex() = default;
+        ModelIndex(UUID64 model_uuid) : m_model_uuid(model_uuid) {}
+        ModelIndex(const ModelIndex &other)
+            : m_uuid(other.m_uuid), m_model_uuid(other.m_model_uuid),
+              m_user_data(other.m_user_data) {}
+
+        bool isValid() const { return m_model_uuid != 0; }
+
+        template <typename T = void> [[nodiscard]] T *data() const {
+            return reinterpret_cast<T *>(m_user_data);
+        }
+        void setData(void *data) { m_user_data = data; }
+
+        [[nodiscard]] UUID64 getUUID() const override { return m_uuid; }
+        [[nodiscard]] UUID64 getModelUUID() const { return m_model_uuid; }
+
+        operator bool() const { return isValid(); }
+
+        ModelIndex &operator=(const ModelIndex &other) {
+            m_uuid       = other.m_uuid;
+            m_model_uuid = other.m_model_uuid;
+            m_user_data  = other.m_user_data;
+            return *this;
+        }
+
+        [[nodiscard]] bool operator==(const ModelIndex &other) const {
+            return m_uuid == other.m_uuid && m_model_uuid == other.m_model_uuid;
+        }
+
+    private:
+        UUID64 m_uuid;
+        UUID64 m_model_uuid = 0;
+
+        void *m_user_data = nullptr;
+    };
+
+    class IDataModel : public IUnique {
+    public:
+        [[nodiscard]] virtual bool validateIndex(const ModelIndex &index) const {
+            return index.isValid() && index.getModelUUID() == getUUID();
+        }
+
+        [[nodiscard]] virtual std::string getDisplayText(const ModelIndex &index) const {
+            return std::any_cast<std::string>(getData(index, ModelDataRole::DATA_ROLE_DISPLAY));
+        }
+
+        [[nodiscard]] virtual std::string getToolTip(const ModelIndex &index) const {
+            return std::any_cast<std::string>(getData(index, ModelDataRole::DATA_ROLE_TOOLTIP));
+        }
+
+        [[nodiscard]] virtual ImageHandle getDecoration(const ModelIndex &index) const {
+            return std::any_cast<ImageHandle>(getData(index, ModelDataRole::DATA_ROLE_DECORATION));
+        }
+
+        [[nodiscard]] virtual std::any getData(const ModelIndex &index, int role) const = 0;
+
+        [[nodiscard]] virtual ModelIndex getIndex(const UUID64 &path) const = 0;
+        [[nodiscard]] virtual ModelIndex
+        getIndex(int64_t row, int64_t column, const ModelIndex &parent = ModelIndex()) const = 0;
+
+        [[nodiscard]] virtual ModelIndex getParent(const ModelIndex &index) const  = 0;
+        [[nodiscard]] virtual ModelIndex getSibling(int64_t row, int64_t column,
+                                                    const ModelIndex &index) const = 0;
+
+        [[nodiscard]] virtual size_t getColumnCount(const ModelIndex &index) const = 0;
+        [[nodiscard]] virtual size_t getRowCount(const ModelIndex &index) const    = 0;
+
+        [[nodiscard]] virtual bool hasChildren(const ModelIndex &parent = ModelIndex()) const = 0;
+
+        [[nodiscard]] virtual ScopePtr<MimeData>
+        createMimeData(const std::vector<ModelIndex> &indexes) const                 = 0;
+        [[nodiscard]] virtual std::vector<std::string> getSupportedMimeTypes() const = 0;
+
+        [[nodiscard]] virtual bool canFetchMore(const ModelIndex &index) = 0;
+        virtual void fetchMore(const ModelIndex &index)                  = 0;
+
+    protected:
+        virtual ModelIndex makeIndex(const fs_path &path, int64_t row,
+                                     const ModelIndex &parent) = 0;
+    };
+
+}  // namespace Toolbox
\ No newline at end of file
diff --git a/src/gui/project/asset.cpp b/src/gui/project/asset.cpp
index b991fa93..403ef6ee 100644
--- a/src/gui/project/asset.cpp
+++ b/src/gui/project/asset.cpp
@@ -11,8 +11,8 @@ namespace Toolbox::UI {
         ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {3, 3});
 
         if (m_model) {
-            m_painter.render(m_model->getIcon(m_index));
-            ImGui::Text("%s", m_model->getPath(m_index).c_str());
+            m_painter.render(m_model->getDecoration(m_index));
+            ImGui::Text("%s", m_model->getDisplayText(m_index).c_str());
         }
 
         ImGui::PopStyleVar();
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 12df64b7..cc1a3d0f 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -33,7 +33,7 @@ namespace Toolbox::UI {
             return;
         }
 
-        if (ImGui::BeginChild("Folder View", { 400, 0 }, true,
+        if (ImGui::BeginChild("Folder View", {400, 0}, true,
                               ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
             if (m_view_proxy.hasChildren(m_view_index)) {
                 if (m_view_proxy.canFetchMore(m_view_index)) {
@@ -45,13 +45,12 @@ namespace Toolbox::UI {
                     if (ImGui::BeginChild(child_index.getUUID(), {160, 180}, true,
                                           ImGuiWindowFlags_ChildWindow |
                                               ImGuiWindowFlags_NoDecoration)) {
-                        const ImageHandle &icon = m_view_proxy.getIcon(child_index);
+                        const ImageHandle &icon = m_view_proxy.getDecoration(child_index);
                         m_icon_painter.render(icon, {140, 140});
 
                         ImGui::RenderTextEllipsis(
                             ImGui::GetWindowDrawList(), {10, 150}, {130, 170}, 120.0f, 150.0f,
-                            m_view_proxy.getPath(child_index).filename().string().c_str(), nullptr,
-                            nullptr);
+                            m_view_proxy.getDisplayText(child_index).c_str(), nullptr, nullptr);
                     }
                     ImGui::EndChild();
                 }
@@ -87,7 +86,9 @@ namespace Toolbox::UI {
             if (is_open) {
                 for (size_t i = 0; i < m_tree_proxy.getRowCount(index); ++i) {
                     ModelIndex child_index = m_tree_proxy.getIndex(i, 0, index);
-                    renderFolderTree(child_index);
+                    if (m_tree_proxy.validateIndex(child_index)) {
+                        renderFolderTree(child_index);
+                    }
                 }
                 ImGui::TreePop();
             }
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index fe1ba839..6d811dea 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -147,110 +147,124 @@ namespace Toolbox {
         return index.data<_FileSystemIndexData>()->m_type == _FileSystemIndexData::Type::ARCHIVE;
     }
 
-    size_t FileSystemModel::getFileSize(const ModelIndex &index) {
+    size_t FileSystemModel::getFileSize(const ModelIndex &index) const {
         if (!isFile(index)) {
             return 0;
         }
         return index.data<_FileSystemIndexData>()->m_size;
     }
 
-    size_t FileSystemModel::getDirSize(const ModelIndex &index, bool recursive) {
+    size_t FileSystemModel::getDirSize(const ModelIndex &index, bool recursive) const {
         if (!(isDirectory(index) || isArchive(index))) {
             return 0;
         }
         return index.data<_FileSystemIndexData>()->m_size;
     }
 
-    const ImageHandle &FileSystemModel::getIcon(const ModelIndex &index) const & {
+    std::any FileSystemModel::getData(const ModelIndex &index, int role) const {
         if (!validateIndex(index)) {
-            return TypeMap().at("_Invalid").m_icon;
+            return {};
         }
 
-        if (isDirectory(index)) {
-            return TypeMap().at("_Folder").m_icon;
-        }
+        switch (role) {
+        case ModelDataRole::DATA_ROLE_DISPLAY:
+            if (!validateIndex(index)) {
+                return "Invalid";
+            }
+            return index.data<_FileSystemIndexData>()->m_path.filename().string();
+        case ModelDataRole::DATA_ROLE_TOOLTIP:
+            return "Tooltip unimplemented!";
+        case ModelDataRole::DATA_ROLE_DECORATION: {
+            if (!validateIndex(index)) {
+                return TypeMap().at("_Invalid").m_icon;
+            }
 
-        if (isArchive(index)) {
-            return TypeMap().at("_Archive").m_icon;
-        }
+            if (isDirectory(index)) {
+                return TypeMap().at("_Folder").m_icon;
+            }
 
-        std::string ext = index.data<_FileSystemIndexData>()->m_path.extension().string();
-        if (ext.empty()) {
-            return TypeMap().at("_Folder").m_icon;
-        }
+            if (isArchive(index)) {
+                return TypeMap().at("_Archive").m_icon;
+            }
 
-        if (TypeMap().find(ext) == TypeMap().end()) {
-            return TypeMap().at("_File").m_icon;
-        }
+            std::string ext = index.data<_FileSystemIndexData>()->m_path.extension().string();
+            if (ext.empty()) {
+                return TypeMap().at("_Folder").m_icon;
+            }
 
-        return TypeMap().at(ext).m_icon;
-    }
+            if (TypeMap().find(ext) == TypeMap().end()) {
+                return TypeMap().at("_File").m_icon;
+            }
 
-    Filesystem::file_time_type FileSystemModel::getLastModified(const ModelIndex &index) const {
-        if (!validateIndex(index)) {
-            return Filesystem::file_time_type();
+            return TypeMap().at(ext).m_icon;
         }
+        case FileSystemDataRole::FS_DATA_ROLE_DATE: {
+            if (!validateIndex(index)) {
+                return Filesystem::file_time_type();
+            }
 
-        Filesystem::file_time_type result = Filesystem::file_time_type();
+            Filesystem::file_time_type result = Filesystem::file_time_type();
 
-        Filesystem::last_write_time(index.data<_FileSystemIndexData>()->m_path)
-            .and_then([&](Filesystem::file_time_type &&time) {
-                result = std::move(time);
-                return Result<Filesystem::file_time_type, FSError>();
-            })
-            .or_else([&](const FSError &error) {
-                TOOLBOX_ERROR_V("[FileSystemModel] Failed to get last write time: {}",
-                                error.m_message[0]);
-                return Result<Filesystem::file_time_type, FSError>();
-            });
-
-        return result;
-    }
+            Filesystem::last_write_time(index.data<_FileSystemIndexData>()->m_path)
+                .and_then([&](Filesystem::file_time_type &&time) {
+                    result = std::move(time);
+                    return Result<Filesystem::file_time_type, FSError>();
+                })
+                .or_else([&](const FSError &error) {
+                    TOOLBOX_ERROR_V("[FileSystemModel] Failed to get last write time: {}",
+                                    error.m_message[0]);
+                    return Result<Filesystem::file_time_type, FSError>();
+                });
 
-    Filesystem::file_status FileSystemModel::getStatus(const ModelIndex &index) const {
-        if (!validateIndex(index)) {
-            return Filesystem::file_status();
+            return result;
         }
+        case FileSystemDataRole::FS_DATA_ROLE_STATUS: {
+            if (!validateIndex(index)) {
+                return Filesystem::file_status();
+            }
 
-        Filesystem::file_status result = Filesystem::file_status();
-
-        Filesystem::status(index.data<_FileSystemIndexData>()->m_path)
-            .and_then([&](Filesystem::file_status &&status) {
-                result = std::move(status);
-                return Result<Filesystem::file_status, FSError>();
-            })
-            .or_else([&](const FSError &error) {
-                TOOLBOX_ERROR_V("[FileSystemModel] Failed to get last write status: {}",
-                                error.m_message[0]);
-                return Result<Filesystem::file_status, FSError>();
-            });
+            Filesystem::file_status result = Filesystem::file_status();
 
-        return result;
-    }
+            Filesystem::status(index.data<_FileSystemIndexData>()->m_path)
+                .and_then([&](Filesystem::file_status &&status) {
+                    result = std::move(status);
+                    return Result<Filesystem::file_status, FSError>();
+                })
+                .or_else([&](const FSError &error) {
+                    TOOLBOX_ERROR_V("[FileSystemModel] Failed to get last write status: {}",
+                                    error.m_message[0]);
+                    return Result<Filesystem::file_status, FSError>();
+                });
 
-    std::string FileSystemModel::getType(const ModelIndex &index) const & {
-        if (!validateIndex(index)) {
-            return TypeMap().at("_Invalid").m_name;
+            return result;
         }
+        case FileSystemDataRole::FS_DATA_ROLE_TYPE: {
+            if (!validateIndex(index)) {
+                return TypeMap().at("_Invalid").m_name;
+            }
 
-        if (isDirectory(index)) {
-            return TypeMap().at("_Folder").m_name;
-        }
+            if (isDirectory(index)) {
+                return TypeMap().at("_Folder").m_name;
+            }
 
-        if (isArchive(index)) {
-            return TypeMap().at("_Archive").m_name;
-        }
+            if (isArchive(index)) {
+                return TypeMap().at("_Archive").m_name;
+            }
 
-        std::string ext = index.data<_FileSystemIndexData>()->m_path.extension().string();
-        if (ext.empty()) {
-            return TypeMap().at("_Folder").m_name;
-        }
+            std::string ext = index.data<_FileSystemIndexData>()->m_path.extension().string();
+            if (ext.empty()) {
+                return TypeMap().at("_Folder").m_name;
+            }
 
-        if (TypeMap().find(ext) == TypeMap().end()) {
-            return TypeMap().at("_File").m_name;
-        }
+            if (TypeMap().find(ext) == TypeMap().end()) {
+                return TypeMap().at("_File").m_name;
+            }
 
-        return TypeMap().at(ext).m_name;
+            return TypeMap().at(ext).m_name;
+        }
+        default:
+            return std::any();
+        }
     }
 
     ModelIndex FileSystemModel::mkdir(const ModelIndex &parent, const std::string &name) {
@@ -591,10 +605,6 @@ namespace Toolbox {
         return s_type_map;
     }
 
-    bool FileSystemModel::validateIndex(const ModelIndex &index) const {
-        return index.isValid() && index.getModelUUID() == getUUID();
-    }
-
     ModelIndex FileSystemModel::makeIndex(const fs_path &path, int64_t row,
                                           const ModelIndex &parent) {
         _FileSystemIndexData *parent_data = nullptr;
@@ -717,8 +727,12 @@ namespace Toolbox {
         m_sort_order = order;
     }
 
-    ModelSortRole FileSystemModelSortFilterProxy::getSortRole() const { return m_sort_role; }
-    void FileSystemModelSortFilterProxy::setSortRole(ModelSortRole role) { m_sort_role = role; }
+    FileSystemModelSortRole FileSystemModelSortFilterProxy::getSortRole() const {
+        return m_sort_role;
+    }
+    void FileSystemModelSortFilterProxy::setSortRole(FileSystemModelSortRole role) {
+        m_sort_role = role;
+    }
 
     const std::string &FileSystemModelSortFilterProxy::getFilter() const & { return m_filter; }
     void FileSystemModelSortFilterProxy::setFilter(const std::string &filter) { m_filter = filter; }
@@ -782,15 +796,6 @@ namespace Toolbox {
         return m_source_model->getDirSize(source_index, recursive);
     }
 
-    const ImageHandle &FileSystemModelSortFilterProxy::getIcon(const ModelIndex &index) const & {
-        if (!m_source_model) {
-            return FileSystemModel::InvalidIcon();
-        }
-
-        ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->getIcon(source_index);
-    }
-
     Filesystem::file_time_type
     FileSystemModelSortFilterProxy::getLastModified(const ModelIndex &index) const {
         if (!m_source_model) {
@@ -811,7 +816,7 @@ namespace Toolbox {
         return m_source_model->getStatus(source_index);
     }
 
-    std::string FileSystemModelSortFilterProxy::getType(const ModelIndex &index) const & {
+    std::string FileSystemModelSortFilterProxy::getType(const ModelIndex &index) const {
         if (!m_source_model) {
             return "Invalid";
         }
@@ -820,6 +825,15 @@ namespace Toolbox {
         return m_source_model->getType(source_index);
     }
 
+    std::any FileSystemModelSortFilterProxy::getData(const ModelIndex &index, int role) const {
+        if (!m_source_model) {
+            return std::any();
+        }
+
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->getData(source_index, role);
+    }
+
     ModelIndex FileSystemModelSortFilterProxy::mkdir(const ModelIndex &parent,
                                                      const std::string &name) {
         if (!m_source_model) {
@@ -1013,10 +1027,6 @@ namespace Toolbox {
         m_source_model->fetchMore(source_index);
     }
 
-    bool FileSystemModelSortFilterProxy::validateIndex(const ModelIndex &index) const {
-        return index.isValid() && index.getModelUUID() == getUUID();
-    }
-
     ModelIndex FileSystemModelSortFilterProxy::toSourceIndex(const ModelIndex &index) const {
         if (!m_source_model) {
             return ModelIndex();
@@ -1053,14 +1063,20 @@ namespace Toolbox {
             return proxy_index;
         }
 
-        std::vector<UUID64> children = parent.data<_FileSystemIndexData>()->m_children;
-        std::copy_if(children.begin(), children.end(), children.begin(), [&](const UUID64 &uuid) {
+        const std::vector<UUID64> &children = parent.data<_FileSystemIndexData>()->m_children;
+        if (children.empty()) {
+            return ModelIndex();
+        }
+
+        std::vector<UUID64> filtered_children(children.size());
+        std::copy_if(children.begin(), children.end(), filtered_children.begin(),
+                     [&](const UUID64 &uuid) {
             ModelIndex child_index = m_source_model->getIndex(uuid);
             if (!child_index.isValid()) {
                 return false;
             }
 
-            if (m_dirs_only && m_source_model->isFile(child_index)) {
+            if (isDirsOnly() && m_source_model->isFile(child_index)) {
                 return false;
             }
 
@@ -1069,35 +1085,41 @@ namespace Toolbox {
         });
 
         switch (m_sort_role) {
-        case ModelSortRole::SORT_ROLE_NAME: {
-            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
-                return _FileSystemIndexDataCompareByName(
-                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
-                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
-            });
+        case FileSystemModelSortRole::SORT_ROLE_NAME: {
+            std::sort(filtered_children.begin(), filtered_children.end(),
+                      [&](const UUID64 &lhs, const UUID64 &rhs) {
+                          return _FileSystemIndexDataCompareByName(
+                              *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                              *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(),
+                              m_sort_order);
+                      });
             break;
         }
-        case ModelSortRole::SORT_ROLE_SIZE: {
-            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
-                return _FileSystemIndexDataCompareBySize(
-                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
-                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
-            });
+        case FileSystemModelSortRole::SORT_ROLE_SIZE: {
+            std::sort(filtered_children.begin(), filtered_children.end(),
+                      [&](const UUID64 &lhs, const UUID64 &rhs) {
+                          return _FileSystemIndexDataCompareBySize(
+                              *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                              *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(),
+                              m_sort_order);
+                      });
             break;
         }
-        case ModelSortRole::SORT_ROLE_DATE:
-            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
-                return _FileSystemIndexDataCompareByDate(
-                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
-                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
-            });
+        case FileSystemModelSortRole::SORT_ROLE_DATE:
+            std::sort(filtered_children.begin(), filtered_children.end(),
+                      [&](const UUID64 &lhs, const UUID64 &rhs) {
+                          return _FileSystemIndexDataCompareByDate(
+                              *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                              *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(),
+                              m_sort_order);
+                      });
             break;
         default:
             break;
         }
 
-        for (size_t i = 0; i < children.size(); i++) {
-            if (children[i] == index.getUUID()) {
+        for (size_t i = 0; i < filtered_children.size(); i++) {
+            if (filtered_children[i] == index.getUUID()) {
                 ModelIndex proxy_index = ModelIndex(getUUID());
                 proxy_index.setData(index.data<_FileSystemIndexData>());
                 return proxy_index;

From fae73384cee3811f12f9c23d7420e8b6676638ef Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Wed, 11 Sep 2024 08:29:13 -0500
Subject: [PATCH 009/129] View works but has performance issues

---
 include/model/fsmodel.hpp      |   4 +-
 include/model/model.hpp        |  10 +-
 src/gui/image/imagepainter.cpp |   2 +
 src/gui/project/asset.cpp      |   2 +-
 src/gui/project/window.cpp     |  47 +++-
 src/image/imagehandle.cpp      |   1 -
 src/model/fsmodel.cpp          | 395 +++++++++++----------------------
 7 files changed, 177 insertions(+), 284 deletions(-)

diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index 99b4d069..d35cd529 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -42,7 +42,7 @@ namespace Toolbox {
     public:
         struct FSTypeInfo {
             std::string m_name;
-            ImageHandle m_icon;
+            std::string m_image_name;
         };
 
     public:
@@ -210,6 +210,8 @@ namespace Toolbox {
         [[nodiscard]] ModelIndex toSourceIndex(const ModelIndex &index) const;
         [[nodiscard]] ModelIndex toProxyIndex(const ModelIndex &index) const;
 
+        [[nodiscard]] bool isFiltered(const UUID64 &uuid) const;
+
         ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent) {
             return ModelIndex();
         }
diff --git a/include/model/model.hpp b/include/model/model.hpp
index c5d71059..3bc22f34 100644
--- a/include/model/model.hpp
+++ b/include/model/model.hpp
@@ -40,8 +40,6 @@ namespace Toolbox {
             : m_uuid(other.m_uuid), m_model_uuid(other.m_model_uuid),
               m_user_data(other.m_user_data) {}
 
-        bool isValid() const { return m_model_uuid != 0; }
-
         template <typename T = void> [[nodiscard]] T *data() const {
             return reinterpret_cast<T *>(m_user_data);
         }
@@ -50,8 +48,6 @@ namespace Toolbox {
         [[nodiscard]] UUID64 getUUID() const override { return m_uuid; }
         [[nodiscard]] UUID64 getModelUUID() const { return m_model_uuid; }
 
-        operator bool() const { return isValid(); }
-
         ModelIndex &operator=(const ModelIndex &other) {
             m_uuid       = other.m_uuid;
             m_model_uuid = other.m_model_uuid;
@@ -73,7 +69,7 @@ namespace Toolbox {
     class IDataModel : public IUnique {
     public:
         [[nodiscard]] virtual bool validateIndex(const ModelIndex &index) const {
-            return index.isValid() && index.getModelUUID() == getUUID();
+            return index.getModelUUID() == getUUID();
         }
 
         [[nodiscard]] virtual std::string getDisplayText(const ModelIndex &index) const {
@@ -84,8 +80,8 @@ namespace Toolbox {
             return std::any_cast<std::string>(getData(index, ModelDataRole::DATA_ROLE_TOOLTIP));
         }
 
-        [[nodiscard]] virtual ImageHandle getDecoration(const ModelIndex &index) const {
-            return std::any_cast<ImageHandle>(getData(index, ModelDataRole::DATA_ROLE_DECORATION));
+        [[nodiscard]] virtual RefPtr<const ImageHandle> getDecoration(const ModelIndex &index) const {
+            return std::any_cast<RefPtr<const ImageHandle>>(getData(index, ModelDataRole::DATA_ROLE_DECORATION));
         }
 
         [[nodiscard]] virtual std::any getData(const ModelIndex &index, int role) const = 0;
diff --git a/src/gui/image/imagepainter.cpp b/src/gui/image/imagepainter.cpp
index 62df787c..dfb86a99 100644
--- a/src/gui/image/imagepainter.cpp
+++ b/src/gui/image/imagepainter.cpp
@@ -17,9 +17,11 @@ namespace Toolbox::UI {
         if (!image) {
             return false;
         }
+        ImVec2 orig_pos = ImGui::GetCursorScreenPos();
         ImGui::SetCursorScreenPos(pos);
         ImGui::Image((ImTextureID)image.m_image_handle, size, m_uv0, m_uv1, m_tint_color,
                      m_border_color);
+        ImGui::SetCursorScreenPos(orig_pos);
         return true;
     }
 
diff --git a/src/gui/project/asset.cpp b/src/gui/project/asset.cpp
index 403ef6ee..7a39201b 100644
--- a/src/gui/project/asset.cpp
+++ b/src/gui/project/asset.cpp
@@ -11,7 +11,7 @@ namespace Toolbox::UI {
         ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {3, 3});
 
         if (m_model) {
-            m_painter.render(m_model->getDecoration(m_index));
+            m_painter.render(*m_model->getDecoration(m_index));
             ImGui::Text("%s", m_model->getDisplayText(m_index).c_str());
         }
 
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index cc1a3d0f..87c3e890 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -2,6 +2,7 @@
 #include "model/fsmodel.hpp"
 
 #include <imgui/imgui.h>
+#include <cmath>
 
 namespace Toolbox::UI {
 
@@ -20,7 +21,7 @@ namespace Toolbox::UI {
     }
 
     void ProjectViewWindow::renderProjectTreeView() {
-        if (ImGui::BeginChild("Tree View", {160, 0}, true,
+        if (ImGui::BeginChild("Tree View", {300, 0}, true,
                               ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
             ModelIndex index = m_tree_proxy.getIndex(0, 0);
             renderFolderTree(index);
@@ -29,31 +30,61 @@ namespace Toolbox::UI {
     }
 
     void ProjectViewWindow::renderProjectFolderView() {
-        if (!m_view_index.isValid()) {
+        if (!m_view_proxy.validateIndex(m_view_index)) {
             return;
         }
 
-        if (ImGui::BeginChild("Folder View", {400, 0}, true,
+        if (ImGui::BeginChild("Folder View", {0, 0}, true,
                               ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
             if (m_view_proxy.hasChildren(m_view_index)) {
                 if (m_view_proxy.canFetchMore(m_view_index)) {
                     m_view_proxy.fetchMore(m_view_index);
                 }
+
+                ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {2, 2});
+                ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
+                ImGui::PushStyleVar(ImGuiStyleVar_ChildBorderSize, 0.0f);
+                ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, {2, 2});
+
+                ImVec2 size = ImGui::GetContentRegionAvail();
+
+                size_t x_count = (size_t)(size.x / 80);
+                if (x_count == 0) {
+                    x_count = 1;
+                }
+
                 for (size_t i = 0; i < m_view_proxy.getRowCount(m_view_index); ++i) {
                     ModelIndex child_index = m_view_proxy.getIndex(i, 0, m_view_index);
 
-                    if (ImGui::BeginChild(child_index.getUUID(), {160, 180}, true,
+                    if (ImGui::BeginChild(child_index.getUUID(), {76, 92}, true,
                                           ImGuiWindowFlags_ChildWindow |
                                               ImGuiWindowFlags_NoDecoration)) {
-                        const ImageHandle &icon = m_view_proxy.getDecoration(child_index);
-                        m_icon_painter.render(icon, {140, 140});
+
+                        m_icon_painter.render(*m_view_proxy.getDecoration(child_index), {72, 72});
+
+                        std::string text = m_view_proxy.getDisplayText(child_index);
+                        ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
+
+                        ImVec2 pos = ImGui::GetCursorScreenPos();
+                        pos.x += std::max<float>(36.0f - (text_size.x / 2.0f), 0.0);
+                        pos.y += 72.0f;
+                        //pos.x += i * size.x / 4.0f;
 
                         ImGui::RenderTextEllipsis(
-                            ImGui::GetWindowDrawList(), {10, 150}, {130, 170}, 120.0f, 150.0f,
-                            m_view_proxy.getDisplayText(child_index).c_str(), nullptr, nullptr);
+                            ImGui::GetWindowDrawList(), pos, pos + ImVec2(72, 20), pos.x + 72.0f,
+                            pos.x + 76.0f, m_view_proxy.getDisplayText(child_index).c_str(),
+                            nullptr, nullptr);
                     }
                     ImGui::EndChild();
+
+                    // ImGui::Text("%s", m_view_proxy.getDisplayText(child_index).c_str());
+
+                    if ((i + 1) % x_count != 0) {
+                        ImGui::SameLine(i * size.x / 4.0f);
+                    }
                 }
+
+                ImGui::PopStyleVar(4);
             }
         }
         ImGui::EndChild();
diff --git a/src/image/imagehandle.cpp b/src/image/imagehandle.cpp
index 1a3b1d4a..487e3041 100644
--- a/src/image/imagehandle.cpp
+++ b/src/image/imagehandle.cpp
@@ -118,7 +118,6 @@ namespace Toolbox {
     }
 
     void ImageHandle::moveGL(ImageHandle &&image) {
-        unloadGL();
         m_image_handle       = image.m_image_handle;
         m_image_format       = image.m_image_format;
         m_image_width        = image.m_image_width;
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 6d811dea..389d4af9 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -2,6 +2,7 @@
 #include <compare>
 #include <set>
 
+#include "gui/application.hpp"
 #include "model/fsmodel.hpp"
 
 namespace Toolbox {
@@ -15,6 +16,7 @@ namespace Toolbox {
         };
 
         UUID64 m_parent                = 0;
+        UUID64 m_self_uuid             = 0;
         std::vector<UUID64> m_children = {};
 
         Type m_type = Type::UNKNOWN;
@@ -22,6 +24,8 @@ namespace Toolbox {
         size_t m_size = 0;
         Filesystem::file_time_type m_date;
 
+        RefPtr<const ImageHandle> m_icon = nullptr;
+
         bool hasChild(UUID64 uuid) const {
             return std::find(m_children.begin(), m_children.end(), uuid) != m_children.end();
         }
@@ -166,6 +170,9 @@ namespace Toolbox {
             return {};
         }
 
+        fs_path fs_icon_path =
+            GUIApplication::instance().getResourcePath("Images/Icons/Filesystem/");
+
         switch (role) {
         case ModelDataRole::DATA_ROLE_DISPLAY:
             if (!validateIndex(index)) {
@@ -176,27 +183,9 @@ namespace Toolbox {
             return "Tooltip unimplemented!";
         case ModelDataRole::DATA_ROLE_DECORATION: {
             if (!validateIndex(index)) {
-                return TypeMap().at("_Invalid").m_icon;
-            }
-
-            if (isDirectory(index)) {
-                return TypeMap().at("_Folder").m_icon;
+                return RefPtr<ImageHandle>(nullptr);
             }
-
-            if (isArchive(index)) {
-                return TypeMap().at("_Archive").m_icon;
-            }
-
-            std::string ext = index.data<_FileSystemIndexData>()->m_path.extension().string();
-            if (ext.empty()) {
-                return TypeMap().at("_Folder").m_icon;
-            }
-
-            if (TypeMap().find(ext) == TypeMap().end()) {
-                return TypeMap().at("_File").m_icon;
-            }
-
-            return TypeMap().at(ext).m_icon;
+            return index.data<_FileSystemIndexData>()->m_icon;
         }
         case FileSystemDataRole::FS_DATA_ROLE_DATE: {
             if (!validateIndex(index)) {
@@ -516,6 +505,9 @@ namespace Toolbox {
     }
 
     bool FileSystemModel::hasChildren(const ModelIndex &parent) const {
+        if (getRowCount(parent) > 0) {
+            return true;
+        }
         return pollChildren(parent) > 0;
     }
 
@@ -564,42 +556,42 @@ namespace Toolbox {
     const std::unordered_map<std::string, FileSystemModel::FSTypeInfo> &FileSystemModel::TypeMap() {
         // clang-format off
         static std::unordered_map<std::string, FileSystemModel::FSTypeInfo> s_type_map = {
-            {"_Invalid", FSTypeInfo("Invalid",                  ImageHandle("Images/Icons/Filesystem/fs_invalid.png"))},
-            {"_Folder",  FSTypeInfo("Folder",                   ImageHandle("Images/Icons/Filesystem/fs_generic_folder.png")) },
-            {"_Archive", FSTypeInfo("Archive",                  ImageHandle("Images/Icons/Filesystem/fs_arc.png"))},
-            {"_File",    FSTypeInfo("File",                     ImageHandle("Images/Icons/Filesystem/fs_generic_file.png"))   },
-            {".txt",     FSTypeInfo("Text",                     ImageHandle("Images/Icons/Filesystem/fs_txt.png"))    },
-            {".md",      FSTypeInfo("Markdown",                 ImageHandle("Images/Icons/Filesystem/fs_md.png"))     },
-            {".c",       FSTypeInfo("C",                        ImageHandle("Images/Icons/Filesystem/fs_c.png"))      },
-            {".h",       FSTypeInfo("Header",                   ImageHandle("Images/Icons/Filesystem/fs_h.png"))      },
-            {".cpp",     FSTypeInfo("C++",                      ImageHandle("Images/Icons/Filesystem/fs_cpp.png"))    },
-            {".hpp",     FSTypeInfo("Header",                   ImageHandle("Images/Icons/Filesystem/fs_hpp.png"))    },
-            {".cxx",     FSTypeInfo("C++",                      ImageHandle("Images/Icons/Filesystem/fs_cpp.png"))    },
-            {".hxx",     FSTypeInfo("Header",                   ImageHandle("Images/Icons/Filesystem/fs_hpp.png"))    },
-            {".c++",     FSTypeInfo("C++",                      ImageHandle("Images/Icons/Filesystem/fs_cpp.png"))    },
-            {".h++",     FSTypeInfo("Header",                   ImageHandle("Images/Icons/Filesystem/fs_hpp.png"))    },
-            {".cc",      FSTypeInfo("C++",                      ImageHandle("Images/Icons/Filesystem/fs_cpp.png"))    },
-            {".hh",      FSTypeInfo("Header",                   ImageHandle("Images/Icons/Filesystem/fs_hpp.png"))    },
-            {".arc",     FSTypeInfo("Archive",                  ImageHandle("Images/Icons/Filesystem/fs_arc.png"))    },
-            {".bas",     FSTypeInfo("JAudio Sequence",          ImageHandle("Images/Icons/Filesystem/fs_bas.png"))    },
-            {".bck",     FSTypeInfo("J3D Bone Animation",       ImageHandle("Images/Icons/Filesystem/fs_bck.png"))    },
-            {".bdl",     FSTypeInfo("J3D Model Data",           ImageHandle("Images/Icons/Filesystem/fs_bdl.png"))    },
-            {".blo",     FSTypeInfo("J2D Screen Layout",        ImageHandle("Images/Icons/Filesystem/fs_blo.png"))    },
-            {".bmd",     FSTypeInfo("J3D Model Data",           ImageHandle("Images/Icons/Filesystem/fs_bmd.png"))    },
-            {".bmg",     FSTypeInfo("Message Data",             ImageHandle("Images/Icons/Filesystem/fs_bmg.png"))    },
-            {".bmt",     FSTypeInfo("J3D Material Table",       ImageHandle("Images/Icons/Filesystem/fs_bmt.png"))    },
-            {".brk",     FSTypeInfo("J3D Color Register Anim",  ImageHandle("Images/Icons/Filesystem/fs_brk.png"))    },
-            {".bti",     FSTypeInfo("J2D Texture Image",        ImageHandle("Images/Icons/Filesystem/fs_bti.png"))    },
-            {".btk",     FSTypeInfo("J2D Texture Animation",    ImageHandle("Images/Icons/Filesystem/fs_btk.png"))    },
-            {".btp",     FSTypeInfo("J2D Texture Pattern Anim", ImageHandle("Images/Icons/Filesystem/fs_btp.png"))    },
-            {".col",     FSTypeInfo("SMS Collision Data",       ImageHandle("Images/Icons/Filesystem/fs_col.png"))    },
-            {".jpa",     FSTypeInfo("JParticle Data",           ImageHandle("Images/Icons/Filesystem/fs_jpa.png"))    },
-            {".map",     FSTypeInfo("Executable Symbol Map",    ImageHandle("Images/Icons/Filesystem/fs_map.png"))    },
-            {".me",      FSTypeInfo("Marked For Delete",        ImageHandle("Images/Icons/Filesystem/fs_me.png"))     },
-            {".prm",     FSTypeInfo("SMS Parameter Data",       ImageHandle("Images/Icons/Filesystem/fs_prm.png"))    },
-            {".sb",      FSTypeInfo("Sunscript",                ImageHandle("Images/Icons/Filesystem/fs_sb.png"))     },
-            {".szs",     FSTypeInfo("Yaz0 Compressed Data",     ImageHandle("Images/Icons/Filesystem/fs_szs.png"))    },
-            {".thp",     FSTypeInfo("DolphinOS Movie Data",     ImageHandle("Images/Icons/Filesystem/fs_thp.png"))    },
+            {"_Invalid", FSTypeInfo("Invalid",                  "fs_invalid.png")       },
+            {"_Folder",  FSTypeInfo("Folder",                   "fs_generic_folder.png")},
+            {"_Archive", FSTypeInfo("Archive",                  "fs_arc.png")           },
+            {"_File",    FSTypeInfo("File",                     "fs_generic_file.png")  },
+            {".txt",     FSTypeInfo("Text",                     "fs_txt.png")           },
+            {".md",      FSTypeInfo("Markdown",                 "fs_md.png")            },
+            {".c",       FSTypeInfo("C",                        "fs_c.png")             },
+            {".h",       FSTypeInfo("Header",                   "fs_h.png")             },
+            {".cpp",     FSTypeInfo("C++",                      "fs_cpp.png")           },
+            {".hpp",     FSTypeInfo("Header",                   "fs_hpp.png")           },
+            {".cxx",     FSTypeInfo("C++",                      "fs_cpp.png")           },
+            {".hxx",     FSTypeInfo("Header",                   "fs_hpp.png")           },
+            {".c++",     FSTypeInfo("C++",                      "fs_cpp.png")           },
+            {".h++",     FSTypeInfo("Header",                   "fs_hpp.png")           },
+            {".cc",      FSTypeInfo("C++",                      "fs_cpp.png")           },
+            {".hh",      FSTypeInfo("Header",                   "fs_hpp.png")           },
+            {".arc",     FSTypeInfo("Archive",                  "fs_arc.png")           },
+            {".bas",     FSTypeInfo("JAudio Sequence",          "fs_bas.png")           },
+            {".bck",     FSTypeInfo("J3D Bone Animation",       "fs_bck.png")           },
+            {".bdl",     FSTypeInfo("J3D Model Data",           "fs_bdl.png")           },
+            {".blo",     FSTypeInfo("J2D Screen Layout",        "fs_blo.png")           },
+            {".bmd",     FSTypeInfo("J3D Model Data",           "fs_bmd.png")           },
+            {".bmg",     FSTypeInfo("Message Data",             "fs_bmg.png")           },
+            {".bmt",     FSTypeInfo("J3D Material Table",       "fs_bmt.png")           },
+            {".brk",     FSTypeInfo("J3D Color Register Anim",  "fs_brk.png")           },
+            {".bti",     FSTypeInfo("J2D Texture Image",        "fs_bti.png")           },
+            {".btk",     FSTypeInfo("J2D Texture Animation",    "fs_btk.png")           },
+            {".btp",     FSTypeInfo("J2D Texture Pattern Anim", "fs_btp.png")           },
+            {".col",     FSTypeInfo("SMS Collision Data",       "fs_col.png")           },
+            {".jpa",     FSTypeInfo("JParticle Data",           "fs_jpa.png")           },
+            {".map",     FSTypeInfo("Executable Symbol Map",    "fs_map.png")           },
+            {".me",      FSTypeInfo("Marked For Delete",        "fs_me.png")            },
+            {".prm",     FSTypeInfo("SMS Parameter Data",       "fs_prm.png")           },
+            {".sb",      FSTypeInfo("Sunscript",                "fs_sb.png")            },
+            {".szs",     FSTypeInfo("Yaz0 Compressed Data",     "fs_szs.png")           },
+            {".thp",     FSTypeInfo("DolphinOS Movie Data",     "fs_thp.png")           },
         };
         // clang-format on
         return s_type_map;
@@ -652,6 +644,36 @@ namespace Toolbox {
 
         ModelIndex index = ModelIndex(getUUID());
 
+        // Establish icon
+        {
+            fs_path fs_icon_path =
+                GUIApplication::instance().getResourcePath("Images/Icons/Filesystem/");
+
+            std::string ext = data->m_path.extension().string();
+
+            if (!validateIndex(index)) {
+                data->m_icon = make_referable<const ImageHandle>(
+                    fs_icon_path / TypeMap().at("_Invalid").m_image_name);
+            } else if (data->m_type == _FileSystemIndexData::Type::DIRECTORY) {
+                data->m_icon = make_referable<const ImageHandle>(
+                    fs_icon_path / TypeMap().at("_Folder").m_image_name);
+            } else if (data->m_type == _FileSystemIndexData::Type::ARCHIVE) {
+                data->m_icon = make_referable<const ImageHandle>(
+                    fs_icon_path / TypeMap().at("_Archive").m_image_name);
+            } else if (ext.empty()) {
+                data->m_icon = make_referable<const ImageHandle>(
+                    fs_icon_path / TypeMap().at("_Folder").m_image_name);
+            } else if (TypeMap().find(ext) == TypeMap().end()) {
+                data->m_icon = make_referable<const ImageHandle>(
+                    fs_icon_path / TypeMap().at("_File").m_image_name);
+            } else {
+                data->m_icon = make_referable<const ImageHandle>(fs_icon_path /
+                                                                 TypeMap().at(ext).m_image_name);
+            }
+        }
+
+        data->m_self_uuid = index.getUUID();
+
         if (!validateIndex(parent)) {
             index.setData(data);
             m_index_map[index.getUUID()] = std::move(index);
@@ -737,156 +759,88 @@ namespace Toolbox {
     const std::string &FileSystemModelSortFilterProxy::getFilter() const & { return m_filter; }
     void FileSystemModelSortFilterProxy::setFilter(const std::string &filter) { m_filter = filter; }
 
-    bool FileSystemModelSortFilterProxy::isReadOnly() const {
-        if (!m_source_model) {
-            return true;
-        }
-        return m_source_model->isReadOnly();
-    }
+    bool FileSystemModelSortFilterProxy::isReadOnly() const { return m_source_model->isReadOnly(); }
 
     void FileSystemModelSortFilterProxy::setReadOnly(bool read_only) {
-        if (!m_source_model) {
-            return;
-        }
         m_source_model->setReadOnly(read_only);
     }
 
     bool FileSystemModelSortFilterProxy::isDirectory(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return false;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->isDirectory(source_index);
+        return m_source_model->isDirectory(std::move(source_index));
     }
 
     bool FileSystemModelSortFilterProxy::isFile(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return false;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->isFile(source_index);
+        return m_source_model->isFile(std::move(source_index));
     }
 
     bool FileSystemModelSortFilterProxy::isArchive(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return false;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->isArchive(source_index);
+        return m_source_model->isArchive(std::move(source_index));
     }
 
     size_t FileSystemModelSortFilterProxy::getFileSize(const ModelIndex &index) {
-        if (!m_source_model) {
-            return 0;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->getFileSize(source_index);
+        return m_source_model->getFileSize(std::move(source_index));
     }
 
     size_t FileSystemModelSortFilterProxy::getDirSize(const ModelIndex &index, bool recursive) {
-        if (!m_source_model) {
-            return 0;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->getDirSize(source_index, recursive);
+        return m_source_model->getDirSize(std::move(source_index), recursive);
     }
 
     Filesystem::file_time_type
     FileSystemModelSortFilterProxy::getLastModified(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return Filesystem::file_time_type();
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->getLastModified(source_index);
+        return m_source_model->getLastModified(std::move(source_index));
     }
 
     Filesystem::file_status
     FileSystemModelSortFilterProxy::getStatus(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return Filesystem::file_status();
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->getStatus(source_index);
+        return m_source_model->getStatus(std::move(source_index));
     }
 
     std::string FileSystemModelSortFilterProxy::getType(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return "Invalid";
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->getType(source_index);
+        return m_source_model->getType(std::move(source_index));
     }
 
     std::any FileSystemModelSortFilterProxy::getData(const ModelIndex &index, int role) const {
-        if (!m_source_model) {
-            return std::any();
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->getData(source_index, role);
+        return m_source_model->getData(std::move(source_index), role);
     }
 
     ModelIndex FileSystemModelSortFilterProxy::mkdir(const ModelIndex &parent,
                                                      const std::string &name) {
-        if (!m_source_model) {
-            return ModelIndex();
-        }
-
         ModelIndex &&source_index = toSourceIndex(parent);
-        return m_source_model->mkdir(source_index, name);
+        return m_source_model->mkdir(std::move(source_index), name);
     }
 
     ModelIndex FileSystemModelSortFilterProxy::touch(const ModelIndex &parent,
                                                      const std::string &name) {
-        if (!m_source_model) {
-            return ModelIndex();
-        }
-
         ModelIndex &&source_index = toSourceIndex(parent);
-        return m_source_model->touch(source_index, name);
+        return m_source_model->touch(std::move(source_index), name);
     }
 
     bool FileSystemModelSortFilterProxy::rmdir(const ModelIndex &index) {
-        if (!m_source_model) {
-            return false;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->rmdir(source_index);
+        return m_source_model->rmdir(std::move(source_index));
     }
 
     bool FileSystemModelSortFilterProxy::remove(const ModelIndex &index) {
-        if (!m_source_model) {
-            return false;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        return m_source_model->remove(source_index);
+        return m_source_model->remove(std::move(source_index));
     }
 
     ModelIndex FileSystemModelSortFilterProxy::getIndex(const fs_path &path) const {
         ModelIndex index = m_source_model->getIndex(path);
-        if (!index.isValid()) {
-            return ModelIndex();
-        }
-
         return toProxyIndex(index);
     }
 
     ModelIndex FileSystemModelSortFilterProxy::getIndex(const UUID64 &uuid) const {
         ModelIndex index = m_source_model->getIndex(uuid);
-        if (!index.isValid()) {
-            return ModelIndex();
-        }
-
         return toProxyIndex(index);
     }
 
@@ -895,98 +849,42 @@ namespace Toolbox {
         ModelIndex parent_src = toSourceIndex(parent);
 
         ModelIndex index = m_source_model->getIndex(row, column, parent_src);
-        if (!index.isValid()) {
-            return ModelIndex();
-        }
-
         return toProxyIndex(index);
     }
 
     fs_path FileSystemModelSortFilterProxy::getPath(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return fs_path();
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        if (!source_index.isValid()) {
-            return fs_path();
-        }
-
-        return m_source_model->getPath(source_index);
+        return m_source_model->getPath(std::move(source_index));
     }
 
     ModelIndex FileSystemModelSortFilterProxy::getParent(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return ModelIndex();
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        if (!source_index.isValid()) {
-            return ModelIndex();
-        }
-
-        return toProxyIndex(m_source_model->getParent(source_index));
+        return toProxyIndex(m_source_model->getParent(std::move(source_index)));
     }
 
     ModelIndex FileSystemModelSortFilterProxy::getSibling(int64_t row, int64_t column,
                                                           const ModelIndex &index) const {
-        if (!m_source_model) {
-            return ModelIndex();
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        if (!source_index.isValid()) {
-            return ModelIndex();
-        }
-
         return toProxyIndex(m_source_model->getSibling(row, column, source_index));
     }
 
     size_t FileSystemModelSortFilterProxy::getColumnCount(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return 0;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        if (!source_index.isValid()) {
-            return 0;
-        }
-
         return m_source_model->getColumnCount(source_index);
     }
 
     size_t FileSystemModelSortFilterProxy::getRowCount(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return 0;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        if (!source_index.isValid()) {
-            return 0;
-        }
-
         return m_source_model->getRowCount(source_index);
     }
 
     bool FileSystemModelSortFilterProxy::hasChildren(const ModelIndex &parent) const {
-        if (!m_source_model) {
-            return false;
-        }
-
         ModelIndex &&source_index = toSourceIndex(parent);
-        if (!source_index.isValid()) {
-            return false;
-        }
-
         return m_source_model->hasChildren(source_index);
     }
 
     ScopePtr<MimeData>
     FileSystemModelSortFilterProxy::createMimeData(const std::vector<ModelIndex> &indexes) const {
-        if (!m_source_model) {
-            return ScopePtr<MimeData>();
-        }
-
         std::vector<ModelIndex> indexes_copy = indexes;
         std::transform(indexes.begin(), indexes.end(), indexes_copy.begin(),
                        [&](const ModelIndex &index) { return toSourceIndex(index); });
@@ -995,43 +893,20 @@ namespace Toolbox {
     }
 
     std::vector<std::string> FileSystemModelSortFilterProxy::getSupportedMimeTypes() const {
-        if (!m_source_model) {
-            return std::vector<std::string>();
-        }
         return m_source_model->getSupportedMimeTypes();
     }
 
     bool FileSystemModelSortFilterProxy::canFetchMore(const ModelIndex &index) {
-        if (!m_source_model) {
-            return false;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        if (!source_index.isValid()) {
-            return false;
-        }
-
-        return m_source_model->canFetchMore(source_index);
+        return m_source_model->canFetchMore(std::move(source_index));
     }
 
     void FileSystemModelSortFilterProxy::fetchMore(const ModelIndex &index) {
-        if (!m_source_model) {
-            return;
-        }
-
         ModelIndex &&source_index = toSourceIndex(index);
-        if (!source_index.isValid()) {
-            return;
-        }
-
-        m_source_model->fetchMore(source_index);
+        m_source_model->fetchMore(std::move(source_index));
     }
 
     ModelIndex FileSystemModelSortFilterProxy::toSourceIndex(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return ModelIndex();
-        }
-
         if (m_source_model->validateIndex(index)) {
             return index;
         }
@@ -1040,14 +915,10 @@ namespace Toolbox {
             return ModelIndex();
         }
 
-        return m_source_model->getIndex(index.data<_FileSystemIndexData>()->m_path);
+        return m_source_model->getIndex(index.data<_FileSystemIndexData>()->m_self_uuid);
     }
 
     ModelIndex FileSystemModelSortFilterProxy::toProxyIndex(const ModelIndex &index) const {
-        if (!m_source_model) {
-            return ModelIndex();
-        }
-
         if (validateIndex(index)) {
             return index;
         }
@@ -1063,63 +934,45 @@ namespace Toolbox {
             return proxy_index;
         }
 
-        const std::vector<UUID64> &children = parent.data<_FileSystemIndexData>()->m_children;
+        std::vector<UUID64> children = parent.data<_FileSystemIndexData>()->m_children;
         if (children.empty()) {
             return ModelIndex();
         }
 
-        std::vector<UUID64> filtered_children(children.size());
-        std::copy_if(children.begin(), children.end(), filtered_children.begin(),
-                     [&](const UUID64 &uuid) {
-            ModelIndex child_index = m_source_model->getIndex(uuid);
-            if (!child_index.isValid()) {
-                return false;
-            }
-
-            if (isDirsOnly() && m_source_model->isFile(child_index)) {
-                return false;
-            }
-
-            fs_path path = child_index.data<_FileSystemIndexData>()->m_path;
-            return path.filename().string().starts_with(m_filter);
-        });
-
         switch (m_sort_role) {
         case FileSystemModelSortRole::SORT_ROLE_NAME: {
-            std::sort(filtered_children.begin(), filtered_children.end(),
-                      [&](const UUID64 &lhs, const UUID64 &rhs) {
-                          return _FileSystemIndexDataCompareByName(
-                              *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
-                              *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(),
-                              m_sort_order);
-                      });
+            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
+                return _FileSystemIndexDataCompareByName(
+                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
+            });
             break;
         }
         case FileSystemModelSortRole::SORT_ROLE_SIZE: {
-            std::sort(filtered_children.begin(), filtered_children.end(),
-                      [&](const UUID64 &lhs, const UUID64 &rhs) {
-                          return _FileSystemIndexDataCompareBySize(
-                              *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
-                              *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(),
-                              m_sort_order);
-                      });
+            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
+                return _FileSystemIndexDataCompareBySize(
+                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
+            });
             break;
         }
         case FileSystemModelSortRole::SORT_ROLE_DATE:
-            std::sort(filtered_children.begin(), filtered_children.end(),
-                      [&](const UUID64 &lhs, const UUID64 &rhs) {
-                          return _FileSystemIndexDataCompareByDate(
-                              *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
-                              *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(),
-                              m_sort_order);
-                      });
+            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
+                return _FileSystemIndexDataCompareByDate(
+                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
+            });
             break;
         default:
             break;
         }
 
-        for (size_t i = 0; i < filtered_children.size(); i++) {
-            if (filtered_children[i] == index.getUUID()) {
+        for (size_t i = 0; i < children.size(); i++) {
+            if (isFiltered(children[i])) {
+                continue;
+            }
+
+            if (children[i] == index.getUUID()) {
                 ModelIndex proxy_index = ModelIndex(getUUID());
                 proxy_index.setData(index.data<_FileSystemIndexData>());
                 return proxy_index;
@@ -1130,4 +983,14 @@ namespace Toolbox {
         return ModelIndex();
     }
 
+    bool FileSystemModelSortFilterProxy::isFiltered(const UUID64 &uuid) const {
+        ModelIndex child_index = m_source_model->getIndex(uuid);
+        if (isDirsOnly() && m_source_model->isFile(child_index)) {
+            return true;
+        }
+
+        fs_path path = child_index.data<_FileSystemIndexData>()->m_path;
+        return !path.filename().string().starts_with(m_filter);
+    }
+
 }  // namespace Toolbox
\ No newline at end of file

From bd79451a08fb7c33eca1aa64d1c588ab782799f5 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Wed, 11 Sep 2024 09:05:27 -0500
Subject: [PATCH 010/129] Update imgui submodule

---
 lib/imgui | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/imgui b/lib/imgui
index e391fe2e..f63c95a0 160000
--- a/lib/imgui
+++ b/lib/imgui
@@ -1 +1 @@
-Subproject commit e391fe2e66eb1c96b1624ae8444dc64c23146ef4
+Subproject commit f63c95a076a401721ceaf21f30d4f12e8c40cb2c

From ffc72eb1397c1e894a63b7746fec92278342d5ea Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Wed, 11 Sep 2024 11:04:55 -0500
Subject: [PATCH 011/129] Update imgui_ext and fix bugs

---
 include/gui/project/window.hpp |   1 +
 include/model/fsmodel.hpp      |   2 +
 src/gui/application.cpp        |   2 +-
 src/gui/imgui_ext.cpp          | 645 ++++++++++++++++++---------------
 src/gui/project/window.cpp     |   9 +-
 src/model/fsmodel.cpp          | 152 +++++---
 6 files changed, 463 insertions(+), 348 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 34c76a19..453f9bac 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -86,6 +86,7 @@ namespace Toolbox::UI {
             m_tree_proxy.setSourceModel(m_file_system_model);
             m_tree_proxy.setDirsOnly(true);
             m_view_proxy.setSourceModel(m_file_system_model);
+            m_view_proxy.setSortRole(FileSystemModelSortRole::SORT_ROLE_NAME);
             m_view_index = m_view_proxy.getIndex(0, 0);
             return true;
         }
diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index d35cd529..a0577a0d 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -209,6 +209,8 @@ namespace Toolbox {
     protected:
         [[nodiscard]] ModelIndex toSourceIndex(const ModelIndex &index) const;
         [[nodiscard]] ModelIndex toProxyIndex(const ModelIndex &index) const;
+        [[nodiscard]] ModelIndex toProxyIndex(int64_t row, int64_t column,
+                                              const ModelIndex &parent = ModelIndex()) const;
 
         [[nodiscard]] bool isFiltered(const UUID64 &uuid) const;
 
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index f39a8937..5316a153 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -304,7 +304,7 @@ namespace Toolbox {
         ImGui::SetNextWindowPos(viewport->Pos);
         ImGui::SetNextWindowSize(viewport->Size);
         ImGui::SetNextWindowViewport(viewport->ID);
-        m_dockspace_id = ImGui::DockSpaceOverViewport(viewport);
+        m_dockspace_id = ImGui::DockSpaceOverViewport(0, viewport);
 
         m_dockspace_built = ImGui::DockBuilderGetNode(m_dockspace_id);
         if (!m_dockspace_built) {
diff --git a/src/gui/imgui_ext.cpp b/src/gui/imgui_ext.cpp
index 105aa3ba..d1837e01 100644
--- a/src/gui/imgui_ext.cpp
+++ b/src/gui/imgui_ext.cpp
@@ -26,6 +26,7 @@ static const ImGuiDataTypeInfo GDataTypeInfo[] = {
     {sizeof(float),          "float",  "%.3f",
      "%f"                                              }, // ImGuiDataType_Float (float are promoted to double in va_arg)
     {sizeof(double),         "double", "%f",    "%lf"  }, // ImGuiDataType_Double
+    {sizeof(bool),           "bool",   "%d",    "%d"   }, // ImGuiDataType_Bool
 };
 IM_STATIC_ASSERT(IM_ARRAYSIZE(GDataTypeInfo) == ImGuiDataType_COUNT);
 
@@ -349,7 +350,7 @@ bool ImGui::AlignedButton(const char *label, ImVec2 size, ImGuiButtonFlags flags
     return ret;
 }
 
-bool ImGui::SwitchButton(const char* label, bool active, ImVec2 size, ImGuiButtonFlags flags) {
+bool ImGui::SwitchButton(const char *label, bool active, ImVec2 size, ImGuiButtonFlags flags) {
     return SwitchButton(label, active, size, flags, ImDrawFlags_RoundCornersNone);
 }
 
@@ -558,6 +559,22 @@ bool ImGui::TreeNodeEx(const char *label, ImGuiTreeNodeFlags flags, bool focused
     return TreeNodeBehavior(window->GetID(label), flags, label, NULL, focused);
 }
 
+// Store ImGuiTreeNodeStackData for just submitted node.
+// Currently only supports 32 level deep and we are fine with (1 << Depth) overflowing into a zero,
+// easy to increase.
+static void TreeNodeStoreStackData(ImGuiTreeNodeFlags flags) {
+    ImGuiContext &g     = *GImGui;
+    ImGuiWindow *window = g.CurrentWindow;
+
+    g.TreeNodeStack.resize(g.TreeNodeStack.Size + 1);
+    ImGuiTreeNodeStackData *tree_node_data = &g.TreeNodeStack.back();
+    tree_node_data->ID                     = g.LastItemData.ID;
+    tree_node_data->TreeFlags              = flags;
+    tree_node_data->InFlags                = g.LastItemData.InFlags;
+    tree_node_data->NavRect                = g.LastItemData.NavRect;
+    window->DC.TreeHasStackDataDepthMask |= (1 << window->DC.TreeDepth);
+}
+
 bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *label,
                              const char *label_end, bool focused) {
     ImGuiWindow *window = GetCurrentWindow();
@@ -577,6 +594,13 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
         label_end = FindRenderedTextEnd(label);
     const ImVec2 label_size = CalcTextSize(label, label_end, false);
 
+    const float text_offset_x =
+        g.FontSize +
+        (display_frame ? padding.x * 3 : padding.x * 2);  // Collapsing arrow width + Spacing
+    const float text_offset_y =
+        ImMax(padding.y, window->DC.CurrLineTextBaseOffset);  // Latch before ItemSize changes it
+    const float text_width = g.FontSize + label_size.x + padding.x * 2;  // Include collapsing arrow
+
     // We vertically grow up to current line height up the typical widget height.
     const float frame_height =
         ImMax(ImMin(window->DC.CurrLineSize.y, g.FontSize + style.FramePadding.y * 2),
@@ -588,73 +612,70 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
                      : (flags & ImGuiTreeNodeFlags_SpanFullWidth) ? window->WorkRect.Min.x
                                                                   : window->DC.CursorPos.x;
     frame_bb.Min.y = window->DC.CursorPos.y;
-    frame_bb.Max.x = span_all_columns ? window->ParentWorkRect.Max.x : window->WorkRect.Max.x;
+    frame_bb.Max.x = span_all_columns ? window->ParentWorkRect.Max.x
+                     : (flags & ImGuiTreeNodeFlags_SpanTextWidth)
+                         ? window->DC.CursorPos.x + text_width + padding.x
+                         : window->WorkRect.Max.x;
     frame_bb.Max.y = window->DC.CursorPos.y + frame_height;
     if (display_frame) {
-        // Framed header expand a little outside the default padding, to the edge of InnerClipRect
-        // (FIXME: May remove this at some point and make InnerClipRect align with WindowPadding.x
-        // instead of WindowPadding.x*0.5f)
-        frame_bb.Min.x -= IM_TRUNC(window->WindowPadding.x * 0.5f - 1.0f);
-        frame_bb.Max.x += IM_TRUNC(window->WindowPadding.x * 0.5f);
+        const float outer_extend =
+            IM_TRUNC(window->WindowPadding.x *
+                     0.5f);  // Framed header expand a little outside of current limits
+        frame_bb.Min.x -= outer_extend;
+        frame_bb.Max.x += outer_extend;
     }
 
-    const float text_offset_x =
-        g.FontSize +
-        (display_frame ? padding.x * 3 : padding.x * 2);  // Collapsing arrow width + Spacing
-    const float text_offset_y =
-        ImMax(padding.y, window->DC.CurrLineTextBaseOffset);  // Latch before ItemSize changes it
-    const float text_width = g.FontSize + (label_size.x > 0.0f ? label_size.x + padding.x * 2
-                                                               : 0.0f);  // Include collapsing
     ImVec2 text_pos(window->DC.CursorPos.x + text_offset_x, window->DC.CursorPos.y + text_offset_y);
     ItemSize(ImVec2(text_width, frame_height), padding.y);
 
     // For regular tree nodes, we arbitrary allow to click past 2 worth of ItemSpacing
     ImRect interact_bb = frame_bb;
-    if (!display_frame &&
-        (flags & (ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_SpanFullWidth |
+    if ((flags & (ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_SpanAvailWidth |
+                  ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_SpanTextWidth |
                   ImGuiTreeNodeFlags_SpanAllColumns)) == 0)
-        interact_bb.Max.x = frame_bb.Min.x + text_width + style.ItemSpacing.x * 2.0f;
-
-    // Modify ClipRect for the ItemAdd(), faster than doing a
-    // PushColumnsBackground/PushTableBackgroundChannel for every Selectable..
-    const float backup_clip_rect_min_x = window->ClipRect.Min.x;
-    const float backup_clip_rect_max_x = window->ClipRect.Max.x;
-    if (span_all_columns) {
-        window->ClipRect.Min.x = window->ParentWorkRect.Min.x;
-        window->ClipRect.Max.x = window->ParentWorkRect.Max.x;
-    }
+        interact_bb.Max.x =
+            frame_bb.Min.x + text_width + (label_size.x > 0.0f ? style.ItemSpacing.x * 2.0f : 0.0f);
 
     // Compute open and multi-select states before ItemAdd() as it clear NextItem data.
-    bool is_open  = TreeNodeUpdateNextOpen(id, flags);
-    bool item_add = ItemAdd(interact_bb, id);
-    g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_HasDisplayRect;
-    g.LastItemData.DisplayRect = frame_bb;
+    ImGuiID storage_id = (g.NextItemData.Flags & ImGuiNextItemDataFlags_HasStorageID)
+                             ? g.NextItemData.StorageId
+                             : id;
+    bool is_open       = TreeNodeUpdateNextOpen(storage_id, flags);
 
+    bool is_visible;
     if (span_all_columns) {
-        window->ClipRect.Min.x = backup_clip_rect_min_x;
-        window->ClipRect.Max.x = backup_clip_rect_max_x;
+        // Modify ClipRect for the ItemAdd(), faster than doing a
+        // PushColumnsBackground/PushTableBackgroundChannel for every Selectable..
+        const float backup_clip_rect_min_x = window->ClipRect.Min.x;
+        const float backup_clip_rect_max_x = window->ClipRect.Max.x;
+        window->ClipRect.Min.x             = window->ParentWorkRect.Min.x;
+        window->ClipRect.Max.x             = window->ParentWorkRect.Max.x;
+        is_visible                         = ItemAdd(interact_bb, id);
+        window->ClipRect.Min.x             = backup_clip_rect_min_x;
+        window->ClipRect.Max.x             = backup_clip_rect_max_x;
+    } else {
+        is_visible = ItemAdd(interact_bb, id);
     }
+    g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_HasDisplayRect;
+    g.LastItemData.DisplayRect = frame_bb;
 
     // If a NavLeft request is happening and ImGuiTreeNodeFlags_NavLeftJumpsBackHere enabled:
     // Store data for the current depth to allow returning to this node from any child item.
     // For this purpose we essentially compare if g.NavIdIsAlive went from 0 to 1 between TreeNode()
     // and TreePop(). It will become tempting to enable ImGuiTreeNodeFlags_NavLeftJumpsBackHere by
-    // default or move it to ImGuiStyle. Currently only supports 32 level deep and we are fine with
-    // (1 << Depth) overflowing into a zero, easy to increase.
-    if (is_open && !g.NavIdIsAlive && (flags & ImGuiTreeNodeFlags_NavLeftJumpsBackHere) &&
-        !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))
-        if (g.NavMoveDir == ImGuiDir_Left && g.NavWindow == window &&
-            NavMoveRequestButNoResultYet()) {
-            g.NavTreeNodeStack.resize(g.NavTreeNodeStack.Size + 1);
-            ImGuiNavTreeNodeData *nav_tree_node_data = &g.NavTreeNodeStack.back();
-            nav_tree_node_data->ID                   = id;
-            nav_tree_node_data->InFlags              = g.LastItemData.InFlags;
-            nav_tree_node_data->NavRect              = g.LastItemData.NavRect;
-            window->DC.TreeJumpToParentOnPopMask |= (1 << window->DC.TreeDepth);
-        }
+    // default or move it to ImGuiStyle.
+    bool store_tree_node_stack_data = false;
+    if (!(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen)) {
+        if ((flags & ImGuiTreeNodeFlags_NavLeftJumpsBackHere) && is_open && !g.NavIdIsAlive)
+            if (g.NavMoveDir == ImGuiDir_Left && g.NavWindow == window &&
+                NavMoveRequestButNoResultYet())
+                store_tree_node_stack_data = true;
+    }
 
     const bool is_leaf = (flags & ImGuiTreeNodeFlags_Leaf) != 0;
-    if (!item_add) {
+    if (!is_visible) {
+        if (store_tree_node_stack_data && is_open)
+            TreeNodeStoreStackData(flags);  // Call before TreePushOverrideID()
         if (is_open && !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))
             TreePushOverrideID(id);
         IMGUI_TEST_ENGINE_ITEM_INFO(g.LastItemData.ID, label,
@@ -664,8 +685,11 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
         return is_open;
     }
 
-    if (span_all_columns)
+    if (span_all_columns) {
         TablePushBackgroundChannel();
+        g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_HasClipRect;
+        g.LastItemData.ClipRect = window->ClipRect;
+    }
 
     ImGuiButtonFlags button_flags = ImGuiTreeNodeFlags_None;
     if ((flags & ImGuiTreeNodeFlags_AllowOverlap) ||
@@ -682,8 +706,13 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
         (text_pos.x - text_offset_x) + (g.FontSize + padding.x * 2.0f) + style.TouchExtraPadding.x;
     const bool is_mouse_x_over_arrow =
         (g.IO.MousePos.x >= arrow_hit_x1 && g.IO.MousePos.x < arrow_hit_x2);
-    if (window != g.HoveredWindow || !is_mouse_x_over_arrow)
-        button_flags |= ImGuiButtonFlags_NoKeyModifiers;
+
+    const bool is_multi_select = (g.LastItemData.InFlags & ImGuiItemFlags_IsMultiSelect) != 0;
+    if (is_multi_select)  // We absolutely need to distinguish open vs select so _OpenOnArrow comes
+                          // by default
+        flags |= (flags & ImGuiTreeNodeFlags_OpenOnMask_) == 0
+                     ? ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick
+                     : ImGuiTreeNodeFlags_OpenOnArrow;
 
     // Open behaviors can be altered with the _OpenOnArrow and _OnOnDoubleClick flags.
     // Some alteration have subtle effects (e.g. toggle on MouseUp vs MouseDown events) due to
@@ -707,27 +736,40 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
     bool selected           = (flags & ImGuiTreeNodeFlags_Selected) != 0;
     const bool was_selected = selected;
 
+    // Multi-selection support (header)
+    if (is_multi_select) {
+        // Handle multi-select + alter button flags for it
+        MultiSelectItemHeader(id, &selected, &button_flags);
+        if (is_mouse_x_over_arrow)
+            button_flags = (button_flags | ImGuiButtonFlags_PressedOnClick) &
+                           ~ImGuiButtonFlags_PressedOnClickRelease;
+    } else {
+        if (window != g.HoveredWindow || !is_mouse_x_over_arrow)
+            button_flags |= ImGuiButtonFlags_NoKeyModifiers;
+    }
+
     bool hovered, held;
     bool pressed = ButtonBehavior(interact_bb, id, &hovered, &held, button_flags);
     bool toggled = false;
     if (!is_leaf) {
         if (pressed && g.DragDropHoldJustPressedId != id) {
-            if ((flags & (ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick)) ==
-                    0 ||
-                (g.NavActivateId == id))
-                toggled = true;
+            if ((flags & ImGuiTreeNodeFlags_OpenOnMask_) == 0 ||
+                (g.NavActivateId == id && !is_multi_select))
+                toggled = true;  // Single click
             if (flags & ImGuiTreeNodeFlags_OpenOnArrow)
                 toggled |=
                     is_mouse_x_over_arrow &&
                     !g.NavDisableMouseHover;  // Lightweight equivalent of IsMouseHoveringRect()
                                               // since ButtonBehavior() already did the job
             if ((flags & ImGuiTreeNodeFlags_OpenOnDoubleClick) && g.IO.MouseClickedCount[0] == 2)
-                toggled = true;
+                toggled = true;  // Double click
         } else if (pressed && g.DragDropHoldJustPressedId == id) {
             IM_ASSERT(button_flags & ImGuiButtonFlags_PressedOnDragDropHold);
             if (!is_open)  // When using Drag and Drop "hold to open" we keep the node highlighted
                            // after opening, but never close it again.
                 toggled = true;
+            else
+                pressed = false;  // Cancel press so it doesn't trigger selection.
         }
 
         if (g.NavId == id && g.NavMoveDir == ImGuiDir_Left && is_open) {
@@ -746,80 +788,96 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
 
         if (toggled) {
             is_open = !is_open;
-            window->DC.StateStorage->SetInt(id, is_open);
+            window->DC.StateStorage->SetInt(storage_id, is_open);
             g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_ToggledOpen;
         }
     }
 
-    // In this branch, TreeNodeBehavior() cannot toggle the selection so this will never trigger.
-    if (selected != was_selected)  //-V547
+    // Multi-selection support (footer)
+    if (is_multi_select) {
+        bool pressed_copy = pressed && !toggled;
+        MultiSelectItemFooter(id, &selected, &pressed_copy);
+        if (pressed)
+            SetNavID(id, window->DC.NavLayerCurrent, g.CurrentFocusScopeId, interact_bb);
+    }
+
+    if (selected != was_selected)
         g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_ToggledSelection;
 
     // Render
-    const ImU32 text_col                       = GetColorU32(ImGuiCol_Text);
-    ImGuiNavHighlightFlags nav_highlight_flags = ImGuiNavHighlightFlags_Compact;
-    if (display_frame) {
-        // Framed type
-        const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive
-                                         : hovered         ? ImGuiCol_HeaderHovered
-                                                           : ImGuiCol_Header);
-        RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, true, style.FrameRounding);
-        RenderNavHighlight(frame_bb, id, nav_highlight_flags);
-        if (flags & ImGuiTreeNodeFlags_Bullet)
-            RenderBullet(window->DrawList,
-                         ImVec2(text_pos.x - text_offset_x * 0.60f, text_pos.y + g.FontSize * 0.5f),
-                         text_col);
-        else if (!is_leaf)
-            RenderArrow(window->DrawList,
-                        ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y), text_col,
-                        is_open ? ((flags & ImGuiTreeNodeFlags_UpsideDownArrow) ? ImGuiDir_Up
-                                                                                : ImGuiDir_Down)
-                                : ImGuiDir_Right,
-                        1.0f);
-        else  // Leaf without bullet, left-adjusted text
-            text_pos.x -= text_offset_x - padding.x;
-        if (flags & ImGuiTreeNodeFlags_ClipLabelForTrailingButton)
-            frame_bb.Max.x -= g.FontSize + style.FramePadding.x;
-
-        if (g.LogEnabled)
-            LogSetNextTextDecoration("###", "###");
-    } else {
-        // Unframed typed for tree nodes
-        if (hovered || selected || focused) {
-            const ImU32 bg_col = GetColorU32((held && hovered)    ? ImGuiCol_HeaderActive
-                                             : hovered || focused ? ImGuiCol_HeaderHovered
-                                                                  : ImGuiCol_Header);
-            RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, false);
+    {
+        const ImU32 text_col                       = GetColorU32(ImGuiCol_Text);
+        ImGuiNavHighlightFlags nav_highlight_flags = ImGuiNavHighlightFlags_Compact;
+        if (is_multi_select)
+            nav_highlight_flags |=
+                ImGuiNavHighlightFlags_AlwaysDraw;  // Always show the nav rectangle
+        if (display_frame) {
+            // Framed type
+            const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive
+                                             : hovered         ? ImGuiCol_HeaderHovered
+                                                               : ImGuiCol_Header);
+            RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, true, style.FrameRounding);
+            RenderNavHighlight(frame_bb, id, nav_highlight_flags);
+            if (flags & ImGuiTreeNodeFlags_Bullet)
+                RenderBullet(
+                    window->DrawList,
+                    ImVec2(text_pos.x - text_offset_x * 0.60f, text_pos.y + g.FontSize * 0.5f),
+                    text_col);
+            else if (!is_leaf)
+                RenderArrow(window->DrawList,
+                            ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y), text_col,
+                            is_open ? ((flags & ImGuiTreeNodeFlags_UpsideDownArrow) ? ImGuiDir_Up
+                                                                                    : ImGuiDir_Down)
+                                    : ImGuiDir_Right,
+                            1.0f);
+            else  // Leaf without bullet, left-adjusted text
+                text_pos.x -= text_offset_x - padding.x;
+            if (flags & ImGuiTreeNodeFlags_ClipLabelForTrailingButton)
+                frame_bb.Max.x -= g.FontSize + style.FramePadding.x;
+            if (g.LogEnabled)
+                LogSetNextTextDecoration("###", "###");
+        } else {
+            // Unframed typed for tree nodes
+            if (hovered || selected || focused) {
+                const ImU32 bg_col = GetColorU32((held && hovered)    ? ImGuiCol_HeaderActive
+                                                 : hovered || focused ? ImGuiCol_HeaderHovered
+                                                                      : ImGuiCol_Header);
+                RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, false);
+            }
+            RenderNavHighlight(frame_bb, id, nav_highlight_flags);
+            if (flags & ImGuiTreeNodeFlags_Bullet)
+                RenderBullet(
+                    window->DrawList,
+                    ImVec2(text_pos.x - text_offset_x * 0.5f, text_pos.y + g.FontSize * 0.5f),
+                    text_col);
+            else if (!is_leaf)
+                RenderArrow(
+                    window->DrawList,
+                    ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y + g.FontSize * 0.15f),
+                    text_col,
+                    is_open ? ((flags & ImGuiTreeNodeFlags_UpsideDownArrow) ? ImGuiDir_Up
+                                                                            : ImGuiDir_Down)
+                            : ImGuiDir_Right,
+                    0.70f);
+            if (g.LogEnabled)
+                LogSetNextTextDecoration(">", NULL);
         }
-        RenderNavHighlight(frame_bb, id, nav_highlight_flags);
-        if (flags & ImGuiTreeNodeFlags_Bullet)
-            RenderBullet(window->DrawList,
-                         ImVec2(text_pos.x - text_offset_x * 0.5f, text_pos.y + g.FontSize * 0.5f),
-                         text_col);
-        else if (!is_leaf)
-            RenderArrow(
-                window->DrawList,
-                ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y + g.FontSize * 0.15f),
-                text_col,
-                is_open
-                    ? ((flags & ImGuiTreeNodeFlags_UpsideDownArrow) ? ImGuiDir_Up : ImGuiDir_Down)
-                    : ImGuiDir_Right,
-                0.70f);
-        if (g.LogEnabled)
-            LogSetNextTextDecoration(">", NULL);
-    }
 
-    if (span_all_columns)
-        TablePopBackgroundChannel();
+        if (span_all_columns)
+            TablePopBackgroundChannel();
 
-    // Label
-    if (display_frame)
-        RenderTextClipped(text_pos, frame_bb.Max, label, label_end, &label_size);
-    else
-        RenderText(text_pos, label, label_end, false);
+        // Label
+        if (display_frame)
+            RenderTextClipped(text_pos, frame_bb.Max, label, label_end, &label_size);
+        else
+            RenderText(text_pos, label, label_end, false);
+    }
 
+    if (store_tree_node_stack_data && is_open)
+        TreeNodeStoreStackData(flags);  // Call before TreePushOverrideID()
     if (is_open && !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))
-        TreePushOverrideID(id);
+        TreePushOverrideID(id);  // Could use TreePush(label) but this avoid computing twice
+
     IMGUI_TEST_ENGINE_ITEM_INFO(id, label,
                                 g.LastItemData.StatusFlags |
                                     (is_leaf ? 0 : ImGuiItemStatusFlags_Openable) |
@@ -829,25 +887,30 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
 
 bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *label,
                              const char *label_end, bool focused, bool *visible) {
-    ImGuiWindow *window = ImGui::GetCurrentWindow();
+    ImGuiWindow *window = GetCurrentWindow();
     if (window->SkipItems)
         return false;
 
-    const float row_y = ImGui::GetCursorPosY();
-
     ImGuiContext &g          = *GImGui;
     const ImGuiStyle &style  = g.Style;
     const bool display_frame = (flags & ImGuiTreeNodeFlags_Framed) != 0;
-    ImVec2 padding           = (display_frame || (flags & ImGuiTreeNodeFlags_FramePadding))
-                                   ? style.FramePadding
-                                   : ImVec2(style.FramePadding.x,
-                                            ImMin(window->DC.CurrLineTextBaseOffset, style.FramePadding.y));
-    padding.y *= 1.2f;
+    const ImVec2 padding =
+        (display_frame || (flags & ImGuiTreeNodeFlags_FramePadding))
+            ? style.FramePadding
+            : ImVec2(style.FramePadding.x,
+                     ImMin(window->DC.CurrLineTextBaseOffset, style.FramePadding.y));
 
     if (!label_end)
-        label_end = ImGui::FindRenderedTextEnd(label);
-    const ImVec2 label_size = ImGui::CalcTextSize(label, label_end, false);
-    const ImVec2 eye_size   = ImGui::CalcTextSize(ICON_FK_EYE, nullptr, false);
+        label_end = FindRenderedTextEnd(label);
+    const ImVec2 label_size = CalcTextSize(label, label_end, false);
+    const ImVec2 eye_size   = CalcTextSize(ICON_FK_EYE, nullptr, false);
+
+    const float text_offset_x =
+        g.FontSize +
+        (display_frame ? padding.x * 3 : padding.x * 2);  // Collapsing arrow width + Spacing
+    const float text_offset_y =
+        ImMax(padding.y, window->DC.CurrLineTextBaseOffset);  // Latch before ItemSize changes it
+    const float text_width = g.FontSize + label_size.x + padding.x * 2;  // Include collapsing arrow
 
     // We vertically grow up to current line height up the typical widget height.
     const float frame_height =
@@ -860,87 +923,81 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
                      : (flags & ImGuiTreeNodeFlags_SpanFullWidth) ? window->WorkRect.Min.x
                                                                   : window->DC.CursorPos.x;
     frame_bb.Min.y = window->DC.CursorPos.y;
-    frame_bb.Max.x = span_all_columns ? window->ParentWorkRect.Max.x : window->WorkRect.Max.x;
+    frame_bb.Max.x = span_all_columns ? window->ParentWorkRect.Max.x
+                     : (flags & ImGuiTreeNodeFlags_SpanTextWidth)
+                         ? window->DC.CursorPos.x + text_width + padding.x
+                         : window->WorkRect.Max.x;
     frame_bb.Max.y = window->DC.CursorPos.y + frame_height;
     if (display_frame) {
-        // Framed header expand a little outside the default padding, to the edge of
-        // InnerClipRect (FIXME: May remove this at some point and make InnerClipRect align with
-        // WindowPadding.x instead of WindowPadding.x*0.5f)
-        frame_bb.Min.x -= IM_TRUNC(window->WindowPadding.x * 0.5f - 1.0f);
-        frame_bb.Max.x += IM_TRUNC(window->WindowPadding.x * 0.5f);
+        const float outer_extend =
+            IM_TRUNC(window->WindowPadding.x *
+                     0.5f);  // Framed header expand a little outside of current limits
+        frame_bb.Min.x -= outer_extend;
+        frame_bb.Max.x += outer_extend;
     }
 
-    const float text_offset_x =
-        g.FontSize +
-        (display_frame ? padding.x * 3 : padding.x * 2);  // Collapsing arrow width + Spacing
-    const float text_offset_y =
-        ImMax(padding.y, window->DC.CurrLineTextBaseOffset);  // Latch before ItemSize changes it
-    const float text_width = g.FontSize + (label_size.x > 0.0f ? label_size.x + padding.x * 2
-                                                               : 0.0f);  // Include collapsing
-    ImVec2 text_pos(window->DC.CursorPos.x + text_offset_x + label_size.y * 1.5f,
-                    window->DC.CursorPos.y + text_offset_y);
     ImVec2 eye_pos(frame_bb.Min.x + padding.x, window->DC.CursorPos.y);
 
-    ImGui::ItemSize(ImVec2(text_width, frame_height), padding.y);
+    ImVec2 text_pos(window->DC.CursorPos.x + text_offset_x, window->DC.CursorPos.y + text_offset_y);
+    ItemSize(ImVec2(text_width, frame_height), padding.y);
 
     ImRect eye_interact_bb = frame_bb;
     eye_interact_bb.Max.x  = frame_bb.Min.x + eye_size.x + style.ItemSpacing.x;
 
     // For regular tree nodes, we arbitrary allow to click past 2 worth of ItemSpacing
     ImRect interact_bb = frame_bb;
-    if (!display_frame &&
-        (flags & (ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_SpanFullWidth |
+    if ((flags & (ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_SpanAvailWidth |
+                  ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_SpanTextWidth |
                   ImGuiTreeNodeFlags_SpanAllColumns)) == 0)
-        interact_bb.Max.x = frame_bb.Min.x + text_width + style.ItemSpacing.x * 2.0f;
-    interact_bb.Min.x += eye_size.x + style.TouchExtraPadding.x;
+        interact_bb.Max.x =
+            frame_bb.Min.x + text_width + (label_size.x > 0.0f ? style.ItemSpacing.x * 2.0f : 0.0f);
+
+    // Compute open and multi-select states before ItemAdd() as it clear NextItem data.
+    ImGuiID storage_id = (g.NextItemData.Flags & ImGuiNextItemDataFlags_HasStorageID)
+                             ? g.NextItemData.StorageId
+                             : id;
+    bool is_open       = TreeNodeUpdateNextOpen(storage_id, flags);
 
-    // Modify ClipRect for the ItemAdd(), faster than doing a
-    // PushColumnsBackground/PushTableBackgroundChannel for every Selectable..
-    const float backup_clip_rect_min_x = window->ClipRect.Min.x;
-    const float backup_clip_rect_max_x = window->ClipRect.Max.x;
+    bool is_visible;
     if (span_all_columns) {
-        window->ClipRect.Min.x = window->ParentWorkRect.Min.x;
-        window->ClipRect.Max.x = window->ParentWorkRect.Max.x;
+        // Modify ClipRect for the ItemAdd(), faster than doing a
+        // PushColumnsBackground/PushTableBackgroundChannel for every Selectable..
+        const float backup_clip_rect_min_x = window->ClipRect.Min.x;
+        const float backup_clip_rect_max_x = window->ClipRect.Max.x;
+        window->ClipRect.Min.x             = window->ParentWorkRect.Min.x;
+        window->ClipRect.Max.x             = window->ParentWorkRect.Max.x;
+        is_visible                         = ItemAdd(interact_bb, id);
+        window->ClipRect.Min.x             = backup_clip_rect_min_x;
+        window->ClipRect.Max.x             = backup_clip_rect_max_x;
+    } else {
+        is_visible = ItemAdd(interact_bb, id);
     }
 
-    // ImGui::SetActiveID(0, ImGui::GetCurrentWindow());
-    ImGuiID eye_interact_id = ImGui::GetID("eye_button##internal");
-    ImGui::ItemAdd(eye_interact_bb, eye_interact_id);
+    ImGuiID eye_interact_id = GetID("eye_button##internal");
+    ItemAdd(eye_interact_bb, eye_interact_id);
 
-    // Compute open and multi-select states before ItemAdd() as it clear NextItem data.
-    bool is_open  = ImGui::TreeNodeUpdateNextOpen(id, flags);
-    bool item_add = ImGui::ItemAdd(interact_bb, id);
     g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_HasDisplayRect;
     g.LastItemData.DisplayRect = frame_bb;
 
-    if (span_all_columns) {
-        window->ClipRect.Min.x = backup_clip_rect_min_x;
-        window->ClipRect.Max.x = backup_clip_rect_max_x;
-    }
-
     // If a NavLeft request is happening and ImGuiTreeNodeFlags_NavLeftJumpsBackHere enabled:
     // Store data for the current depth to allow returning to this node from any child item.
-    // For this purpose we essentially compare if g.NavIdIsAlive went from 0 to 1 between
-    // TreeNode() and TreePop(). It will become tempting to enable
-    // ImGuiTreeNodeFlags_NavLeftJumpsBackHere by default or move it to ImGuiStyle. Currently
-    // only supports 32 level deep and we are fine with (1 << Depth) overflowing into a zero,
-    // easy to increase.
-    if (is_open && !g.NavIdIsAlive && (flags & ImGuiTreeNodeFlags_NavLeftJumpsBackHere) &&
-        !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))
-        if (g.NavMoveDir == ImGuiDir_Left && g.NavWindow == window &&
-            ImGui::NavMoveRequestButNoResultYet()) {
-            g.NavTreeNodeStack.resize(g.NavTreeNodeStack.Size + 1);
-            ImGuiNavTreeNodeData *nav_tree_node_data = &g.NavTreeNodeStack.back();
-            nav_tree_node_data->ID                   = id;
-            nav_tree_node_data->InFlags              = g.LastItemData.InFlags;
-            nav_tree_node_data->NavRect              = g.LastItemData.NavRect;
-            window->DC.TreeJumpToParentOnPopMask |= (1 << window->DC.TreeDepth);
-        }
+    // For this purpose we essentially compare if g.NavIdIsAlive went from 0 to 1 between TreeNode()
+    // and TreePop(). It will become tempting to enable ImGuiTreeNodeFlags_NavLeftJumpsBackHere by
+    // default or move it to ImGuiStyle.
+    bool store_tree_node_stack_data = false;
+    if (!(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen)) {
+        if ((flags & ImGuiTreeNodeFlags_NavLeftJumpsBackHere) && is_open && !g.NavIdIsAlive)
+            if (g.NavMoveDir == ImGuiDir_Left && g.NavWindow == window &&
+                NavMoveRequestButNoResultYet())
+                store_tree_node_stack_data = true;
+    }
 
     const bool is_leaf = (flags & ImGuiTreeNodeFlags_Leaf) != 0;
-    if (!item_add) {
+    if (!is_visible) {
+        if (store_tree_node_stack_data && is_open)
+            TreeNodeStoreStackData(flags);  // Call before TreePushOverrideID()
         if (is_open && !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))
-            ImGui::TreePushOverrideID(id);
+            TreePushOverrideID(id);
         IMGUI_TEST_ENGINE_ITEM_INFO(g.LastItemData.ID, label,
                                     g.LastItemData.StatusFlags |
                                         (is_leaf ? 0 : ImGuiItemStatusFlags_Openable) |
@@ -948,8 +1005,11 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
         return is_open;
     }
 
-    if (span_all_columns)
-        ImGui::TablePushBackgroundChannel();
+    if (span_all_columns) {
+        TablePushBackgroundChannel();
+        g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_HasClipRect;
+        g.LastItemData.ClipRect = window->ClipRect;
+    }
 
     const float eye_hit_x1 = eye_pos.x - style.TouchExtraPadding.x;
     const float eye_hit_x2 = eye_pos.x + (eye_size.x) + style.TouchExtraPadding.x;
@@ -978,15 +1038,19 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
 
     // We allow clicking on the arrow section with keyboard modifiers held, in order to easily
     // allow browsing a tree while preserving selection with code implementing multi-selection
-    // patterns. When clicking on the rest of the tree node we always disallow keyboard
-    // modifiers.
+    // patterns. When clicking on the rest of the tree node we always disallow keyboard modifiers.
     const float arrow_hit_x1 = (text_pos.x - text_offset_x) - style.TouchExtraPadding.x;
     const float arrow_hit_x2 =
         (text_pos.x - text_offset_x) + (g.FontSize + padding.x * 2.0f) + style.TouchExtraPadding.x;
     const bool is_mouse_x_over_arrow =
         (g.IO.MousePos.x >= arrow_hit_x1 && g.IO.MousePos.x < arrow_hit_x2);
-    if (window != g.HoveredWindow || !is_mouse_x_over_arrow)
-        button_flags |= ImGuiButtonFlags_NoKeyModifiers;
+
+    const bool is_multi_select = (g.LastItemData.InFlags & ImGuiItemFlags_IsMultiSelect) != 0;
+    if (is_multi_select)  // We absolutely need to distinguish open vs select so _OpenOnArrow comes
+                          // by default
+        flags |= (flags & ImGuiTreeNodeFlags_OpenOnMask_) == 0
+                     ? ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick
+                     : ImGuiTreeNodeFlags_OpenOnArrow;
 
     // Open behaviors can be altered with the _OpenOnArrow and _OnOnDoubleClick flags.
     // Some alteration have subtle effects (e.g. toggle on MouseUp vs MouseDown events) due to
@@ -996,9 +1060,9 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
     // - Single-click on arrow = Toggle on MouseDown (when _OpenOnArrow=1)
     // - Double-click on label = Toggle on MouseDoubleClick (when _OpenOnDoubleClick=1)
     // - Double-click on arrow = Toggle on MouseDoubleClick (when _OpenOnDoubleClick=1 and
-    // _OpenOnArrow=0) It is rather standard that arrow click react on Down rather than Up. We
-    // set ImGuiButtonFlags_PressedOnClickRelease on OpenOnDoubleClick because we want the item
-    // to be active on the initial MouseDown in order for drag and drop to work.
+    // _OpenOnArrow=0) It is rather standard that arrow click react on Down rather than Up. We set
+    // ImGuiButtonFlags_PressedOnClickRelease on OpenOnDoubleClick because we want the item to be
+    // active on the initial MouseDown in order for drag and drop to work.
     if (is_mouse_x_over_arrow)
         button_flags |= ImGuiButtonFlags_PressedOnClick;
     else if (flags & ImGuiTreeNodeFlags_OpenOnDoubleClick)
@@ -1010,138 +1074,152 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
     bool selected           = (flags & ImGuiTreeNodeFlags_Selected) != 0;
     const bool was_selected = selected;
 
+    // Multi-selection support (header)
+    if (is_multi_select) {
+        // Handle multi-select + alter button flags for it
+        MultiSelectItemHeader(id, &selected, &button_flags);
+        if (is_mouse_x_over_arrow)
+            button_flags = (button_flags | ImGuiButtonFlags_PressedOnClick) &
+                           ~ImGuiButtonFlags_PressedOnClickRelease;
+    } else {
+        if (window != g.HoveredWindow || !is_mouse_x_over_arrow)
+            button_flags |= ImGuiButtonFlags_NoKeyModifiers;
+    }
+
     bool hovered, held;
-    bool pressed = ImGui::ButtonBehavior(interact_bb, id, &hovered, &held, button_flags);
+    bool pressed = ButtonBehavior(interact_bb, id, &hovered, &held, button_flags);
     bool toggled = false;
     if (!is_leaf) {
         if (pressed && g.DragDropHoldJustPressedId != id) {
-            if ((flags & (ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_OpenOnDoubleClick)) ==
-                    0 ||
-                (g.NavActivateId == id))
-                toggled = true;
+            if ((flags & ImGuiTreeNodeFlags_OpenOnMask_) == 0 ||
+                (g.NavActivateId == id && !is_multi_select))
+                toggled = true;  // Single click
             if (flags & ImGuiTreeNodeFlags_OpenOnArrow)
                 toggled |=
                     is_mouse_x_over_arrow &&
                     !g.NavDisableMouseHover;  // Lightweight equivalent of IsMouseHoveringRect()
                                               // since ButtonBehavior() already did the job
             if ((flags & ImGuiTreeNodeFlags_OpenOnDoubleClick) && g.IO.MouseClickedCount[0] == 2)
-                toggled = true;
+                toggled = true;  // Double click
         } else if (pressed && g.DragDropHoldJustPressedId == id) {
             IM_ASSERT(button_flags & ImGuiButtonFlags_PressedOnDragDropHold);
-            if (!is_open)  // When using Drag and Drop "hold to open" we keep the node
-                           // highlighted after opening, but never close it again.
+            if (!is_open)  // When using Drag and Drop "hold to open" we keep the node highlighted
+                           // after opening, but never close it again.
                 toggled = true;
+            else
+                pressed = false;  // Cancel press so it doesn't trigger selection.
         }
 
         if (g.NavId == id && g.NavMoveDir == ImGuiDir_Left && is_open) {
             toggled = true;
-            ImGui::NavClearPreferredPosForAxis(ImGuiAxis_X);
-            ImGui::NavMoveRequestCancel();
+            NavClearPreferredPosForAxis(ImGuiAxis_X);
+            NavMoveRequestCancel();
         }
         if (g.NavId == id && g.NavMoveDir == ImGuiDir_Right &&
             !is_open)  // If there's something upcoming on the line we may want to give it the
                        // priority?
         {
             toggled = true;
-            ImGui::NavClearPreferredPosForAxis(ImGuiAxis_X);
-            ImGui::NavMoveRequestCancel();
+            NavClearPreferredPosForAxis(ImGuiAxis_X);
+            NavMoveRequestCancel();
         }
 
         if (toggled) {
             is_open = !is_open;
-            window->DC.StateStorage->SetInt(id, is_open);
+            window->DC.StateStorage->SetInt(storage_id, is_open);
             g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_ToggledOpen;
         }
     }
 
-    // In this branch, TreeNodeBehavior() cannot toggle the selection so this will never
-    // trigger.
-    if (selected != was_selected)  //-V547
+    // Multi-selection support (footer)
+    if (is_multi_select) {
+        bool pressed_copy = pressed && !toggled;
+        MultiSelectItemFooter(id, &selected, &pressed_copy);
+        if (pressed)
+            SetNavID(id, window->DC.NavLayerCurrent, g.CurrentFocusScopeId, interact_bb);
+    }
+
+    if (selected != was_selected)
         g.LastItemData.StatusFlags |= ImGuiItemStatusFlags_ToggledSelection;
 
     // Render
-    const ImU32 text_col                       = ImGui::GetColorU32(ImGuiCol_Text);
-    ImGuiNavHighlightFlags nav_highlight_flags = ImGuiNavHighlightFlags_Compact;
-    if (display_frame) {
-        // Framed type
-        const ImU32 bg_col = ImGui::GetColorU32((held && hovered) ? ImGuiCol_HeaderActive
-                                                : hovered         ? ImGuiCol_HeaderHovered
-                                                                  : ImGuiCol_Header);
-        ImGui::RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, true, style.FrameRounding);
-        ImGui::RenderNavHighlight(frame_bb, id, nav_highlight_flags);
-
-        if (flags & ImGuiTreeNodeFlags_Bullet)
-            ImGui::RenderBullet(
-                window->DrawList,
-                ImVec2(text_pos.x - text_offset_x * 0.60f, text_pos.y + g.FontSize * 0.5f),
-                text_col);
-        else if (!is_leaf)
-            ImGui::RenderArrow(
-                window->DrawList, ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y),
-                text_col,
-                is_open
-                    ? ((flags & ImGuiTreeNodeFlags_UpsideDownArrow) ? ImGuiDir_Up : ImGuiDir_Down)
-                    : ImGuiDir_Right,
-                1.0f);
-        else  // Leaf without bullet, left-adjusted text
-            text_pos.x -= text_offset_x - padding.x;
-        if (flags & ImGuiTreeNodeFlags_ClipLabelForTrailingButton)
-            frame_bb.Max.x -= g.FontSize + style.FramePadding.x;
-
-        if (g.LogEnabled)
-            ImGui::LogSetNextTextDecoration("###", "###");
-    } else {
-        // Unframed typed for tree nodes
-        if (hovered || selected || focused) {
-            const ImU32 bg_col = ImGui::GetColorU32((held && hovered)    ? ImGuiCol_HeaderActive
-                                                    : hovered || focused ? ImGuiCol_HeaderHovered
-                                                                         : ImGuiCol_Header);
-            ImGui::RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, false);
+    {
+        const ImU32 text_col                       = GetColorU32(ImGuiCol_Text);
+        ImGuiNavHighlightFlags nav_highlight_flags = ImGuiNavHighlightFlags_Compact;
+        if (is_multi_select)
+            nav_highlight_flags |=
+                ImGuiNavHighlightFlags_AlwaysDraw;  // Always show the nav rectangle
+        if (display_frame) {
+            // Framed type
+            const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive
+                                             : hovered         ? ImGuiCol_HeaderHovered
+                                                               : ImGuiCol_Header);
+            RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, true, style.FrameRounding);
+            RenderNavHighlight(frame_bb, id, nav_highlight_flags);
+            if (flags & ImGuiTreeNodeFlags_Bullet)
+                RenderBullet(
+                    window->DrawList,
+                    ImVec2(text_pos.x - text_offset_x * 0.60f, text_pos.y + g.FontSize * 0.5f),
+                    text_col);
+            else if (!is_leaf)
+                RenderArrow(window->DrawList,
+                            ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y), text_col,
+                            is_open ? ((flags & ImGuiTreeNodeFlags_UpsideDownArrow) ? ImGuiDir_Up
+                                                                                    : ImGuiDir_Down)
+                                    : ImGuiDir_Right,
+                            1.0f);
+            else  // Leaf without bullet, left-adjusted text
+                text_pos.x -= text_offset_x - padding.x;
+            if (flags & ImGuiTreeNodeFlags_ClipLabelForTrailingButton)
+                frame_bb.Max.x -= g.FontSize + style.FramePadding.x;
+            if (g.LogEnabled)
+                LogSetNextTextDecoration("###", "###");
+        } else {
+            // Unframed typed for tree nodes
+            if (hovered || selected || focused) {
+                const ImU32 bg_col = GetColorU32((held && hovered)    ? ImGuiCol_HeaderActive
+                                                 : hovered || focused ? ImGuiCol_HeaderHovered
+                                                                      : ImGuiCol_Header);
+                RenderFrame(frame_bb.Min, frame_bb.Max, bg_col, false);
+            }
+            RenderNavHighlight(frame_bb, id, nav_highlight_flags);
+            if (flags & ImGuiTreeNodeFlags_Bullet)
+                RenderBullet(
+                    window->DrawList,
+                    ImVec2(text_pos.x - text_offset_x * 0.5f, text_pos.y + g.FontSize * 0.5f),
+                    text_col);
+            else if (!is_leaf)
+                RenderArrow(
+                    window->DrawList,
+                    ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y + g.FontSize * 0.15f),
+                    text_col,
+                    is_open ? ((flags & ImGuiTreeNodeFlags_UpsideDownArrow) ? ImGuiDir_Up
+                                                                            : ImGuiDir_Down)
+                            : ImGuiDir_Right,
+                    0.70f);
+            if (g.LogEnabled)
+                LogSetNextTextDecoration(">", NULL);
         }
-        ImGui::RenderNavHighlight(frame_bb, id, nav_highlight_flags);
-
-        if (flags & ImGuiTreeNodeFlags_Bullet)
-            ImGui::RenderBullet(
-                window->DrawList,
-                ImVec2(text_pos.x - text_offset_x * 0.5f, text_pos.y + g.FontSize * 0.5f),
-                text_col);
-        else if (!is_leaf)
-            ImGui::RenderArrow(
-                window->DrawList,
-                ImVec2(text_pos.x - text_offset_x + padding.x, text_pos.y + g.FontSize * 0.15f),
-                text_col,
-                is_open
-                    ? ((flags & ImGuiTreeNodeFlags_UpsideDownArrow) ? ImGuiDir_Up : ImGuiDir_Down)
-                    : ImGuiDir_Right,
-                0.70f);
-        if (g.LogEnabled)
-            ImGui::LogSetNextTextDecoration(">", NULL);
-    }
-
-    if (span_all_columns)
-        ImGui::TablePopBackgroundChannel();
 
-    // Label
-    if (display_frame)
-        ImGui::RenderTextClipped(text_pos, frame_bb.Max, label, label_end, &label_size);
-    else
-        ImGui::RenderText(text_pos, label, label_end, false);
-
-    ImGui::PushStyleColor(ImGuiCol_Button, {0, 0, 0, 0});
-    ImGui::PushStyleColor(ImGuiCol_ButtonActive, {0, 0, 0, 0});
-    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, {0, 0, 0, 0});
+        if (span_all_columns)
+            TablePopBackgroundChannel();
 
-    ImGui::RenderText(eye_pos, *visible ? ICON_FK_EYE : ICON_FK_EYE_SLASH, nullptr, false);
-
-    ImGui::PopStyleColor(3);
+        // Label
+        if (display_frame)
+            RenderTextClipped(text_pos, frame_bb.Max, label, label_end, &label_size);
+        else
+            RenderText(text_pos, label, label_end, false);
+    }
 
+    if (store_tree_node_stack_data && is_open)
+        TreeNodeStoreStackData(flags);  // Call before TreePushOverrideID()
     if (is_open && !(flags & ImGuiTreeNodeFlags_NoTreePushOnOpen))
-        ImGui::TreePushOverrideID(id);
+        TreePushOverrideID(id);  // Could use TreePush(label) but this avoid computing twice
+
     IMGUI_TEST_ENGINE_ITEM_INFO(id, label,
                                 g.LastItemData.StatusFlags |
                                     (is_leaf ? 0 : ImGuiItemStatusFlags_Openable) |
                                     (is_open ? ImGuiItemStatusFlags_Opened : 0));
-
     return is_open;
 }
 
@@ -1325,8 +1403,8 @@ bool ImGui::IsDragDropSource(ImGuiDragDropFlags flags) {
     return source_drag_active;
 }
 
-
-void ImGui::RenderDragDropTargetRect(const ImRect &bb, const ImRect &item_clip_rect, ImGuiDropFlags flags) {
+void ImGui::RenderDragDropTargetRect(const ImRect &bb, const ImRect &item_clip_rect,
+                                     ImGuiDropFlags flags) {
     ImGuiContext &g     = *GImGui;
     ImGuiWindow *window = g.CurrentWindow;
     ImRect bb_display   = bb;
@@ -1339,7 +1417,8 @@ void ImGui::RenderDragDropTargetRect(const ImRect &bb, const ImRect &item_clip_r
 
     if (flags == ImGuiDropFlags_None || flags == ImGuiDropFlags_InsertChild) {
         window->DrawList->AddRect(bb_display.Min, bb_display.Max,
-                                  GetColorU32(ImGuiCol_DragDropTarget), 0.0f, ImDrawFlags_None, 2.0f);
+                                  GetColorU32(ImGuiCol_DragDropTarget), 0.0f, ImDrawFlags_None,
+                                  2.0f);
     } else if (flags == ImGuiDropFlags_InsertBefore) {
         float y = bb_display.Min.y;
         window->DrawList->AddLine(ImVec2(bb_display.Min.x, y), ImVec2(bb_display.Max.x, y),
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 87c3e890..63bc1b1a 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -68,10 +68,9 @@ namespace Toolbox::UI {
                         ImVec2 pos = ImGui::GetCursorScreenPos();
                         pos.x += std::max<float>(36.0f - (text_size.x / 2.0f), 0.0);
                         pos.y += 72.0f;
-                        //pos.x += i * size.x / 4.0f;
 
                         ImGui::RenderTextEllipsis(
-                            ImGui::GetWindowDrawList(), pos, pos + ImVec2(72, 20), pos.x + 72.0f,
+                            ImGui::GetWindowDrawList(), pos, pos + ImVec2(64, 20), pos.x + 64.0f,
                             pos.x + 76.0f, m_view_proxy.getDisplayText(child_index).c_str(),
                             nullptr, nullptr);
                     }
@@ -80,7 +79,7 @@ namespace Toolbox::UI {
                     // ImGui::Text("%s", m_view_proxy.getDisplayText(child_index).c_str());
 
                     if ((i + 1) % x_count != 0) {
-                        ImGui::SameLine(i * size.x / 4.0f);
+                        ImGui::SameLine();
                     }
                 }
 
@@ -112,7 +111,7 @@ namespace Toolbox::UI {
             if (m_tree_proxy.canFetchMore(index)) {
                 m_tree_proxy.fetchMore(index);
             }
-            is_open = ImGui::TreeNodeEx(m_tree_proxy.getPath(index).filename().string().c_str(),
+            is_open = ImGui::TreeNodeEx(m_tree_proxy.getDisplayText(index).c_str(),
                                         ImGuiTreeNodeFlags_OpenOnArrow);
             if (is_open) {
                 for (size_t i = 0; i < m_tree_proxy.getRowCount(index); ++i) {
@@ -124,7 +123,7 @@ namespace Toolbox::UI {
                 ImGui::TreePop();
             }
         } else {
-            if (ImGui::TreeNodeEx(m_tree_proxy.getPath(index).filename().string().c_str(),
+            if (ImGui::TreeNodeEx(m_tree_proxy.getDisplayText(index).c_str(),
                                   ImGuiTreeNodeFlags_Leaf)) {
                 ImGui::TreePop();
             }
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 389d4af9..a83bc593 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -21,6 +21,7 @@ namespace Toolbox {
 
         Type m_type = Type::UNKNOWN;
         fs_path m_path;
+        std::string m_name;
         size_t m_size = 0;
         Filesystem::file_time_type m_date;
 
@@ -31,7 +32,7 @@ namespace Toolbox {
         }
 
         std::strong_ordering operator<=>(const _FileSystemIndexData &rhs) const {
-            return m_path <=> rhs.m_path;
+            return m_self_uuid <=> rhs.m_self_uuid;
         }
     };
 
@@ -57,9 +58,9 @@ namespace Toolbox {
 
         // Sort by name
         if (order == ModelSortOrder::SORT_ASCENDING) {
-            return lhs.m_path < rhs.m_path;
+            return lhs.m_name < rhs.m_name;
         } else {
-            return lhs.m_path > rhs.m_path;
+            return lhs.m_name > rhs.m_name;
         }
     }
 
@@ -178,7 +179,7 @@ namespace Toolbox {
             if (!validateIndex(index)) {
                 return "Invalid";
             }
-            return index.data<_FileSystemIndexData>()->m_path.filename().string();
+            return index.data<_FileSystemIndexData>()->m_name;
         case ModelDataRole::DATA_ROLE_TOOLTIP:
             return "Tooltip unimplemented!";
         case ModelDataRole::DATA_ROLE_DECORATION: {
@@ -194,7 +195,8 @@ namespace Toolbox {
 
             Filesystem::file_time_type result = Filesystem::file_time_type();
 
-            Filesystem::last_write_time(index.data<_FileSystemIndexData>()->m_path)
+            fs_path path = getPath(index);
+            Filesystem::last_write_time(path)
                 .and_then([&](Filesystem::file_time_type &&time) {
                     result = std::move(time);
                     return Result<Filesystem::file_time_type, FSError>();
@@ -214,7 +216,8 @@ namespace Toolbox {
 
             Filesystem::file_status result = Filesystem::file_status();
 
-            Filesystem::status(index.data<_FileSystemIndexData>()->m_path)
+            fs_path path = getPath(index);
+            Filesystem::status(path)
                 .and_then([&](Filesystem::file_status &&status) {
                     result = std::move(status);
                     return Result<Filesystem::file_status, FSError>();
@@ -240,7 +243,12 @@ namespace Toolbox {
                 return TypeMap().at("_Archive").m_name;
             }
 
-            std::string ext = index.data<_FileSystemIndexData>()->m_path.extension().string();
+            std::string name = index.data<_FileSystemIndexData>()->m_name;
+            std::string ext  = "";
+            if (size_t epos = name.find('.'); epos != std::string::npos) {
+                ext = name.substr(epos);
+            }
+
             if (ext.empty()) {
                 return TypeMap().at("_Folder").m_name;
             }
@@ -264,7 +272,8 @@ namespace Toolbox {
         bool result = false;
 
         if (isDirectory(parent)) {
-            fs_path path = parent.data<_FileSystemIndexData>()->m_path / name;
+            fs_path path = getPath(parent);
+            path /= name;
             Filesystem::create_directory(path)
                 .and_then([&](bool created) {
                     if (!created) {
@@ -332,11 +341,11 @@ namespace Toolbox {
         bool result = false;
 
         if (isDirectory(index)) {
-            Filesystem::remove_all(index.data<_FileSystemIndexData>()->m_path)
+            Filesystem::remove_all(getPath(index))
                 .and_then([&](bool removed) {
                     if (!removed) {
                         TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove directory: {}",
-                                        index.data<_FileSystemIndexData>()->m_path.string());
+                                        getPath(index).string());
                         return Result<bool, FSError>();
                     }
                     result = true;
@@ -348,11 +357,11 @@ namespace Toolbox {
                     return Result<bool, FSError>();
                 });
         } else if (isArchive(index)) {
-            Filesystem::remove(index.data<_FileSystemIndexData>()->m_path)
+            Filesystem::remove(getPath(index))
                 .and_then([&](bool removed) {
                     if (!removed) {
                         TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove archive: {}",
-                                        index.data<_FileSystemIndexData>()->m_path.string());
+                                        getPath(index).string());
                         return Result<bool, FSError>();
                     }
                     result = true;
@@ -390,11 +399,11 @@ namespace Toolbox {
         bool result = false;
 
         if (isFile(index)) {
-            Filesystem::remove(index.data<_FileSystemIndexData>()->m_path)
+            Filesystem::remove(getPath(index))
                 .and_then([&](bool removed) {
                     if (!removed) {
                         TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove file: {}",
-                                        index.data<_FileSystemIndexData>()->m_path.string());
+                                        getPath(index).string());
                         return Result<bool, FSError>();
                     }
                     result = true;
@@ -432,7 +441,7 @@ namespace Toolbox {
         }
 
         for (const auto &[uuid, index] : m_index_map) {
-            if (index.data<_FileSystemIndexData>()->m_path == path) {
+            if (getPath(index) == path) {
                 return index;
             }
         }
@@ -440,7 +449,12 @@ namespace Toolbox {
         return ModelIndex();
     }
 
-    ModelIndex FileSystemModel::getIndex(const UUID64 &uuid) const { return m_index_map.at(uuid); }
+    ModelIndex FileSystemModel::getIndex(const UUID64 &uuid) const {
+        if (m_index_map.find(uuid) == m_index_map.end()) {
+            return ModelIndex();
+        }
+        return m_index_map.at(uuid);
+    }
 
     ModelIndex FileSystemModel::getIndex(int64_t row, int64_t column,
                                          const ModelIndex &parent) const {
@@ -539,7 +553,7 @@ namespace Toolbox {
         }
 
         if (isDirectory(index)) {
-            fs_path path = index.data<_FileSystemIndexData>()->m_path;
+            fs_path path = getPath(index);
 
             size_t i = 0;
             for (const auto &entry : Filesystem::directory_iterator(path)) {
@@ -616,7 +630,9 @@ namespace Toolbox {
 
         _FileSystemIndexData *data = new _FileSystemIndexData;
         data->m_path               = path;
+        data->m_name               = path.filename().string();
         data->m_size               = 0;
+        data->m_children           = {};
 
         if (Filesystem::is_directory(path).value_or(false)) {
             data->m_type = _FileSystemIndexData::Type::DIRECTORY;
@@ -718,8 +734,7 @@ namespace Toolbox {
 
         if (isDirectory(index)) {
             // Count the children in the filesystem
-            for (const auto &entry :
-                 Filesystem::directory_iterator(index.data<_FileSystemIndexData>()->m_path)) {
+            for (const auto &entry : Filesystem::directory_iterator(getPath(index))) {
                 count += 1;
             }
         } else if (isArchive(index)) {
@@ -847,9 +862,7 @@ namespace Toolbox {
     ModelIndex FileSystemModelSortFilterProxy::getIndex(int64_t row, int64_t column,
                                                         const ModelIndex &parent) const {
         ModelIndex parent_src = toSourceIndex(parent);
-
-        ModelIndex index = m_source_model->getIndex(row, column, parent_src);
-        return toProxyIndex(index);
+        return toProxyIndex(row, column, parent_src);
     }
 
     fs_path FileSystemModelSortFilterProxy::getPath(const ModelIndex &index) const {
@@ -919,78 +932,99 @@ namespace Toolbox {
     }
 
     ModelIndex FileSystemModelSortFilterProxy::toProxyIndex(const ModelIndex &index) const {
-        if (validateIndex(index)) {
-            return index;
-        }
-
         if (!m_source_model->validateIndex(index)) {
             return ModelIndex();
         }
 
-        const ModelIndex &parent = m_source_model->getParent(index);
-        if (!m_source_model->validateIndex(parent)) {
-            ModelIndex proxy_index = ModelIndex(getUUID());
-            proxy_index.setData(index.data<_FileSystemIndexData>());
-            return proxy_index;
+        ModelIndex proxy_index = ModelIndex(getUUID());
+        proxy_index.setData(index.data<_FileSystemIndexData>());
+        return proxy_index;
+    }
+
+    ModelIndex FileSystemModelSortFilterProxy::toProxyIndex(int64_t row, int64_t column,
+                                                            const ModelIndex &src_parent) const {
+        std::vector<UUID64> filtered_children = {};
+
+        if (!m_source_model->validateIndex(src_parent)) {
+            size_t i          = 0;
+            ModelIndex root_s = m_source_model->getIndex(i++, 0);
+            while (m_source_model->validateIndex(root_s)) {
+                filtered_children.push_back(root_s.getUUID());
+                root_s = m_source_model->getIndex(i++, 0);
+            }
+        } else {
+            const std::vector<UUID64> &children =
+                src_parent.data<_FileSystemIndexData>()->m_children;
+            if (children.empty()) {
+                return ModelIndex();
+            }
+
+            filtered_children = children;
         }
 
-        std::vector<UUID64> children = parent.data<_FileSystemIndexData>()->m_children;
-        if (children.empty()) {
+        if (row >= filtered_children.size()) {
             return ModelIndex();
         }
 
         switch (m_sort_role) {
         case FileSystemModelSortRole::SORT_ROLE_NAME: {
-            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
-                return _FileSystemIndexDataCompareByName(
-                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
-                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
-            });
+            std::sort(filtered_children.begin(), filtered_children.end(),
+                      [&](const UUID64 &lhs, const UUID64 &rhs) {
+                          return _FileSystemIndexDataCompareByName(
+                              *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                              *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(),
+                              m_sort_order);
+                      });
             break;
         }
         case FileSystemModelSortRole::SORT_ROLE_SIZE: {
-            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
-                return _FileSystemIndexDataCompareBySize(
-                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
-                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
-            });
+            std::sort(filtered_children.begin(), filtered_children.end(),
+                      [&](const UUID64 &lhs, const UUID64 &rhs) {
+                          return _FileSystemIndexDataCompareBySize(
+                              *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                              *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(),
+                              m_sort_order);
+                      });
             break;
         }
         case FileSystemModelSortRole::SORT_ROLE_DATE:
-            std::sort(children.begin(), children.end(), [&](const UUID64 &lhs, const UUID64 &rhs) {
-                return _FileSystemIndexDataCompareByDate(
-                    *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
-                    *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(), m_sort_order);
-            });
+            std::sort(filtered_children.begin(), filtered_children.end(),
+                      [&](const UUID64 &lhs, const UUID64 &rhs) {
+                          return _FileSystemIndexDataCompareByDate(
+                              *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
+                              *m_source_model->getIndex(rhs).data<_FileSystemIndexData>(),
+                              m_sort_order);
+                      });
             break;
         default:
             break;
         }
 
-        for (size_t i = 0; i < children.size(); i++) {
-            if (isFiltered(children[i])) {
+        size_t i = 0;
+        for (const UUID64 &uuid : filtered_children) {
+            if (isFiltered(uuid)) {
                 continue;
             }
-
-            if (children[i] == index.getUUID()) {
-                ModelIndex proxy_index = ModelIndex(getUUID());
-                proxy_index.setData(index.data<_FileSystemIndexData>());
-                return proxy_index;
+            if (i++ == row) {
+                ModelIndex src_index = m_source_model->getIndex(uuid);
+                return toProxyIndex(src_index);
             }
         }
 
-        // Should never reach here
         return ModelIndex();
     }
 
     bool FileSystemModelSortFilterProxy::isFiltered(const UUID64 &uuid) const {
         ModelIndex child_index = m_source_model->getIndex(uuid);
-        if (isDirsOnly() && m_source_model->isFile(child_index)) {
+        bool is_file =
+            child_index.data<_FileSystemIndexData>()->m_type == _FileSystemIndexData::Type::FILE;
+
+        if (isDirsOnly() && is_file) {
             return true;
         }
 
-        fs_path path = child_index.data<_FileSystemIndexData>()->m_path;
-        return !path.filename().string().starts_with(m_filter);
+        const std::string &name = child_index.data<_FileSystemIndexData>()->m_name;
+        return !name.starts_with(m_filter);
     }
 
 }  // namespace Toolbox
\ No newline at end of file

From 59534ee1878bb2644cfaecf5ee1d4c1695d3d4b1 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Thu, 12 Sep 2024 23:35:30 -0500
Subject: [PATCH 012/129] Memory leak exists in proxy model

---
 include/gui/project/window.hpp |   1 +
 include/model/fsmodel.hpp      |  10 +-
 src/gui/project/window.cpp     |  25 +++--
 src/image/imagehandle.cpp      |   1 +
 src/model/fsmodel.cpp          | 191 ++++++++++++++++++++++-----------
 vcpkg.json                     |   2 +-
 6 files changed, 153 insertions(+), 77 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 453f9bac..95fd05a1 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -82,6 +82,7 @@ namespace Toolbox::UI {
         [[nodiscard]] bool onLoadData(const std::filesystem::path& path) override {
             m_project_root = path;
             m_file_system_model = make_referable<FileSystemModel>();
+            m_file_system_model->initialize();
             m_file_system_model->setRoot(m_project_root);
             m_tree_proxy.setSourceModel(m_file_system_model);
             m_tree_proxy.setDirsOnly(true);
diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index a0577a0d..4bca060d 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -49,6 +49,8 @@ namespace Toolbox {
         FileSystemModel()  = default;
         ~FileSystemModel() = default;
 
+        void initialize();
+
         [[nodiscard]] UUID64 getUUID() const override { return m_uuid; }
 
         [[nodiscard]] const fs_path &getRoot() const &;
@@ -138,6 +140,7 @@ namespace Toolbox {
         UUID64 m_root_index;
 
         mutable std::unordered_map<UUID64, ModelIndex> m_index_map;
+        mutable std::unordered_map<std::string, RefPtr<const ImageHandle>> m_icon_map;
     };
 
     class FileSystemModelSortFilterProxy : public IDataModel {
@@ -206,13 +209,15 @@ namespace Toolbox {
         [[nodiscard]] bool canFetchMore(const ModelIndex &index);
         void fetchMore(const ModelIndex &index);
 
-    protected:
         [[nodiscard]] ModelIndex toSourceIndex(const ModelIndex &index) const;
         [[nodiscard]] ModelIndex toProxyIndex(const ModelIndex &index) const;
+
+    protected:
         [[nodiscard]] ModelIndex toProxyIndex(int64_t row, int64_t column,
                                               const ModelIndex &parent = ModelIndex()) const;
 
         [[nodiscard]] bool isFiltered(const UUID64 &uuid) const;
+        void cacheIndex(const ModelIndex &index) const;
 
         ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent) {
             return ModelIndex();
@@ -227,6 +232,9 @@ namespace Toolbox {
         std::string m_filter                   = "";
 
         bool m_dirs_only = false;
+
+        mutable std::unordered_map<UUID64, bool> m_filter_map;
+        mutable std::unordered_map<UUID64, std::vector<int64_t>> m_row_map;
     };
 
 }  // namespace Toolbox
\ No newline at end of file
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 63bc1b1a..108f3a4a 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -1,8 +1,8 @@
 #include "gui/project/window.hpp"
 #include "model/fsmodel.hpp"
 
-#include <imgui/imgui.h>
 #include <cmath>
+#include <imgui/imgui.h>
 
 namespace Toolbox::UI {
 
@@ -30,15 +30,15 @@ namespace Toolbox::UI {
     }
 
     void ProjectViewWindow::renderProjectFolderView() {
-        if (!m_view_proxy.validateIndex(m_view_index)) {
+        if (!m_file_system_model->validateIndex(m_view_index)) {
             return;
         }
 
         if (ImGui::BeginChild("Folder View", {0, 0}, true,
                               ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
-            if (m_view_proxy.hasChildren(m_view_index)) {
-                if (m_view_proxy.canFetchMore(m_view_index)) {
-                    m_view_proxy.fetchMore(m_view_index);
+            if (m_file_system_model->hasChildren(m_view_index)) {
+                if (m_file_system_model->canFetchMore(m_view_index)) {
+                    m_file_system_model->fetchMore(m_view_index);
                 }
 
                 ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {2, 2});
@@ -53,16 +53,16 @@ namespace Toolbox::UI {
                     x_count = 1;
                 }
 
-                for (size_t i = 0; i < m_view_proxy.getRowCount(m_view_index); ++i) {
-                    ModelIndex child_index = m_view_proxy.getIndex(i, 0, m_view_index);
+                for (size_t i = 0; i < m_file_system_model->getRowCount(m_view_index); ++i) {
+                    ModelIndex child_index = m_file_system_model->getIndex(i, 0, m_view_index);
 
                     if (ImGui::BeginChild(child_index.getUUID(), {76, 92}, true,
                                           ImGuiWindowFlags_ChildWindow |
                                               ImGuiWindowFlags_NoDecoration)) {
 
-                        m_icon_painter.render(*m_view_proxy.getDecoration(child_index), {72, 72});
+                        m_icon_painter.render(*m_file_system_model->getDecoration(child_index), {72, 72});
 
-                        std::string text = m_view_proxy.getDisplayText(child_index);
+                        std::string text = m_file_system_model->getDisplayText(child_index);
                         ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
 
                         ImVec2 pos = ImGui::GetCursorScreenPos();
@@ -71,7 +71,7 @@ namespace Toolbox::UI {
 
                         ImGui::RenderTextEllipsis(
                             ImGui::GetWindowDrawList(), pos, pos + ImVec2(64, 20), pos.x + 64.0f,
-                            pos.x + 76.0f, m_view_proxy.getDisplayText(child_index).c_str(),
+                            pos.x + 76.0f, m_file_system_model->getDisplayText(child_index).c_str(),
                             nullptr, nullptr);
                     }
                     ImGui::EndChild();
@@ -113,6 +113,11 @@ namespace Toolbox::UI {
             }
             is_open = ImGui::TreeNodeEx(m_tree_proxy.getDisplayText(index).c_str(),
                                         ImGuiTreeNodeFlags_OpenOnArrow);
+
+            if (ImGui::IsItemClicked()) {
+                m_view_index = m_tree_proxy.toSourceIndex(index);
+            }
+
             if (is_open) {
                 for (size_t i = 0; i < m_tree_proxy.getRowCount(index); ++i) {
                     ModelIndex child_index = m_tree_proxy.getIndex(i, 0, index);
diff --git a/src/image/imagehandle.cpp b/src/image/imagehandle.cpp
index 487e3041..1a3b1d4a 100644
--- a/src/image/imagehandle.cpp
+++ b/src/image/imagehandle.cpp
@@ -118,6 +118,7 @@ namespace Toolbox {
     }
 
     void ImageHandle::moveGL(ImageHandle &&image) {
+        unloadGL();
         m_image_handle       = image.m_image_handle;
         m_image_format       = image.m_image_format;
         m_image_width        = image.m_image_width;
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index a83bc593..ece9ba7e 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -110,6 +110,22 @@ namespace Toolbox {
         }
     }
 
+    void FileSystemModel::initialize() {
+        m_icon_map.clear();
+        m_index_map.clear();
+        m_root_path  = fs_path();
+        m_root_index = 0;
+        m_options    = FileSystemModelOptions();
+        m_read_only  = false;
+
+        fs_path fs_icon_path =
+            GUIApplication::instance().getResourcePath("Images/Icons/Filesystem/");
+
+        for (auto &[key, value] : TypeMap()) {
+            m_icon_map[key] = make_referable<const ImageHandle>(fs_icon_path / value.m_image_name);
+        }
+    }
+
     const fs_path &FileSystemModel::getRoot() const & { return m_root_path; }
 
     void FileSystemModel::setRoot(const fs_path &path) {
@@ -384,8 +400,9 @@ namespace Toolbox {
                                                           parent_data->m_children.end(),
                                                           index.getUUID()),
                                               parent_data->m_children.end());
-                m_index_map.erase(index.getUUID());
             }
+            delete index.data<_FileSystemIndexData>();
+            m_index_map.erase(index.getUUID());
         }
 
         return result;
@@ -428,8 +445,9 @@ namespace Toolbox {
                                                           parent_data->m_children.end(),
                                                           index.getUUID()),
                                               parent_data->m_children.end());
-                m_index_map.erase(index.getUUID());
             }
+            delete index.data<_FileSystemIndexData>();
+            m_index_map.erase(index.getUUID());
         }
 
         return result;
@@ -449,12 +467,7 @@ namespace Toolbox {
         return ModelIndex();
     }
 
-    ModelIndex FileSystemModel::getIndex(const UUID64 &uuid) const {
-        if (m_index_map.find(uuid) == m_index_map.end()) {
-            return ModelIndex();
-        }
-        return m_index_map.at(uuid);
-    }
+    ModelIndex FileSystemModel::getIndex(const UUID64 &uuid) const { return m_index_map.at(uuid); }
 
     ModelIndex FileSystemModel::getIndex(int64_t row, int64_t column,
                                          const ModelIndex &parent) const {
@@ -668,23 +681,17 @@ namespace Toolbox {
             std::string ext = data->m_path.extension().string();
 
             if (!validateIndex(index)) {
-                data->m_icon = make_referable<const ImageHandle>(
-                    fs_icon_path / TypeMap().at("_Invalid").m_image_name);
+                data->m_icon = m_icon_map["_Invalid"];
             } else if (data->m_type == _FileSystemIndexData::Type::DIRECTORY) {
-                data->m_icon = make_referable<const ImageHandle>(
-                    fs_icon_path / TypeMap().at("_Folder").m_image_name);
+                data->m_icon = m_icon_map["_Folder"];
             } else if (data->m_type == _FileSystemIndexData::Type::ARCHIVE) {
-                data->m_icon = make_referable<const ImageHandle>(
-                    fs_icon_path / TypeMap().at("_Archive").m_image_name);
+                data->m_icon = m_icon_map["_Archive"];
             } else if (ext.empty()) {
-                data->m_icon = make_referable<const ImageHandle>(
-                    fs_icon_path / TypeMap().at("_Folder").m_image_name);
-            } else if (TypeMap().find(ext) == TypeMap().end()) {
-                data->m_icon = make_referable<const ImageHandle>(
-                    fs_icon_path / TypeMap().at("_File").m_image_name);
+                data->m_icon = m_icon_map["_Folder"];
+            } else if (m_icon_map.find(ext) == m_icon_map.end()) {
+                data->m_icon = m_icon_map["_File"];
             } else {
-                data->m_icon = make_referable<const ImageHandle>(fs_icon_path /
-                                                                 TypeMap().at(ext).m_image_name);
+                data->m_icon = m_icon_map[ext];
             }
         }
 
@@ -708,11 +715,6 @@ namespace Toolbox {
         return index;
     }
 
-    void FileSystemModel::cacheIndex(ModelIndex &index) {}
-    void FileSystemModel::cacheFolder(ModelIndex &index) {}
-    void FileSystemModel::cacheFile(ModelIndex &index) {}
-    void FileSystemModel::cacheArchive(ModelIndex &index) {}
-
     ModelIndex FileSystemModel::getParentArchive(const ModelIndex &index) const {
         ModelIndex parent = getParent(index);
         do {
@@ -866,19 +868,36 @@ namespace Toolbox {
     }
 
     fs_path FileSystemModelSortFilterProxy::getPath(const ModelIndex &index) const {
-        ModelIndex &&source_index = toSourceIndex(index);
+        ModelIndex source_index = toSourceIndex(index);
         return m_source_model->getPath(std::move(source_index));
     }
 
     ModelIndex FileSystemModelSortFilterProxy::getParent(const ModelIndex &index) const {
-        ModelIndex &&source_index = toSourceIndex(index);
+        ModelIndex source_index = toSourceIndex(index);
         return toProxyIndex(m_source_model->getParent(std::move(source_index)));
     }
 
     ModelIndex FileSystemModelSortFilterProxy::getSibling(int64_t row, int64_t column,
                                                           const ModelIndex &index) const {
-        ModelIndex &&source_index = toSourceIndex(index);
-        return toProxyIndex(m_source_model->getSibling(row, column, source_index));
+        ModelIndex source_index       = toSourceIndex(index);
+        ModelIndex src_parent         = getParent(source_index);
+        const UUID64 &src_parent_uuid = src_parent.getUUID();
+
+        u64 map_key = src_parent_uuid;
+        if (!m_source_model->validateIndex(src_parent)) {
+            map_key = 0;
+        }
+
+        if (m_row_map.find(map_key) == m_row_map.end()) {
+            cacheIndex(src_parent);
+        }
+
+        if (row < m_row_map[map_key].size()) {
+            int64_t the_row = m_row_map[map_key][row];
+            return toProxyIndex(m_source_model->getIndex(the_row, column, src_parent));
+        }
+
+        return ModelIndex();
     }
 
     size_t FileSystemModelSortFilterProxy::getColumnCount(const ModelIndex &index) const {
@@ -888,6 +907,11 @@ namespace Toolbox {
 
     size_t FileSystemModelSortFilterProxy::getRowCount(const ModelIndex &index) const {
         ModelIndex &&source_index = toSourceIndex(index);
+
+        if (m_row_map.find(source_index.getUUID()) != m_row_map.end()) {
+            return m_row_map[source_index.getUUID()].size();
+        }
+
         return m_source_model->getRowCount(source_index);
     }
 
@@ -943,32 +967,83 @@ namespace Toolbox {
 
     ModelIndex FileSystemModelSortFilterProxy::toProxyIndex(int64_t row, int64_t column,
                                                             const ModelIndex &src_parent) const {
-        std::vector<UUID64> filtered_children = {};
+        const UUID64 &src_parent_uuid = src_parent.getUUID();
 
+        u64 map_key = src_parent_uuid;
         if (!m_source_model->validateIndex(src_parent)) {
+            map_key = 0;
+        }
+
+        if (m_row_map.find(map_key) == m_row_map.end()) {
+            cacheIndex(src_parent);
+        }
+
+        if (row < m_row_map[map_key].size()) {
+            int64_t the_row = m_row_map[map_key][row];
+            return toProxyIndex(m_source_model->getIndex(the_row, column, src_parent));
+        }
+
+        return ModelIndex();
+    }
+
+    bool FileSystemModelSortFilterProxy::isFiltered(const UUID64 &uuid) const {
+        ModelIndex child_index = m_source_model->getIndex(uuid);
+        bool is_file =
+            child_index.data<_FileSystemIndexData>()->m_type == _FileSystemIndexData::Type::FILE;
+
+        if (isDirsOnly() && is_file) {
+            return true;
+        }
+
+        const std::string &name = child_index.data<_FileSystemIndexData>()->m_name;
+        return !name.starts_with(m_filter);
+    }
+
+    void FileSystemModelSortFilterProxy::cacheIndex(const ModelIndex &dir_index) const {
+        std::vector<UUID64> orig_children  = {};
+        std::vector<UUID64> proxy_children = {};
+
+        const UUID64 &src_parent_uuid = dir_index.getUUID();
+
+        u64 map_key = src_parent_uuid;
+        if (!m_source_model->validateIndex(dir_index)) {
+            map_key = 0;
+        }
+
+        if (m_row_map.find(map_key) != m_row_map.end()) {
+            return;
+        }
+
+        if (!m_source_model->validateIndex(dir_index)) {
             size_t i          = 0;
             ModelIndex root_s = m_source_model->getIndex(i++, 0);
             while (m_source_model->validateIndex(root_s)) {
-                filtered_children.push_back(root_s.getUUID());
+                orig_children.push_back(root_s.getUUID());
+                if (isFiltered(root_s.getUUID())) {
+                    root_s = m_source_model->getIndex(i++, 0);
+                    continue;
+                }
+                proxy_children.push_back(root_s.getUUID());
                 root_s = m_source_model->getIndex(i++, 0);
             }
         } else {
-            const std::vector<UUID64> &children =
-                src_parent.data<_FileSystemIndexData>()->m_children;
-            if (children.empty()) {
-                return ModelIndex();
+            orig_children = dir_index.data<_FileSystemIndexData>()->m_children;
+            if (orig_children.empty()) {
+                return;
             }
 
-            filtered_children = children;
+            std::copy_if(orig_children.begin(), orig_children.end(),
+                         std::back_inserter(proxy_children),
+                         [&](const UUID64 &uuid) { return !isFiltered(uuid); });
         }
 
-        if (row >= filtered_children.size()) {
-            return ModelIndex();
+        if (proxy_children.empty()) {
+            return;
         }
 
         switch (m_sort_role) {
         case FileSystemModelSortRole::SORT_ROLE_NAME: {
-            std::sort(filtered_children.begin(), filtered_children.end(),
+            std::sort(proxy_children.begin(), proxy_children.end(),
                       [&](const UUID64 &lhs, const UUID64 &rhs) {
                           return _FileSystemIndexDataCompareByName(
                               *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
@@ -978,7 +1053,7 @@ namespace Toolbox {
             break;
         }
         case FileSystemModelSortRole::SORT_ROLE_SIZE: {
-            std::sort(filtered_children.begin(), filtered_children.end(),
+            std::sort(proxy_children.begin(), proxy_children.end(),
                       [&](const UUID64 &lhs, const UUID64 &rhs) {
                           return _FileSystemIndexDataCompareBySize(
                               *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
@@ -988,7 +1063,7 @@ namespace Toolbox {
             break;
         }
         case FileSystemModelSortRole::SORT_ROLE_DATE:
-            std::sort(filtered_children.begin(), filtered_children.end(),
+            std::sort(proxy_children.begin(), proxy_children.end(),
                       [&](const UUID64 &lhs, const UUID64 &rhs) {
                           return _FileSystemIndexDataCompareByDate(
                               *m_source_model->getIndex(lhs).data<_FileSystemIndexData>(),
@@ -1000,31 +1075,17 @@ namespace Toolbox {
             break;
         }
 
-        size_t i = 0;
-        for (const UUID64 &uuid : filtered_children) {
-            if (isFiltered(uuid)) {
-                continue;
-            }
-            if (i++ == row) {
-                ModelIndex src_index = m_source_model->getIndex(uuid);
-                return toProxyIndex(src_index);
+        // Build the row map
+        m_row_map[map_key] = {};
+        m_row_map[map_key].resize(proxy_children.size());
+        for (size_t i = 0; i < proxy_children.size(); i++) {
+            for (size_t j = 0; j < orig_children.size(); j++) {
+                if (proxy_children[i] == orig_children[j]) {
+                    m_row_map[map_key][i] = j;
+                    break;
+                }
             }
         }
-
-        return ModelIndex();
-    }
-
-    bool FileSystemModelSortFilterProxy::isFiltered(const UUID64 &uuid) const {
-        ModelIndex child_index = m_source_model->getIndex(uuid);
-        bool is_file =
-            child_index.data<_FileSystemIndexData>()->m_type == _FileSystemIndexData::Type::FILE;
-
-        if (isDirsOnly() && is_file) {
-            return true;
-        }
-
-        const std::string &name = child_index.data<_FileSystemIndexData>()->m_name;
-        return !name.starts_with(m_filter);
     }
 
 }  // namespace Toolbox
\ No newline at end of file
diff --git a/vcpkg.json b/vcpkg.json
index a462341a..0087cda5 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -4,5 +4,5 @@
   "dependencies": [
     "libiconv"
   ],
-  "builtin-baseline": "5016afa7ed49f8bac5dc801555b7d6af9fe79f58"
+  "builtin-baseline": "036916f2ca7fbf3effec439119500da00ae478dd"
 }
\ No newline at end of file

From 7e6081118b7dd39e3f638f5f3e8c8ac28ea557ee Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Wed, 18 Sep 2024 09:21:35 -0700
Subject: [PATCH 013/129] Fix missing return on loadProjectFolder

---
 src/project/project.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/project/project.cpp b/src/project/project.cpp
index 7ae7cd92..9fd8540b 100644
--- a/src/project/project.cpp
+++ b/src/project/project.cpp
@@ -31,6 +31,8 @@ namespace Toolbox {
 
             return Result<bool, FSError>();
         });
+
+        return true;
     }
 
     fs_path ProjectManager::getProjectFolder() const { return m_project_folder; }

From cd8383a7623b5d11e81c18d9af00496c232a0048 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Wed, 18 Sep 2024 10:32:44 -0700
Subject: [PATCH 014/129] Oops don't crash on empty dolphin paths

---
 src/dolphin/hook.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/dolphin/hook.cpp b/src/dolphin/hook.cpp
index 101e3558..42ee9dbf 100644
--- a/src/dolphin/hook.cpp
+++ b/src/dolphin/hook.cpp
@@ -180,8 +180,12 @@ namespace Toolbox::Dolphin {
 
         std::string dolphin_path = settings.m_dolphin_path.string();
         size_t last_not_null = dolphin_path.find_last_not_of('\000');
-        std::string used_substr = dolphin_path.substr(last_not_null - 5, last_not_null);
-        if (!used_substr.starts_with("-nogui"sv)){
+        bool is_nogui = false;
+        if (last_not_null != std::string::npos && last_not_null > 5) {
+          std::string used_substr = dolphin_path.substr(last_not_null - 5, last_not_null);
+          is_nogui = used_substr.starts_with("-nogui"sv);
+        }
+        if (!is_nogui){
           dolphin_args += "-d -c";
         }
 #ifdef TOOLBOX_PLATFORM_LINUX

From cd6bea5100edec8abd36ecf40d719deef0fd52de Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Wed, 18 Sep 2024 11:34:29 -0700
Subject: [PATCH 015/129] Type this buffer to fix some valgrind warnings

---
 include/core/memory.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/core/memory.hpp b/include/core/memory.hpp
index c7d5e4d3..d6c7e27e 100644
--- a/include/core/memory.hpp
+++ b/include/core/memory.hpp
@@ -81,7 +81,7 @@ namespace Toolbox {
             if (m_buf && size == m_size) {
                 return;
             }
-            void *new_buf = new u8[size];
+            byte_t *new_buf = new byte_t[size];
             if (m_buf && m_size > 0) {
                 memcpy(new_buf, m_buf, std::min(size, m_size));
                 delete[] m_buf;
@@ -98,9 +98,9 @@ namespace Toolbox {
         template <typename T = void> const T *buf() const { return reinterpret_cast<T *>(m_buf); }
 
         void setBuf(void *buf, size_t size) {
-            if (m_buf != buf) {
+            if (m_buf != (byte_t*)buf) {
                 free();
-                m_buf      = buf;
+                m_buf      = (byte_t*)buf;
                 m_owns_buf = false;
             }
             m_size = size;
@@ -152,7 +152,7 @@ namespace Toolbox {
         bool operator==(const Buffer &other) { return m_buf == other.m_buf; }
 
     private:
-        void *m_buf     = nullptr;
+        byte_t *m_buf   = nullptr;
         size_t m_size   = 0;
         bool m_owns_buf = true;
     };

From 5d5922167a8b08834ddf2ec21e860d06507499e2 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 19 Sep 2024 12:55:22 -0700
Subject: [PATCH 016/129] Fix memory leak of ModelIndex user data

---
 include/model/fsmodel.hpp | 2 +-
 src/model/fsmodel.cpp     | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index 4bca060d..e540e136 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -47,7 +47,7 @@ namespace Toolbox {
 
     public:
         FileSystemModel()  = default;
-        ~FileSystemModel() = default;
+        ~FileSystemModel();
 
         void initialize();
 
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index ece9ba7e..3a4f5645 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -110,6 +110,12 @@ namespace Toolbox {
         }
     }
 
+    FileSystemModel::~FileSystemModel() {
+        for (auto &[key, value] : m_index_map) {
+            delete value.data<_FileSystemIndexData>();
+        }
+    }
+
     void FileSystemModel::initialize() {
         m_icon_map.clear();
         m_index_map.clear();

From 1ddca44749d7328e6baeab84456a80842099080f Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 19 Sep 2024 13:50:37 -0700
Subject: [PATCH 017/129] Try reverting libiconv version upgrade to fix CI
 error

---
 vcpkg.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vcpkg.json b/vcpkg.json
index 0087cda5..a462341a 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -4,5 +4,5 @@
   "dependencies": [
     "libiconv"
   ],
-  "builtin-baseline": "036916f2ca7fbf3effec439119500da00ae478dd"
+  "builtin-baseline": "5016afa7ed49f8bac5dc801555b7d6af9fe79f58"
 }
\ No newline at end of file

From 14f182b3f8da4607e607d97816c547c6842969d3 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 20 Sep 2024 12:42:15 -0700
Subject: [PATCH 018/129] Remove dead code in fsmodel.cpp

The fs_icon_path variable is never used in this function, and
validateIndex is called at the top of the function and won't let the
rest run if it returns false.
---
 src/model/fsmodel.cpp | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 3a4f5645..b42dcea6 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -193,27 +193,15 @@ namespace Toolbox {
             return {};
         }
 
-        fs_path fs_icon_path =
-            GUIApplication::instance().getResourcePath("Images/Icons/Filesystem/");
-
         switch (role) {
         case ModelDataRole::DATA_ROLE_DISPLAY:
-            if (!validateIndex(index)) {
-                return "Invalid";
-            }
             return index.data<_FileSystemIndexData>()->m_name;
         case ModelDataRole::DATA_ROLE_TOOLTIP:
             return "Tooltip unimplemented!";
         case ModelDataRole::DATA_ROLE_DECORATION: {
-            if (!validateIndex(index)) {
-                return RefPtr<ImageHandle>(nullptr);
-            }
             return index.data<_FileSystemIndexData>()->m_icon;
         }
         case FileSystemDataRole::FS_DATA_ROLE_DATE: {
-            if (!validateIndex(index)) {
-                return Filesystem::file_time_type();
-            }
 
             Filesystem::file_time_type result = Filesystem::file_time_type();
 
@@ -232,9 +220,6 @@ namespace Toolbox {
             return result;
         }
         case FileSystemDataRole::FS_DATA_ROLE_STATUS: {
-            if (!validateIndex(index)) {
-                return Filesystem::file_status();
-            }
 
             Filesystem::file_status result = Filesystem::file_status();
 
@@ -253,9 +238,6 @@ namespace Toolbox {
             return result;
         }
         case FileSystemDataRole::FS_DATA_ROLE_TYPE: {
-            if (!validateIndex(index)) {
-                return TypeMap().at("_Invalid").m_name;
-            }
 
             if (isDirectory(index)) {
                 return TypeMap().at("_Folder").m_name;

From 9008c951c403cf236ec478b5ef804b6858049e6c Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 20 Sep 2024 13:01:36 -0700
Subject: [PATCH 019/129] Small reuse of a variable

---
 src/gui/project/window.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 108f3a4a..20bbe336 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -71,7 +71,7 @@ namespace Toolbox::UI {
 
                         ImGui::RenderTextEllipsis(
                             ImGui::GetWindowDrawList(), pos, pos + ImVec2(64, 20), pos.x + 64.0f,
-                            pos.x + 76.0f, m_file_system_model->getDisplayText(child_index).c_str(),
+                            pos.x + 76.0f, text.c_str(),
                             nullptr, nullptr);
                     }
                     ImGui::EndChild();

From 115530a03a0c1143c16132af4bc71f93f4f0b248 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 20 Sep 2024 14:40:57 -0700
Subject: [PATCH 020/129] Allow entering folders through double click in folder
 view (project)

---
 include/gui/project/window.hpp |  1 +
 src/gui/project/window.cpp     | 25 ++++++++++++++++++++++++-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 95fd05a1..8bd7653f 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -41,6 +41,7 @@ namespace Toolbox::UI {
         void renderProjectFolderButton();
         void renderProjectFileButton();
 
+        bool isViewedAncestor(const ModelIndex &index);
         void renderFolderTree(const ModelIndex &index);
         void initFolderAssets(const ModelIndex &index);
 
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 20bbe336..7d9dad3c 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -68,6 +68,11 @@ namespace Toolbox::UI {
                         ImVec2 pos = ImGui::GetCursorScreenPos();
                         pos.x += std::max<float>(36.0f - (text_size.x / 2.0f), 0.0);
                         pos.y += 72.0f;
+                        if (ImGui::IsMouseDoubleClicked(0) &&
+                            ImGui::IsItemHovered(ImGuiHoveredFlags_None) &&
+                            m_file_system_model->isDirectory(child_index)) {
+                            m_view_index = m_tree_proxy.toSourceIndex(child_index);
+                        }
 
                         ImGui::RenderTextEllipsis(
                             ImGui::GetWindowDrawList(), pos, pos + ImVec2(64, 20), pos.x + 64.0f,
@@ -105,14 +110,32 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {}
 
+    bool ProjectViewWindow::isViewedAncestor(const ModelIndex &index) {
+        if (m_view_index == m_tree_proxy.toSourceIndex(index)) {
+            return true;
+        }
+        for (size_t i = 0; i < m_tree_proxy.getRowCount(index); ++i) {
+            ModelIndex child_index = m_tree_proxy.getIndex(i, 0, index);
+            if (isViewedAncestor(child_index)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     void ProjectViewWindow::renderFolderTree(const ModelIndex &index) {
         bool is_open = false;
         if (m_tree_proxy.hasChildren(index)) {
             if (m_tree_proxy.canFetchMore(index)) {
                 m_tree_proxy.fetchMore(index);
             }
+            ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_OpenOnArrow;
+
+            if (isViewedAncestor(index)) {
+                flags |= ImGuiTreeNodeFlags_DefaultOpen;
+            }
             is_open = ImGui::TreeNodeEx(m_tree_proxy.getDisplayText(index).c_str(),
-                                        ImGuiTreeNodeFlags_OpenOnArrow);
+                                        flags);
 
             if (ImGui::IsItemClicked()) {
                 m_view_index = m_tree_proxy.toSourceIndex(index);

From 73cf5eda1e013cf62f1e02d337227e6967a46ff1 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 20 Sep 2024 14:41:27 -0700
Subject: [PATCH 021/129] Add an indicator of which tree folder is open in
 folder view

---
 src/gui/project/window.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 7d9dad3c..6587863f 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -131,6 +131,9 @@ namespace Toolbox::UI {
             }
             ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_OpenOnArrow;
 
+            if (m_view_index == m_tree_proxy.toSourceIndex(index)){
+                flags |= ImGuiTreeNodeFlags_Selected;
+            }
             if (isViewedAncestor(index)) {
                 flags |= ImGuiTreeNodeFlags_DefaultOpen;
             }

From 30bff8a9fcc014e46b47719e4b3bb68fbf470c28 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 20 Sep 2024 14:42:21 -0700
Subject: [PATCH 022/129] Add selection of items in folder view

Is just visual so far though, can't do anything with it.
---
 include/gui/project/window.hpp |  1 +
 src/gui/project/window.cpp     | 14 ++++++++++++++
 2 files changed, 15 insertions(+)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 8bd7653f..9c3e211e 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -114,6 +114,7 @@ namespace Toolbox::UI {
         std::vector<ModelIndex> m_selected_indices;
         std::vector<ProjectAsset> m_view_assets;
         ModelIndex m_view_index;
+        ModelIndex m_selected_index;
 
         std::unordered_map<std::string, ImageHandle> m_icon_map;
         ImagePainter m_icon_painter;
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 6587863f..0385d61d 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -56,6 +56,13 @@ namespace Toolbox::UI {
                 for (size_t i = 0; i < m_file_system_model->getRowCount(m_view_index); ++i) {
                     ModelIndex child_index = m_file_system_model->getIndex(i, 0, m_view_index);
 
+                    if (m_selected_index == m_tree_proxy.toSourceIndex(child_index)){
+                        ImGui::PushStyleColor(ImGuiCol_ChildBg, ImGui::ColorConvertFloat4ToU32(ImGui::GetStyleColorVec4(ImGuiCol_TabSelected)));
+                    } else {
+                        ImGui::PushStyleColor(ImGuiCol_ChildBg,
+                                              ImGui::ColorConvertFloat4ToU32(ImGui::GetStyleColorVec4(ImGuiCol_ChildBg)));
+
+                    }
                     if (ImGui::BeginChild(child_index.getUUID(), {76, 92}, true,
                                           ImGuiWindowFlags_ChildWindow |
                                               ImGuiWindowFlags_NoDecoration)) {
@@ -73,6 +80,12 @@ namespace Toolbox::UI {
                             m_file_system_model->isDirectory(child_index)) {
                             m_view_index = m_tree_proxy.toSourceIndex(child_index);
                         }
+                        else if (ImGui::IsItemClicked()) {
+                            m_selected_index = m_tree_proxy.toSourceIndex(child_index);
+                        } else if (ImGui::IsMouseClicked(0) &&
+                                   m_selected_index == m_tree_proxy.toSourceIndex(child_index)) {
+                            m_selected_index = ModelIndex();
+                        }
 
                         ImGui::RenderTextEllipsis(
                             ImGui::GetWindowDrawList(), pos, pos + ImVec2(64, 20), pos.x + 64.0f,
@@ -80,6 +93,7 @@ namespace Toolbox::UI {
                             nullptr, nullptr);
                     }
                     ImGui::EndChild();
+                    ImGui::PopStyleColor(1);
 
                     // ImGui::Text("%s", m_view_proxy.getDisplayText(child_index).c_str());
 

From 6cca6bbe9f46ba792389af491704fcabb8bbf9a9 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 20 Sep 2024 15:19:19 -0700
Subject: [PATCH 023/129] Add multi-select

Also, it turns out there was already a member variable for tracking
the selection, so remove the one I added and use that instead.
---
 include/gui/project/window.hpp |  1 -
 src/gui/project/window.cpp     | 20 +++++++++++++-------
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 9c3e211e..8bd7653f 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -114,7 +114,6 @@ namespace Toolbox::UI {
         std::vector<ModelIndex> m_selected_indices;
         std::vector<ProjectAsset> m_view_assets;
         ModelIndex m_view_index;
-        ModelIndex m_selected_index;
 
         std::unordered_map<std::string, ImageHandle> m_icon_map;
         ImagePainter m_icon_painter;
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 0385d61d..d9cec9ca 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -55,8 +55,12 @@ namespace Toolbox::UI {
 
                 for (size_t i = 0; i < m_file_system_model->getRowCount(m_view_index); ++i) {
                     ModelIndex child_index = m_file_system_model->getIndex(i, 0, m_view_index);
+                    bool is_selected =
+                        std::find(m_selected_indices.begin(), m_selected_indices.end(),
+                                  m_tree_proxy.toSourceIndex(child_index)) !=
+                        m_selected_indices.end();
 
-                    if (m_selected_index == m_tree_proxy.toSourceIndex(child_index)){
+                    if (is_selected) {
                         ImGui::PushStyleColor(ImGuiCol_ChildBg, ImGui::ColorConvertFloat4ToU32(ImGui::GetStyleColorVec4(ImGuiCol_TabSelected)));
                     } else {
                         ImGui::PushStyleColor(ImGuiCol_ChildBg,
@@ -79,12 +83,14 @@ namespace Toolbox::UI {
                             ImGui::IsItemHovered(ImGuiHoveredFlags_None) &&
                             m_file_system_model->isDirectory(child_index)) {
                             m_view_index = m_tree_proxy.toSourceIndex(child_index);
-                        }
-                        else if (ImGui::IsItemClicked()) {
-                            m_selected_index = m_tree_proxy.toSourceIndex(child_index);
-                        } else if (ImGui::IsMouseClicked(0) &&
-                                   m_selected_index == m_tree_proxy.toSourceIndex(child_index)) {
-                            m_selected_index = ModelIndex();
+                        } else if (ImGui::IsItemClicked()) {
+                            if (!ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
+                                m_selected_indices.clear();
+                            }
+                            m_selected_indices.push_back(m_tree_proxy.toSourceIndex(child_index));
+                        } else if (ImGui::IsMouseClicked(0) && is_selected &&
+                                   !ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
+                            m_selected_indices.clear();
                         }
 
                         ImGui::RenderTextEllipsis(

From 84078df520e5bdbe8e42cd23246032e7ff7c32f1 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sun, 22 Sep 2024 09:54:25 -0500
Subject: [PATCH 024/129] Handle a warning and optimize semantics

---
 src/gui/application.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 33a5f087..107af960 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -559,11 +559,11 @@ namespace Toolbox {
                 int num_filters               = 0;
                 nfdu8filteritem_t *nfd_filters = nullptr;
                 if (maybe_filters) {
-                    auto filters = maybe_filters.value();
+                    FileDialogFilter filters = std::move(maybe_filters.value());
                     num_filters = filters.numFilters();
                     filters.copyFiltersOutU8(m_filters);
                     nfd_filters = new nfdu8filteritem_t[num_filters];
-                    for (int i = 0; i < filters.numFilters(); ++i){
+                    for (int i = 0; i < num_filters; ++i) {
                         nfd_filters[i] = {m_filters[i].first.c_str(), m_filters[i].second.c_str()};
                     }
                 }

From e5c03d1b2f42fc16cf42ab974b1e43cd2860f181 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sun, 22 Sep 2024 10:02:24 -0500
Subject: [PATCH 025/129] Set methods to const and initialize members on
 construct for FileDialog

---
 include/gui/application.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/gui/application.hpp b/include/gui/application.hpp
index 44039c33..aa31395f 100644
--- a/include/gui/application.hpp
+++ b/include/gui/application.hpp
@@ -211,10 +211,10 @@ namespace Toolbox {
                         bool is_directory = false,
                         std::optional<FileDialogFilter>
                             maybe_filters = std::nullopt);
-        bool isAlreadyOpen() { return m_thread_running; }
-        bool isDone() { return !m_thread_running && !m_closed && m_thread_initialized; }
-        bool isOk() { return m_result == NFD_OKAY; }
-        std::filesystem::path getFilenameResult() { return m_selected_path; }
+        bool isAlreadyOpen() const { return m_thread_running; }
+        bool isDone() const { return !m_thread_running && !m_closed && m_thread_initialized; }
+        bool isOk() const { return m_result == NFD_OKAY; }
+        std::filesystem::path getFilenameResult() const { return m_selected_path; }
         void close() { m_closed = true; }
 
     private:
@@ -222,8 +222,8 @@ namespace Toolbox {
         std::vector<std::pair<std::string, std::string>> m_filters;
 
         // The result of the last dialog box.
-        nfdu8char_t *m_selected_path;
-        nfdresult_t m_result;
+        nfdu8char_t *m_selected_path = nullptr;
+        nfdresult_t m_result = NFD_OKAY;
         // The thread that we run the dialog in. If
         // m_thread_initialized is true, this should be an initialized
         // thread object.

From 2d8a9f5efa7fa69dcfe2ccd552ce506bf07948a5 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Wed, 25 Sep 2024 13:29:02 -0700
Subject: [PATCH 026/129] Clicking on the text label area also selects item

---
 src/gui/project/window.cpp | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index d9cec9ca..9f951bfb 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -79,19 +79,6 @@ namespace Toolbox::UI {
                         ImVec2 pos = ImGui::GetCursorScreenPos();
                         pos.x += std::max<float>(36.0f - (text_size.x / 2.0f), 0.0);
                         pos.y += 72.0f;
-                        if (ImGui::IsMouseDoubleClicked(0) &&
-                            ImGui::IsItemHovered(ImGuiHoveredFlags_None) &&
-                            m_file_system_model->isDirectory(child_index)) {
-                            m_view_index = m_tree_proxy.toSourceIndex(child_index);
-                        } else if (ImGui::IsItemClicked()) {
-                            if (!ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
-                                m_selected_indices.clear();
-                            }
-                            m_selected_indices.push_back(m_tree_proxy.toSourceIndex(child_index));
-                        } else if (ImGui::IsMouseClicked(0) && is_selected &&
-                                   !ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
-                            m_selected_indices.clear();
-                        }
 
                         ImGui::RenderTextEllipsis(
                             ImGui::GetWindowDrawList(), pos, pos + ImVec2(64, 20), pos.x + 64.0f,
@@ -100,6 +87,19 @@ namespace Toolbox::UI {
                     }
                     ImGui::EndChild();
                     ImGui::PopStyleColor(1);
+                    if (ImGui::IsMouseDoubleClicked(0) &&
+                        ImGui::IsItemHovered(ImGuiHoveredFlags_None) &&
+                        m_file_system_model->isDirectory(child_index)) {
+                        m_view_index = m_tree_proxy.toSourceIndex(child_index);
+                    } else if (ImGui::IsItemClicked()) {
+                        if (!ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
+                            m_selected_indices.clear();
+                        }
+                        m_selected_indices.push_back(m_tree_proxy.toSourceIndex(child_index));
+                    } else if (ImGui::IsMouseClicked(0) && is_selected &&
+                               !ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
+                        m_selected_indices.clear();
+                    }
 
                     // ImGui::Text("%s", m_view_proxy.getDisplayText(child_index).c_str());
 

From 5cc02b972b53e8691d158943db28948017eaaaa0 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 26 Sep 2024 17:24:49 -0700
Subject: [PATCH 027/129] Add ability to rename files in project manager

---
 include/gui/project/window.hpp |  2 ++
 include/model/fsmodel.hpp      |  1 +
 src/gui/project/window.cpp     | 52 +++++++++++++++++++++++++---------
 src/model/fsmodel.cpp          | 28 ++++++++++++++++++
 4 files changed, 70 insertions(+), 13 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 8bd7653f..81623226 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -114,6 +114,8 @@ namespace Toolbox::UI {
         std::vector<ModelIndex> m_selected_indices;
         std::vector<ProjectAsset> m_view_assets;
         ModelIndex m_view_index;
+        bool m_is_renaming = false;
+        char m_rename_buffer[128];
 
         std::unordered_map<std::string, ImageHandle> m_icon_map;
         ImagePainter m_icon_painter;
diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index e540e136..2536f64d 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -87,6 +87,7 @@ namespace Toolbox {
 
         ModelIndex mkdir(const ModelIndex &parent, const std::string &name);
         ModelIndex touch(const ModelIndex &parent, const std::string &name);
+        ModelIndex rename(const ModelIndex &file, const std::string &new_name);
 
         bool rmdir(const ModelIndex &index);
         bool remove(const ModelIndex &index);
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 9f951bfb..d2d8d555 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -68,6 +68,8 @@ namespace Toolbox::UI {
 
                     }
                     if (ImGui::BeginChild(child_index.getUUID(), {76, 92}, true,
+                    bool inputTextHovered = false;
+
                                           ImGuiWindowFlags_ChildWindow |
                                               ImGuiWindowFlags_NoDecoration)) {
 
@@ -77,27 +79,51 @@ namespace Toolbox::UI {
                         ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
 
                         ImVec2 pos = ImGui::GetCursorScreenPos();
-                        pos.x += std::max<float>(36.0f - (text_size.x / 2.0f), 0.0);
-                        pos.y += 72.0f;
-
-                        ImGui::RenderTextEllipsis(
-                            ImGui::GetWindowDrawList(), pos, pos + ImVec2(64, 20), pos.x + 64.0f,
-                            pos.x + 76.0f, text.c_str(),
-                            nullptr, nullptr);
+                        ImVec2 newPos = pos;
+                        newPos.x += std::max<float>(36.0f - (text_size.x / 2.0f), 0.0);
+                        newPos.y += 72.0f;
+                        if (m_is_renaming && is_selected) {
+                            ImGui::SetCursorScreenPos(newPos);
+                            ImGui::SetKeyboardFocusHere();
+                            bool done = ImGui::InputText("##", m_rename_buffer,
+                                                         IM_ARRAYSIZE(m_rename_buffer),
+                                                         ImGuiInputTextFlags_AutoSelectAll
+                                                         | ImGuiInputTextFlags_EnterReturnsTrue);
+                            if (done) {
+                                m_file_system_model->rename(child_index, m_rename_buffer);
+                            }
+                            ImGui::SetCursorScreenPos(pos);
+                        } else {
+                            ImGui::RenderTextEllipsis(
+                                ImGui::GetWindowDrawList(), newPos, newPos + ImVec2(64, 20), pos.x + 64.0f,
+                                newPos.x + 76.0f, text.c_str(),
+                                nullptr, nullptr);
+                        }
+                        inputTextHovered = ImGui::IsItemHovered();
                     }
                     ImGui::EndChild();
                     ImGui::PopStyleColor(1);
+
+                    // Handle click responses
                     if (ImGui::IsMouseDoubleClicked(0) &&
-                        ImGui::IsItemHovered(ImGuiHoveredFlags_None) &&
+                        ImGui::IsWindowHovered(ImGuiHoveredFlags_None) &&
                         m_file_system_model->isDirectory(child_index)) {
                         m_view_index = m_tree_proxy.toSourceIndex(child_index);
-                    } else if (ImGui::IsItemClicked()) {
-                        if (!ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
-                            m_selected_indices.clear();
+                    } else if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(0)) {
+                        if (is_selected){
+                            m_is_renaming = true;
+                            std::strncpy(m_rename_buffer, text.c_str(),
+                                         IM_ARRAYSIZE(m_rename_buffer));
+                        } else {
+                            if (!ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
+                                m_selected_indices.clear();
+                            }
+                            m_is_renaming = false;
+                            m_selected_indices.push_back(m_tree_proxy.toSourceIndex(child_index));
                         }
-                        m_selected_indices.push_back(m_tree_proxy.toSourceIndex(child_index));
                     } else if (ImGui::IsMouseClicked(0) && is_selected &&
-                               !ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
+                               !ImGui::IsKeyDown(ImGuiMod_Ctrl) && !inputTextHovered) {
+                        m_is_renaming = false;
                         m_selected_indices.clear();
                     }
 
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index b42dcea6..9324a5d2 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -441,6 +441,34 @@ namespace Toolbox {
         return result;
     }
 
+    ModelIndex FileSystemModel::rename(const ModelIndex &file, const std::string &new_name){
+        if (!validateIndex(file)) {
+            return ModelIndex();
+        }
+        if (!isDirectory(file) && !isFile(file)) {
+            TOOLBOX_ERROR("[FileSystemModel] Not a directory or file!");
+            return ModelIndex();
+        }
+        fs_path from = file.data<_FileSystemIndexData>()->m_path;
+        fs_path to = from.parent_path() / new_name;
+        ModelIndex parent = getParent(file);
+        _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
+
+        int dest_index =
+            std::find(parent_data->m_children.begin(), parent_data->m_children.end(), file.getUUID()) -
+            parent_data->m_children.begin();
+
+        Filesystem::rename(from, to);
+
+        delete file.data<_FileSystemIndexData>();
+        m_index_map.erase(file.getUUID());
+        parent_data->m_children.erase(std::remove(parent_data->m_children.begin(),
+                                                  parent_data->m_children.end(),
+                                                  file.getUUID()),
+                                      parent_data->m_children.end());
+        return makeIndex(to, dest_index, parent);
+    }
+
     ModelIndex FileSystemModel::getIndex(const fs_path &path) const {
         if (m_index_map.empty()) {
             return ModelIndex();

From 1b815fce55d62c5c13dc303dfe294d04f3448799 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 26 Sep 2024 17:30:08 -0700
Subject: [PATCH 028/129] Oops partial commits are hard

---
 src/gui/project/window.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index d2d8d555..99564a4c 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -67,15 +67,14 @@ namespace Toolbox::UI {
                                               ImGui::ColorConvertFloat4ToU32(ImGui::GetStyleColorVec4(ImGuiCol_ChildBg)));
 
                     }
-                    if (ImGui::BeginChild(child_index.getUUID(), {76, 92}, true,
                     bool inputTextHovered = false;
-
+                    std::string text = m_file_system_model->getDisplayText(child_index);
+                    if (ImGui::BeginChild(child_index.getUUID(), {76, 92}, true,
                                           ImGuiWindowFlags_ChildWindow |
-                                              ImGuiWindowFlags_NoDecoration)) {
+                                          ImGuiWindowFlags_NoDecoration)) {
 
                         m_icon_painter.render(*m_file_system_model->getDecoration(child_index), {72, 72});
 
-                        std::string text = m_file_system_model->getDisplayText(child_index);
                         ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
 
                         ImVec2 pos = ImGui::GetCursorScreenPos();

From 6a1bb1d5460bffbf4e00e177fefccf6af5e53f13 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 26 Sep 2024 17:49:48 -0700
Subject: [PATCH 029/129] Some nicer box sizes for renaming

---
 src/gui/project/window.cpp | 35 ++++++++++++++++++++++++++++-------
 1 file changed, 28 insertions(+), 7 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 99564a4c..2728de3e 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -4,6 +4,15 @@
 #include <cmath>
 #include <imgui/imgui.h>
 
+#if defined(__linux__)
+inline int max(int x, int y){
+    return x < y ? y : x;
+}
+inline int min(int x, int y){
+    return x < y ? x : y;
+}
+#endif
+
 namespace Toolbox::UI {
 
     ProjectViewWindow::ProjectViewWindow(const std::string &name) : ImWindow(name) {}
@@ -67,24 +76,35 @@ namespace Toolbox::UI {
                                               ImGui::ColorConvertFloat4ToU32(ImGui::GetStyleColorVec4(ImGuiCol_ChildBg)));
 
                     }
-                    bool inputTextHovered = false;
+                    // Get the label and it's size
                     std::string text = m_file_system_model->getDisplayText(child_index);
-                    if (ImGui::BeginChild(child_index.getUUID(), {76, 92}, true,
+                    ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
+                    ImVec2 rename_size = ImGui::CalcTextSize(m_rename_buffer);
+
+                    int box_width = m_is_renaming && is_selected ? max(rename_size.x,76) : 76;
+                    bool inputTextHovered = false;
+
+                    if (ImGui::BeginChild(child_index.getUUID(), {box_width, 92}, true,
                                           ImGuiWindowFlags_ChildWindow |
                                           ImGuiWindowFlags_NoDecoration)) {
 
+                        // Render the icon
                         m_icon_painter.render(*m_file_system_model->getDecoration(child_index), {72, 72});
 
-                        ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
-
+                        // Render the label
                         ImVec2 pos = ImGui::GetCursorScreenPos();
                         ImVec2 newPos = pos;
-                        newPos.x += std::max<float>(36.0f - (text_size.x / 2.0f), 0.0);
+                        newPos.x += std::max<float>(
+                            36.0f -
+                            (((m_is_renaming && is_selected) ? max(rename_size.x, 40) : text_size.x) /
+                                 2.0f),
+                            0.0);
                         newPos.y += 72.0f;
                         if (m_is_renaming && is_selected) {
                             ImGui::SetCursorScreenPos(newPos);
                             ImGui::SetKeyboardFocusHere();
-                            bool done = ImGui::InputText("##", m_rename_buffer,
+                            ImGui::PushItemWidth(max(rename_size.x, 40));
+                            bool done = ImGui::InputText("##rename", m_rename_buffer,
                                                          IM_ARRAYSIZE(m_rename_buffer),
                                                          ImGuiInputTextFlags_AutoSelectAll
                                                          | ImGuiInputTextFlags_EnterReturnsTrue);
@@ -92,6 +112,7 @@ namespace Toolbox::UI {
                                 m_file_system_model->rename(child_index, m_rename_buffer);
                             }
                             ImGui::SetCursorScreenPos(pos);
+                            ImGui::PopItemWidth();
                         } else {
                             ImGui::RenderTextEllipsis(
                                 ImGui::GetWindowDrawList(), newPos, newPos + ImVec2(64, 20), pos.x + 64.0f,
@@ -208,4 +229,4 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::initFolderAssets(const ModelIndex &index) {}
 
-}  // namespace Toolbox::UI
\ No newline at end of file
+}  // namespace Toolbox::UI

From c963954d7b5e82b21a7a362c8f096090ac301236 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 27 Sep 2024 13:37:24 -0700
Subject: [PATCH 030/129] Fix folder navigation in the presence of renaming

---
 src/gui/project/window.cpp | 72 +++++++++++++++++++++++---------------
 1 file changed, 44 insertions(+), 28 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 2728de3e..85e00560 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -61,12 +61,12 @@ namespace Toolbox::UI {
                 if (x_count == 0) {
                     x_count = 1;
                 }
+                bool any_items_hovered = false;
 
                 for (size_t i = 0; i < m_file_system_model->getRowCount(m_view_index); ++i) {
                     ModelIndex child_index = m_file_system_model->getIndex(i, 0, m_view_index);
                     bool is_selected =
-                        std::find(m_selected_indices.begin(), m_selected_indices.end(),
-                                  m_tree_proxy.toSourceIndex(child_index)) !=
+                        std::find(m_selected_indices.begin(), m_selected_indices.end(), child_index) !=
                         m_selected_indices.end();
 
                     if (is_selected) {
@@ -82,8 +82,6 @@ namespace Toolbox::UI {
                     ImVec2 rename_size = ImGui::CalcTextSize(m_rename_buffer);
 
                     int box_width = m_is_renaming && is_selected ? max(rename_size.x,76) : 76;
-                    bool inputTextHovered = false;
-
                     if (ImGui::BeginChild(child_index.getUUID(), {box_width, 92}, true,
                                           ImGuiWindowFlags_ChildWindow |
                                           ImGuiWindowFlags_NoDecoration)) {
@@ -119,33 +117,45 @@ namespace Toolbox::UI {
                                 newPos.x + 76.0f, text.c_str(),
                                 nullptr, nullptr);
                         }
-                        inputTextHovered = ImGui::IsItemHovered();
-                    }
-                    ImGui::EndChild();
-                    ImGui::PopStyleColor(1);
-
-                    // Handle click responses
-                    if (ImGui::IsMouseDoubleClicked(0) &&
-                        ImGui::IsWindowHovered(ImGuiHoveredFlags_None) &&
-                        m_file_system_model->isDirectory(child_index)) {
-                        m_view_index = m_tree_proxy.toSourceIndex(child_index);
-                    } else if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(0)) {
-                        if (is_selected){
-                            m_is_renaming = true;
-                            std::strncpy(m_rename_buffer, text.c_str(),
-                                         IM_ARRAYSIZE(m_rename_buffer));
-                        } else {
-                            if (!ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
-                                m_selected_indices.clear();
+                        any_items_hovered = any_items_hovered || ImGui::IsItemHovered() || ImGui::IsWindowHovered(ImGuiHoveredFlags_None);
+                        // Handle click responses
+                        if (ImGui::IsWindowHovered(ImGuiHoveredFlags_None)) {
+                            if (ImGui::IsMouseDoubleClicked(0)) {
+                                if (m_file_system_model->isDirectory(child_index)) {
+                                    m_view_index = m_tree_proxy.toSourceIndex(child_index);
+                                }
+                                m_is_renaming = false;
+                            } else if (ImGui::IsMouseClicked(0)) {
+                                TOOLBOX_INFO("Got a click on item");
+                                if (is_selected){
+                                    TOOLBOX_INFO("Item was already selected");
+                                    if (ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
+                                        m_selected_indices.erase(std::find(
+                                            m_selected_indices.begin(), m_selected_indices.end(),
+                                            child_index));
+                                        m_is_renaming = false;
+                                    } else {
+                                        TOOLBOX_INFO("Control key is not down");
+                                        m_is_renaming = true;
+                                        std::strncpy(m_rename_buffer, text.c_str(),
+                                                     IM_ARRAYSIZE(m_rename_buffer));
+                                    }
+                                } else {
+                                    TOOLBOX_INFO("Item wasn't already selected, selecting now.");
+                                    TOOLBOX_INFO_V("There are {} selected indices",
+                                                   m_selected_indices.size());
+                                    if (!ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
+                                        m_selected_indices.clear();
+                                    }
+                                    m_selected_indices.push_back(
+                                        child_index);
+                                    m_is_renaming = false;
+                                }
                             }
-                            m_is_renaming = false;
-                            m_selected_indices.push_back(m_tree_proxy.toSourceIndex(child_index));
                         }
-                    } else if (ImGui::IsMouseClicked(0) && is_selected &&
-                               !ImGui::IsKeyDown(ImGuiMod_Ctrl) && !inputTextHovered) {
-                        m_is_renaming = false;
-                        m_selected_indices.clear();
                     }
+                    ImGui::EndChild();
+                    ImGui::PopStyleColor(1);
 
                     // ImGui::Text("%s", m_view_proxy.getDisplayText(child_index).c_str());
 
@@ -154,6 +164,12 @@ namespace Toolbox::UI {
                     }
                 }
 
+                // Clearing the selection
+                if (!any_items_hovered && ImGui::IsMouseClicked(0)) {
+                    TOOLBOX_INFO("No items are hovered and there was a click, clearing selection");
+                    m_selected_indices.clear();
+                    m_is_renaming = false;
+                }
                 ImGui::PopStyleVar(4);
             }
         }

From b509efd594e4c2f77ceef131edecf0bca078bcc1 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 27 Sep 2024 13:42:08 -0700
Subject: [PATCH 031/129] Replace custom min/max with std:: versions

---
 src/gui/project/window.cpp | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 85e00560..1b233ed3 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -4,15 +4,6 @@
 #include <cmath>
 #include <imgui/imgui.h>
 
-#if defined(__linux__)
-inline int max(int x, int y){
-    return x < y ? y : x;
-}
-inline int min(int x, int y){
-    return x < y ? x : y;
-}
-#endif
-
 namespace Toolbox::UI {
 
     ProjectViewWindow::ProjectViewWindow(const std::string &name) : ImWindow(name) {}
@@ -81,7 +72,7 @@ namespace Toolbox::UI {
                     ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
                     ImVec2 rename_size = ImGui::CalcTextSize(m_rename_buffer);
 
-                    int box_width = m_is_renaming && is_selected ? max(rename_size.x,76) : 76;
+                    int box_width = m_is_renaming && is_selected ? std::max(rename_size.x,76.0f) : 76;
                     if (ImGui::BeginChild(child_index.getUUID(), {box_width, 92}, true,
                                           ImGuiWindowFlags_ChildWindow |
                                           ImGuiWindowFlags_NoDecoration)) {
@@ -94,14 +85,14 @@ namespace Toolbox::UI {
                         ImVec2 newPos = pos;
                         newPos.x += std::max<float>(
                             36.0f -
-                            (((m_is_renaming && is_selected) ? max(rename_size.x, 40) : text_size.x) /
+                            (((m_is_renaming && is_selected) ? std::max(rename_size.x, 40.0f) : text_size.x) /
                                  2.0f),
                             0.0);
                         newPos.y += 72.0f;
                         if (m_is_renaming && is_selected) {
                             ImGui::SetCursorScreenPos(newPos);
                             ImGui::SetKeyboardFocusHere();
-                            ImGui::PushItemWidth(max(rename_size.x, 40));
+                            ImGui::PushItemWidth(std::max(rename_size.x, 40.0f));
                             bool done = ImGui::InputText("##rename", m_rename_buffer,
                                                          IM_ARRAYSIZE(m_rename_buffer),
                                                          ImGuiInputTextFlags_AutoSelectAll

From f3dbb5c9e53e93cd7f1e3632a83333f10fd701ce Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 27 Sep 2024 15:58:01 -0500
Subject: [PATCH 032/129] Fix memory leak and performance issue with proxy
 model

---
 include/gui/pad/window.hpp     |  2 +-
 include/gui/project/window.hpp |  2 ++
 include/model/fsmodel.cpp      |  0
 include/model/fsmodel.hpp      |  2 ++
 include/resource/resource.hpp  |  6 ++---
 src/gui/application.cpp        |  6 ++---
 src/gui/project/window.cpp     | 48 ++++++++++++++++++----------------
 src/model/fsmodel.cpp          | 39 ++++++++++++++++-----------
 src/resource/resource.cpp      | 28 ++++++++++----------
 9 files changed, 75 insertions(+), 58 deletions(-)
 create mode 100644 include/model/fsmodel.cpp

diff --git a/include/gui/pad/window.hpp b/include/gui/pad/window.hpp
index 5f48e7d0..3951988c 100644
--- a/include/gui/pad/window.hpp
+++ b/include/gui/pad/window.hpp
@@ -153,7 +153,7 @@ namespace Toolbox::UI {
 
         CreateLinkDialog m_create_link_dialog;
 
-        RefPtr<ImageHandle> m_dolphin_logo;
+        RefPtr<const ImageHandle> m_dolphin_logo;
         ImagePainter m_image_painter;
     };
 
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 81623226..d3306dda 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -119,6 +119,8 @@ namespace Toolbox::UI {
 
         std::unordered_map<std::string, ImageHandle> m_icon_map;
         ImagePainter m_icon_painter;
+
+        std::unordered_map<UUID64, ImVec2> m_text_sizes;
     };
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/model/fsmodel.cpp b/include/model/fsmodel.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index 2536f64d..3b8a8d9d 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -213,6 +213,8 @@ namespace Toolbox {
         [[nodiscard]] ModelIndex toSourceIndex(const ModelIndex &index) const;
         [[nodiscard]] ModelIndex toProxyIndex(const ModelIndex &index) const;
 
+        [[nodiscard]] UUID64 getSourceUUID(const ModelIndex &index) const;
+
     protected:
         [[nodiscard]] ModelIndex toProxyIndex(int64_t row, int64_t column,
                                               const ModelIndex &parent = ModelIndex()) const;
diff --git a/include/resource/resource.hpp b/include/resource/resource.hpp
index dcfa6a52..9ccf0037 100644
--- a/include/resource/resource.hpp
+++ b/include/resource/resource.hpp
@@ -73,9 +73,9 @@ namespace Toolbox {
                                        const UUID64 &resource_path_uuid = 0) const;
         [[nodiscard]] bool hasDataPath(fs_path &&path, const UUID64 &resource_path_uuid = 0) const;
 
-        [[nodiscard]] Result<RefPtr<ImageHandle>, FSError>
+        [[nodiscard]] Result<RefPtr<const ImageHandle>, FSError>
         getImageHandle(const fs_path &path, const UUID64 &resource_path_uuid = 0) const;
-        [[nodiscard]] Result<RefPtr<ImageHandle>, FSError>
+        [[nodiscard]] Result<RefPtr<const ImageHandle>, FSError>
         getImageHandle(fs_path &&path, const UUID64 &resource_path_uuid = 0) const;
 
         [[nodiscard]] Result<void, FSError>
@@ -105,7 +105,7 @@ namespace Toolbox {
         UUID64 m_uuid;
         std::vector<ResourcePath> m_resource_paths;
 
-        mutable std::unordered_map<fs_path, RefPtr<ImageHandle>> m_image_handle_cache;
+        mutable std::unordered_map<fs_path, RefPtr<const ImageHandle>> m_image_handle_cache;
         mutable std::unordered_map<fs_path, ResourceData> m_data_preload_cache;
     };
 
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index bacb619d..621de2be 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -88,7 +88,8 @@ namespace Toolbox {
             m_resource_manager.includeResourcePath(cwd / "Fonts", true);
             m_resource_manager.includeResourcePath(cwd / "Images", true);
             m_resource_manager.includeResourcePath(cwd / "Images", true);
-            m_resource_manager.includeResourcePath(cwd / fs_path("Images") / "Icons", true);
+            m_resource_manager.includeResourcePath(cwd / "Images/Icons", true);
+            m_resource_manager.includeResourcePath(cwd / "Images/Icons/Filesystem", true);
             m_resource_manager.includeResourcePath(cwd / "Templates", false);
             m_resource_manager.includeResourcePath(cwd / "Themes", true);
         }
@@ -190,7 +191,6 @@ namespace Toolbox {
 
         m_task_communicator.tStart(false, nullptr);
 
-
         createWindow<LoggingWindow>("Application Log");
 
         determineEnvironmentConflicts();
@@ -580,7 +580,7 @@ namespace Toolbox {
                 nfdu8filteritem_t *nfd_filters = nullptr;
                 if (maybe_filters) {
                     FileDialogFilter filters = std::move(maybe_filters.value());
-                    num_filters = filters.numFilters();
+                    num_filters              = filters.numFilters();
                     filters.copyFiltersOutU8(m_filters);
                     nfd_filters = new nfdu8filteritem_t[num_filters];
                     for (int i = 0; i < num_filters; ++i) {
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index d2d8d555..4ecab832 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -53,32 +53,37 @@ namespace Toolbox::UI {
                     x_count = 1;
                 }
 
-                for (size_t i = 0; i < m_file_system_model->getRowCount(m_view_index); ++i) {
-                    ModelIndex child_index = m_file_system_model->getIndex(i, 0, m_view_index);
+                ModelIndex view_index = m_view_proxy.toProxyIndex(m_view_index);
+
+                for (size_t i = 0; i < m_view_proxy.getRowCount(m_view_index); ++i) {
+                    ModelIndex child_index = m_view_proxy.getIndex(i, 0, view_index);
                     bool is_selected =
                         std::find(m_selected_indices.begin(), m_selected_indices.end(),
                                   m_tree_proxy.toSourceIndex(child_index)) !=
                         m_selected_indices.end();
 
                     if (is_selected) {
-                        ImGui::PushStyleColor(ImGuiCol_ChildBg, ImGui::ColorConvertFloat4ToU32(ImGui::GetStyleColorVec4(ImGuiCol_TabSelected)));
+                        ImGui::PushStyleColor(ImGuiCol_ChildBg,
+                                              ImGui::ColorConvertFloat4ToU32(
+                                                  ImGui::GetStyleColorVec4(ImGuiCol_TabSelected)));
                     } else {
                         ImGui::PushStyleColor(ImGuiCol_ChildBg,
-                                              ImGui::ColorConvertFloat4ToU32(ImGui::GetStyleColorVec4(ImGuiCol_ChildBg)));
-
+                                              ImGui::ColorConvertFloat4ToU32(
+                                                  ImGui::GetStyleColorVec4(ImGuiCol_ChildBg)));
                     }
-                    if (ImGui::BeginChild(child_index.getUUID(), {76, 92}, true,
+
                     bool inputTextHovered = false;
+                    std::string text      = m_view_proxy.getDisplayText(child_index);
+                    //ImVec2 text_size      = ImGui::CalcTextSize(text.c_str());
+                    ImVec2 text_size = {50.0f, 20.0f};
 
+                    if (ImGui::BeginChild(m_view_proxy.getSourceUUID(child_index), {76, 92}, true,
                                           ImGuiWindowFlags_ChildWindow |
                                               ImGuiWindowFlags_NoDecoration)) {
 
-                        m_icon_painter.render(*m_file_system_model->getDecoration(child_index), {72, 72});
-
-                        std::string text = m_file_system_model->getDisplayText(child_index);
-                        ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
+                        m_icon_painter.render(*m_view_proxy.getDecoration(child_index), {72, 72});
 
-                        ImVec2 pos = ImGui::GetCursorScreenPos();
+                        ImVec2 pos    = ImGui::GetCursorScreenPos();
                         ImVec2 newPos = pos;
                         newPos.x += std::max<float>(36.0f - (text_size.x / 2.0f), 0.0);
                         newPos.y += 72.0f;
@@ -87,17 +92,17 @@ namespace Toolbox::UI {
                             ImGui::SetKeyboardFocusHere();
                             bool done = ImGui::InputText("##", m_rename_buffer,
                                                          IM_ARRAYSIZE(m_rename_buffer),
-                                                         ImGuiInputTextFlags_AutoSelectAll
-                                                         | ImGuiInputTextFlags_EnterReturnsTrue);
+                                                         ImGuiInputTextFlags_AutoSelectAll |
+                                                             ImGuiInputTextFlags_EnterReturnsTrue);
                             if (done) {
-                                m_file_system_model->rename(child_index, m_rename_buffer);
+                                m_file_system_model->rename(m_view_proxy.toSourceIndex(child_index),
+                                                            m_rename_buffer);
                             }
                             ImGui::SetCursorScreenPos(pos);
                         } else {
                             ImGui::RenderTextEllipsis(
-                                ImGui::GetWindowDrawList(), newPos, newPos + ImVec2(64, 20), pos.x + 64.0f,
-                                newPos.x + 76.0f, text.c_str(),
-                                nullptr, nullptr);
+                                ImGui::GetWindowDrawList(), newPos, newPos + ImVec2(64, 20),
+                                pos.x + 64.0f, newPos.x + 76.0f, text.c_str(), nullptr, nullptr);
                         }
                         inputTextHovered = ImGui::IsItemHovered();
                     }
@@ -107,10 +112,10 @@ namespace Toolbox::UI {
                     // Handle click responses
                     if (ImGui::IsMouseDoubleClicked(0) &&
                         ImGui::IsWindowHovered(ImGuiHoveredFlags_None) &&
-                        m_file_system_model->isDirectory(child_index)) {
+                        m_view_proxy.isDirectory(child_index)) {
                         m_view_index = m_tree_proxy.toSourceIndex(child_index);
                     } else if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(0)) {
-                        if (is_selected){
+                        if (is_selected) {
                             m_is_renaming = true;
                             std::strncpy(m_rename_buffer, text.c_str(),
                                          IM_ARRAYSIZE(m_rename_buffer));
@@ -177,14 +182,13 @@ namespace Toolbox::UI {
             }
             ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_OpenOnArrow;
 
-            if (m_view_index == m_tree_proxy.toSourceIndex(index)){
+            if (m_view_index == m_tree_proxy.toSourceIndex(index)) {
                 flags |= ImGuiTreeNodeFlags_Selected;
             }
             if (isViewedAncestor(index)) {
                 flags |= ImGuiTreeNodeFlags_DefaultOpen;
             }
-            is_open = ImGui::TreeNodeEx(m_tree_proxy.getDisplayText(index).c_str(),
-                                        flags);
+            is_open = ImGui::TreeNodeEx(m_tree_proxy.getDisplayText(index).c_str(), flags);
 
             if (ImGui::IsItemClicked()) {
                 m_view_index = m_tree_proxy.toSourceIndex(index);
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 9324a5d2..79adcdb5 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -124,11 +124,16 @@ namespace Toolbox {
         m_options    = FileSystemModelOptions();
         m_read_only  = false;
 
-        fs_path fs_icon_path =
-            GUIApplication::instance().getResourcePath("Images/Icons/Filesystem/");
+        const ResourceManager &res_manager = GUIApplication::instance().getResourceManager();
+        UUID64 fs_icons_uuid = res_manager.getResourcePathUUID("Images/Icons/Filesystem");
 
         for (auto &[key, value] : TypeMap()) {
-            m_icon_map[key] = make_referable<const ImageHandle>(fs_icon_path / value.m_image_name);
+            auto result = res_manager.getImageHandle(value.m_image_name, fs_icons_uuid);
+            if (result) {
+                m_icon_map[key] = result.value();
+            } else {
+                TOOLBOX_ERROR_V("[FileSystemModel] Failed to load icon: {}", value.m_image_name);
+            }
         }
     }
 
@@ -441,7 +446,7 @@ namespace Toolbox {
         return result;
     }
 
-    ModelIndex FileSystemModel::rename(const ModelIndex &file, const std::string &new_name){
+    ModelIndex FileSystemModel::rename(const ModelIndex &file, const std::string &new_name) {
         if (!validateIndex(file)) {
             return ModelIndex();
         }
@@ -449,22 +454,21 @@ namespace Toolbox {
             TOOLBOX_ERROR("[FileSystemModel] Not a directory or file!");
             return ModelIndex();
         }
-        fs_path from = file.data<_FileSystemIndexData>()->m_path;
-        fs_path to = from.parent_path() / new_name;
-        ModelIndex parent = getParent(file);
+        fs_path from                      = file.data<_FileSystemIndexData>()->m_path;
+        fs_path to                        = from.parent_path() / new_name;
+        ModelIndex parent                 = getParent(file);
         _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
 
-        int dest_index =
-            std::find(parent_data->m_children.begin(), parent_data->m_children.end(), file.getUUID()) -
-            parent_data->m_children.begin();
+        int dest_index = std::find(parent_data->m_children.begin(), parent_data->m_children.end(),
+                                   file.getUUID()) -
+                         parent_data->m_children.begin();
 
         Filesystem::rename(from, to);
 
         delete file.data<_FileSystemIndexData>();
         m_index_map.erase(file.getUUID());
         parent_data->m_children.erase(std::remove(parent_data->m_children.begin(),
-                                                  parent_data->m_children.end(),
-                                                  file.getUUID()),
+                                                  parent_data->m_children.end(), file.getUUID()),
                                       parent_data->m_children.end());
         return makeIndex(to, dest_index, parent);
     }
@@ -691,9 +695,6 @@ namespace Toolbox {
 
         // Establish icon
         {
-            fs_path fs_icon_path =
-                GUIApplication::instance().getResourcePath("Images/Icons/Filesystem/");
-
             std::string ext = data->m_path.extension().string();
 
             if (!validateIndex(index)) {
@@ -1002,6 +1003,14 @@ namespace Toolbox {
         return ModelIndex();
     }
 
+    UUID64 FileSystemModelSortFilterProxy::getSourceUUID(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return 0;
+        }
+
+        return index.data<_FileSystemIndexData>()->m_self_uuid;
+    }
+
     bool FileSystemModelSortFilterProxy::isFiltered(const UUID64 &uuid) const {
         ModelIndex child_index = m_source_model->getIndex(uuid);
         bool is_file =
diff --git a/src/resource/resource.cpp b/src/resource/resource.cpp
index aab013fd..54e04756 100644
--- a/src/resource/resource.cpp
+++ b/src/resource/resource.cpp
@@ -149,14 +149,14 @@ namespace Toolbox {
         return result;
     }
 
-    Result<RefPtr<ImageHandle>, FSError>
+    Result<RefPtr<const ImageHandle>, FSError>
     ResourceManager::getImageHandle(const fs_path &path, const UUID64 &resource_path_uuid) const {
         if (m_image_handle_cache.find(path) != m_image_handle_cache.end()) {
-            return Result<RefPtr<ImageHandle>, FSError>(m_image_handle_cache[path]);
+            return Result<RefPtr<const ImageHandle>, FSError>(m_image_handle_cache[path]);
         }
 
         if (!hasDataPath(path, resource_path_uuid)) {
-            return make_fs_error<RefPtr<ImageHandle>>(std::error_code(),
+            return make_fs_error<RefPtr<const ImageHandle>>(std::error_code(),
                                                       {"Resource path not found"});
         }
 
@@ -164,10 +164,10 @@ namespace Toolbox {
             const ResourceData &data = m_data_preload_cache[path];
 
             std::span<u8> data_span(static_cast<u8 *>(data.m_data_ptr), data.m_data_size);
-            RefPtr<ImageHandle> handle = make_referable<ImageHandle>(data_span);
+            RefPtr<const ImageHandle> handle = make_referable<const ImageHandle>(data_span);
 
             if (!handle->isValid()) {
-                return make_fs_error<RefPtr<ImageHandle>>(std::error_code(),
+                return make_fs_error<RefPtr<const ImageHandle>>(std::error_code(),
                                                           {"Failed to load image"});
             }
 
@@ -178,23 +178,23 @@ namespace Toolbox {
         fs_path resource_path = getResourcePath(resource_path_uuid).value_or(fs_path());
         fs_path abs_path      = resource_path / path;
 
-        RefPtr<ImageHandle> handle = make_referable<ImageHandle>(abs_path);
+        RefPtr<const ImageHandle> handle = make_referable<const ImageHandle>(abs_path);
         if (!handle->isValid()) {
-            return make_fs_error<RefPtr<ImageHandle>>(std::error_code(), {"Failed to load image"});
+            return make_fs_error<RefPtr<const ImageHandle>>(std::error_code(), {"Failed to load image"});
         }
 
         m_image_handle_cache[path] = handle;
         return handle;
     }
 
-    Result<RefPtr<ImageHandle>, FSError>
+    Result<RefPtr<const ImageHandle>, FSError>
     ResourceManager::getImageHandle(fs_path &&path, const UUID64 &resource_path_uuid) const {
         if (m_image_handle_cache.find(path) != m_image_handle_cache.end()) {
-            return Result<RefPtr<ImageHandle>, FSError>(m_image_handle_cache[path]);
+            return Result<RefPtr<const ImageHandle>, FSError>(m_image_handle_cache[path]);
         }
 
         if (!hasDataPath(path, resource_path_uuid)) {
-            return make_fs_error<RefPtr<ImageHandle>>(std::error_code(),
+            return make_fs_error<RefPtr<const ImageHandle>>(std::error_code(),
                                                       {"Resource path not found"});
         }
 
@@ -202,10 +202,10 @@ namespace Toolbox {
             const ResourceData &data = m_data_preload_cache[path];
 
             std::span<u8> data_span(static_cast<u8 *>(data.m_data_ptr), data.m_data_size);
-            RefPtr<ImageHandle> handle = make_referable<ImageHandle>(data_span);
+            RefPtr<const ImageHandle> handle = make_referable<const ImageHandle>(data_span);
 
             if (!handle->isValid()) {
-                return make_fs_error<RefPtr<ImageHandle>>(std::error_code(),
+                return make_fs_error<RefPtr<const ImageHandle>>(std::error_code(),
                                                           {"Failed to load image"});
             }
 
@@ -216,9 +216,9 @@ namespace Toolbox {
         fs_path resource_path = getResourcePath(resource_path_uuid).value_or(fs_path());
         fs_path abs_path      = resource_path / path;
 
-        RefPtr<ImageHandle> handle = make_referable<ImageHandle>(abs_path);
+        RefPtr<const ImageHandle> handle = make_referable<const ImageHandle>(abs_path);
         if (!handle->isValid()) {
-            return make_fs_error<RefPtr<ImageHandle>>(std::error_code(), {"Failed to load image"});
+            return make_fs_error<RefPtr<const ImageHandle>>(std::error_code(), {"Failed to load image"});
         }
 
         m_image_handle_cache[path] = handle;

From 575cbab62d70bda127a35e9173c8aa0ca0b6662d Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 27 Sep 2024 13:58:51 -0700
Subject: [PATCH 033/129] Oops remove debug logging

---
 src/gui/project/window.cpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 1b233ed3..34495673 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -117,24 +117,18 @@ namespace Toolbox::UI {
                                 }
                                 m_is_renaming = false;
                             } else if (ImGui::IsMouseClicked(0)) {
-                                TOOLBOX_INFO("Got a click on item");
                                 if (is_selected){
-                                    TOOLBOX_INFO("Item was already selected");
                                     if (ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
                                         m_selected_indices.erase(std::find(
                                             m_selected_indices.begin(), m_selected_indices.end(),
                                             child_index));
                                         m_is_renaming = false;
                                     } else {
-                                        TOOLBOX_INFO("Control key is not down");
                                         m_is_renaming = true;
                                         std::strncpy(m_rename_buffer, text.c_str(),
                                                      IM_ARRAYSIZE(m_rename_buffer));
                                     }
                                 } else {
-                                    TOOLBOX_INFO("Item wasn't already selected, selecting now.");
-                                    TOOLBOX_INFO_V("There are {} selected indices",
-                                                   m_selected_indices.size());
                                     if (!ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
                                         m_selected_indices.clear();
                                     }

From 85af285863906a9a59d75640524ad2e5b84f559e Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 27 Sep 2024 13:59:58 -0700
Subject: [PATCH 034/129] Add deleting logic

---
 src/gui/project/window.cpp | 54 ++++++++++++++++++++++++++++++++++----
 1 file changed, 49 insertions(+), 5 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 34495673..f357b44c 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -149,12 +149,56 @@ namespace Toolbox::UI {
                     }
                 }
 
-                // Clearing the selection
-                if (!any_items_hovered && ImGui::IsMouseClicked(0)) {
-                    TOOLBOX_INFO("No items are hovered and there was a click, clearing selection");
-                    m_selected_indices.clear();
-                    m_is_renaming = false;
+                ImVec2 center = ImGui::GetMainViewport()->GetCenter();
+                ImGui::SetNextWindowPos(center, ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
+                static bool dont_ask_for_deletes = false;
+                if (ImGui::BeginPopupModal("Delete?", NULL, ImGuiWindowFlags_AlwaysAutoResize)) {
+                    std::string message = "";
+
+                    if (m_selected_indices.size() == 1) {
+                        message = TOOLBOX_FORMAT_FN(
+                            "Are you sure you want to delete {}?",
+                            m_file_system_model->getDisplayText(m_selected_indices[0]));
+                    } else if (m_selected_indices.size() > 1) {
+                        message = TOOLBOX_FORMAT_FN(
+                            "Are you sure you want to delete the {} selected files?",
+                            m_selected_indices.size());
+                    } else {
+                        TOOLBOX_ERROR("Selected 0 files to delete!");
+                    }
+                    ImGui::Text(message.c_str());
+                    ImGui::Separator();
+                    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
+                    ImGui::Checkbox("Don't ask me next time", &dont_ask_for_deletes);
+                    ImGui::PopStyleVar();
+                    if (ImGui::Button("OK", ImVec2(120, 0))) {
+                        for (auto &item_index : m_selected_indices) {
+                            m_file_system_model->remove(item_index);
+                        }
+                        ImGui::CloseCurrentPopup();
+                    }
+                    ImGui::SetItemDefaultFocus();
+                    ImGui::SameLine();
+                    if (ImGui::Button("Cancel", ImVec2(120, 0))) { ImGui::CloseCurrentPopup(); }
+                    ImGui::EndPopup();
+                } else {
+                    // Clearing the selection
+                    if (!any_items_hovered && ImGui::IsMouseClicked(0)) {
+                        m_selected_indices.clear();
+                        m_is_renaming = false;
+                    }
+                    // Delete stuff
+                    if (ImGui::IsKeyPressed(ImGuiKey_Delete) && !m_selected_indices.empty()) {
+                        if (dont_ask_for_deletes) {
+                            for (auto &item_index : m_selected_indices) {
+                                m_file_system_model->remove(item_index);
+                            }
+                        } else {
+                            ImGui::OpenPopup("Delete?");
+                        }
+                    }
                 }
+
                 ImGui::PopStyleVar(4);
             }
         }

From 37e4642c5535a1f0af4c92e435202634723b9947 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 27 Sep 2024 16:29:31 -0500
Subject: [PATCH 035/129] Fix folder navigation and force proxy indexes to
 match their source uuid

---
 include/model/fsmodel.cpp  |  0
 include/model/model.hpp    |  4 ++++
 src/gui/project/window.cpp | 10 ++++++----
 src/model/fsmodel.cpp      |  3 +++
 4 files changed, 13 insertions(+), 4 deletions(-)
 delete mode 100644 include/model/fsmodel.cpp

diff --git a/include/model/fsmodel.cpp b/include/model/fsmodel.cpp
deleted file mode 100644
index e69de29b..00000000
diff --git a/include/model/model.hpp b/include/model/model.hpp
index 3bc22f34..76c1d46a 100644
--- a/include/model/model.hpp
+++ b/include/model/model.hpp
@@ -34,6 +34,8 @@ namespace Toolbox {
 
     class ModelIndex final : public IUnique {
     public:
+        friend class IDataModel;
+
         ModelIndex() = default;
         ModelIndex(UUID64 model_uuid) : m_model_uuid(model_uuid) {}
         ModelIndex(const ModelIndex &other)
@@ -109,6 +111,8 @@ namespace Toolbox {
     protected:
         virtual ModelIndex makeIndex(const fs_path &path, int64_t row,
                                      const ModelIndex &parent) = 0;
+
+        static void setIndexUUID(ModelIndex &index, UUID64 uuid) { index.m_uuid = uuid; }
     };
 
 }  // namespace Toolbox
\ No newline at end of file
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 72889fa9..01cf2df7 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -78,8 +78,7 @@ namespace Toolbox::UI {
 
                     float box_width = m_is_renaming && is_selected ? std::max(rename_size.x, 76.0f)
                                                                    : 76.0f;
-                    if (ImGui::BeginChild(
-                            m_view_proxy.getSourceUUID(child_index), {box_width, 92.0f}, true,
+                    if (ImGui::BeginChild(child_index.getUUID(), {box_width, 92.0f}, true,
                             ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
 
                         m_icon_painter.render(*m_view_proxy.getDecoration(child_index), {72.0f, 72.0f});
@@ -117,10 +116,13 @@ namespace Toolbox::UI {
                         // Handle click responses
                         if (ImGui::IsWindowHovered(ImGuiHoveredFlags_None)) {
                             if (ImGui::IsMouseDoubleClicked(0)) {
+                                m_is_renaming = false;
                                 if (m_view_proxy.isDirectory(child_index)) {
-                                    m_view_index = m_tree_proxy.toSourceIndex(child_index);
+                                    m_view_index = m_view_proxy.toSourceIndex(child_index);
+                                    ImGui::EndChild();
+                                    ImGui::PopStyleColor(1);
+                                    break;
                                 }
-                                m_is_renaming = false;
                             } else if (ImGui::IsMouseClicked(0)) {
                                 if (is_selected){
                                     if (ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 79adcdb5..c485a367 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -979,6 +979,9 @@ namespace Toolbox {
 
         ModelIndex proxy_index = ModelIndex(getUUID());
         proxy_index.setData(index.data<_FileSystemIndexData>());
+        
+        IDataModel::setIndexUUID(proxy_index, index.getUUID());
+
         return proxy_index;
     }
 

From 55e211d7f3517ca1e5c2e48c59ed511d11b1f60c Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 27 Sep 2024 16:38:47 -0500
Subject: [PATCH 036/129] Fix missing return

---
 src/gui/themes.cpp | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/src/gui/themes.cpp b/src/gui/themes.cpp
index 5ed66710..a2efcde4 100644
--- a/src/gui/themes.cpp
+++ b/src/gui/themes.cpp
@@ -240,21 +240,7 @@ namespace Toolbox::UI {
             }
         }
 
-        /*return Toolbox::Filesystem::current_path().and_then([this](std::filesystem::path &&cwd) {
-            for (auto &subpath : Toolbox::Filesystem::directory_iterator{cwd / "Themes"}) {
-                try {
-                    auto theme = make_referable<ConfigTheme>(subpath.path().stem().string());
-                    if (theme->name() == "Default") {
-                        theme->apply();
-                        m_active_theme = m_themes.size();
-                    }
-                    m_themes.emplace_back(theme);
-                } catch (std::runtime_error &e) {
-                    return make_fs_error<void>(std::error_code(), {e.what()});
-                }
-            }
-            return Result<void, FSError>();
-        });*/
+        return {};
     }
 
 }  // namespace Toolbox::UI
\ No newline at end of file

From e70a5d60ceec6ed6704c101d2913b2ea2fad8b50 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 27 Sep 2024 19:39:01 -0500
Subject: [PATCH 037/129] Start implementation of basic watchdog

---
 CMakeLists.txt                  |   2 +
 include/gui/project/window.hpp  |  17 +--
 include/watchdog/fswatchdog.hpp |  76 ++++++++++++++
 src/gui/project/window.cpp      |  59 +++++++++--
 src/watchdog/fswatchdog.cpp     | 177 ++++++++++++++++++++++++++++++++
 5 files changed, 313 insertions(+), 18 deletions(-)
 create mode 100644 include/watchdog/fswatchdog.hpp
 create mode 100644 src/watchdog/fswatchdog.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b4723974..38a5c141 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -88,6 +88,8 @@ file(GLOB TOOLBOX_SRC
     "include/window/*.hpp"
     "src/objlib/meta/*.cpp"
     "include/objlib/meta/*.hpp"
+    "src/watchdog/*.cpp"
+    "include/watchdog/*.hpp"
     "src/io/*.cpp"
     "src/gui/*.cpp"
     "include/gui/*.hpp"
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index d3306dda..6d451ac4 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -22,6 +22,7 @@
 #include "gui/project/asset.hpp"
 
 #include "model/fsmodel.hpp"
+#include "watchdog/fswatchdog.hpp"
 
 #include <imgui.h>
 
@@ -80,18 +81,8 @@ namespace Toolbox::UI {
             return {};
         }
 
-        [[nodiscard]] bool onLoadData(const std::filesystem::path& path) override {
-            m_project_root = path;
-            m_file_system_model = make_referable<FileSystemModel>();
-            m_file_system_model->initialize();
-            m_file_system_model->setRoot(m_project_root);
-            m_tree_proxy.setSourceModel(m_file_system_model);
-            m_tree_proxy.setDirsOnly(true);
-            m_view_proxy.setSourceModel(m_file_system_model);
-            m_view_proxy.setSortRole(FileSystemModelSortRole::SORT_ROLE_NAME);
-            m_view_index = m_view_proxy.getIndex(0, 0);
-            return true;
-        }
+        [[nodiscard]] bool onLoadData(const std::filesystem::path &path) override;
+
         [[nodiscard]] bool onSaveData(std::optional<std::filesystem::path> path) override {
             return true;
         }
@@ -106,6 +97,8 @@ namespace Toolbox::UI {
     private:
         fs_path m_project_root;
 
+        FileSystemWatchdog m_fs_watchdog;
+
         // TODO: Have filesystem model.
         FileSystemModelSortFilterProxy m_tree_proxy;
         FileSystemModelSortFilterProxy m_view_proxy;
diff --git a/include/watchdog/fswatchdog.hpp b/include/watchdog/fswatchdog.hpp
new file mode 100644
index 00000000..29cdc040
--- /dev/null
+++ b/include/watchdog/fswatchdog.hpp
@@ -0,0 +1,76 @@
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "core/threaded.hpp"
+#include "fsystem.hpp"
+
+namespace Toolbox {
+
+    class FileSystemWatchdog : public Threaded<void> {
+    public:
+        using file_added_cb    = std::function<void(const fs_path &path)>;
+        using file_removed_cb  = std::function<void(const fs_path &path)>;
+        using file_modified_cb = std::function<void(const fs_path &path)>;
+
+        using dir_added_cb    = std::function<void(const fs_path &path)>;
+        using dir_removed_cb  = std::function<void(const fs_path &path)>;
+        using dir_modified_cb = std::function<void(const fs_path &path)>;
+
+        FileSystemWatchdog()          = default;
+        virtual ~FileSystemWatchdog() = default;
+
+        void reset();
+        void sleep();
+        void wake();
+
+        void addPath(const fs_path &path);
+        void addPath(fs_path &&path);
+
+        void removePath(const fs_path &path);
+        void removePath(fs_path &&path);
+
+    public:
+        void onFileAdded(file_added_cb cb);
+        void onFileRemoved(file_removed_cb cb);
+        void onFileModified(file_modified_cb cb);
+
+        void onDirAdded(dir_added_cb cb);
+        void onDirRemoved(dir_removed_cb cb);
+        void onDirModified(dir_modified_cb cb);
+
+    protected:
+        void tRun(void *param) override;
+
+        void observePath(const fs_path &path);
+        void observePathF(const fs_path &path);
+
+        struct FileInfo {
+            Filesystem::file_status m_status;
+            Filesystem::file_time_type m_time;
+            size_t m_size;
+            bool m_is_dir;
+            bool m_exists;
+        };
+
+        FileInfo createFileInfo(const fs_path &path);
+        void signalChanges(const fs_path &path, const FileInfo &a, const FileInfo &b);
+
+    private:
+        bool m_asleep = false;
+
+        std::unordered_map<fs_path, FileInfo> m_path_infos;
+        std::unordered_set<fs_path> m_watch_paths;
+
+        file_added_cb m_file_added_cb;
+        file_removed_cb m_file_removed_cb;
+        file_modified_cb m_file_modified_cb;
+
+        dir_added_cb m_dir_added_cb;
+        dir_removed_cb m_dir_removed_cb;
+        dir_modified_cb m_dir_modified_cb;
+
+        std::mutex m_mutex;
+    };
+
+}  // namespace Toolbox
\ No newline at end of file
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 01cf2df7..987ad230 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -79,9 +79,11 @@ namespace Toolbox::UI {
                     float box_width = m_is_renaming && is_selected ? std::max(rename_size.x, 76.0f)
                                                                    : 76.0f;
                     if (ImGui::BeginChild(child_index.getUUID(), {box_width, 92.0f}, true,
-                            ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
+                                          ImGuiWindowFlags_ChildWindow |
+                                              ImGuiWindowFlags_NoDecoration)) {
 
-                        m_icon_painter.render(*m_view_proxy.getDecoration(child_index), {72.0f, 72.0f});
+                        m_icon_painter.render(*m_view_proxy.getDecoration(child_index),
+                                              {72.0f, 72.0f});
 
                         // Render the label
                         ImVec2 pos    = ImGui::GetCursorScreenPos();
@@ -119,12 +121,13 @@ namespace Toolbox::UI {
                                 m_is_renaming = false;
                                 if (m_view_proxy.isDirectory(child_index)) {
                                     m_view_index = m_view_proxy.toSourceIndex(child_index);
+                                    m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
                                     ImGui::EndChild();
                                     ImGui::PopStyleColor(1);
                                     break;
                                 }
                             } else if (ImGui::IsMouseClicked(0)) {
-                                if (is_selected){
+                                if (is_selected) {
                                     if (ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
                                         m_selected_indices.erase(
                                             std::find(m_selected_indices.begin(),
@@ -185,7 +188,9 @@ namespace Toolbox::UI {
                     }
                     ImGui::SetItemDefaultFocus();
                     ImGui::SameLine();
-                    if (ImGui::Button("Cancel", ImVec2(120, 0))) { ImGui::CloseCurrentPopup(); }
+                    if (ImGui::Button("Cancel", ImVec2(120, 0))) {
+                        ImGui::CloseCurrentPopup();
+                    }
                     ImGui::EndPopup();
                 } else {
                     // Clearing the selection
@@ -215,9 +220,50 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::renderProjectFileButton() {}
 
-    void ProjectViewWindow::onAttach() {}
+    bool ProjectViewWindow::onLoadData(const std::filesystem::path &path) {
+        m_project_root      = path;
+        m_file_system_model = make_referable<FileSystemModel>();
+        m_file_system_model->initialize();
+        m_file_system_model->setRoot(m_project_root);
+        m_tree_proxy.setSourceModel(m_file_system_model);
+        m_tree_proxy.setDirsOnly(true);
+        m_view_proxy.setSourceModel(m_file_system_model);
+        m_view_proxy.setSortRole(FileSystemModelSortRole::SORT_ROLE_NAME);
+        m_view_index = m_view_proxy.getIndex(0, 0);
+        m_fs_watchdog.reset();
+        m_fs_watchdog.addPath(m_project_root);
+        m_fs_watchdog.onFileRemoved([this](const fs_path &path) {
+            TOOLBOX_INFO_V("File removed: {}", path.string());
+            //m_file_system_model->removeIndex(m_file_system_model->getIndex(path));
+        });
+        m_fs_watchdog.onFileAdded(
+            [this](const fs_path &path) {
+            TOOLBOX_INFO_V("File added: {}", path.string());
+            fs_path parent = path.parent_path();
+            /*m_file_system_model->addIndex(;*/
+        });
+        m_fs_watchdog.onFileModified([this](const fs_path& path) {
+            TOOLBOX_INFO_V("File modified: {}", path.string());
+            //m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
+        });
+        m_fs_watchdog.onDirAdded([this](const fs_path& path) {
+            TOOLBOX_INFO_V("Dir added: {}", path.string());
+            //m_file_system_model->addIndex(m_file_system_model->getIndex(path));
+        });
+        m_fs_watchdog.onDirModified([this](const fs_path& path) {
+            TOOLBOX_INFO_V("Dir modified: {}", path.string());
+            //m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
+        });
+        m_fs_watchdog.onDirRemoved([this](const fs_path &path) {
+            TOOLBOX_INFO_V("Dir removed: {}", path.string());
+            //m_file_system_model->renameIndex(m_file_system_model->getIndex(old_path), new_path);
+        });
+        return true;
+    }
+
+    void ProjectViewWindow::onAttach() { m_fs_watchdog.tStart(false, nullptr); }
 
-    void ProjectViewWindow::onDetach() {}
+    void ProjectViewWindow::onDetach() { m_fs_watchdog.tKill(true); }
 
     void ProjectViewWindow::onImGuiUpdate(TimeStep delta_time) {}
 
@@ -258,6 +304,7 @@ namespace Toolbox::UI {
 
             if (ImGui::IsItemClicked()) {
                 m_view_index = m_tree_proxy.toSourceIndex(index);
+                m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
             }
 
             if (is_open) {
diff --git a/src/watchdog/fswatchdog.cpp b/src/watchdog/fswatchdog.cpp
new file mode 100644
index 00000000..85ab6516
--- /dev/null
+++ b/src/watchdog/fswatchdog.cpp
@@ -0,0 +1,177 @@
+#include "watchdog/fswatchdog.hpp"
+
+namespace Toolbox {
+
+    void FileSystemWatchdog::reset() {
+        std::scoped_lock lock(m_mutex);
+        m_watch_paths.clear();
+        m_path_infos.clear();
+    }
+
+    void FileSystemWatchdog::sleep() {
+        std::scoped_lock lock(m_mutex);
+        m_asleep = true;
+    }
+
+    void FileSystemWatchdog::wake() {
+        std::scoped_lock lock(m_mutex);
+        m_asleep = false;
+    }
+
+    void FileSystemWatchdog::addPath(const fs_path &path) {
+        std::scoped_lock lock(m_mutex);
+        m_watch_paths.insert(path);
+    }
+
+    void FileSystemWatchdog::addPath(fs_path &&path) {
+        std::scoped_lock lock(m_mutex);
+        m_watch_paths.emplace(std::move(path));
+    }
+
+    void FileSystemWatchdog::removePath(const fs_path &path) {
+        std::scoped_lock lock(m_mutex);
+        m_watch_paths.erase(path);
+    }
+
+    void FileSystemWatchdog::removePath(fs_path &&path) {
+        std::scoped_lock lock(m_mutex);
+        m_watch_paths.erase(std::move(path));
+    }
+
+    void FileSystemWatchdog::onFileAdded(file_added_cb cb) {
+        std::scoped_lock lock(m_mutex);
+        m_file_added_cb = cb;
+    }
+
+    void FileSystemWatchdog::onFileRemoved(file_removed_cb cb) {
+        std::scoped_lock lock(m_mutex);
+        m_file_removed_cb = cb;
+    }
+
+    void FileSystemWatchdog::onFileModified(file_modified_cb cb) {
+        std::scoped_lock lock(m_mutex);
+        m_file_modified_cb = cb;
+    }
+
+    void FileSystemWatchdog::onDirAdded(dir_added_cb cb) {
+        std::scoped_lock lock(m_mutex);
+        m_dir_added_cb = cb;
+    }
+
+    void FileSystemWatchdog::onDirRemoved(dir_removed_cb cb) {
+        std::scoped_lock lock(m_mutex);
+        m_dir_removed_cb = cb;
+    }
+
+    void FileSystemWatchdog::onDirModified(dir_modified_cb cb) {
+        std::scoped_lock lock(m_mutex);
+        m_dir_modified_cb = cb;
+    }
+
+    void FileSystemWatchdog::tRun(void *param) {
+        while (!tIsSignalKill()) {
+            while (m_asleep) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            }
+
+            {
+                std::scoped_lock lock(m_mutex);
+                for (const auto &path : m_watch_paths) {
+                    observePath(path);
+                }
+            }
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+    }
+
+    void FileSystemWatchdog::observePath(const fs_path &path) {
+        if (m_path_infos.find(path) == m_path_infos.end()) {
+            m_path_infos[path] = createFileInfo(path);
+            return;
+        }
+
+        const FileInfo &old_info = m_path_infos[path];
+        FileInfo new_info        = createFileInfo(path);
+
+        signalChanges(path, old_info, new_info);
+
+        if (new_info.m_is_dir) {
+            for (const auto &entry : Toolbox::Filesystem::directory_iterator(path)) {
+                observePathF(entry.path());
+            }
+        }
+
+        m_path_infos[path] = new_info;
+    }
+
+    void FileSystemWatchdog::observePathF(const fs_path &path) {
+        if (m_path_infos.find(path) == m_path_infos.end()) {
+            m_path_infos[path] = createFileInfo(path);
+            return;
+        }
+
+        const FileInfo &old_info = m_path_infos[path];
+        FileInfo new_info        = createFileInfo(path);
+
+        signalChanges(path, old_info, new_info);
+
+        m_path_infos[path] = new_info;
+    }
+
+    FileSystemWatchdog::FileInfo FileSystemWatchdog::createFileInfo(const fs_path &path) {
+        FileInfo info;
+
+        info.m_is_dir = Toolbox::Filesystem::is_directory(path).value_or(false);
+        info.m_exists = Toolbox::Filesystem::exists(path).value_or(false);
+        info.m_time =
+            Toolbox::Filesystem::last_write_time(path).value_or(Filesystem::file_time_type::min());
+
+        if (!info.m_is_dir && info.m_exists) {
+            info.m_size = Toolbox::Filesystem::file_size(path).value_or(0);
+        }
+
+        return info;
+    }
+
+    void FileSystemWatchdog::signalChanges(const fs_path &path, const FileInfo &a,
+                                           const FileInfo &b) {
+        if (a.m_exists != b.m_exists) {
+            if (b.m_exists) {
+                if (b.m_is_dir) {
+                    if (m_dir_added_cb) {
+                        m_dir_added_cb(path);
+                    }
+                } else {
+                    if (m_file_added_cb) {
+                        m_file_added_cb(path);
+                    }
+                }
+            } else {
+                if (b.m_is_dir) {
+                    if (m_dir_removed_cb) {
+                        m_dir_removed_cb(path);
+                    }
+                } else {
+                    if (m_file_removed_cb) {
+                        m_file_removed_cb(path);
+                    }
+                }
+            }
+        } else {
+            if (b.m_exists) {
+                if (b.m_time != a.m_time) {
+                    if (b.m_is_dir) {
+                        if (m_dir_modified_cb) {
+                            m_dir_modified_cb(path);
+                        }
+                    } else {
+                        if (m_file_modified_cb) {
+                            m_file_modified_cb(path);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+}  // namespace Toolbox

From f702fcb8aed32b94f6eef847b0f29bd090be13b0 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sat, 28 Sep 2024 21:46:42 -0500
Subject: [PATCH 038/129] Watchdog works now

---
 include/watchdog/fswatchdog.hpp |   95 ++-
 lib/FileWatch.hpp               | 1160 +++++++++++++++++++++++++++++++
 src/gui/project/window.cpp      |   22 +-
 src/watchdog/fswatchdog.cpp     |  216 +++---
 4 files changed, 1378 insertions(+), 115 deletions(-)
 create mode 100644 lib/FileWatch.hpp

diff --git a/include/watchdog/fswatchdog.hpp b/include/watchdog/fswatchdog.hpp
index 29cdc040..a6e9b290 100644
--- a/include/watchdog/fswatchdog.hpp
+++ b/include/watchdog/fswatchdog.hpp
@@ -2,20 +2,67 @@
 #include <unordered_map>
 #include <unordered_set>
 
+#include <FileWatch.hpp>
+
+#include "core/memory.hpp"
 #include "core/threaded.hpp"
 #include "fsystem.hpp"
+#include "platform/process.hpp"
 
 namespace Toolbox {
 
-    class FileSystemWatchdog : public Threaded<void> {
+    class FileSystemWatchdog;
+
+    class PathWatcher_ {
     public:
-        using file_added_cb    = std::function<void(const fs_path &path)>;
-        using file_removed_cb  = std::function<void(const fs_path &path)>;
-        using file_modified_cb = std::function<void(const fs_path &path)>;
+        PathWatcher_(FileSystemWatchdog *watchdog, const fs_path &path);
+        ~PathWatcher_();
+
+        const fs_path &getPath() const & { return m_path; }
+
+        bool operator==(const PathWatcher_ &other) const { return m_path == other.m_path; }
+
+    protected:
+        void watchDirectory(const fs_path &path);
+        void watchFile(const fs_path &path);
+        void closeDirectory();
+        void closeFile();
+
+        void callback_(const fs_path &path, const filewatch::Event event);
+
+    private:
+        FileSystemWatchdog *m_watchdog;
+        fs_path m_path;
+        bool m_is_dir;
+        bool m_is_file;
+        bool m_is_open;
+        ScopePtr<filewatch::FileWatch<fs_path>> m_watch;
+    };
+
+}
+
 
-        using dir_added_cb    = std::function<void(const fs_path &path)>;
-        using dir_removed_cb  = std::function<void(const fs_path &path)>;
-        using dir_modified_cb = std::function<void(const fs_path &path)>;
+
+namespace std {
+
+    // Hash for PathWatcher
+    template <> struct hash<Toolbox::PathWatcher_> {
+        size_t operator()(const Toolbox::PathWatcher_ &_Keyval) const noexcept {
+            return std::hash<Toolbox::fs_path>{}(_Keyval.getPath());
+        }
+    };
+
+}  // namespace std
+
+namespace Toolbox {
+
+    class FileSystemWatchdog : public Threaded<void> {
+        friend class Toolbox::PathWatcher_;
+
+    public:
+        using file_changed_cb = std::function<void(const fs_path &path)>;
+        using dir_changed_cb  = std::function<void(const fs_path &path)>;
+        using path_changed_cb = std::function<void(const fs_path &path)>;
 
         FileSystemWatchdog()          = default;
         virtual ~FileSystemWatchdog() = default;
@@ -31,13 +78,15 @@ namespace Toolbox {
         void removePath(fs_path &&path);
 
     public:
-        void onFileAdded(file_added_cb cb);
-        void onFileRemoved(file_removed_cb cb);
-        void onFileModified(file_modified_cb cb);
+        void onFileAdded(file_changed_cb cb);
+        void onFileModified(file_changed_cb cb);
 
-        void onDirAdded(dir_added_cb cb);
-        void onDirRemoved(dir_removed_cb cb);
-        void onDirModified(dir_modified_cb cb);
+        void onDirAdded(dir_changed_cb cb);
+        void onDirModified(dir_changed_cb cb);
+
+        void onPathRenamedSrc(path_changed_cb cb);
+        void onPathRenamedDst(path_changed_cb cb);
+        void onPathRemoved(path_changed_cb cb);
 
     protected:
         void tRun(void *param) override;
@@ -60,17 +109,21 @@ namespace Toolbox {
         bool m_asleep = false;
 
         std::unordered_map<fs_path, FileInfo> m_path_infos;
-        std::unordered_set<fs_path> m_watch_paths;
 
-        file_added_cb m_file_added_cb;
-        file_removed_cb m_file_removed_cb;
-        file_modified_cb m_file_modified_cb;
+        std::unordered_set<PathWatcher_> m_file_paths;
+        std::unordered_set<PathWatcher_> m_dir_paths;
+
+        file_changed_cb m_file_added_cb;
+        file_changed_cb m_file_modified_cb;
+
+        dir_changed_cb m_dir_added_cb;
+        dir_changed_cb m_dir_modified_cb;
 
-        dir_added_cb m_dir_added_cb;
-        dir_removed_cb m_dir_removed_cb;
-        dir_modified_cb m_dir_modified_cb;
+        path_changed_cb m_path_renamed_src_cb;
+        path_changed_cb m_path_renamed_dst_cb;
+        path_changed_cb m_path_removed_cb;
 
         std::mutex m_mutex;
     };
 
-}  // namespace Toolbox
\ No newline at end of file
+}  // namespace Toolbox
diff --git a/lib/FileWatch.hpp b/lib/FileWatch.hpp
new file mode 100644
index 00000000..bee35672
--- /dev/null
+++ b/lib/FileWatch.hpp
@@ -0,0 +1,1160 @@
+//	MIT License
+//
+//	Copyright(c) 2017 Thomas Monkman
+//
+//	Permission is hereby granted, free of charge, to any person obtaining a copy
+//	of this software and associated documentation files(the "Software"), to deal
+//	in the Software without restriction, including without limitation the rights
+//	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//	copies of the Software, and to permit persons to whom the Software is
+//	furnished to do so, subject to the following conditions :
+//
+//	The above copyright notice and this permission notice shall be included in all
+//	copies or substantial portions of the Software.
+//
+//	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+//	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//	SOFTWARE.
+
+#ifndef FILEWATCHER_H
+#define FILEWATCHER_H
+
+#include <cstdio>
+#include <fstream>
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+// clang-format off
+#include <windows.h>
+// clang-format on
+#include <Pathcch.h>
+#include <shlwapi.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <tchar.h>
+#endif  // WIN32
+
+#if __unix__
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/inotify.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif  // __unix__
+
+#ifdef __linux__
+#include <linux/limits.h>
+#endif
+
+#if defined(__APPLE__) || defined(__MACH__)
+#include <CoreFoundation/CoreFoundation.h>
+#include <CoreServices/CoreServices.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#define FILEWATCH_PLATFORM_MAC 1
+#endif
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cassert>
+#include <condition_variable>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cwchar>
+#include <functional>
+#include <future>
+#include <iostream>
+#include <mutex>
+#include <regex>
+#include <string>
+#include <system_error>
+#include <thread>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#ifdef FILEWATCH_PLATFORM_MAC
+extern "C" int __getdirentries64(int, char *, int, long *);
+#endif  // FILEWATCH_PLATFORM_MAC
+
+namespace filewatch {
+    enum class Event { added, removed, modified, renamed_old, renamed_new };
+
+    template <typename StringType> struct IsWChar {
+        static constexpr bool value = false;
+    };
+
+    template <> struct IsWChar<wchar_t> {
+        static constexpr bool value = true;
+    };
+
+    template <typename Fn, typename... Args> struct Invokable {
+        static Fn make() { return (Fn *)0; }
+
+        template <typename T> static T defaultValue() { return *(T *)0; }
+
+        static void call(int) { make()(defaultValue<Args...>()); }
+
+        static int call(long value);
+
+        static constexpr bool value = std::is_same<decltype(call(0)), int>::value;
+    };
+
+#define _FILEWATCH_TO_STRING(x) #x
+#define FILEWATCH_TO_STRING(x)  _FILEWATCH_TO_STRING(x)
+
+    [[maybe_unused]] static const char *event_to_string(Event event) {
+        switch (event) {
+        case Event::added:
+            return FILEWATCH_TO_STRING(Event::added);
+        case Event::removed:
+            return FILEWATCH_TO_STRING(Event::removed);
+        case Event::modified:
+            return FILEWATCH_TO_STRING(Event::modified);
+        case Event::renamed_old:
+            return FILEWATCH_TO_STRING(Event : renamed_old);
+        case Event::renamed_new:
+            return FILEWATCH_TO_STRING(Event::renamed_new);
+        }
+        assert(false);
+    }
+
+    template <typename StringType>
+    static typename std::enable_if<std::is_same<typename StringType::value_type, wchar_t>::value,
+                                   bool>::type
+    isParentOrSelfDirectory(const StringType &path) {
+        return path == L"." || path == L"..";
+    }
+
+    template <typename StringType>
+    static typename std::enable_if<std::is_same<typename StringType::value_type, char>::value,
+                                   bool>::type
+    isParentOrSelfDirectory(const StringType &path) {
+        return path == "." || path == "..";
+    }
+
+    /**
+     * \class FileWatch
+     *
+     * \brief Watches a folder or file, and will notify of changes via function callback.
+     *
+     * \author Thomas Monkman
+     *
+     */
+    template <class StringType> class FileWatch {
+        typedef typename StringType::value_type C;
+        typedef std::basic_string<C, std::char_traits<C>> UnderpinningString;
+        typedef std::basic_regex<C, std::regex_traits<C>> UnderpinningRegex;
+
+    public:
+        FileWatch(StringType path, UnderpinningRegex pattern,
+                  std::function<void(const StringType &file, const Event event_type)> callback)
+            : _path(absolute_path_of(path)), _pattern(pattern), _callback(callback),
+              _directory(get_directory(path)) {
+            init();
+        }
+
+        FileWatch(StringType path,
+                  std::function<void(const StringType &file, const Event event_type)> callback)
+            : FileWatch<StringType>(path, UnderpinningRegex(_regex_all), callback) {}
+
+        ~FileWatch() { destroy(); }
+
+        FileWatch(const FileWatch<StringType> &other)
+            : FileWatch<StringType>(other._path, other._callback) {}
+
+        FileWatch<StringType> &operator=(const FileWatch<StringType> &other) {
+            if (this == &other) {
+                return *this;
+            }
+
+            destroy();
+            _path      = other._path;
+            _callback  = other._callback;
+            _directory = get_directory(other._path);
+            init();
+            return *this;
+        }
+
+        // Const memeber varibles don't let me implent moves nicely, if moves are really wanted
+        // std::unique_ptr should be used and move that.
+        FileWatch<StringType>(FileWatch<StringType> &&)              = delete;
+        FileWatch<StringType> &operator=(FileWatch<StringType> &&) & = delete;
+
+    private:
+        static constexpr C _regex_all[]      = {'.', '*', '\0'};
+        static constexpr C _this_directory[] = {'.', '/', '\0'};
+
+        struct PathParts {
+            PathParts(StringType directory, StringType filename)
+                : directory(directory), filename(filename) {}
+            StringType directory;
+            StringType filename;
+        };
+        const StringType _path;
+
+        UnderpinningRegex _pattern;
+
+        static constexpr std::size_t _buffer_size = {1024 * 256};
+
+        // only used if watch a single file
+        StringType _filename;
+
+        std::function<void(const StringType &file, const Event event_type)> _callback;
+
+        std::thread _watch_thread;
+
+        std::condition_variable _cv;
+        std::mutex _callback_mutex;
+        std::vector<std::pair<StringType, Event>> _callback_information;
+        std::thread _callback_thread;
+
+        std::promise<void> _running;
+        std::atomic<bool> _destory = {false};
+        bool _watching_single_file = {false};
+
+#ifdef _WIN32
+        HANDLE _directory   = {nullptr};
+        HANDLE _close_event = {nullptr};
+
+        const DWORD _listen_filters = FILE_NOTIFY_CHANGE_SECURITY | FILE_NOTIFY_CHANGE_CREATION |
+                                      FILE_NOTIFY_CHANGE_LAST_ACCESS |
+                                      FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_SIZE |
+                                      FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_DIR_NAME |
+                                      FILE_NOTIFY_CHANGE_FILE_NAME;
+
+        const std::unordered_map<DWORD, Event> _event_type_mapping = {
+            {FILE_ACTION_ADDED,            Event::added      },
+            {FILE_ACTION_REMOVED,          Event::removed    },
+            {FILE_ACTION_MODIFIED,         Event::modified   },
+            {FILE_ACTION_RENAMED_OLD_NAME, Event::renamed_old},
+            {FILE_ACTION_RENAMED_NEW_NAME, Event::renamed_new}
+        };
+#endif  // WIN32
+
+#if __unix__
+        struct FolderInfo {
+            int folder;
+            int watch;
+        };
+
+        FolderInfo _directory;
+
+        const std::uint32_t _listen_filters = IN_MODIFY | IN_CREATE | IN_DELETE;
+
+        const static std::size_t event_size = (sizeof(struct inotify_event));
+#endif  // __unix__
+
+#if FILEWATCH_PLATFORM_MAC
+        struct FileState {
+            int fd;
+            uint32_t nlink;
+            time_t last_modification;
+
+            FileState(int fd, uint32_t nlink, time_t lt)
+                : fd(fd), nlink(nlink), last_modification(lt) {}
+            FileState(const FileState &)            = delete;
+            FileState &operator=(const FileState &) = delete;
+            FileState(FileState &&other)
+                : fd(other.fd), nlink(other.nlink), last_modification(other.last_modification) {
+                other.fd = -1;
+            }
+
+            FileState invalidate_and_clone() {
+                int fd = this->fd;
+
+                this->fd = -1;
+                return FileState{fd, nlink, last_modification};
+            }
+
+            ~FileState() {
+                if (fd != -1) {
+                    close(fd);
+                }
+            }
+        };
+        std::unordered_map<StringType, FileState> _directory_snapshot{};
+        bool _previous_event_is_rename          = false;
+        CFRunLoopRef _run_loop                  = nullptr;
+        int _file_fd                            = -1;
+        struct timespec _last_modification_time = {};
+        FSEventStreamRef _directory;
+        // fd for single file
+#endif  // FILEWATCH_PLATFORM_MAC
+
+        void init() {
+#ifdef _WIN32
+            _close_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+            if (!_close_event) {
+                throw std::system_error(GetLastError(), std::system_category());
+            }
+#endif  // WIN32
+
+            _callback_thread = std::thread([this]() {
+                try {
+                    callback_thread();
+                } catch (...) {
+                    try {
+                        _running.set_exception(std::current_exception());
+                    } catch (...) {
+                    }  // set_exception() may throw too
+                }
+            });
+
+            _watch_thread = std::thread([this]() {
+                try {
+                    monitor_directory();
+                } catch (...) {
+                    try {
+                        _running.set_exception(std::current_exception());
+                    } catch (...) {
+                    }  // set_exception() may throw too
+                }
+            });
+
+            std::future<void> future = _running.get_future();
+            future.get();  // block until the monitor_directory is up and running
+        }
+
+        void destroy() {
+            _destory = true;
+            _running = std::promise<void>();
+
+#ifdef _WIN32
+            SetEvent(_close_event);
+#elif __unix__
+            inotify_rm_watch(_directory.folder, _directory.watch);
+#elif FILEWATCH_PLATFORM_MAC
+            if (_run_loop) {
+                CFRunLoopStop(_run_loop);
+            }
+#endif  // __unix__
+
+            _cv.notify_all();
+            _watch_thread.join();
+            _callback_thread.join();
+
+#ifdef _WIN32
+            CloseHandle(_directory);
+#elif __unix__
+            close(_directory.folder);
+#elif FILEWATCH_PLATFORM_MAC
+            FSEventStreamStop(_directory);
+            FSEventStreamInvalidate(_directory);
+            FSEventStreamRelease(_directory);
+            _directory = nullptr;
+#endif  // FILEWATCH_PLATFORM_MAC
+        }
+
+        const PathParts split_directory_and_file(const StringType &path) const {
+            const auto predict = [](C character) {
+#ifdef _WIN32
+                return character == C('\\') || character == C('/');
+#elif __unix__ || FILEWATCH_PLATFORM_MAC
+                return character == C('/');
+#endif  // __unix__
+            };
+
+            UnderpinningString path_string = path;
+            const auto pivot =
+                std::find_if(path_string.rbegin(), path_string.rend(), predict).base();
+            // if the path is something like "test.txt" there will be no directory part, however we
+            // still need one, so insert './'
+            const StringType directory = [&]() {
+                const auto extracted_directory = UnderpinningString(path_string.begin(), pivot);
+                return (extracted_directory.size() > 0) ? extracted_directory
+                                                        : UnderpinningString(_this_directory);
+            }();
+            const StringType filename = UnderpinningString(pivot, path_string.end());
+            return PathParts(directory, filename);
+        }
+
+        bool pass_filter(const UnderpinningString &file_path) {
+            if (_watching_single_file) {
+#if 1
+                const UnderpinningString extracted_filename = [](const StringType &str) {
+                    if constexpr (std::is_same_v<std::filesystem::path, StringType>) {
+                        if constexpr (std::is_same_v<std::wstring, UnderpinningString>) {
+                            return UnderpinningString(str.wstring());
+                        } else {
+                            return UnderpinningString(str.string());
+                        }
+                    } else {
+                        return UnderpinningString(str);
+                    }
+                }(split_directory_and_file(file_path).filename);
+#else
+                const UnderpinningString extracted_filename = {
+                    split_directory_and_file(file_path).filename};
+#endif
+                // if we are watching a single file, only that file should trigger action
+                return extracted_filename == _filename;
+            }
+            return std::regex_match(file_path, _pattern);
+        }
+
+#ifdef _WIN32
+        template <typename... Args> DWORD GetFileAttributesX(const char *lpFileName, Args... args) {
+            return GetFileAttributesA(lpFileName, args...);
+        }
+        template <typename... Args>
+        DWORD GetFileAttributesX(const wchar_t *lpFileName, Args... args) {
+            return GetFileAttributesW(lpFileName, args...);
+        }
+
+        template <typename... Args> HANDLE CreateFileX(const char *lpFileName, Args... args) {
+            return CreateFileA(lpFileName, args...);
+        }
+        template <typename... Args> HANDLE CreateFileX(const wchar_t *lpFileName, Args... args) {
+            return CreateFileW(lpFileName, args...);
+        }
+
+        HANDLE get_directory(const StringType &path) {
+            auto file_info = GetFileAttributesX(path.c_str());
+
+            if (file_info == INVALID_FILE_ATTRIBUTES) {
+                throw std::system_error(GetLastError(), std::system_category());
+            }
+            _watching_single_file = (file_info & FILE_ATTRIBUTE_DIRECTORY) == false;
+
+            const StringType watch_path = [this, &path]() {
+                if (_watching_single_file) {
+                    const auto parsed_path = split_directory_and_file(path);
+                    _filename              = parsed_path.filename;
+                    return parsed_path.directory;
+                } else {
+                    return path;
+                }
+            }();
+
+            HANDLE directory =
+                CreateFileX(watch_path.c_str(),   // pointer to the file name
+                            FILE_LIST_DIRECTORY,  // access (read/write) mode
+                            FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,  // share mode
+                            nullptr,        // security descriptor
+                            OPEN_EXISTING,  // how to create
+                            FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,  // file attributes
+                            HANDLE(0));  // file with attributes to copy
+
+            if (directory == INVALID_HANDLE_VALUE) {
+                throw std::system_error(GetLastError(), std::system_category());
+            }
+            return directory;
+        }
+
+        void convert_wstring(const std::wstring &wstr, std::string &out) {
+            int size_needed =
+                WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
+            out.resize(size_needed, '\0');
+            WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &out[0], size_needed, NULL,
+                                NULL);
+        }
+
+        void convert_wstring(const std::wstring &wstr, std::wstring &out) { out = wstr; }
+
+        void monitor_directory() {
+            std::vector<BYTE> buffer(_buffer_size);
+            DWORD bytes_returned = 0;
+            OVERLAPPED overlapped_buffer{0};
+
+            overlapped_buffer.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+            if (!overlapped_buffer.hEvent) {
+                std::cerr << "Error creating monitor event" << std::endl;
+            }
+
+            std::array<HANDLE, 2> handles{overlapped_buffer.hEvent, _close_event};
+
+            auto async_pending = false;
+            _running.set_value();
+            do {
+                std::vector<std::pair<StringType, Event>> parsed_information;
+                ReadDirectoryChangesW(_directory, buffer.data(), static_cast<DWORD>(buffer.size()),
+                                      TRUE, _listen_filters, &bytes_returned, &overlapped_buffer,
+                                      NULL);
+
+                async_pending = true;
+
+                switch (WaitForMultipleObjects(2, handles.data(), FALSE, INFINITE)) {
+                case WAIT_OBJECT_0: {
+                    if (!GetOverlappedResult(_directory, &overlapped_buffer, &bytes_returned,
+                                             TRUE)) {
+                        throw std::system_error(GetLastError(), std::system_category());
+                    }
+                    async_pending = false;
+
+                    if (bytes_returned == 0) {
+                        break;
+                    }
+
+                    FILE_NOTIFY_INFORMATION *file_information =
+                        reinterpret_cast<FILE_NOTIFY_INFORMATION *>(&buffer[0]);
+                    do {
+                        std::wstring changed_file_w{file_information->FileName,
+                                                    file_information->FileNameLength /
+                                                        sizeof(file_information->FileName[0])};
+                        UnderpinningString changed_file;
+                        convert_wstring(changed_file_w, changed_file);
+                        if (pass_filter(changed_file)) {
+                            parsed_information.emplace_back(
+                                StringType{changed_file},
+                                _event_type_mapping.at(file_information->Action));
+                        }
+
+                        if (file_information->NextEntryOffset == 0) {
+                            break;
+                        }
+
+                        file_information = reinterpret_cast<FILE_NOTIFY_INFORMATION *>(
+                            reinterpret_cast<BYTE *>(file_information) +
+                            file_information->NextEntryOffset);
+                    } while (true);
+                    break;
+                }
+                case WAIT_OBJECT_0 + 1:
+                    // quit
+                    break;
+                case WAIT_FAILED:
+                    break;
+                }
+                // dispatch callbacks
+                {
+                    std::lock_guard<std::mutex> lock(_callback_mutex);
+                    _callback_information.insert(_callback_information.end(),
+                                                 parsed_information.begin(),
+                                                 parsed_information.end());
+                }
+                _cv.notify_all();
+            } while (_destory == false);
+
+            if (async_pending) {
+                // clean up running async io
+                CancelIo(_directory);
+                GetOverlappedResult(_directory, &overlapped_buffer, &bytes_returned, TRUE);
+            }
+        }
+#endif  // WIN32
+
+#if __unix__
+
+        bool is_file(const StringType &path) const {
+            struct stat statbuf = {};
+            if (stat(path.c_str(), &statbuf) != 0) {
+                throw std::system_error(errno, std::system_category());
+            }
+            return S_ISREG(statbuf.st_mode);
+        }
+
+        FolderInfo get_directory(const StringType &path) {
+            const auto folder = inotify_init();
+            if (folder < 0) {
+                throw std::system_error(errno, std::system_category());
+            }
+
+            _watching_single_file = is_file(path);
+
+            const StringType watch_path = [this, &path]() {
+                if (_watching_single_file) {
+                    const auto parsed_path = split_directory_and_file(path);
+                    _filename              = parsed_path.filename;
+                    return parsed_path.directory;
+                } else {
+                    return path;
+                }
+            }();
+
+            const auto watch =
+                inotify_add_watch(folder, watch_path.c_str(), IN_MODIFY | IN_CREATE | IN_DELETE);
+            if (watch < 0) {
+                throw std::system_error(errno, std::system_category());
+            }
+            return {folder, watch};
+        }
+
+        void monitor_directory() {
+            std::vector<char> buffer(_buffer_size);
+
+            _running.set_value();
+            while (_destory == false) {
+                const auto length =
+                    read(_directory.folder, static_cast<void *>(buffer.data()), buffer.size());
+                if (length > 0) {
+                    int i = 0;
+                    std::vector<std::pair<StringType, Event>> parsed_information;
+                    while (i < length) {
+                        struct inotify_event *event =
+                            reinterpret_cast<struct inotify_event *>(&buffer[i]);  // NOLINT
+                        if (event->len) {
+                            const UnderpinningString changed_file{event->name};
+                            if (pass_filter(changed_file)) {
+                                if (event->mask & IN_CREATE) {
+                                    parsed_information.emplace_back(StringType{changed_file},
+                                                                    Event::added);
+                                } else if (event->mask & IN_DELETE) {
+                                    parsed_information.emplace_back(StringType{changed_file},
+                                                                    Event::removed);
+                                } else if (event->mask & IN_MODIFY) {
+                                    parsed_information.emplace_back(StringType{changed_file},
+                                                                    Event::modified);
+                                }
+                            }
+                        }
+                        i += event_size + event->len;
+                    }
+                    // dispatch callbacks
+                    {
+                        std::lock_guard<std::mutex> lock(_callback_mutex);
+                        _callback_information.insert(_callback_information.end(),
+                                                     parsed_information.begin(),
+                                                     parsed_information.end());
+                    }
+                    _cv.notify_all();
+                }
+            }
+        }
+#endif  // __unix__
+
+#if FILEWATCH_PLATFORM_MAC
+        static StringType absolute_path_of(const StringType &path) {
+            char buf[PATH_MAX];
+            int fd          = open((const char *)path.c_str(), O_RDONLY);
+            const char *str = buf;
+            struct stat stat;
+            mbstate_t state;
+
+            assert(fd != -1);
+            fcntl(fd, F_GETPATH, buf);
+            fstat(fd, &stat);
+
+            if (stat.st_mode & S_IFREG || stat.st_mode & S_IFLNK) {
+                size_t len = strlen(buf);
+
+                for (size_t i = len - 1; i >= 0; i--) {
+                    if (buf[i] == '/') {
+                        buf[i] = '\0';
+                        break;
+                    }
+                }
+            }
+            close(fd);
+
+            if (IsWChar<C>::value) {
+                size_t needed = mbsrtowcs(nullptr, &str, 0, &state) + 1;
+                StringType s;
+
+                s.reserve(needed);
+                mbsrtowcs((wchar_t *)&s[0], &str, s.size(), &state);
+                return s;
+            }
+            return StringType{buf};
+        }
+#elif defined(__unix__)
+        static StringType absolute_path_of(const StringType &path) {
+            char buf[PATH_MAX];
+            const char *str = buf;
+            struct stat stat;
+            mbstate_t state;
+
+            realpath((const char *)path.c_str(), buf);
+            ::stat((const char *)path.c_str(), &stat);
+
+            if (stat.st_mode & S_IFREG || stat.st_mode & S_IFLNK) {
+                size_t len = strlen(buf);
+
+                for (size_t i = len - 1; i >= 0; i--) {
+                    if (buf[i] == '/') {
+                        buf[i] = '\0';
+                        break;
+                    }
+                }
+            }
+
+            if (IsWChar<C>::value) {
+                size_t needed = mbsrtowcs(nullptr, &str, 0, &state) + 1;
+                StringType s;
+
+                s.reserve(needed);
+                mbsrtowcs((wchar_t *)&s[0], &str, s.size(), &state);
+                return s;
+            }
+            return StringType{buf};
+        }
+#elif _WIN32
+        static StringType absolute_path_of(const StringType &path) {
+            constexpr size_t size = IsWChar<C>::value ? MAX_PATH : 32767 * sizeof(wchar_t);
+            char buf[size * 10]        = {};
+
+            DWORD length =
+                IsWChar<C>::value
+                    ? GetFullPathNameW((LPCWSTR)path.c_str(), size / sizeof(TCHAR), (LPWSTR)buf,
+                                       nullptr)
+                    : GetFullPathNameA((LPCSTR)path.c_str(), size / sizeof(TCHAR), buf, nullptr);
+
+            UnderpinningString tmp = UnderpinningString((C *)buf, length);
+
+            return StringType(tmp);
+        }
+#endif
+
+#if FILEWATCH_PLATFORM_MAC
+        static StringType utf8StringToUtf32String(const char *buffer) {
+            mbstate_t state{};
+            StringType s{};
+
+            size_t needed = mbsrtowcs(nullptr, &buffer, 0, &state) + 1;
+            s.reserve(needed);
+            mbsrtowcs((wchar_t *)&s[0], &buffer, s.size(), &state);
+            return s;
+        }
+
+        template <typename Fn, class = std::enable_if<Invokable<Fn, StringType>::value>>
+        static void walkDirectory(const StringType &path, Fn callback) {
+            int fd = open(path.c_str(), O_RDONLY);
+            char buf[1024];
+            long basep = 0;
+
+            if (fd == -1) {
+                return;
+            }
+
+            int ret = __getdirentries64(fd, buf, sizeof(buf), &basep);
+
+            while (ret > 0) {
+                char *current = buf;
+                int offset    = 0;
+
+                while (offset < ret) {
+                    struct dirent *dirent = (struct dirent *)current;
+                    StringType name = IsWChar<C>::value ? utf8StringToUtf32String(dirent->d_name)
+                                                        : StringType(dirent->d_name);
+
+                    callback(std::move(name));
+                    current += dirent->d_reclen;
+                    offset += dirent->d_reclen;
+                }
+                ret = __getdirentries64(fd, buf, sizeof(buf), &basep);
+            }
+            close(fd);
+        }
+
+        static StringType nameofFd(int fd) {
+            size_t len = 0;
+            char buf[MAXPATHLEN];
+
+            if (fcntl(fd, F_GETPATH, buf) == -1) {
+                return StringType{};
+            }
+            if (IsWChar<C>::value) {
+                return utf8StringToUtf32String(buf);
+            }
+
+            len = strnlen(buf, MAXPATHLEN);
+            for (int i = len - 1; i >= 0; i--) {
+                if (buf[i] == '/') {
+                    return StringType{buf + i + 1, len - i - 1};
+                }
+            }
+            return StringType{buf, len};
+        }
+
+        static StringType fullPathOfFd(int fd) {
+            char buf[MAXPATHLEN];
+
+            if (fcntl(fd, F_GETPATH, buf) == -1) {
+                return StringType{};
+            }
+            if (IsWChar<C>::value) {
+                return utf8StringToUtf32String(buf);
+            }
+            return StringType{(C *)buf};
+        }
+
+        static StringType pathOfFd(int fd) {
+            size_t len = 0;
+            char buf[MAXPATHLEN];
+
+            if (fcntl(fd, F_GETPATH, buf) == -1) {
+                return StringType{};
+            }
+            if (IsWChar<C>::value) {
+                return utf8StringToUtf32String(buf);
+            }
+
+            len = strnlen(buf, MAXPATHLEN);
+            for (int i = len - 1; i >= 0; i--) {
+                if (buf[i] == '/') {
+                    return StringType{buf, static_cast<size_t>(i)};
+                }
+            }
+            return StringType{buf, len};
+        }
+
+        static bool fdIsRemoved(int fd) {
+            char buf[MAXPATHLEN];
+            return fcntl(fd, F_GETPATH, buf) == -1;
+        }
+
+        FileState makeFileState(const StringType &path) {
+            int fd = openFile(path);
+            struct stat stat;
+
+            fstat(fd, &stat);
+
+            return FileState{openFile(path), stat.st_nlink, stat.st_mtimespec.tv_sec};
+        }
+
+        static StringType filenameOf(const StringType &file) {
+            for (int i = file.size() - 1; i >= 0; i--) {
+                if (file[i] == '/') {
+                    return file.substr(i + 1);
+                }
+            }
+            return file;
+        }
+
+        static bool isInDirectory(const StringType &file, const StringType &path) {
+            if (file.size() < path.size()) {
+                return false;
+            }
+            return strncmp(file.data(), path.data(), path.size()) == 0;
+        }
+
+        PathParts splitPath(const StringType &path) {
+            PathParts split = split_directory_and_file(path);
+
+            if (split.directory.size() > 0 && split.directory[split.directory.size() - 1] == '/') {
+                split.directory.erase(split.directory.size() - 1);
+            }
+            return split;
+        }
+
+        StringType fullPathOf(const StringType &file) { return _path + '/' + file; }
+
+        int openFile(const StringType &file) {
+            int fd = open(fullPathOf(file).c_str(), O_RDONLY);
+            assert(fd != -1);
+            return fd;
+        }
+
+        void walkAndSeeChanges() {
+            struct RenamedPair {
+                StringType old;
+                StringType current;
+            };
+            struct EventInfo {
+                StringType file;
+                struct timespec time;
+                Event event;
+            };
+            std::unordered_map<StringType, FileState> newSnapshot{};
+            std::vector<EventInfo> events{};
+
+            for (auto &entry : _directory_snapshot) {
+                struct stat stat;
+
+                fstat(entry.second.fd, &stat);
+                if (fdIsRemoved(entry.second.fd)) {
+                    events.push_back(EventInfo{
+                        .event = Event::removed, .file = entry.first, .time = stat.st_ctimespec});
+                    continue;
+                }
+
+                StringType fullPath = fullPathOfFd(entry.second.fd);
+                PathParts pathPair  = splitPath(fullPath);
+
+                if (pathPair.directory != _path) {
+                    events.push_back(EventInfo{
+                        .event = Event::removed, .file = entry.first, .time = stat.st_ctimespec});
+                    continue;
+                }
+                if (entry.first != pathPair.filename) {
+                    events.push_back(EventInfo{.event = Event::renamed_old,
+                                               .file  = entry.first,
+                                               .time  = stat.st_ctimespec});
+                    events.push_back(EventInfo{.event = Event::renamed_new,
+                                               .file  = pathPair.filename,
+                                               .time  = stat.st_ctimespec});
+                } else {
+                    if (stat.st_mtimespec.tv_sec > entry.second.last_modification) {
+                        entry.second.last_modification = stat.st_mtimespec.tv_sec;
+                        events.push_back(EventInfo{.event = Event::modified,
+                                                   .file  = pathPair.filename,
+                                                   .time  = stat.st_mtimespec});
+                    }
+                }
+                newSnapshot.insert(std::make_pair(std::move(pathPair.filename),
+                                                  std::move(entry.second.invalidate_and_clone())));
+            }
+
+            walkDirectory(_path, [&](StringType file) {
+                if (isParentOrSelfDirectory(file) || !std::regex_match(file, _pattern)) {
+                    return;
+                }
+                if (newSnapshot.count(file) == 0) {
+                    FileState state = makeFileState(file);
+                    struct stat stat;
+
+                    fstat(state.fd, &stat);
+                    events.push_back(
+                        EventInfo{.event = Event::added, .file = file, .time = stat.st_mtimespec});
+                    newSnapshot.insert(std::make_pair(file, std::move(state)));
+                }
+            });
+
+            std::swap(_directory_snapshot, newSnapshot);
+
+            std::sort(events.begin(), events.end(), [](const EventInfo &a, EventInfo &b) {
+                if (a.time.tv_sec == b.time.tv_sec) {
+                    return a.time.tv_nsec < b.time.tv_nsec;
+                }
+                return a.time.tv_sec < b.time.tv_sec;
+            });
+
+            {
+                std::lock_guard<std::mutex> lock(_callback_mutex);
+
+                for (const auto &event : events) {
+                    _callback_information.push_back(std::make_pair(event.file, event.event));
+                }
+            }
+            _cv.notify_all();
+        }
+
+        void seeSingleFileChanges() {
+            struct EventInfo {
+                StringType file;
+                Event event;
+            };
+
+            int eventCount = 1;
+            EventInfo eventInfos[2];
+
+            if (fdIsRemoved(_file_fd)) {
+                eventInfos[0].event = Event::removed;
+                eventInfos[0].file  = _filename;
+            } else {
+                StringType absPath = pathOfFd(_file_fd);
+                PathParts split    = splitPath(absPath);
+
+                if (split.directory != _path) {
+                    eventInfos[0].event = Event::removed;
+                    eventInfos[0].file  = _filename;
+                } else if (split.filename != _filename) {
+                    eventInfos[0].event = Event::renamed_old;
+                    eventInfos[0].file  = std::move(_filename);
+                    eventInfos[1].event = Event::renamed_new;
+                    eventInfos[1].file  = split.filename;
+                    eventCount          = 2;
+                    _filename           = std::move(split.filename);
+                } else {
+                    struct stat stat;
+
+                    fstat(_file_fd, &stat);
+
+                    if (stat.st_mtimespec.tv_sec > _last_modification_time.tv_sec) {
+                        eventInfos[0].event     = Event::modified;
+                        eventInfos[0].file      = _filename;
+                        _last_modification_time = stat.st_mtimespec;
+                    } else if (stat.st_mtimespec.tv_nsec > _last_modification_time.tv_nsec) {
+                        eventInfos[0].event     = Event::modified;
+                        eventInfos[0].file      = _filename;
+                        _last_modification_time = stat.st_mtimespec;
+                    } else {
+                        return;
+                    }
+                }
+            }
+
+            {
+                std::lock_guard<std::mutex> lock(_callback_mutex);
+                for (int i = 0; i < eventCount; i++) {
+                    _callback_information.push_back(
+                        std::make_pair(eventInfos[i].file, eventInfos[i].event));
+                }
+            }
+            _cv.notify_all();
+        }
+
+        void notify(CFStringRef path, const FSEventStreamEventFlags flags) {
+            CFIndex pathLength = CFStringGetLength(path);
+            CFIndex written    = 0;
+            char buffer[PATH_MAX + 1];
+
+            CFStringGetBytes(path,
+                             CFRange{
+                                 .location = 0,
+                                 .length   = pathLength,
+                             },
+                             IsWChar<C>::value ? kCFStringEncodingUTF32 : kCFStringEncodingUTF8, 0,
+                             false, (UInt8 *)buffer, PATH_MAX, &written);
+
+            buffer[written] = 0;
+
+            StringType absolutePath{(const C *)buffer, static_cast<size_t>(pathLength)};
+            PathParts pathPair = splitPath(absolutePath);
+
+            if (_watching_single_file && pathPair.filename != _filename) {
+                return;
+            }
+            if (pathPair.directory != _path || !std::regex_match(pathPair.filename, _pattern)) {
+                return;
+            }
+
+            Event event = Event::modified;
+            if (_previous_event_is_rename) {
+                event = Event::renamed_new;
+                _directory_snapshot.insert(
+                    std::make_pair(pathPair.filename, std::move(makeFileState(pathPair.filename))));
+                _previous_event_is_rename = false;
+            } else if (flags & kFSEventStreamEventFlagItemRenamed) {
+                const auto state = _directory_snapshot.find(pathPair.filename);
+                assert(state != _directory_snapshot.end());
+                StringType fdPath = pathOfFd(state->second.fd);
+
+                // moved/delete to Trash folder
+                if (!isInDirectory(absolutePath, fdPath)) {
+                    event = Event::removed;
+                    _directory_snapshot.erase(pathPair.filename);
+                } else {
+                    event                     = Event::renamed_old;
+                    _previous_event_is_rename = true;
+                }
+            } else if (flags & kFSEventStreamEventFlagItemCreated) {
+                _directory_snapshot.insert(
+                    std::make_pair(pathPair.filename, std::move(makeFileState(pathPair.filename))));
+                event = Event::added;
+            } else if (flags & kFSEventStreamEventFlagItemRemoved) {
+                _directory_snapshot.erase(pathPair.filename);
+                event = Event::removed;
+            }
+
+            {
+                std::lock_guard<std::mutex> lock(_callback_mutex);
+                _callback_information.push_back(
+                    std::make_pair(std::move(pathPair.filename), event));
+            }
+            _cv.notify_all();
+        }
+
+        static void handleFsEvent(__attribute__((unused)) ConstFSEventStreamRef streamFef,
+                                  void *clientCallBackInfo, size_t numEvents, CFArrayRef eventPaths,
+                                  const FSEventStreamEventFlags *eventFlags,
+                                  __attribute__((unused)) const FSEventStreamEventId *eventIds) {
+            FileWatch<StringType> *self = (FileWatch<StringType> *)clientCallBackInfo;
+
+            for (size_t i = 0; i < numEvents; i++) {
+                FSEventStreamEventFlags flag = eventFlags[i];
+                CFStringRef path             = (CFStringRef)CFArrayGetValueAtIndex(eventPaths, i);
+
+                if (self->_watching_single_file) {
+                    self->seeSingleFileChanges();
+                } else if (flag & kFSEventStreamEventFlagMustScanSubDirs) {
+                    self->walkAndSeeChanges();
+                } else {
+                    self->notify(path, flag);
+                }
+            }
+        }
+
+        FSEventStreamRef openStream(const StringType &directory) {
+            CFStringEncoding encoding = IsWChar<C>::value ? kCFStringEncodingUTF32
+                                                          : kCFStringEncodingASCII;
+            CFStringRef path =
+                CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)directory.data(),
+                                        directory.size(), encoding, false);
+            CFArrayRef paths = CFArrayCreate(kCFAllocatorDefault, (const void **)&path, 1, nullptr);
+            FSEventStreamContext context{.info = (void *)this};
+            FSEventStreamRef event = FSEventStreamCreate(
+                kCFAllocatorDefault, (FSEventStreamCallback)handleFsEvent, &context, paths,
+                kFSEventStreamEventIdSinceNow, 0,
+                kFSEventStreamCreateFlagNoDefer | kFSEventStreamCreateFlagFileEvents |
+                    kFSEventStreamCreateFlagUseCFTypes);
+
+            CFRelease(path);
+            CFRelease(paths);
+            return event;
+        }
+
+        FSEventStreamRef openStreamForDirectory(const StringType &directory) {
+            FSEventStreamRef stream = openStream(directory);
+            walkDirectory(directory, [this](StringType path) mutable {
+                if (!isParentOrSelfDirectory(path) && std::regex_match(path, _pattern)) {
+                    _directory_snapshot.insert(
+                        std::make_pair(std::move(path), std::move(makeFileState(path))));
+                }
+            });
+            return stream;
+        }
+
+        FSEventStreamRef openStreamForFile(const StringType &file) {
+            PathParts split = splitPath(file);
+
+            _watching_single_file = true;
+            _filename             = std::move(split.filename);
+            _file_fd              = openFile(file);
+            return openStreamForDirectory(split.directory);
+        }
+
+        FSEventStreamRef get_directory(const StringType &directory) {
+            struct stat stat;
+
+            ::stat((const char *)directory.c_str(), &stat);
+            if (stat.st_mode & S_IFDIR) {
+                return openStreamForDirectory(directory);
+            }
+            _last_modification_time = stat.st_mtimespec;
+            return openStreamForFile(directory);
+        }
+
+        void monitor_directory() {
+            _run_loop = CFRunLoopGetCurrent();
+            FSEventStreamScheduleWithRunLoop(_directory, _run_loop, kCFRunLoopDefaultMode);
+            FSEventStreamStart(_directory);
+            _running.set_value();
+            CFRunLoopRun();
+        }
+#endif  // FILEWATCH_PLATFORM_MAC
+
+        void callback_thread() {
+            while (_destory == false) {
+                std::unique_lock<std::mutex> lock(_callback_mutex);
+                if (_callback_information.empty() && _destory == false) {
+                    _cv.wait(lock, [this] { return _callback_information.size() > 0 || _destory; });
+                }
+                decltype(_callback_information) callback_information = {};
+                std::swap(callback_information, _callback_information);
+                lock.unlock();
+
+                for (const auto &file : callback_information) {
+                    if (_callback) {
+                        try {
+                            _callback(file.first, file.second);
+                        } catch (const std::exception &) {
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    template <class StringType>
+    constexpr typename FileWatch<StringType>::C FileWatch<StringType>::_regex_all[];
+    template <class StringType>
+    constexpr typename FileWatch<StringType>::C FileWatch<StringType>::_this_directory[];
+}  // namespace filewatch
+#endif
\ No newline at end of file
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 987ad230..8db91c64 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -121,7 +121,7 @@ namespace Toolbox::UI {
                                 m_is_renaming = false;
                                 if (m_view_proxy.isDirectory(child_index)) {
                                     m_view_index = m_view_proxy.toSourceIndex(child_index);
-                                    m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
+                                    //m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
                                     ImGui::EndChild();
                                     ImGui::PopStyleColor(1);
                                     break;
@@ -232,10 +232,6 @@ namespace Toolbox::UI {
         m_view_index = m_view_proxy.getIndex(0, 0);
         m_fs_watchdog.reset();
         m_fs_watchdog.addPath(m_project_root);
-        m_fs_watchdog.onFileRemoved([this](const fs_path &path) {
-            TOOLBOX_INFO_V("File removed: {}", path.string());
-            //m_file_system_model->removeIndex(m_file_system_model->getIndex(path));
-        });
         m_fs_watchdog.onFileAdded(
             [this](const fs_path &path) {
             TOOLBOX_INFO_V("File added: {}", path.string());
@@ -254,9 +250,17 @@ namespace Toolbox::UI {
             TOOLBOX_INFO_V("Dir modified: {}", path.string());
             //m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
         });
-        m_fs_watchdog.onDirRemoved([this](const fs_path &path) {
-            TOOLBOX_INFO_V("Dir removed: {}", path.string());
-            //m_file_system_model->renameIndex(m_file_system_model->getIndex(old_path), new_path);
+        m_fs_watchdog.onPathRenamedSrc([this](const fs_path &path) {
+            TOOLBOX_INFO_V("Path renamed from: {}", path.string());
+            // m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
+        });
+        m_fs_watchdog.onPathRenamedDst([this](const fs_path &path) {
+            TOOLBOX_INFO_V("Path renamed to: {}", path.string());
+            // m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
+        });
+        m_fs_watchdog.onPathRemoved([this](const fs_path &path) {
+            TOOLBOX_INFO_V("Path removed: {}", path.string());
+            // m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
         });
         return true;
     }
@@ -304,7 +308,7 @@ namespace Toolbox::UI {
 
             if (ImGui::IsItemClicked()) {
                 m_view_index = m_tree_proxy.toSourceIndex(index);
-                m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
+                //m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
             }
 
             if (is_open) {
diff --git a/src/watchdog/fswatchdog.cpp b/src/watchdog/fswatchdog.cpp
index 85ab6516..69dea6ba 100644
--- a/src/watchdog/fswatchdog.cpp
+++ b/src/watchdog/fswatchdog.cpp
@@ -1,10 +1,15 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "core/core.hpp"
 #include "watchdog/fswatchdog.hpp"
 
 namespace Toolbox {
 
     void FileSystemWatchdog::reset() {
         std::scoped_lock lock(m_mutex);
-        m_watch_paths.clear();
+        m_dir_paths.clear();
+        m_file_paths.clear();
         m_path_infos.clear();
     }
 
@@ -20,52 +25,91 @@ namespace Toolbox {
 
     void FileSystemWatchdog::addPath(const fs_path &path) {
         std::scoped_lock lock(m_mutex);
-        m_watch_paths.insert(path);
+        if (Toolbox::Filesystem::is_directory(path).value_or(false)) {
+            m_dir_paths.emplace(this, path);
+        } else {
+            m_file_paths.emplace(this, path);
+        }
     }
 
     void FileSystemWatchdog::addPath(fs_path &&path) {
         std::scoped_lock lock(m_mutex);
-        m_watch_paths.emplace(std::move(path));
+        if (Toolbox::Filesystem::is_directory(path).value_or(false)) {
+            m_dir_paths.emplace(this, std::move(path));
+        } else {
+            m_file_paths.emplace(this, std::move(path));
+        }
     }
 
     void FileSystemWatchdog::removePath(const fs_path &path) {
         std::scoped_lock lock(m_mutex);
-        m_watch_paths.erase(path);
+
+        for (auto it = m_dir_paths.begin(); it != m_dir_paths.end(); ++it) {
+            if (it->getPath() == path) {
+                m_dir_paths.erase(it);
+                return;
+            }
+        }
+
+        for (auto it = m_file_paths.begin(); it != m_file_paths.end(); ++it) {
+            if (it->getPath() == path) {
+                m_file_paths.erase(it);
+                return;
+            }
+        }
     }
 
     void FileSystemWatchdog::removePath(fs_path &&path) {
         std::scoped_lock lock(m_mutex);
-        m_watch_paths.erase(std::move(path));
+
+        for (auto it = m_dir_paths.begin(); it != m_dir_paths.end(); ++it) {
+            if (it->getPath() == path) {
+                m_dir_paths.erase(it);
+                return;
+            }
+        }
+
+        for (auto it = m_file_paths.begin(); it != m_file_paths.end(); ++it) {
+            if (it->getPath() == path) {
+                m_file_paths.erase(it);
+                return;
+            }
+        }
     }
 
-    void FileSystemWatchdog::onFileAdded(file_added_cb cb) {
+    void FileSystemWatchdog::onFileAdded(file_changed_cb cb) {
         std::scoped_lock lock(m_mutex);
         m_file_added_cb = cb;
     }
 
-    void FileSystemWatchdog::onFileRemoved(file_removed_cb cb) {
+    void FileSystemWatchdog::onFileModified(file_changed_cb cb) {
         std::scoped_lock lock(m_mutex);
-        m_file_removed_cb = cb;
+        m_file_modified_cb = cb;
     }
 
-    void FileSystemWatchdog::onFileModified(file_modified_cb cb) {
+    void FileSystemWatchdog::onDirAdded(dir_changed_cb cb) {
         std::scoped_lock lock(m_mutex);
-        m_file_modified_cb = cb;
+        m_dir_added_cb = cb;
     }
 
-    void FileSystemWatchdog::onDirAdded(dir_added_cb cb) {
+    void FileSystemWatchdog::onDirModified(dir_changed_cb cb) {
         std::scoped_lock lock(m_mutex);
-        m_dir_added_cb = cb;
+        m_dir_modified_cb = cb;
     }
 
-    void FileSystemWatchdog::onDirRemoved(dir_removed_cb cb) {
+    void FileSystemWatchdog::onPathRenamedSrc(path_changed_cb cb) {
         std::scoped_lock lock(m_mutex);
-        m_dir_removed_cb = cb;
+        m_path_renamed_src_cb = cb;
     }
 
-    void FileSystemWatchdog::onDirModified(dir_modified_cb cb) {
+    void FileSystemWatchdog::onPathRenamedDst(path_changed_cb cb) {
         std::scoped_lock lock(m_mutex);
-        m_dir_modified_cb = cb;
+        m_path_renamed_dst_cb = cb;
+    }
+
+    void FileSystemWatchdog::onPathRemoved(file_changed_cb cb) {
+        std::scoped_lock lock(m_mutex);
+        m_path_removed_cb = cb;
     }
 
     void FileSystemWatchdog::tRun(void *param) {
@@ -74,103 +118,105 @@ namespace Toolbox {
                 std::this_thread::sleep_for(std::chrono::milliseconds(100));
             }
 
+#if 0
             {
                 std::scoped_lock lock(m_mutex);
-                for (const auto &path : m_watch_paths) {
+                for (const auto &path : m_file_paths) {
+                    observePathF(path);
+                }
+                for (const auto &path : m_dir_paths) {
                     observePath(path);
                 }
             }
+#endif
             std::this_thread::sleep_for(std::chrono::milliseconds(100));
         }
     }
 
-    void FileSystemWatchdog::observePath(const fs_path &path) {
-        if (m_path_infos.find(path) == m_path_infos.end()) {
-            m_path_infos[path] = createFileInfo(path);
-            return;
-        }
-
-        const FileInfo &old_info = m_path_infos[path];
-        FileInfo new_info        = createFileInfo(path);
+    PathWatcher_::PathWatcher_(FileSystemWatchdog *watchdog, const fs_path &path) {
+        m_watchdog = watchdog;
+        m_path     = path;
+        m_is_dir   = Toolbox::Filesystem::is_directory(path).value_or(false);
+        m_is_file  = !m_is_dir;
+        m_is_open  = false;
 
-        signalChanges(path, old_info, new_info);
-
-        if (new_info.m_is_dir) {
-            for (const auto &entry : Toolbox::Filesystem::directory_iterator(path)) {
-                observePathF(entry.path());
-            }
+        if (m_is_dir) {
+            watchDirectory(path);
+        } else {
+            watchFile(path);
         }
-
-        m_path_infos[path] = new_info;
     }
 
-    void FileSystemWatchdog::observePathF(const fs_path &path) {
-        if (m_path_infos.find(path) == m_path_infos.end()) {
-            m_path_infos[path] = createFileInfo(path);
-            return;
+    PathWatcher_::~PathWatcher_() {
+        if (m_is_dir) {
+            closeDirectory();
+        } else {
+            closeFile();
         }
+    }
 
-        const FileInfo &old_info = m_path_infos[path];
-        FileInfo new_info        = createFileInfo(path);
-
-        signalChanges(path, old_info, new_info);
+    void PathWatcher_::watchDirectory(const fs_path &path) {
+        m_watch =
+            make_scoped<filewatch::FileWatch<fs_path>>(path, TOOLBOX_BIND_EVENT_FN(callback_));
+    }
 
-        m_path_infos[path] = new_info;
+    void PathWatcher_::watchFile(const fs_path &path) {
+        m_watch =
+            make_scoped<filewatch::FileWatch<fs_path>>(path, TOOLBOX_BIND_EVENT_FN(callback_));
     }
 
-    FileSystemWatchdog::FileInfo FileSystemWatchdog::createFileInfo(const fs_path &path) {
-        FileInfo info;
+    void PathWatcher_::closeDirectory() { m_watch.reset(); }
 
-        info.m_is_dir = Toolbox::Filesystem::is_directory(path).value_or(false);
-        info.m_exists = Toolbox::Filesystem::exists(path).value_or(false);
-        info.m_time =
-            Toolbox::Filesystem::last_write_time(path).value_or(Filesystem::file_time_type::min());
+    void PathWatcher_::closeFile() { m_watch.reset(); }
 
-        if (!info.m_is_dir && info.m_exists) {
-            info.m_size = Toolbox::Filesystem::file_size(path).value_or(0);
+    void PathWatcher_::callback_(const fs_path &path, const filewatch::Event event) {
+        std::scoped_lock lock(m_watchdog->m_mutex);
+
+        if (m_watchdog->m_asleep) {
+            return;
         }
 
-        return info;
-    }
-
-    void FileSystemWatchdog::signalChanges(const fs_path &path, const FileInfo &a,
-                                           const FileInfo &b) {
-        if (a.m_exists != b.m_exists) {
-            if (b.m_exists) {
-                if (b.m_is_dir) {
-                    if (m_dir_added_cb) {
-                        m_dir_added_cb(path);
-                    }
-                } else {
-                    if (m_file_added_cb) {
-                        m_file_added_cb(path);
-                    }
+        fs_path abs_path = m_path / path;
+        bool is_dir      = Filesystem::is_directory(abs_path).value_or(false);
+
+        switch (event) {
+        case filewatch::Event::added:
+            if (is_dir) {
+                if (m_watchdog->m_dir_added_cb) {
+                    m_watchdog->m_dir_added_cb(abs_path);
                 }
             } else {
-                if (b.m_is_dir) {
-                    if (m_dir_removed_cb) {
-                        m_dir_removed_cb(path);
-                    }
-                } else {
-                    if (m_file_removed_cb) {
-                        m_file_removed_cb(path);
-                    }
+                if (m_watchdog->m_file_added_cb) {
+                    m_watchdog->m_file_added_cb(abs_path);
                 }
             }
-        } else {
-            if (b.m_exists) {
-                if (b.m_time != a.m_time) {
-                    if (b.m_is_dir) {
-                        if (m_dir_modified_cb) {
-                            m_dir_modified_cb(path);
-                        }
-                    } else {
-                        if (m_file_modified_cb) {
-                            m_file_modified_cb(path);
-                        }
-                    }
+            break;
+        case filewatch::Event::modified:
+            if (is_dir) {
+                if (m_watchdog->m_dir_modified_cb) {
+                    m_watchdog->m_dir_modified_cb(abs_path);
+                }
+            } else {
+                if (m_watchdog->m_file_modified_cb) {
+                    m_watchdog->m_file_modified_cb(abs_path);
                 }
             }
+            break;
+        case filewatch::Event::removed:
+            if (m_watchdog->m_path_removed_cb) {
+                m_watchdog->m_path_removed_cb(abs_path);
+            }
+            break;
+        case filewatch::Event::renamed_old:
+            if (m_watchdog->m_path_renamed_src_cb) {
+                m_watchdog->m_path_renamed_src_cb(abs_path);
+            }
+            break;
+        case filewatch::Event::renamed_new:
+            if (m_watchdog->m_path_renamed_dst_cb) {
+                m_watchdog->m_path_renamed_dst_cb(abs_path);
+            }
+            break;
         }
     }
 

From 4579be27454442afcff1dd7781e095086696dcd5 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sat, 28 Sep 2024 23:59:57 -0500
Subject: [PATCH 039/129] Integrate watchdog updates into fs model

---
 include/gui/project/window.hpp  |   3 -
 include/model/fsmodel.hpp       |  87 ++++-
 include/watchdog/fswatchdog.hpp |   2 +
 src/gui/project/window.cpp      |  45 +--
 src/model/fsmodel.cpp           | 622 +++++++++++++++++++++++++-------
 5 files changed, 590 insertions(+), 169 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 6d451ac4..3aa25906 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -22,7 +22,6 @@
 #include "gui/project/asset.hpp"
 
 #include "model/fsmodel.hpp"
-#include "watchdog/fswatchdog.hpp"
 
 #include <imgui.h>
 
@@ -97,8 +96,6 @@ namespace Toolbox::UI {
     private:
         fs_path m_project_root;
 
-        FileSystemWatchdog m_fs_watchdog;
-
         // TODO: Have filesystem model.
         FileSystemModelSortFilterProxy m_tree_proxy;
         FileSystemModelSortFilterProxy m_view_proxy;
diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index 3b8a8d9d..619278c5 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -16,6 +16,8 @@
 #include "model/model.hpp"
 #include "unique.hpp"
 
+#include "watchdog/fswatchdog.hpp"
+
 namespace Toolbox {
 
     enum class FileSystemModelSortRole {
@@ -32,6 +34,22 @@ namespace Toolbox {
     };
     TOOLBOX_BITWISE_ENUM(FileSystemModelOptions)
 
+    enum class FileSystemModelEventFlags {
+        NONE                  = 0,
+        EVENT_FILE_ADDED      = BIT(0),
+        EVENT_FILE_MODIFIED   = BIT(1),
+        EVENT_FOLDER_ADDED    = BIT(2),
+        EVENT_FOLDER_MODIFIED = BIT(3),
+        EVENT_PATH_RENAMED    = BIT(4),
+        EVENT_PATH_REMOVED    = BIT(5),
+        EVENT_FILE_ANY =
+            EVENT_FILE_ADDED | EVENT_FILE_MODIFIED | EVENT_PATH_RENAMED | EVENT_PATH_REMOVED,
+        EVENT_FOLDER_ANY =
+            EVENT_FOLDER_ADDED | EVENT_FOLDER_MODIFIED | EVENT_PATH_RENAMED | EVENT_PATH_REMOVED,
+        EVENT_ANY = EVENT_FILE_ANY | EVENT_FOLDER_ANY,
+    };
+    TOOLBOX_BITWISE_ENUM(FileSystemModelEventFlags)
+
     enum FileSystemDataRole {
         FS_DATA_ROLE_DATE = ModelDataRole::DATA_ROLE_USER,
         FS_DATA_ROLE_STATUS,
@@ -46,7 +64,7 @@ namespace Toolbox {
         };
 
     public:
-        FileSystemModel()  = default;
+        FileSystemModel() = default;
         ~FileSystemModel();
 
         void initialize();
@@ -115,24 +133,77 @@ namespace Toolbox {
         [[nodiscard]] bool canFetchMore(const ModelIndex &index) override;
         void fetchMore(const ModelIndex &index) override;
 
+        using event_listener_t = std::function<void(const fs_path &, FileSystemModelEventFlags)>;
+        void addEventListener(UUID64 uuid, event_listener_t listener, FileSystemModelEventFlags flags);
+        void removeEventListener(UUID64 uuid);
+
         static const ImageHandle &InvalidIcon();
         static const std::unordered_map<std::string, FSTypeInfo> &TypeMap();
 
     protected:
-        ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent) override;
+        [[nodiscard]] bool isDirectory_(const ModelIndex &index) const;
+        [[nodiscard]] bool isFile_(const ModelIndex &index) const;
+        [[nodiscard]] bool isArchive_(const ModelIndex &index) const;
+
+        [[nodiscard]] size_t getFileSize_(const ModelIndex &index) const;
+        [[nodiscard]] size_t getDirSize_(const ModelIndex &index, bool recursive) const;
+
+        // Implementation of public API for mutex locking reasons
+        [[nodiscard]] std::any getData_(const ModelIndex &index, int role) const;
+
+        ModelIndex mkdir_(const ModelIndex &parent, const std::string &name);
+        ModelIndex touch_(const ModelIndex &parent, const std::string &name);
+        ModelIndex rename_(const ModelIndex &file, const std::string &new_name);
+
+        bool rmdir_(const ModelIndex &index);
+        bool remove_(const ModelIndex &index);
+
+        [[nodiscard]] ModelIndex getIndex_(const fs_path &path) const;
+        [[nodiscard]] ModelIndex getIndex_(const UUID64 &path) const;
+        [[nodiscard]] ModelIndex getIndex_(int64_t row, int64_t column,
+                                           const ModelIndex &parent = ModelIndex()) const;
+        [[nodiscard]] fs_path getPath_(const ModelIndex &index) const;
+
+        [[nodiscard]] ModelIndex getParent_(const ModelIndex &index) const;
+        [[nodiscard]] ModelIndex getSibling_(int64_t row, int64_t column,
+                                             const ModelIndex &index) const;
+
+        [[nodiscard]] size_t getColumnCount_(const ModelIndex &index) const;
+        [[nodiscard]] size_t getRowCount_(const ModelIndex &index) const;
 
-        void cacheIndex(ModelIndex &index);
-        void cacheFolder(ModelIndex &index);
-        void cacheFile(ModelIndex &index);
-        void cacheArchive(ModelIndex &index);
+        [[nodiscard]] bool hasChildren_(const ModelIndex &parent = ModelIndex()) const;
+
+        [[nodiscard]] ScopePtr<MimeData>
+        createMimeData_(const std::vector<ModelIndex> &indexes) const;
+
+        [[nodiscard]] bool canFetchMore_(const ModelIndex &index);
+        void fetchMore_(const ModelIndex &index);
+        // -- END -- //
+
+        ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent) override;
 
         ModelIndex getParentArchive(const ModelIndex &index) const;
 
         size_t pollChildren(const ModelIndex &index) const;
 
+        void folderAdded(const fs_path &path);
+        void folderModified(const fs_path &path);
+
+        void fileAdded(const fs_path &path);
+        void fileModified(const fs_path &path);
+
+        void pathRenamedSrc(const fs_path &old_path);
+        void pathRenamedDst(const fs_path &new_path);
+
+        void pathRemoved(const fs_path &path);
+
     private:
         UUID64 m_uuid;
 
+        mutable std::mutex m_mutex;
+        FileSystemWatchdog m_watchdog;
+        std::unordered_map<UUID64, std::pair<event_listener_t, FileSystemModelEventFlags>> m_listeners;
+
         fs_path m_root_path;
 
         FileSystemModelOptions m_options = FileSystemModelOptions::NONE;
@@ -142,6 +213,8 @@ namespace Toolbox {
 
         mutable std::unordered_map<UUID64, ModelIndex> m_index_map;
         mutable std::unordered_map<std::string, RefPtr<const ImageHandle>> m_icon_map;
+
+        fs_path m_rename_src;
     };
 
     class FileSystemModelSortFilterProxy : public IDataModel {
@@ -226,6 +299,8 @@ namespace Toolbox {
             return ModelIndex();
         }
 
+        void fsUpdateEvent(const fs_path &path, FileSystemModelEventFlags flags);
+
     private:
         UUID64 m_uuid;
 
diff --git a/include/watchdog/fswatchdog.hpp b/include/watchdog/fswatchdog.hpp
index a6e9b290..064eb54e 100644
--- a/include/watchdog/fswatchdog.hpp
+++ b/include/watchdog/fswatchdog.hpp
@@ -1,3 +1,5 @@
+#pragma once
+
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 8db91c64..f6de6489 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -58,6 +58,11 @@ namespace Toolbox::UI {
 
                 for (size_t i = 0; i < m_view_proxy.getRowCount(m_view_index); ++i) {
                     ModelIndex child_index = m_view_proxy.getIndex(i, 0, view_index);
+                    if (!m_view_proxy.validateIndex(child_index)) {
+                        TOOLBOX_DEBUG_LOG_V("Invalid index: {}", i);
+                        continue;
+                    }
+
                     bool is_selected =
                         std::find(m_selected_indices.begin(), m_selected_indices.end(),
                                   child_index) != m_selected_indices.end();
@@ -121,7 +126,7 @@ namespace Toolbox::UI {
                                 m_is_renaming = false;
                                 if (m_view_proxy.isDirectory(child_index)) {
                                     m_view_index = m_view_proxy.toSourceIndex(child_index);
-                                    //m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
+                                    // m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
                                     ImGui::EndChild();
                                     ImGui::PopStyleColor(1);
                                     break;
@@ -230,44 +235,12 @@ namespace Toolbox::UI {
         m_view_proxy.setSourceModel(m_file_system_model);
         m_view_proxy.setSortRole(FileSystemModelSortRole::SORT_ROLE_NAME);
         m_view_index = m_view_proxy.getIndex(0, 0);
-        m_fs_watchdog.reset();
-        m_fs_watchdog.addPath(m_project_root);
-        m_fs_watchdog.onFileAdded(
-            [this](const fs_path &path) {
-            TOOLBOX_INFO_V("File added: {}", path.string());
-            fs_path parent = path.parent_path();
-            /*m_file_system_model->addIndex(;*/
-        });
-        m_fs_watchdog.onFileModified([this](const fs_path& path) {
-            TOOLBOX_INFO_V("File modified: {}", path.string());
-            //m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
-        });
-        m_fs_watchdog.onDirAdded([this](const fs_path& path) {
-            TOOLBOX_INFO_V("Dir added: {}", path.string());
-            //m_file_system_model->addIndex(m_file_system_model->getIndex(path));
-        });
-        m_fs_watchdog.onDirModified([this](const fs_path& path) {
-            TOOLBOX_INFO_V("Dir modified: {}", path.string());
-            //m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
-        });
-        m_fs_watchdog.onPathRenamedSrc([this](const fs_path &path) {
-            TOOLBOX_INFO_V("Path renamed from: {}", path.string());
-            // m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
-        });
-        m_fs_watchdog.onPathRenamedDst([this](const fs_path &path) {
-            TOOLBOX_INFO_V("Path renamed to: {}", path.string());
-            // m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
-        });
-        m_fs_watchdog.onPathRemoved([this](const fs_path &path) {
-            TOOLBOX_INFO_V("Path removed: {}", path.string());
-            // m_file_system_model->updateIndex(m_file_system_model->getIndex(path));
-        });
         return true;
     }
 
-    void ProjectViewWindow::onAttach() { m_fs_watchdog.tStart(false, nullptr); }
+    void ProjectViewWindow::onAttach() {}
 
-    void ProjectViewWindow::onDetach() { m_fs_watchdog.tKill(true); }
+    void ProjectViewWindow::onDetach() {}
 
     void ProjectViewWindow::onImGuiUpdate(TimeStep delta_time) {}
 
@@ -308,7 +281,7 @@ namespace Toolbox::UI {
 
             if (ImGui::IsItemClicked()) {
                 m_view_index = m_tree_proxy.toSourceIndex(index);
-                //m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
+                // m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
             }
 
             if (is_open) {
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index c485a367..5a36fbc5 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -114,6 +114,7 @@ namespace Toolbox {
         for (auto &[key, value] : m_index_map) {
             delete value.data<_FileSystemIndexData>();
         }
+        m_watchdog.tKill(true);
     }
 
     void FileSystemModel::initialize() {
@@ -135,6 +136,16 @@ namespace Toolbox {
                 TOOLBOX_ERROR_V("[FileSystemModel] Failed to load icon: {}", value.m_image_name);
             }
         }
+
+        m_watchdog.onDirAdded(TOOLBOX_BIND_EVENT_FN(folderAdded));
+        m_watchdog.onDirModified(TOOLBOX_BIND_EVENT_FN(folderModified));
+        m_watchdog.onFileAdded(TOOLBOX_BIND_EVENT_FN(fileAdded));
+        m_watchdog.onFileModified(TOOLBOX_BIND_EVENT_FN(fileModified));
+        m_watchdog.onPathRemoved(TOOLBOX_BIND_EVENT_FN(pathRemoved));
+        m_watchdog.onPathRenamedSrc(TOOLBOX_BIND_EVENT_FN(pathRenamedSrc));
+        m_watchdog.onPathRenamedDst(TOOLBOX_BIND_EVENT_FN(pathRenamedDst));
+
+        m_watchdog.tStart(false, nullptr);
     }
 
     const fs_path &FileSystemModel::getRoot() const & { return m_root_path; }
@@ -144,10 +155,17 @@ namespace Toolbox {
             return;
         }
 
-        m_index_map.clear();
+        {
+            std::scoped_lock lock(m_mutex);
+
+            m_watchdog.reset();
+            m_watchdog.addPath(path);
+
+            m_index_map.clear();
 
-        m_root_path  = path;
-        m_root_index = makeIndex(path, 0, ModelIndex()).getUUID();
+            m_root_path  = path;
+            m_root_index = makeIndex(path, 0, ModelIndex()).getUUID();
+        }
     }
 
     FileSystemModelOptions FileSystemModel::getOptions() const { return m_options; }
@@ -159,41 +177,219 @@ namespace Toolbox {
     void FileSystemModel::setReadOnly(bool read_only) { m_read_only = read_only; }
 
     bool FileSystemModel::isDirectory(const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return isDirectory_(index);
+    }
+
+    bool FileSystemModel::isFile(const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return isFile_(index);
+    }
+
+    bool FileSystemModel::isArchive(const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return isArchive_(index);
+    }
+
+    size_t FileSystemModel::getFileSize(const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return getFileSize_(index);
+    }
+
+    size_t FileSystemModel::getDirSize(const ModelIndex &index, bool recursive) const {
+        std::scoped_lock lock(m_mutex);
+        return getDirSize_(index, recursive);
+    }
+
+    std::any FileSystemModel::getData(const ModelIndex &index, int role) const {
+        std::scoped_lock lock(m_mutex);
+        return getData_(index, role);
+    }
+
+    ModelIndex FileSystemModel::mkdir(const ModelIndex &parent, const std::string &name) {
+        std::scoped_lock lock(m_mutex);
+        return mkdir_(parent, name);
+    }
+
+    ModelIndex FileSystemModel::touch(const ModelIndex &parent, const std::string &name) {
+        std::scoped_lock lock(m_mutex);
+        return touch_(parent, name);
+    }
+
+    bool FileSystemModel::rmdir(const ModelIndex &index) {
+        std::scoped_lock lock(m_mutex);
+        return rmdir_(index);
+    }
+
+    bool FileSystemModel::remove(const ModelIndex &index) {
+        std::scoped_lock lock(m_mutex);
+        return remove_(index);
+    }
+
+    ModelIndex FileSystemModel::rename(const ModelIndex &file, const std::string &new_name) {
+        std::scoped_lock lock(m_mutex);
+        return rename_(file, new_name);
+    }
+
+    ModelIndex FileSystemModel::getIndex(const fs_path &path) const {
+        std::scoped_lock lock(m_mutex);
+        return getIndex_(path);
+    }
+
+    ModelIndex FileSystemModel::getIndex(const UUID64 &uuid) const {
+        std::scoped_lock lock(m_mutex);
+        return getIndex_(uuid);
+    }
+
+    ModelIndex FileSystemModel::getIndex(int64_t row, int64_t column,
+                                         const ModelIndex &parent) const {
+        std::scoped_lock lock(m_mutex);
+        return getIndex_(row, column, parent);
+    }
+
+    fs_path FileSystemModel::getPath(const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return getPath_(index);
+    }
+
+    ModelIndex FileSystemModel::getParent(const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return getParent_(index);
+    }
+
+    ModelIndex FileSystemModel::getSibling(int64_t row, int64_t column,
+                                           const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return getSibling_(row, column, index);
+    }
+
+    size_t FileSystemModel::getColumnCount(const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return getColumnCount_(index);
+    }
+
+    size_t FileSystemModel::getRowCount(const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return getRowCount_(index);
+    }
+
+    bool FileSystemModel::hasChildren(const ModelIndex &parent) const {
+        std::scoped_lock lock(m_mutex);
+        return hasChildren_(parent);
+    }
+
+    ScopePtr<MimeData>
+    FileSystemModel::createMimeData(const std::vector<ModelIndex> &indexes) const {
+        std::scoped_lock lock(m_mutex);
+        return createMimeData_(indexes);
+    }
+
+    std::vector<std::string> FileSystemModel::getSupportedMimeTypes() const {
+        return std::vector<std::string>();
+    }
+
+    bool FileSystemModel::canFetchMore(const ModelIndex &index) {
+        std::scoped_lock lock(m_mutex);
+        return canFetchMore_(index);
+    }
+
+    void FileSystemModel::fetchMore(const ModelIndex &index) {
+        std::scoped_lock lock(m_mutex);
+        return fetchMore_(index);
+    }
+
+    void FileSystemModel::addEventListener(UUID64 uuid, event_listener_t listener,
+                                           FileSystemModelEventFlags flags) {
+        m_listeners[uuid] = {listener, flags};
+    }
+
+    void FileSystemModel::removeEventListener(UUID64 uuid) { m_listeners.erase(uuid); }
+
+    const ImageHandle &FileSystemModel::InvalidIcon() {
+        static ImageHandle s_invalid_fs_icon = ImageHandle("Images/Icons/fs_invalid.png");
+        return s_invalid_fs_icon;
+    }
+
+    const std::unordered_map<std::string, FileSystemModel::FSTypeInfo> &FileSystemModel::TypeMap() {
+        // clang-format off
+        static std::unordered_map<std::string, FileSystemModel::FSTypeInfo> s_type_map = {
+            {"_Invalid", FSTypeInfo("Invalid",                  "fs_invalid.png")       },
+            {"_Folder",  FSTypeInfo("Folder",                   "fs_generic_folder.png")},
+            {"_Archive", FSTypeInfo("Archive",                  "fs_arc.png")           },
+            {"_File",    FSTypeInfo("File",                     "fs_generic_file.png")  },
+            {".txt",     FSTypeInfo("Text",                     "fs_txt.png")           },
+            {".md",      FSTypeInfo("Markdown",                 "fs_md.png")            },
+            {".c",       FSTypeInfo("C",                        "fs_c.png")             },
+            {".h",       FSTypeInfo("Header",                   "fs_h.png")             },
+            {".cpp",     FSTypeInfo("C++",                      "fs_cpp.png")           },
+            {".hpp",     FSTypeInfo("Header",                   "fs_hpp.png")           },
+            {".cxx",     FSTypeInfo("C++",                      "fs_cpp.png")           },
+            {".hxx",     FSTypeInfo("Header",                   "fs_hpp.png")           },
+            {".c++",     FSTypeInfo("C++",                      "fs_cpp.png")           },
+            {".h++",     FSTypeInfo("Header",                   "fs_hpp.png")           },
+            {".cc",      FSTypeInfo("C++",                      "fs_cpp.png")           },
+            {".hh",      FSTypeInfo("Header",                   "fs_hpp.png")           },
+            {".arc",     FSTypeInfo("Archive",                  "fs_arc.png")           },
+            {".bas",     FSTypeInfo("JAudio Sequence",          "fs_bas.png")           },
+            {".bck",     FSTypeInfo("J3D Bone Animation",       "fs_bck.png")           },
+            {".bdl",     FSTypeInfo("J3D Model Data",           "fs_bdl.png")           },
+            {".blo",     FSTypeInfo("J2D Screen Layout",        "fs_blo.png")           },
+            {".bmd",     FSTypeInfo("J3D Model Data",           "fs_bmd.png")           },
+            {".bmg",     FSTypeInfo("Message Data",             "fs_bmg.png")           },
+            {".bmt",     FSTypeInfo("J3D Material Table",       "fs_bmt.png")           },
+            {".brk",     FSTypeInfo("J3D Color Register Anim",  "fs_brk.png")           },
+            {".bti",     FSTypeInfo("J2D Texture Image",        "fs_bti.png")           },
+            {".btk",     FSTypeInfo("J2D Texture Animation",    "fs_btk.png")           },
+            {".btp",     FSTypeInfo("J2D Texture Pattern Anim", "fs_btp.png")           },
+            {".col",     FSTypeInfo("SMS Collision Data",       "fs_col.png")           },
+            {".jpa",     FSTypeInfo("JParticle Data",           "fs_jpa.png")           },
+            {".map",     FSTypeInfo("Executable Symbol Map",    "fs_map.png")           },
+            {".me",      FSTypeInfo("Marked For Delete",        "fs_me.png")            },
+            {".prm",     FSTypeInfo("SMS Parameter Data",       "fs_prm.png")           },
+            {".sb",      FSTypeInfo("Sunscript",                "fs_sb.png")            },
+            {".szs",     FSTypeInfo("Yaz0 Compressed Data",     "fs_szs.png")           },
+            {".thp",     FSTypeInfo("DolphinOS Movie Data",     "fs_thp.png")           },
+        };
+        // clang-format on
+        return s_type_map;
+    }
+
+    bool FileSystemModel::isDirectory_(const ModelIndex &index) const {
         if (!validateIndex(index)) {
             return false;
         }
         return index.data<_FileSystemIndexData>()->m_type == _FileSystemIndexData::Type::DIRECTORY;
     }
 
-    bool FileSystemModel::isFile(const ModelIndex &index) const {
+    bool FileSystemModel::isFile_(const ModelIndex &index) const {
         if (!validateIndex(index)) {
             return false;
         }
         return index.data<_FileSystemIndexData>()->m_type == _FileSystemIndexData::Type::FILE;
     }
 
-    bool FileSystemModel::isArchive(const ModelIndex &index) const {
+    bool FileSystemModel::isArchive_(const ModelIndex &index) const {
         if (!validateIndex(index)) {
             return false;
         }
         return index.data<_FileSystemIndexData>()->m_type == _FileSystemIndexData::Type::ARCHIVE;
     }
 
-    size_t FileSystemModel::getFileSize(const ModelIndex &index) const {
-        if (!isFile(index)) {
+    size_t FileSystemModel::getFileSize_(const ModelIndex &index) const {
+        if (!isFile_(index)) {
             return 0;
         }
         return index.data<_FileSystemIndexData>()->m_size;
     }
 
-    size_t FileSystemModel::getDirSize(const ModelIndex &index, bool recursive) const {
-        if (!(isDirectory(index) || isArchive(index))) {
+    size_t FileSystemModel::getDirSize_(const ModelIndex &index, bool recursive) const {
+        if (!(isDirectory_(index) || isArchive_(index))) {
             return 0;
         }
         return index.data<_FileSystemIndexData>()->m_size;
     }
 
-    std::any FileSystemModel::getData(const ModelIndex &index, int role) const {
+    std::any FileSystemModel::getData_(const ModelIndex &index, int role) const {
         if (!validateIndex(index)) {
             return {};
         }
@@ -210,7 +406,7 @@ namespace Toolbox {
 
             Filesystem::file_time_type result = Filesystem::file_time_type();
 
-            fs_path path = getPath(index);
+            fs_path path = getPath_(index);
             Filesystem::last_write_time(path)
                 .and_then([&](Filesystem::file_time_type &&time) {
                     result = std::move(time);
@@ -228,7 +424,7 @@ namespace Toolbox {
 
             Filesystem::file_status result = Filesystem::file_status();
 
-            fs_path path = getPath(index);
+            fs_path path = getPath_(index);
             Filesystem::status(path)
                 .and_then([&](Filesystem::file_status &&status) {
                     result = std::move(status);
@@ -244,11 +440,11 @@ namespace Toolbox {
         }
         case FileSystemDataRole::FS_DATA_ROLE_TYPE: {
 
-            if (isDirectory(index)) {
+            if (isDirectory_(index)) {
                 return TypeMap().at("_Folder").m_name;
             }
 
-            if (isArchive(index)) {
+            if (isArchive_(index)) {
                 return TypeMap().at("_Archive").m_name;
             }
 
@@ -273,15 +469,15 @@ namespace Toolbox {
         }
     }
 
-    ModelIndex FileSystemModel::mkdir(const ModelIndex &parent, const std::string &name) {
+    ModelIndex FileSystemModel::mkdir_(const ModelIndex &parent, const std::string &name) {
         if (!validateIndex(parent)) {
             return ModelIndex();
         }
 
         bool result = false;
 
-        if (isDirectory(parent)) {
-            fs_path path = getPath(parent);
+        if (isDirectory_(parent)) {
+            fs_path path = getPath_(parent);
             path /= name;
             Filesystem::create_directory(path)
                 .and_then([&](bool created) {
@@ -298,7 +494,7 @@ namespace Toolbox {
                                     error.m_message[0]);
                     return Result<bool, FSError>();
                 });
-        } else if (isArchive(parent)) {
+        } else if (isArchive_(parent)) {
             TOOLBOX_ERROR("[FileSystemModel] Archive creation is unimplemented!");
         } else {
             TOOLBOX_ERROR("[FileSystemModel] Parent index is not a directory!");
@@ -312,14 +508,14 @@ namespace Toolbox {
                          parent);
     }
 
-    ModelIndex FileSystemModel::touch(const ModelIndex &parent, const std::string &name) {
+    ModelIndex FileSystemModel::touch_(const ModelIndex &parent, const std::string &name) {
         if (!validateIndex(parent)) {
             return ModelIndex();
         }
 
         bool result = false;
 
-        if (isDirectory(parent)) {
+        if (isDirectory_(parent)) {
             fs_path path = parent.data<_FileSystemIndexData>()->m_path / name;
             std::ofstream file(path);
             if (!file.is_open()) {
@@ -328,7 +524,7 @@ namespace Toolbox {
             }
             file.close();
             result = true;
-        } else if (isArchive(parent)) {
+        } else if (isArchive_(parent)) {
             TOOLBOX_ERROR("[FileSystemModel] Archive creation is unimplemented!");
         } else {
             TOOLBOX_ERROR("[FileSystemModel] Parent index is not a directory!");
@@ -342,15 +538,15 @@ namespace Toolbox {
                          parent);
     }
 
-    bool FileSystemModel::rmdir(const ModelIndex &index) {
+    bool FileSystemModel::rmdir_(const ModelIndex &index) {
         if (!validateIndex(index)) {
             return false;
         }
 
         bool result = false;
 
-        if (isDirectory(index)) {
-            Filesystem::remove_all(getPath(index))
+        if (isDirectory_(index)) {
+            Filesystem::remove_all(getPath_(index))
                 .and_then([&](bool removed) {
                     if (!removed) {
                         TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove directory: {}",
@@ -365,8 +561,8 @@ namespace Toolbox {
                                     error.m_message[0]);
                     return Result<bool, FSError>();
                 });
-        } else if (isArchive(index)) {
-            Filesystem::remove(getPath(index))
+        } else if (isArchive_(index)) {
+            Filesystem::remove(getPath_(index))
                 .and_then([&](bool removed) {
                     if (!removed) {
                         TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove archive: {}",
@@ -386,7 +582,7 @@ namespace Toolbox {
         }
 
         if (result) {
-            ModelIndex parent = getParent(index);
+            ModelIndex parent = getParent_(index);
             if (validateIndex(parent)) {
                 _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
                 parent_data->m_children.erase(std::remove(parent_data->m_children.begin(),
@@ -401,19 +597,19 @@ namespace Toolbox {
         return result;
     }
 
-    bool FileSystemModel::remove(const ModelIndex &index) {
+    bool FileSystemModel::remove_(const ModelIndex &index) {
         if (!validateIndex(index)) {
             return false;
         }
 
         bool result = false;
 
-        if (isFile(index)) {
-            Filesystem::remove(getPath(index))
+        if (isFile_(index)) {
+            Filesystem::remove(getPath_(index))
                 .and_then([&](bool removed) {
                     if (!removed) {
                         TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove file: {}",
-                                        getPath(index).string());
+                                        getPath_(index).string());
                         return Result<bool, FSError>();
                     }
                     result = true;
@@ -424,14 +620,14 @@ namespace Toolbox {
                                     error.m_message[0]);
                     return Result<bool, FSError>();
                 });
-        } else if (isArchive(index)) {
+        } else if (isArchive_(index)) {
             TOOLBOX_ERROR("[FileSystemModel] Index is not a file!");
         } else {
             TOOLBOX_ERROR("[FileSystemModel] Index is not a file!");
         }
 
         if (result) {
-            ModelIndex parent = getParent(index);
+            ModelIndex parent = getParent_(index);
             if (validateIndex(parent)) {
                 _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
                 parent_data->m_children.erase(std::remove(parent_data->m_children.begin(),
@@ -446,17 +642,17 @@ namespace Toolbox {
         return result;
     }
 
-    ModelIndex FileSystemModel::rename(const ModelIndex &file, const std::string &new_name) {
+    ModelIndex FileSystemModel::rename_(const ModelIndex &file, const std::string &new_name) {
         if (!validateIndex(file)) {
             return ModelIndex();
         }
-        if (!isDirectory(file) && !isFile(file)) {
+        if (!isDirectory_(file) && !isFile_(file)) {
             TOOLBOX_ERROR("[FileSystemModel] Not a directory or file!");
             return ModelIndex();
         }
         fs_path from                      = file.data<_FileSystemIndexData>()->m_path;
         fs_path to                        = from.parent_path() / new_name;
-        ModelIndex parent                 = getParent(file);
+        ModelIndex parent                 = getParent_(file);
         _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
 
         int dest_index = std::find(parent_data->m_children.begin(), parent_data->m_children.end(),
@@ -473,13 +669,13 @@ namespace Toolbox {
         return makeIndex(to, dest_index, parent);
     }
 
-    ModelIndex FileSystemModel::getIndex(const fs_path &path) const {
+    ModelIndex FileSystemModel::getIndex_(const fs_path &path) const {
         if (m_index_map.empty()) {
             return ModelIndex();
         }
 
         for (const auto &[uuid, index] : m_index_map) {
-            if (getPath(index) == path) {
+            if (getPath_(index) == path) {
                 return index;
             }
         }
@@ -487,10 +683,10 @@ namespace Toolbox {
         return ModelIndex();
     }
 
-    ModelIndex FileSystemModel::getIndex(const UUID64 &uuid) const { return m_index_map.at(uuid); }
+    ModelIndex FileSystemModel::getIndex_(const UUID64 &uuid) const { return m_index_map.at(uuid); }
 
-    ModelIndex FileSystemModel::getIndex(int64_t row, int64_t column,
-                                         const ModelIndex &parent) const {
+    ModelIndex FileSystemModel::getIndex_(int64_t row, int64_t column,
+                                          const ModelIndex &parent) const {
         if (!validateIndex(parent)) {
             if (m_root_index != 0 && row == 0 && column == 0) {
                 return m_index_map.at(m_root_index);
@@ -506,7 +702,7 @@ namespace Toolbox {
         return m_index_map.at(parent_data->m_children[row]);
     }
 
-    fs_path FileSystemModel::getPath(const ModelIndex &index) const {
+    fs_path FileSystemModel::getPath_(const ModelIndex &index) const {
         if (!validateIndex(index)) {
             return fs_path();
         }
@@ -514,7 +710,7 @@ namespace Toolbox {
         return index.data<_FileSystemIndexData>()->m_path;
     }
 
-    ModelIndex FileSystemModel::getParent(const ModelIndex &index) const {
+    ModelIndex FileSystemModel::getParent_(const ModelIndex &index) const {
         if (!validateIndex(index)) {
             return ModelIndex();
         }
@@ -527,23 +723,23 @@ namespace Toolbox {
         return m_index_map.at(id);
     }
 
-    ModelIndex FileSystemModel::getSibling(int64_t row, int64_t column,
-                                           const ModelIndex &index) const {
+    ModelIndex FileSystemModel::getSibling_(int64_t row, int64_t column,
+                                            const ModelIndex &index) const {
         if (!validateIndex(index)) {
             return ModelIndex();
         }
 
-        const ModelIndex &parent = getParent(index);
+        const ModelIndex &parent = getParent_(index);
         if (!validateIndex(parent)) {
             return ModelIndex();
         }
 
-        return getIndex(row, column, parent);
+        return getIndex_(row, column, parent);
     }
 
-    size_t FileSystemModel::getColumnCount(const ModelIndex &index) const { return 1; }
+    size_t FileSystemModel::getColumnCount_(const ModelIndex &index) const { return 1; }
 
-    size_t FileSystemModel::getRowCount(const ModelIndex &index) const {
+    size_t FileSystemModel::getRowCount_(const ModelIndex &index) const {
         if (!validateIndex(index)) {
             return 0;
         }
@@ -551,42 +747,38 @@ namespace Toolbox {
         return index.data<_FileSystemIndexData>()->m_children.size();
     }
 
-    bool FileSystemModel::hasChildren(const ModelIndex &parent) const {
-        if (getRowCount(parent) > 0) {
+    bool FileSystemModel::hasChildren_(const ModelIndex &parent) const {
+        if (getRowCount_(parent) > 0) {
             return true;
         }
         return pollChildren(parent) > 0;
     }
 
     ScopePtr<MimeData>
-    FileSystemModel::createMimeData(const std::vector<ModelIndex> &indexes) const {
+    FileSystemModel::createMimeData_(const std::vector<ModelIndex> &indexes) const {
         TOOLBOX_ERROR("[FileSystemModel] Mimedata unimplemented!");
         return ScopePtr<MimeData>();
     }
 
-    std::vector<std::string> FileSystemModel::getSupportedMimeTypes() const {
-        return std::vector<std::string>();
-    }
-
-    bool FileSystemModel::canFetchMore(const ModelIndex &index) {
+    bool FileSystemModel::canFetchMore_(const ModelIndex &index) {
         if (!validateIndex(index)) {
             return false;
         }
 
-        if (!isDirectory(index) && !isArchive(index)) {
+        if (!isDirectory_(index) && !isArchive_(index)) {
             return false;
         }
 
         return index.data<_FileSystemIndexData>()->m_children.empty();
     }
 
-    void FileSystemModel::fetchMore(const ModelIndex &index) {
+    void FileSystemModel::fetchMore_(const ModelIndex &index) {
         if (!validateIndex(index)) {
             return;
         }
 
-        if (isDirectory(index)) {
-            fs_path path = getPath(index);
+        if (isDirectory_(index)) {
+            fs_path path = getPath_(index);
 
             size_t i = 0;
             for (const auto &entry : Filesystem::directory_iterator(path)) {
@@ -595,55 +787,6 @@ namespace Toolbox {
         }
     }
 
-    const ImageHandle &FileSystemModel::InvalidIcon() {
-        static ImageHandle s_invalid_fs_icon = ImageHandle("Images/Icons/fs_invalid.png");
-        return s_invalid_fs_icon;
-    }
-
-    const std::unordered_map<std::string, FileSystemModel::FSTypeInfo> &FileSystemModel::TypeMap() {
-        // clang-format off
-        static std::unordered_map<std::string, FileSystemModel::FSTypeInfo> s_type_map = {
-            {"_Invalid", FSTypeInfo("Invalid",                  "fs_invalid.png")       },
-            {"_Folder",  FSTypeInfo("Folder",                   "fs_generic_folder.png")},
-            {"_Archive", FSTypeInfo("Archive",                  "fs_arc.png")           },
-            {"_File",    FSTypeInfo("File",                     "fs_generic_file.png")  },
-            {".txt",     FSTypeInfo("Text",                     "fs_txt.png")           },
-            {".md",      FSTypeInfo("Markdown",                 "fs_md.png")            },
-            {".c",       FSTypeInfo("C",                        "fs_c.png")             },
-            {".h",       FSTypeInfo("Header",                   "fs_h.png")             },
-            {".cpp",     FSTypeInfo("C++",                      "fs_cpp.png")           },
-            {".hpp",     FSTypeInfo("Header",                   "fs_hpp.png")           },
-            {".cxx",     FSTypeInfo("C++",                      "fs_cpp.png")           },
-            {".hxx",     FSTypeInfo("Header",                   "fs_hpp.png")           },
-            {".c++",     FSTypeInfo("C++",                      "fs_cpp.png")           },
-            {".h++",     FSTypeInfo("Header",                   "fs_hpp.png")           },
-            {".cc",      FSTypeInfo("C++",                      "fs_cpp.png")           },
-            {".hh",      FSTypeInfo("Header",                   "fs_hpp.png")           },
-            {".arc",     FSTypeInfo("Archive",                  "fs_arc.png")           },
-            {".bas",     FSTypeInfo("JAudio Sequence",          "fs_bas.png")           },
-            {".bck",     FSTypeInfo("J3D Bone Animation",       "fs_bck.png")           },
-            {".bdl",     FSTypeInfo("J3D Model Data",           "fs_bdl.png")           },
-            {".blo",     FSTypeInfo("J2D Screen Layout",        "fs_blo.png")           },
-            {".bmd",     FSTypeInfo("J3D Model Data",           "fs_bmd.png")           },
-            {".bmg",     FSTypeInfo("Message Data",             "fs_bmg.png")           },
-            {".bmt",     FSTypeInfo("J3D Material Table",       "fs_bmt.png")           },
-            {".brk",     FSTypeInfo("J3D Color Register Anim",  "fs_brk.png")           },
-            {".bti",     FSTypeInfo("J2D Texture Image",        "fs_bti.png")           },
-            {".btk",     FSTypeInfo("J2D Texture Animation",    "fs_btk.png")           },
-            {".btp",     FSTypeInfo("J2D Texture Pattern Anim", "fs_btp.png")           },
-            {".col",     FSTypeInfo("SMS Collision Data",       "fs_col.png")           },
-            {".jpa",     FSTypeInfo("JParticle Data",           "fs_jpa.png")           },
-            {".map",     FSTypeInfo("Executable Symbol Map",    "fs_map.png")           },
-            {".me",      FSTypeInfo("Marked For Delete",        "fs_me.png")            },
-            {".prm",     FSTypeInfo("SMS Parameter Data",       "fs_prm.png")           },
-            {".sb",      FSTypeInfo("Sunscript",                "fs_sb.png")            },
-            {".szs",     FSTypeInfo("Yaz0 Compressed Data",     "fs_szs.png")           },
-            {".thp",     FSTypeInfo("DolphinOS Movie Data",     "fs_thp.png")           },
-        };
-        // clang-format on
-        return s_type_map;
-    }
-
     ModelIndex FileSystemModel::makeIndex(const fs_path &path, int64_t row,
                                           const ModelIndex &parent) {
         _FileSystemIndexData *parent_data = nullptr;
@@ -664,7 +807,6 @@ namespace Toolbox {
         _FileSystemIndexData *data = new _FileSystemIndexData;
         data->m_path               = path;
         data->m_name               = path.filename().string();
-        data->m_size               = 0;
         data->m_children           = {};
 
         if (Filesystem::is_directory(path).value_or(false)) {
@@ -691,6 +833,21 @@ namespace Toolbox {
                 return Result<Filesystem::file_time_type, FSError>();
             });
 
+        if (data->m_type == _FileSystemIndexData::Type::FILE) {
+            Filesystem::file_size(data->m_path)
+                .and_then([&](size_t size) {
+                    data->m_size = size;
+                    return Result<size_t, FSError>();
+                })
+                .or_else([&](const FSError &error) {
+                    TOOLBOX_ERROR_V("[FileSystemModel] Failed to get file size: {}",
+                                    error.m_message[0]);
+                    return Result<size_t, FSError>();
+                });
+        } else {
+            data->m_size = 0;
+        }
+
         ModelIndex index = ModelIndex(getUUID());
 
         // Establish icon
@@ -733,12 +890,12 @@ namespace Toolbox {
     }
 
     ModelIndex FileSystemModel::getParentArchive(const ModelIndex &index) const {
-        ModelIndex parent = getParent(index);
+        ModelIndex parent = getParent_(index);
         do {
-            if (isArchive(parent)) {
+            if (isArchive_(parent)) {
                 return parent;
             }
-            parent = getParent(parent);
+            parent = getParent_(parent);
         } while (validateIndex(parent));
 
         return ModelIndex();
@@ -751,15 +908,15 @@ namespace Toolbox {
 
         size_t count = 0;
 
-        if (isDirectory(index)) {
+        if (isDirectory_(index)) {
             // Count the children in the filesystem
-            for (const auto &entry : Filesystem::directory_iterator(getPath(index))) {
+            for (const auto &entry : Filesystem::directory_iterator(getPath_(index))) {
                 count += 1;
             }
-        } else if (isArchive(index)) {
+        } else if (isArchive_(index)) {
             // Count the children in the archive
             TOOLBOX_ERROR("[FileSystemModel] Archive polling unimplemented!");
-        } else if (isFile(index)) {
+        } else if (isFile_(index)) {
             // Files have no children
             count = 0;
         } else {
@@ -770,12 +927,220 @@ namespace Toolbox {
         return count;
     }
 
+    void FileSystemModel::folderAdded(const fs_path &path) {
+        {
+            std::scoped_lock lock(m_mutex);
+
+            ModelIndex parent = getIndex_(path.parent_path());
+            if (!validateIndex(parent)) {
+                return;
+            }
+
+            makeIndex(path, getRowCount_(parent), parent);
+        }
+
+        for (const auto &[key, listener] : m_listeners) {
+            if ((listener.second & FileSystemModelEventFlags::EVENT_FOLDER_ADDED) !=
+                FileSystemModelEventFlags::NONE) {
+                listener.first(path, FileSystemModelEventFlags::EVENT_FOLDER_ADDED);
+            }
+        }
+    }
+
+    void FileSystemModel::folderModified(const fs_path &path) {
+        {
+            std::scoped_lock lock(m_mutex);
+
+            ModelIndex index = getIndex_(path);
+            if (!validateIndex(index)) {
+                return;
+            }
+
+            _FileSystemIndexData *data = index.data<_FileSystemIndexData>();
+
+            Filesystem::last_write_time(data->m_path)
+                .and_then([&](Filesystem::file_time_type &&time) {
+                    data->m_date = std::move(time);
+                    return Result<Filesystem::file_time_type, FSError>();
+                })
+                .or_else([&](const FSError &error) {
+                    TOOLBOX_ERROR_V("[FileSystemModel] Failed to get last write time: {}",
+                                    error.m_message[0]);
+                    return Result<Filesystem::file_time_type, FSError>();
+                });
+        }
+
+        for (const auto &[key, listener] : m_listeners) {
+            if ((listener.second & FileSystemModelEventFlags::EVENT_FOLDER_MODIFIED) !=
+                FileSystemModelEventFlags::NONE) {
+                listener.first(path, FileSystemModelEventFlags::EVENT_FOLDER_MODIFIED);
+            }
+        }
+    }
+
+    void FileSystemModel::fileAdded(const fs_path &path) {
+        {
+            std::scoped_lock lock(m_mutex);
+
+            ModelIndex parent = getIndex_(path.parent_path());
+            if (!validateIndex(parent)) {
+                return;
+            }
+
+            makeIndex(path, getRowCount_(parent), parent);
+        }
+
+        for (const auto &[key, listener] : m_listeners) {
+            if ((listener.second & FileSystemModelEventFlags::EVENT_FILE_ADDED) !=
+                FileSystemModelEventFlags::NONE) {
+                listener.first(path, FileSystemModelEventFlags::EVENT_FILE_ADDED);
+            }
+        }
+    }
+
+    void FileSystemModel::fileModified(const fs_path &path) {
+        {
+            std::scoped_lock lock(m_mutex);
+
+            ModelIndex index = getIndex_(path);
+            if (!validateIndex(index)) {
+                return;
+            }
+
+            _FileSystemIndexData *data = index.data<_FileSystemIndexData>();
+
+            Filesystem::last_write_time(data->m_path)
+                .and_then([&](Filesystem::file_time_type &&time) {
+                    data->m_date = std::move(time);
+                    return Result<Filesystem::file_time_type, FSError>();
+                })
+                .or_else([&](const FSError &error) {
+                    TOOLBOX_ERROR_V("[FileSystemModel] Failed to get last write time: {}",
+                                    error.m_message[0]);
+                    return Result<Filesystem::file_time_type, FSError>();
+                });
+
+            Filesystem::file_size(data->m_path)
+                .and_then([&](size_t size) {
+                    data->m_size = size;
+                    return Result<size_t, FSError>();
+                })
+                .or_else([&](const FSError &error) {
+                    TOOLBOX_ERROR_V("[FileSystemModel] Failed to get file size: {}",
+                                    error.m_message[0]);
+                    return Result<size_t, FSError>();
+                });
+        }
+
+        for (const auto &[key, listener] : m_listeners) {
+            if ((listener.second & FileSystemModelEventFlags::EVENT_FILE_MODIFIED) !=
+                FileSystemModelEventFlags::NONE) {
+                listener.first(path, FileSystemModelEventFlags::EVENT_FILE_MODIFIED);
+            }
+        }
+    }
+
+    void FileSystemModel::pathRenamedSrc(const fs_path &old_path) {
+        std::scoped_lock lock(m_mutex);
+        m_rename_src = old_path;
+    }
+
+    void FileSystemModel::pathRenamedDst(const fs_path &new_path) {
+        {
+            std::scoped_lock lock(m_mutex);
+
+            ModelIndex index = getIndex_(m_rename_src);
+            if (!validateIndex(index)) {
+                return;
+            }
+
+            _FileSystemIndexData *data = index.data<_FileSystemIndexData>();
+            data->m_path               = new_path;
+            data->m_name               = new_path.filename().string();
+
+            // Reparent index if necessary
+            ModelIndex parent = getParent_(index);
+            if (!validateIndex(parent)) {
+                return;
+            }
+
+            if (parent.data<_FileSystemIndexData>()->m_path != new_path.parent_path()) {
+                _FileSystemIndexData *old_parent_data = parent.data<_FileSystemIndexData>();
+                old_parent_data->m_children.erase(std::remove(old_parent_data->m_children.begin(),
+                                                              old_parent_data->m_children.end(),
+                                                              index.getUUID()),
+                                                  old_parent_data->m_children.end());
+
+                ModelIndex new_parent = getIndex_(new_path.parent_path());
+                if (!validateIndex(new_parent)) {
+                    return;
+                }
+
+                _FileSystemIndexData *new_parent_data = new_parent.data<_FileSystemIndexData>();
+                new_parent_data->m_children.push_back(index.getUUID());
+            }
+        }
+
+        for (const auto &[key, listener] : m_listeners) {
+            if ((listener.second & FileSystemModelEventFlags::EVENT_PATH_RENAMED) !=
+                FileSystemModelEventFlags::NONE) {
+                listener.first(new_path, FileSystemModelEventFlags::EVENT_PATH_RENAMED);
+            }
+        }
+    }
+
+    void FileSystemModel::pathRemoved(const fs_path &path) {
+        {
+            std::scoped_lock lock(m_mutex);
+
+            ModelIndex index = getIndex_(path);
+            if (!validateIndex(index)) {
+                return;
+            }
+
+            ModelIndex parent = getParent_(index);
+            if (!validateIndex(parent)) {
+                return;
+            }
+
+            {
+                _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
+                parent_data->m_children.erase(std::remove(parent_data->m_children.begin(),
+                                                          parent_data->m_children.end(),
+                                                          index.getUUID()),
+                                              parent_data->m_children.end());
+                delete index.data<_FileSystemIndexData>();
+                m_index_map.erase(index.getUUID());
+            }
+        }
+
+        for (const auto &[key, listener] : m_listeners) {
+            if ((listener.second & FileSystemModelEventFlags::EVENT_PATH_REMOVED) !=
+                FileSystemModelEventFlags::NONE) {
+                listener.first(path, FileSystemModelEventFlags::EVENT_PATH_REMOVED);
+            }
+        }
+    }
+
     RefPtr<FileSystemModel> FileSystemModelSortFilterProxy::getSourceModel() const {
         return m_source_model;
     }
 
     void FileSystemModelSortFilterProxy::setSourceModel(RefPtr<FileSystemModel> model) {
+        if (m_source_model == model) {
+            return;
+        }
+
+        if (m_source_model) {
+            m_source_model->removeEventListener(getUUID());
+        }
+
         m_source_model = model;
+
+        if (m_source_model) {
+            m_source_model->addEventListener(getUUID(), TOOLBOX_BIND_EVENT_FN(fsUpdateEvent),
+                                                          FileSystemModelEventFlags::EVENT_ANY);
+        }
     }
 
     ModelSortOrder FileSystemModelSortFilterProxy::getSortOrder() const { return m_sort_order; }
@@ -924,11 +1289,6 @@ namespace Toolbox {
 
     size_t FileSystemModelSortFilterProxy::getRowCount(const ModelIndex &index) const {
         ModelIndex &&source_index = toSourceIndex(index);
-
-        if (m_row_map.find(source_index.getUUID()) != m_row_map.end()) {
-            return m_row_map[source_index.getUUID()].size();
-        }
-
         return m_source_model->getRowCount(source_index);
     }
 
@@ -979,7 +1339,7 @@ namespace Toolbox {
 
         ModelIndex proxy_index = ModelIndex(getUUID());
         proxy_index.setData(index.data<_FileSystemIndexData>());
-        
+
         IDataModel::setIndexUUID(proxy_index, index.getUUID());
 
         return proxy_index;
@@ -1116,4 +1476,18 @@ namespace Toolbox {
         }
     }
 
+    void FileSystemModelSortFilterProxy::fsUpdateEvent(const fs_path &path,
+                                                       FileSystemModelEventFlags flags) {
+        if ((flags & FileSystemModelEventFlags::EVENT_ANY) == FileSystemModelEventFlags::NONE) {
+            return;
+        }
+
+        if ((flags & FileSystemModelEventFlags::EVENT_PATH_RENAMED) !=
+            FileSystemModelEventFlags::NONE) {
+            m_filter_map.clear();
+        }
+
+        m_row_map.clear();
+    }
+
 }  // namespace Toolbox
\ No newline at end of file

From 018db646f8d3bb3cfc7faf990409a8cfbc44a27a Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sun, 29 Sep 2024 12:45:47 -0500
Subject: [PATCH 040/129] Fix race condition in filter proxy

---
 include/model/fsmodel.hpp |  9 +++++++--
 src/model/fsmodel.cpp     | 25 +++++++++++++++++--------
 2 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index 619278c5..346d3fcc 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -134,7 +134,8 @@ namespace Toolbox {
         void fetchMore(const ModelIndex &index) override;
 
         using event_listener_t = std::function<void(const fs_path &, FileSystemModelEventFlags)>;
-        void addEventListener(UUID64 uuid, event_listener_t listener, FileSystemModelEventFlags flags);
+        void addEventListener(UUID64 uuid, event_listener_t listener,
+                              FileSystemModelEventFlags flags);
         void removeEventListener(UUID64 uuid);
 
         static const ImageHandle &InvalidIcon();
@@ -202,7 +203,8 @@ namespace Toolbox {
 
         mutable std::mutex m_mutex;
         FileSystemWatchdog m_watchdog;
-        std::unordered_map<UUID64, std::pair<event_listener_t, FileSystemModelEventFlags>> m_listeners;
+        std::unordered_map<UUID64, std::pair<event_listener_t, FileSystemModelEventFlags>>
+            m_listeners;
 
         fs_path m_root_path;
 
@@ -293,7 +295,9 @@ namespace Toolbox {
                                               const ModelIndex &parent = ModelIndex()) const;
 
         [[nodiscard]] bool isFiltered(const UUID64 &uuid) const;
+
         void cacheIndex(const ModelIndex &index) const;
+        void cacheIndex_(const ModelIndex &index) const;
 
         ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent) {
             return ModelIndex();
@@ -311,6 +315,7 @@ namespace Toolbox {
 
         bool m_dirs_only = false;
 
+        mutable std::mutex m_cache_mutex;
         mutable std::unordered_map<UUID64, bool> m_filter_map;
         mutable std::unordered_map<UUID64, std::vector<int64_t>> m_row_map;
     };
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 5a36fbc5..3d79d0a3 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -1139,7 +1139,7 @@ namespace Toolbox {
 
         if (m_source_model) {
             m_source_model->addEventListener(getUUID(), TOOLBOX_BIND_EVENT_FN(fsUpdateEvent),
-                                                          FileSystemModelEventFlags::EVENT_ANY);
+                                             FileSystemModelEventFlags::EVENT_ANY);
         }
     }
 
@@ -1261,6 +1261,8 @@ namespace Toolbox {
 
     ModelIndex FileSystemModelSortFilterProxy::getSibling(int64_t row, int64_t column,
                                                           const ModelIndex &index) const {
+        std::unique_lock lock(m_cache_mutex);
+
         ModelIndex source_index       = toSourceIndex(index);
         ModelIndex src_parent         = getParent(source_index);
         const UUID64 &src_parent_uuid = src_parent.getUUID();
@@ -1271,7 +1273,7 @@ namespace Toolbox {
         }
 
         if (m_row_map.find(map_key) == m_row_map.end()) {
-            cacheIndex(src_parent);
+            cacheIndex_(src_parent);
         }
 
         if (row < m_row_map[map_key].size()) {
@@ -1346,7 +1348,9 @@ namespace Toolbox {
     }
 
     ModelIndex FileSystemModelSortFilterProxy::toProxyIndex(int64_t row, int64_t column,
-                                                            const ModelIndex &src_parent) const {
+                                                             const ModelIndex &src_parent) const {
+        std::unique_lock lock(m_cache_mutex);
+
         const UUID64 &src_parent_uuid = src_parent.getUUID();
 
         u64 map_key = src_parent_uuid;
@@ -1355,7 +1359,7 @@ namespace Toolbox {
         }
 
         if (m_row_map.find(map_key) == m_row_map.end()) {
-            cacheIndex(src_parent);
+            cacheIndex_(src_parent);
         }
 
         if (row < m_row_map[map_key].size()) {
@@ -1388,6 +1392,11 @@ namespace Toolbox {
     }
 
     void FileSystemModelSortFilterProxy::cacheIndex(const ModelIndex &dir_index) const {
+        std::unique_lock lock(m_cache_mutex);
+        cacheIndex_(dir_index);
+    }
+
+    void FileSystemModelSortFilterProxy::cacheIndex_(const ModelIndex &dir_index) const {
         std::vector<UUID64> orig_children  = {};
         std::vector<UUID64> proxy_children = {};
 
@@ -1482,12 +1491,12 @@ namespace Toolbox {
             return;
         }
 
-        if ((flags & FileSystemModelEventFlags::EVENT_PATH_RENAMED) !=
-            FileSystemModelEventFlags::NONE) {
+        {
+            std::scoped_lock lock(m_cache_mutex);
+
             m_filter_map.clear();
+            m_row_map.clear();
         }
-
-        m_row_map.clear();
     }
 
 }  // namespace Toolbox
\ No newline at end of file

From 67d613cf8613305d573fea57e9957534f80a9562 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sun, 29 Sep 2024 16:12:26 -0500
Subject: [PATCH 041/129] Start implementing context menu

---
 include/gui/context_menu.hpp   |  24 ++++-
 include/gui/project/window.hpp |  22 +++--
 src/gui/project/window.cpp     | 168 ++++++++++++++++++++++++++++-----
 src/model/fsmodel.cpp          |   4 +-
 4 files changed, 181 insertions(+), 37 deletions(-)

diff --git a/include/gui/context_menu.hpp b/include/gui/context_menu.hpp
index 6bc500c9..b2c221a3 100644
--- a/include/gui/context_menu.hpp
+++ b/include/gui/context_menu.hpp
@@ -22,8 +22,9 @@ namespace Toolbox::UI {
 
     template <typename _DataT> class ContextMenu {
     public:
-        using operator_t  = std::function<void(_DataT)>;
-        using condition_t = std::function<bool()>;
+        using operator_t   = std::function<void(_DataT)>;
+        using condition_t  = std::function<bool()>;
+        using open_event_t = std::function<void(_DataT)>;
 
         struct ContextOp {
             std::string m_name;
@@ -45,12 +46,16 @@ namespace Toolbox::UI {
 
         void render(std::optional<std::string> label, _DataT ctx);
 
+        void onOpen(open_event_t open) { m_open_event = open; }
+
     protected:
         void processKeybinds(_DataT ctx);
 
     private:
         std::vector<ContextOp> m_options;
         std::set<size_t> m_dividers;
+        open_event_t m_open_event;
+        bool m_was_open = false;
     };
 
     template <typename _DataT>
@@ -81,8 +86,17 @@ namespace Toolbox::UI {
     inline void ContextMenu<_DataT>::render(std::optional<std::string> label, _DataT ctx) {
         processKeybinds(ctx);
 
-        if (!ImGui::BeginPopupContextItem(label ? label->c_str() : nullptr))
+        if (!ImGui::BeginPopupContextItem(label ? label->c_str() : nullptr)) {
+            m_was_open = false;
             return;
+        }
+
+        if (!m_was_open && m_open_event) {
+            m_open_event(ctx);
+        }
+        m_was_open = true;
+
+        size_t prev_opt_index = 0; 
 
         for (size_t i = 0; i < m_options.size(); ++i) {
             ContextOp &option = m_options.at(i);
@@ -90,9 +104,10 @@ namespace Toolbox::UI {
                 continue;
             }
 
-            if (m_dividers.find(i) != m_dividers.end()) {
+            if (prev_opt_index > 0 && m_dividers.find(prev_opt_index + 1) != m_dividers.end()) {
                 ImGui::Separator();
             }
+            prev_opt_index = i;
 
             std::string keybind_name = option.m_keybind.toString();
 
@@ -117,6 +132,7 @@ namespace Toolbox::UI {
             bool keybind_pressed = option.m_keybind.isInputMatching();
 
             if (keybind_pressed && !option.m_keybind_used) {
+                m_open_event(ctx);
                 option.m_keybind_used = true;
                 option.m_op(ctx);
             }
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 3aa25906..8bea3b42 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -16,10 +16,11 @@
 
 #include "core/clipboard.hpp"
 #include "game/task.hpp"
+#include "gui/context_menu.hpp"
 #include "gui/event/event.hpp"
 #include "gui/image/imagepainter.hpp"
-#include "gui/window.hpp"
 #include "gui/project/asset.hpp"
+#include "gui/window.hpp"
 
 #include "model/fsmodel.hpp"
 
@@ -69,16 +70,12 @@ namespace Toolbox::UI {
             };
         }
 
-        [[nodiscard]] std::string context() const override {
-            return m_project_root.string();
-        }
+        [[nodiscard]] std::string context() const override { return m_project_root.string(); }
 
         [[nodiscard]] bool unsaved() const override { return false; }
 
         // Returns the supported file types, empty string is designed for a folder.
-        [[nodiscard]] std::vector<std::string> extensions() const override {
-            return {};
-        }
+        [[nodiscard]] std::vector<std::string> extensions() const override { return {}; }
 
         [[nodiscard]] bool onLoadData(const std::filesystem::path &path) override;
 
@@ -93,6 +90,12 @@ namespace Toolbox::UI {
         void onDragEvent(RefPtr<DragEvent> ev) override;
         void onDropEvent(RefPtr<DropEvent> ev) override;
 
+        void buildContextMenu();
+
+        // Selection actions
+        void actionDeleteIndexes(std::vector<ModelIndex> &indices);
+        void actionOpenIndexes(const std::vector<ModelIndex> &indices);
+
     private:
         fs_path m_project_root;
 
@@ -110,7 +113,10 @@ namespace Toolbox::UI {
         std::unordered_map<std::string, ImageHandle> m_icon_map;
         ImagePainter m_icon_painter;
 
-        std::unordered_map<UUID64, ImVec2> m_text_sizes;
+        ContextMenu<ModelIndex> m_context_menu;
+        std::vector<ModelIndex> m_selected_indices_ctx;
+        bool m_delete_without_request = false;
+        bool m_delete_requested     = false;
     };
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index f6de6489..f4d5c2c6 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -18,6 +18,7 @@ namespace Toolbox::UI {
         renderProjectFolderView();
         renderProjectFolderButton();
         renderProjectFileButton();
+        m_context_menu.render("Project View", m_view_index);
     }
 
     void ProjectViewWindow::renderProjectTreeView() {
@@ -63,9 +64,11 @@ namespace Toolbox::UI {
                         continue;
                     }
 
+                    ModelIndex source_child_index = m_view_proxy.toSourceIndex(child_index);
+
                     bool is_selected =
                         std::find(m_selected_indices.begin(), m_selected_indices.end(),
-                                  child_index) != m_selected_indices.end();
+                                  source_child_index) != m_selected_indices.end();
 
                     if (is_selected) {
                         ImGui::PushStyleColor(ImGuiCol_ChildBg,
@@ -126,7 +129,6 @@ namespace Toolbox::UI {
                                 m_is_renaming = false;
                                 if (m_view_proxy.isDirectory(child_index)) {
                                     m_view_index = m_view_proxy.toSourceIndex(child_index);
-                                    // m_fs_watchdog.addPath(m_file_system_model->getPath(m_view_index));
                                     ImGui::EndChild();
                                     ImGui::PopStyleColor(1);
                                     break;
@@ -134,9 +136,9 @@ namespace Toolbox::UI {
                             } else if (ImGui::IsMouseClicked(0)) {
                                 if (is_selected) {
                                     if (ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
-                                        m_selected_indices.erase(
-                                            std::find(m_selected_indices.begin(),
-                                                      m_selected_indices.end(), child_index));
+                                        m_selected_indices.erase(std::find(
+                                            m_selected_indices.begin(), m_selected_indices.end(),
+                                            source_child_index));
                                         m_is_renaming = false;
                                     } else {
                                         m_is_renaming = true;
@@ -147,7 +149,7 @@ namespace Toolbox::UI {
                                     if (!ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
                                         m_selected_indices.clear();
                                     }
-                                    m_selected_indices.push_back(child_index);
+                                    m_selected_indices.push_back(source_child_index);
                                     m_is_renaming = false;
                                 }
                             }
@@ -165,30 +167,28 @@ namespace Toolbox::UI {
 
                 ImVec2 center = ImGui::GetMainViewport()->GetCenter();
                 ImGui::SetNextWindowPos(center, ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
-                static bool dont_ask_for_deletes = false;
+
                 if (ImGui::BeginPopupModal("Delete?", NULL, ImGuiWindowFlags_AlwaysAutoResize)) {
                     std::string message = "";
 
-                    if (m_selected_indices.size() == 1) {
+                    if (m_selected_indices_ctx.size() == 1) {
                         message = TOOLBOX_FORMAT_FN(
                             "Are you sure you want to delete {}?",
                             m_file_system_model->getDisplayText(m_selected_indices[0]));
-                    } else if (m_selected_indices.size() > 1) {
+                    } else if (m_selected_indices_ctx.size() > 1) {
                         message = TOOLBOX_FORMAT_FN(
                             "Are you sure you want to delete the {} selected files?",
-                            m_selected_indices.size());
+                            m_selected_indices_ctx.size());
                     } else {
                         TOOLBOX_ERROR("Selected 0 files to delete!");
                     }
                     ImGui::Text(message.c_str());
                     ImGui::Separator();
                     ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
-                    ImGui::Checkbox("Don't ask me next time", &dont_ask_for_deletes);
+                    ImGui::Checkbox("Don't ask me next time", &m_delete_without_request);
                     ImGui::PopStyleVar();
                     if (ImGui::Button("OK", ImVec2(120, 0))) {
-                        for (auto &item_index : m_selected_indices) {
-                            m_file_system_model->remove(item_index);
-                        }
+                        actionDeleteIndexes(m_selected_indices_ctx);
                         ImGui::CloseCurrentPopup();
                     }
                     ImGui::SetItemDefaultFocus();
@@ -204,14 +204,9 @@ namespace Toolbox::UI {
                         m_is_renaming = false;
                     }
                     // Delete stuff
-                    if (ImGui::IsKeyPressed(ImGuiKey_Delete) && !m_selected_indices.empty()) {
-                        if (dont_ask_for_deletes) {
-                            for (auto &item_index : m_selected_indices) {
-                                m_file_system_model->remove(item_index);
-                            }
-                        } else {
-                            ImGui::OpenPopup("Delete?");
-                        }
+                    if (m_delete_requested) {
+                        ImGui::OpenPopup("Delete?");
+                        m_delete_requested = false;
                     }
                 }
 
@@ -238,7 +233,7 @@ namespace Toolbox::UI {
         return true;
     }
 
-    void ProjectViewWindow::onAttach() {}
+    void ProjectViewWindow::onAttach() { buildContextMenu(); }
 
     void ProjectViewWindow::onDetach() {}
 
@@ -250,6 +245,133 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {}
 
+    void ProjectViewWindow::buildContextMenu() {
+        m_context_menu = ContextMenu<ModelIndex>();
+
+        m_context_menu.onOpen(
+            [this](const ModelIndex &index) { m_selected_indices_ctx = m_selected_indices; });
+
+        m_context_menu.addOption(
+            "Open", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_O}),
+            [this]() {
+                return m_selected_indices_ctx.size() > 0 &&
+                       std::all_of(m_selected_indices_ctx.begin(), m_selected_indices_ctx.end(),
+                                   [this](const ModelIndex &index) {
+                                       return m_file_system_model->isFile(index);
+                                   });
+            },
+            [this](auto) { actionOpenIndexes(m_selected_indices_ctx); });
+
+        m_context_menu.addOption(
+            "Open in Explorer",
+            KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTSHIFT, KeyCode::KEY_O}),
+            [this]() {
+                return std::all_of(
+                    m_selected_indices_ctx.begin(), m_selected_indices_ctx.end(),
+                    [this](const ModelIndex &index) { return m_file_system_model->isFile(index); });
+            },
+            [this](auto) {
+                if (m_selected_indices_ctx.size() == 0) {
+                    // TODO: Implement this interface
+                    // Toolbox::Platform::OpenFileExplorer(path);
+                } else {
+                    std::set<fs_path> paths;
+                    for (const ModelIndex &item_index : m_selected_indices_ctx) {
+                        fs_path path = m_file_system_model->getPath(item_index);
+                        if (m_file_system_model->isDirectory(item_index)) {
+                            paths.insert(path);
+                        } else {
+                            paths.insert(path.parent_path());
+                        }
+                    }
+                    for (const fs_path &path : paths) {
+                        // TODO: Implement this interface
+                        // Toolbox::Platform::OpenFileExplorer(path);
+                    }
+                }
+            });
+
+        m_context_menu.addDivider();
+
+        m_context_menu.addOption(
+            "Copy Path",
+            KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTSHIFT, KeyCode::KEY_C}),
+            [this]() { return true; },
+            [this](auto) {
+                std::string paths;
+                if (m_selected_indices_ctx.size() == 0) {
+                    paths = m_file_system_model->getPath(m_view_index).string();
+                } else {
+                    for (const ModelIndex &item_index : m_selected_indices_ctx) {
+                        fs_path path = m_file_system_model->getPath(item_index);
+                        paths += path.string() + "\n";
+                    }
+                }
+                ImGui::SetClipboardText(paths.c_str());
+            });
+
+        m_context_menu.addDivider();
+
+        m_context_menu.addOption(
+            "Cut", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_X}),
+            [this]() { return m_selected_indices_ctx.size() > 0; }, [this](auto) {});
+
+        m_context_menu.addOption(
+            "Copy", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C}),
+            [this]() { return m_selected_indices_ctx.size() > 0; }, [this](auto) {});
+
+        m_context_menu.addDivider();
+
+        m_context_menu.addOption(
+            "Delete", KeyBind({KeyCode::KEY_DELETE}),
+            [this]() { return m_selected_indices_ctx.size() > 0; },
+            [this](auto) {
+                if (m_delete_without_request) {
+                    actionDeleteIndexes(m_selected_indices_ctx);
+                } else {
+                    m_delete_requested = true;
+                }
+            });
+
+        m_context_menu.addOption(
+            "Rename", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_R}),
+            [this]() { return m_selected_indices_ctx.size() == 1; },
+            [this](auto) {
+                m_is_renaming = true;
+                std::strncpy(m_rename_buffer,
+                             m_file_system_model->getDisplayText(m_selected_indices_ctx[0]).c_str(),
+                             IM_ARRAYSIZE(m_rename_buffer));
+            });
+
+        m_context_menu.addDivider();  
+
+        m_context_menu.addOption(
+            "New...", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N}),
+            [this]() { return m_selected_indices_ctx.size() == 0; },
+            [this](const ModelIndex &view_index) {
+                // TODO: Open a dialog that gives the user different file types to create.
+            });
+    }
+
+    void ProjectViewWindow::actionDeleteIndexes(std::vector<ModelIndex> &indices) {
+        for (auto &item_index : indices) {
+            m_file_system_model->remove(item_index);
+        }
+        indices.clear();
+    }
+
+    void ProjectViewWindow::actionOpenIndexes(const std::vector<ModelIndex> &indices) {
+        for (auto &item_index : indices) {
+            if (m_file_system_model->isDirectory(item_index)) {
+                m_view_index = item_index;
+                continue;
+            }
+
+            // TODO: Open files based on extension. Can be either internal or external
+            // depending on the file type.
+        }
+    }
+
     bool ProjectViewWindow::isViewedAncestor(const ModelIndex &index) {
         if (m_view_index == m_tree_proxy.toSourceIndex(index)) {
             return true;
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 3d79d0a3..ac6a7103 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -339,7 +339,7 @@ namespace Toolbox {
             {".bmt",     FSTypeInfo("J3D Material Table",       "fs_bmt.png")           },
             {".brk",     FSTypeInfo("J3D Color Register Anim",  "fs_brk.png")           },
             {".bti",     FSTypeInfo("J2D Texture Image",        "fs_bti.png")           },
-            {".btk",     FSTypeInfo("J2D Texture Animation",    "fs_btk.png")           },
+            {".btk",     FSTypeInfo("J2D Texture UV Anim",      "fs_btk.png")           },
             {".btp",     FSTypeInfo("J2D Texture Pattern Anim", "fs_btp.png")           },
             {".col",     FSTypeInfo("SMS Collision Data",       "fs_col.png")           },
             {".jpa",     FSTypeInfo("JParticle Data",           "fs_jpa.png")           },
@@ -1348,7 +1348,7 @@ namespace Toolbox {
     }
 
     ModelIndex FileSystemModelSortFilterProxy::toProxyIndex(int64_t row, int64_t column,
-                                                             const ModelIndex &src_parent) const {
+                                                            const ModelIndex &src_parent) const {
         std::unique_lock lock(m_cache_mutex);
 
         const UUID64 &src_parent_uuid = src_parent.getUUID();

From 400835aa704fedb1f9f5b9ad8ccb806eaad5dccd Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Sun, 29 Sep 2024 15:02:50 -0700
Subject: [PATCH 042/129] Fix FileWatch.hpp to build on Unix platforms

---
 lib/FileWatch.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/FileWatch.hpp b/lib/FileWatch.hpp
index bee35672..8df7621e 100644
--- a/lib/FileWatch.hpp
+++ b/lib/FileWatch.hpp
@@ -88,6 +88,7 @@
 #include <unordered_set>
 #include <utility>
 #include <vector>
+#include <filesystem>
 
 #ifdef FILEWATCH_PLATFORM_MAC
 extern "C" int __getdirentries64(int, char *, int, long *);
@@ -686,7 +687,7 @@ namespace filewatch {
 
             if (IsWChar<C>::value) {
                 size_t needed = mbsrtowcs(nullptr, &str, 0, &state) + 1;
-                StringType s;
+                UnderpinningString s;
 
                 s.reserve(needed);
                 mbsrtowcs((wchar_t *)&s[0], &str, s.size(), &state);

From e6af82344df43e54cfc95cd8f2f09b2d89ee6da1 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 30 Sep 2024 10:34:08 -0500
Subject: [PATCH 043/129] Stablize visuals and stuff

---
 include/gui/project/window.hpp |   7 +-
 src/gui/project/window.cpp     | 150 ++++++++++++++++++---------------
 2 files changed, 89 insertions(+), 68 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 8bea3b42..66652298 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -95,6 +95,7 @@ namespace Toolbox::UI {
         // Selection actions
         void actionDeleteIndexes(std::vector<ModelIndex> &indices);
         void actionOpenIndexes(const std::vector<ModelIndex> &indices);
+        void actionRenameIndex(const ModelIndex &index);
 
     private:
         fs_path m_project_root;
@@ -107,14 +108,16 @@ namespace Toolbox::UI {
         std::vector<ModelIndex> m_selected_indices;
         std::vector<ProjectAsset> m_view_assets;
         ModelIndex m_view_index;
-        bool m_is_renaming = false;
-        char m_rename_buffer[128];
 
         std::unordered_map<std::string, ImageHandle> m_icon_map;
         ImagePainter m_icon_painter;
 
         ContextMenu<ModelIndex> m_context_menu;
         std::vector<ModelIndex> m_selected_indices_ctx;
+
+        bool m_is_renaming = false;
+        char m_rename_buffer[128];
+
         bool m_delete_without_request = false;
         bool m_delete_requested     = false;
     };
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index f4d5c2c6..de1ea520 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -35,6 +35,8 @@ namespace Toolbox::UI {
             return;
         }
 
+        const ImGuiStyle &style = ImGui::GetStyle();
+
         if (ImGui::BeginChild("Folder View", {0, 0}, true,
                               ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
             if (m_file_system_model->hasChildren(m_view_index)) {
@@ -46,6 +48,7 @@ namespace Toolbox::UI {
                 ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
                 ImGui::PushStyleVar(ImGuiStyleVar_ChildBorderSize, 0.0f);
                 ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, {2, 2});
+                ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 3.0f);
 
                 ImVec2 size = ImGui::GetContentRegionAvail();
 
@@ -79,87 +82,101 @@ namespace Toolbox::UI {
                                               ImGui::ColorConvertFloat4ToU32(
                                                   ImGui::GetStyleColorVec4(ImGuiCol_ChildBg)));
                     }
+                    const bool is_selected_rename = m_is_renaming && is_selected;
+
                     // Get the label and it's size
                     std::string text   = m_view_proxy.getDisplayText(child_index);
                     ImVec2 text_size   = ImGui::CalcTextSize(text.c_str());
                     ImVec2 rename_size = ImGui::CalcTextSize(m_rename_buffer);
 
-                    float box_width = m_is_renaming && is_selected ? std::max(rename_size.x, 76.0f)
-                                                                   : 76.0f;
-                    if (ImGui::BeginChild(child_index.getUUID(), {box_width, 92.0f}, true,
+                    const float box_width   = 76.0f;
+                    const float label_width = box_width - style.WindowPadding.x * 4.0f;
+                    const float text_width  = is_selected_rename
+                                                  ? std::min(rename_size.x, label_width)
+                                                  : std::min(text_size.x, label_width);
+
+                    if (ImGui::BeginChild(child_index.getUUID(), {box_width, 100.0f}, true,
                                           ImGuiWindowFlags_ChildWindow |
                                               ImGuiWindowFlags_NoDecoration)) {
-
-                        m_icon_painter.render(*m_view_proxy.getDecoration(child_index),
-                                              {72.0f, 72.0f});
+                        ImVec2 pos       = ImGui::GetCursorScreenPos() + style.WindowPadding;
+                        ImVec2 icon_size = ImVec2(box_width - style.WindowPadding.x * 2.0f,
+                                                  box_width - style.WindowPadding.x * 2.0f);
+                        m_icon_painter.render(*m_view_proxy.getDecoration(child_index), pos,
+                                              icon_size);
 
                         // Render the label
-                        ImVec2 pos    = ImGui::GetCursorScreenPos();
-                        ImVec2 newPos = pos;
-                        newPos.x += std::max<float>(36.0f - (((m_is_renaming && is_selected)
-                                                                  ? std::max(rename_size.x, 40.0f)
-                                                                  : text_size.x) /
-                                                             2.0f),
-                                                    0.0);
-                        newPos.y += 72.0f;
-                        if (m_is_renaming && is_selected) {
-                            ImGui::SetCursorScreenPos(newPos);
-                            ImGui::SetKeyboardFocusHere();
-                            ImGui::PushItemWidth(std::max(rename_size.x, 40.0f));
-                            bool done = ImGui::InputText("##rename", m_rename_buffer,
-                                                         IM_ARRAYSIZE(m_rename_buffer),
-                                                         ImGuiInputTextFlags_AutoSelectAll |
-                                                             ImGuiInputTextFlags_EnterReturnsTrue);
-                            if (done) {
-                                m_file_system_model->rename(m_view_proxy.toSourceIndex(child_index),
-                                                            m_rename_buffer);
+                        {
+                            if (m_is_renaming && is_selected) {
+                                ImVec2 rename_pos =
+                                    pos + ImVec2(style.WindowPadding.x,
+                                                 icon_size.y + style.ItemInnerSpacing.y -
+                                                     style.FramePadding.y);
+
+                                ImGui::SetCursorScreenPos(rename_pos);
+                                ImGui::SetKeyboardFocusHere();
+
+                                ImGui::PushItemWidth(label_width);
+                                bool done = ImGui::InputText(
+                                    "##rename", m_rename_buffer, IM_ARRAYSIZE(m_rename_buffer),
+                                    ImGuiInputTextFlags_AutoSelectAll |
+                                        ImGuiInputTextFlags_EnterReturnsTrue);
+                                if (done) {
+                                    m_file_system_model->rename(
+                                        m_view_proxy.toSourceIndex(child_index), m_rename_buffer);
+                                }
+                                ImGui::SetCursorScreenPos(pos);
+                                ImGui::PopItemWidth();
+                            } else {
+                                ImVec2 text_pos =
+                                    pos + ImVec2(style.WindowPadding.x,
+                                                 icon_size.y + style.ItemInnerSpacing.y);
+                                text_pos.x +=
+                                    std::max((label_width / 2.0f) - (text_width / 2.0f), 0.0f);
+
+                                float ellipsis_max = text_pos.x + label_width;
+                                ImVec2 text_clip_max =
+                                    ImVec2(ellipsis_max - 8.0f, text_pos.y + 20.0f);
+                                ImGui::RenderTextEllipsis(ImGui::GetWindowDrawList(), text_pos,
+                                                          text_clip_max, ellipsis_max, ellipsis_max,
+                                                          text.c_str(), nullptr, nullptr);
                             }
-                            ImGui::SetCursorScreenPos(pos);
-                            ImGui::PopItemWidth();
-                        } else {
-                            ImGui::RenderTextEllipsis(
-                                ImGui::GetWindowDrawList(), newPos, newPos + ImVec2(64, 20),
-                                pos.x + 64.0f, newPos.x + 76.0f, text.c_str(), nullptr, nullptr);
                         }
-                        any_items_hovered = any_items_hovered || ImGui::IsItemHovered() ||
-                                            ImGui::IsWindowHovered(ImGuiHoveredFlags_None);
+
                         // Handle click responses
-                        if (ImGui::IsWindowHovered(ImGuiHoveredFlags_None)) {
-                            if (ImGui::IsMouseDoubleClicked(0)) {
-                                m_is_renaming = false;
-                                if (m_view_proxy.isDirectory(child_index)) {
-                                    m_view_index = m_view_proxy.toSourceIndex(child_index);
-                                    ImGui::EndChild();
-                                    ImGui::PopStyleColor(1);
-                                    break;
-                                }
-                            } else if (ImGui::IsMouseClicked(0)) {
-                                if (is_selected) {
+                        {
+                            any_items_hovered = any_items_hovered || ImGui::IsItemHovered() ||
+                                                ImGui::IsWindowHovered(ImGuiHoveredFlags_None);
+                            if (ImGui::IsWindowHovered(ImGuiHoveredFlags_None)) {
+                                if (ImGui::IsMouseDoubleClicked(0)) {
+                                    m_is_renaming = false;
+                                    if (m_view_proxy.isDirectory(child_index)) {
+                                        m_view_index = m_view_proxy.toSourceIndex(child_index);
+                                        ImGui::EndChild();
+                                        ImGui::PopStyleColor(1);
+                                        break;
+                                    }
+                                } else if (ImGui::IsMouseClicked(0)) {
+                                    m_is_renaming = false;
                                     if (ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
-                                        m_selected_indices.erase(std::find(
-                                            m_selected_indices.begin(), m_selected_indices.end(),
-                                            source_child_index));
-                                        m_is_renaming = false;
+                                        if (is_selected) {
+                                            m_selected_indices.erase(std::remove(
+                                                m_selected_indices.begin(),
+                                                m_selected_indices.end(), source_child_index));
+                                        } else {
+                                            m_selected_indices.push_back(source_child_index);
+                                        }
                                     } else {
-                                        m_is_renaming = true;
-                                        std::strncpy(m_rename_buffer, text.c_str(),
-                                                     IM_ARRAYSIZE(m_rename_buffer));
-                                    }
-                                } else {
-                                    if (!ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
                                         m_selected_indices.clear();
+                                        m_selected_indices.push_back(source_child_index);
                                     }
-                                    m_selected_indices.push_back(source_child_index);
-                                    m_is_renaming = false;
                                 }
                             }
                         }
                     }
+
                     ImGui::EndChild();
                     ImGui::PopStyleColor(1);
 
-                    // ImGui::Text("%s", m_view_proxy.getDisplayText(child_index).c_str());
-
                     if ((i + 1) % x_count != 0) {
                         ImGui::SameLine();
                     }
@@ -210,7 +227,7 @@ namespace Toolbox::UI {
                     }
                 }
 
-                ImGui::PopStyleVar(4);
+                ImGui::PopStyleVar(5);
             }
         }
         ImGui::EndChild();
@@ -336,14 +353,9 @@ namespace Toolbox::UI {
         m_context_menu.addOption(
             "Rename", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_R}),
             [this]() { return m_selected_indices_ctx.size() == 1; },
-            [this](auto) {
-                m_is_renaming = true;
-                std::strncpy(m_rename_buffer,
-                             m_file_system_model->getDisplayText(m_selected_indices_ctx[0]).c_str(),
-                             IM_ARRAYSIZE(m_rename_buffer));
-            });
+            [this](auto) { actionRenameIndex(m_selected_indices_ctx[0]); });
 
-        m_context_menu.addDivider();  
+        m_context_menu.addDivider();
 
         m_context_menu.addOption(
             "New...", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N}),
@@ -372,6 +384,12 @@ namespace Toolbox::UI {
         }
     }
 
+    void ProjectViewWindow::actionRenameIndex(const ModelIndex &index) {
+        m_is_renaming         = true;
+        std::string file_name = m_file_system_model->getDisplayText(index);
+        std::strncpy(m_rename_buffer, file_name.c_str(), IM_ARRAYSIZE(m_rename_buffer));
+    }
+
     bool ProjectViewWindow::isViewedAncestor(const ModelIndex &index) {
         if (m_view_index == m_tree_proxy.toSourceIndex(index)) {
             return true;

From eff39f70fe25ab2bdd91df4f3c0de16bf4f388bf Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 30 Sep 2024 11:15:19 -0500
Subject: [PATCH 044/129] Add support for shift-click range selection

---
 include/gui/project/window.hpp |  1 +
 include/model/fsmodel.hpp      | 35 +++++++++------
 include/model/model.hpp        |  3 ++
 src/gui/project/window.cpp     | 32 +++++++++++++-
 src/model/fsmodel.cpp          | 81 ++++++++++++++++++++++++++++++----
 5 files changed, 128 insertions(+), 24 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 66652298..5217a9df 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -105,6 +105,7 @@ namespace Toolbox::UI {
         FileSystemModelSortFilterProxy m_view_proxy;
         RefPtr<FileSystemModel> m_file_system_model;
 
+        ModelIndex m_last_selected_index;
         std::vector<ModelIndex> m_selected_indices;
         std::vector<ProjectAsset> m_view_assets;
         ModelIndex m_view_index;
diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index 346d3fcc..a005e9b2 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -124,6 +124,9 @@ namespace Toolbox {
         [[nodiscard]] size_t getColumnCount(const ModelIndex &index) const override;
         [[nodiscard]] size_t getRowCount(const ModelIndex &index) const override;
 
+        [[nodiscard]] int64_t getColumn(const ModelIndex &index) const override;
+        [[nodiscard]] int64_t getRow(const ModelIndex &index) const override;
+
         [[nodiscard]] bool hasChildren(const ModelIndex &parent = ModelIndex()) const override;
 
         [[nodiscard]] ScopePtr<MimeData>
@@ -172,6 +175,9 @@ namespace Toolbox {
         [[nodiscard]] size_t getColumnCount_(const ModelIndex &index) const;
         [[nodiscard]] size_t getRowCount_(const ModelIndex &index) const;
 
+        [[nodiscard]] int64_t getColumn_(const ModelIndex &index) const;
+        [[nodiscard]] int64_t getRow_(const ModelIndex &index) const;
+
         [[nodiscard]] bool hasChildren_(const ModelIndex &parent = ModelIndex()) const;
 
         [[nodiscard]] ScopePtr<MimeData>
@@ -264,32 +270,33 @@ namespace Toolbox {
         bool remove(const ModelIndex &index);
 
         [[nodiscard]] ModelIndex getIndex(const fs_path &path) const;
-        [[nodiscard]] ModelIndex getIndex(const UUID64 &path) const;
+        [[nodiscard]] ModelIndex getIndex(const UUID64 &path) const override;
         [[nodiscard]] ModelIndex getIndex(int64_t row, int64_t column,
-                                          const ModelIndex &parent = ModelIndex()) const;
+                                          const ModelIndex &parent = ModelIndex()) const override;
         [[nodiscard]] fs_path getPath(const ModelIndex &index) const;
 
-        [[nodiscard]] ModelIndex getParent(const ModelIndex &index) const;
+        [[nodiscard]] ModelIndex getParent(const ModelIndex &index) const override;
         [[nodiscard]] ModelIndex getSibling(int64_t row, int64_t column,
-                                            const ModelIndex &index) const;
+                                            const ModelIndex &index) const override;
 
-        [[nodiscard]] size_t getColumnCount(const ModelIndex &index) const;
-        [[nodiscard]] size_t getRowCount(const ModelIndex &index) const;
+        [[nodiscard]] size_t getColumnCount(const ModelIndex &index) const override;
+        [[nodiscard]] size_t getRowCount(const ModelIndex &index) const override;
 
-        [[nodiscard]] bool hasChildren(const ModelIndex &parent = ModelIndex()) const;
+        [[nodiscard]] int64_t getColumn(const ModelIndex &index) const override;
+        [[nodiscard]] int64_t getRow(const ModelIndex &index) const override;
+
+        [[nodiscard]] bool hasChildren(const ModelIndex &parent = ModelIndex()) const override;
 
         [[nodiscard]] ScopePtr<MimeData>
-        createMimeData(const std::vector<ModelIndex> &indexes) const;
-        [[nodiscard]] std::vector<std::string> getSupportedMimeTypes() const;
+        createMimeData(const std::vector<ModelIndex> &indexes) const override;
+        [[nodiscard]] std::vector<std::string> getSupportedMimeTypes() const override;
 
-        [[nodiscard]] bool canFetchMore(const ModelIndex &index);
-        void fetchMore(const ModelIndex &index);
+        [[nodiscard]] bool canFetchMore(const ModelIndex &index) override;
+        void fetchMore(const ModelIndex &index) override;
 
         [[nodiscard]] ModelIndex toSourceIndex(const ModelIndex &index) const;
         [[nodiscard]] ModelIndex toProxyIndex(const ModelIndex &index) const;
 
-        [[nodiscard]] UUID64 getSourceUUID(const ModelIndex &index) const;
-
     protected:
         [[nodiscard]] ModelIndex toProxyIndex(int64_t row, int64_t column,
                                               const ModelIndex &parent = ModelIndex()) const;
@@ -299,7 +306,7 @@ namespace Toolbox {
         void cacheIndex(const ModelIndex &index) const;
         void cacheIndex_(const ModelIndex &index) const;
 
-        ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent) {
+        ModelIndex makeIndex(const fs_path &path, int64_t row, const ModelIndex &parent) override {
             return ModelIndex();
         }
 
diff --git a/include/model/model.hpp b/include/model/model.hpp
index 76c1d46a..11fb3c8c 100644
--- a/include/model/model.hpp
+++ b/include/model/model.hpp
@@ -99,6 +99,9 @@ namespace Toolbox {
         [[nodiscard]] virtual size_t getColumnCount(const ModelIndex &index) const = 0;
         [[nodiscard]] virtual size_t getRowCount(const ModelIndex &index) const    = 0;
 
+        [[nodiscard]] virtual int64_t getColumn(const ModelIndex &index) const = 0;
+        [[nodiscard]] virtual int64_t getRow(const ModelIndex &index) const = 0;
+
         [[nodiscard]] virtual bool hasChildren(const ModelIndex &parent = ModelIndex()) const = 0;
 
         [[nodiscard]] virtual ScopePtr<MimeData>
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index de1ea520..37cedab4 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -157,17 +157,47 @@ namespace Toolbox::UI {
                                     }
                                 } else if (ImGui::IsMouseClicked(0)) {
                                     m_is_renaming = false;
-                                    if (ImGui::IsKeyDown(ImGuiMod_Ctrl)) {
+                                    if (Input::GetKey(KeyCode::KEY_LEFTCONTROL) ||
+                                        Input::GetKey(KeyCode::KEY_RIGHTCONTROL)) {
                                         if (is_selected) {
                                             m_selected_indices.erase(std::remove(
                                                 m_selected_indices.begin(),
                                                 m_selected_indices.end(), source_child_index));
+                                            m_last_selected_index = ModelIndex();
                                         } else {
                                             m_selected_indices.push_back(source_child_index);
+                                            m_last_selected_index = source_child_index;
                                         }
+                                    } else if (Input::GetKey(KeyCode::KEY_LEFTSHIFT) ||
+                                               Input::GetKey(KeyCode::KEY_RIGHTSHIFT)) {
+                                        if (m_file_system_model->validateIndex(
+                                                m_last_selected_index)) {
+                                            int64_t this_row = m_view_proxy.getRow(child_index);
+                                            int64_t last_row = m_view_proxy.getRow(
+                                                m_view_proxy.toProxyIndex(m_last_selected_index));
+                                            if (this_row > last_row) {
+                                                for (int64_t i = last_row + 1; i <= this_row; ++i) {
+                                                    ModelIndex span_index =
+                                                        m_view_proxy.getIndex(i, 0, view_index);
+                                                    m_selected_indices.push_back(
+                                                        m_view_proxy.toSourceIndex(span_index));
+                                                }
+                                            } else if (this_row < last_row) {
+                                                for (int64_t i = this_row; i < last_row; ++i) {
+                                                    ModelIndex span_index =
+                                                        m_view_proxy.getIndex(i, 0, view_index);
+                                                    m_selected_indices.push_back(
+                                                        m_view_proxy.toSourceIndex(span_index));
+                                                }
+                                            }
+                                        } else {
+                                            m_selected_indices.push_back(source_child_index);
+                                        }
+                                        m_last_selected_index = source_child_index;
                                     } else {
                                         m_selected_indices.clear();
                                         m_selected_indices.push_back(source_child_index);
+                                        m_last_selected_index = source_child_index;
                                     }
                                 }
                             }
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index ac6a7103..4801feb7 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -273,6 +273,16 @@ namespace Toolbox {
         return getRowCount_(index);
     }
 
+    int64_t FileSystemModel::getColumn(const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return getColumn_(index);
+    }
+
+    int64_t FileSystemModel::getRow(const ModelIndex &index) const {
+        std::scoped_lock lock(m_mutex);
+        return getRow_(index);
+    }
+
     bool FileSystemModel::hasChildren(const ModelIndex &parent) const {
         std::scoped_lock lock(m_mutex);
         return hasChildren_(parent);
@@ -747,6 +757,32 @@ namespace Toolbox {
         return index.data<_FileSystemIndexData>()->m_children.size();
     }
 
+    int64_t FileSystemModel::getColumn_(const ModelIndex &index) const {
+        return validateIndex(index) ? 0 : -1;
+    }
+
+    int64_t FileSystemModel::getRow_(const ModelIndex &index) const {
+        if (!validateIndex(index)) {
+            return -1;
+        }
+
+        ModelIndex parent = getParent_(index);
+        if (!validateIndex(parent)) {
+            return 0;
+        }
+
+        _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
+        int64_t row                       = 0;
+        for (const UUID64 &uuid : parent_data->m_children) {
+            if (uuid == index.getUUID()) {
+                return row;
+            }
+            ++row;
+        }
+
+        return -1;
+    }
+
     bool FileSystemModel::hasChildren_(const ModelIndex &parent) const {
         if (getRowCount_(parent) > 0) {
             return true;
@@ -1264,7 +1300,7 @@ namespace Toolbox {
         std::unique_lock lock(m_cache_mutex);
 
         ModelIndex source_index       = toSourceIndex(index);
-        ModelIndex src_parent         = getParent(source_index);
+        ModelIndex src_parent         = m_source_model->getParent(source_index);
         const UUID64 &src_parent_uuid = src_parent.getUUID();
 
         u64 map_key = src_parent_uuid;
@@ -1294,6 +1330,41 @@ namespace Toolbox {
         return m_source_model->getRowCount(source_index);
     }
 
+    int64_t FileSystemModelSortFilterProxy::getColumn(const ModelIndex &index) const {
+        ModelIndex &&source_index = toSourceIndex(index);
+        return m_source_model->getColumn(source_index);
+    }
+
+    int64_t FileSystemModelSortFilterProxy::getRow(const ModelIndex &index) const {
+
+        ModelIndex &&source_index     = toSourceIndex(index);
+        ModelIndex src_parent         = m_source_model->getParent(source_index);
+        const UUID64 &src_parent_uuid = src_parent.getUUID();
+
+        u64 map_key = src_parent_uuid;
+        if (!m_source_model->validateIndex(src_parent)) {
+            map_key = 0;
+        }
+
+        if (m_row_map.find(map_key) == m_row_map.end()) {
+            cacheIndex_(src_parent);
+        }
+
+        int64_t src_row = m_source_model->getRow(source_index);
+        if (src_row == -1) {
+            return src_row;
+        }
+
+        const std::vector<int64_t> &row_map = m_row_map[map_key];
+        for (size_t i = 0; i < row_map.size(); ++i) {
+            if (src_row == row_map[i]) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
     bool FileSystemModelSortFilterProxy::hasChildren(const ModelIndex &parent) const {
         ModelIndex &&source_index = toSourceIndex(parent);
         return m_source_model->hasChildren(source_index);
@@ -1370,14 +1441,6 @@ namespace Toolbox {
         return ModelIndex();
     }
 
-    UUID64 FileSystemModelSortFilterProxy::getSourceUUID(const ModelIndex &index) const {
-        if (!validateIndex(index)) {
-            return 0;
-        }
-
-        return index.data<_FileSystemIndexData>()->m_self_uuid;
-    }
-
     bool FileSystemModelSortFilterProxy::isFiltered(const UUID64 &uuid) const {
         ModelIndex child_index = m_source_model->getIndex(uuid);
         bool is_file =

From deb5cfbd276a1a9a7cc116f351a0ae4523d62b4f Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 30 Sep 2024 14:22:49 -0500
Subject: [PATCH 045/129] Adjust shift-click span selection logic to better
 match Windows

---
 src/gui/project/window.cpp | 53 ++++++++++++++++++++------------------
 1 file changed, 28 insertions(+), 25 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 37cedab4..74762479 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -168,36 +168,39 @@ namespace Toolbox::UI {
                                             m_selected_indices.push_back(source_child_index);
                                             m_last_selected_index = source_child_index;
                                         }
-                                    } else if (Input::GetKey(KeyCode::KEY_LEFTSHIFT) ||
-                                               Input::GetKey(KeyCode::KEY_RIGHTSHIFT)) {
-                                        if (m_file_system_model->validateIndex(
-                                                m_last_selected_index)) {
-                                            int64_t this_row = m_view_proxy.getRow(child_index);
-                                            int64_t last_row = m_view_proxy.getRow(
-                                                m_view_proxy.toProxyIndex(m_last_selected_index));
-                                            if (this_row > last_row) {
-                                                for (int64_t i = last_row + 1; i <= this_row; ++i) {
-                                                    ModelIndex span_index =
-                                                        m_view_proxy.getIndex(i, 0, view_index);
-                                                    m_selected_indices.push_back(
-                                                        m_view_proxy.toSourceIndex(span_index));
-                                                }
-                                            } else if (this_row < last_row) {
-                                                for (int64_t i = this_row; i < last_row; ++i) {
-                                                    ModelIndex span_index =
-                                                        m_view_proxy.getIndex(i, 0, view_index);
-                                                    m_selected_indices.push_back(
-                                                        m_view_proxy.toSourceIndex(span_index));
+                                    } else {
+                                        m_selected_indices.clear();
+                                        if (Input::GetKey(KeyCode::KEY_LEFTSHIFT) ||
+                                            Input::GetKey(KeyCode::KEY_RIGHTSHIFT)) {
+                                            if (m_file_system_model->validateIndex(
+                                                    m_last_selected_index)) {
+                                                int64_t this_row = m_view_proxy.getRow(child_index);
+                                                int64_t last_row =
+                                                    m_view_proxy.getRow(m_view_proxy.toProxyIndex(
+                                                        m_last_selected_index));
+                                                if (this_row > last_row) {
+                                                    for (int64_t i = last_row; i <= this_row;
+                                                         ++i) {
+                                                        ModelIndex span_index =
+                                                            m_view_proxy.getIndex(i, 0, view_index);
+                                                        m_selected_indices.push_back(
+                                                            m_view_proxy.toSourceIndex(span_index));
+                                                    }
+                                                } else {
+                                                    for (int64_t i = this_row; i <= last_row; ++i) {
+                                                        ModelIndex span_index =
+                                                            m_view_proxy.getIndex(i, 0, view_index);
+                                                        m_selected_indices.push_back(
+                                                            m_view_proxy.toSourceIndex(span_index));
+                                                    }
                                                 }
+                                            } else {
+                                                m_selected_indices.push_back(source_child_index);
                                             }
                                         } else {
                                             m_selected_indices.push_back(source_child_index);
+                                            m_last_selected_index = source_child_index;
                                         }
-                                        m_last_selected_index = source_child_index;
-                                    } else {
-                                        m_selected_indices.clear();
-                                        m_selected_indices.push_back(source_child_index);
-                                        m_last_selected_index = source_child_index;
                                     }
                                 }
                             }

From ac4d95caa11c688be9549feeb2b5dd5e6818a5dd Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 30 Sep 2024 18:37:54 -0500
Subject: [PATCH 046/129] More polish on context menu and such

---
 include/gui/context_menu.hpp   |  10 ++-
 include/gui/imgui_ext.hpp      |   3 +-
 include/gui/project/window.hpp |   7 +-
 src/gui/imgui_ext.cpp          |  18 ++++
 src/gui/project/window.cpp     | 146 +++++++++++++++++----------------
 5 files changed, 106 insertions(+), 78 deletions(-)

diff --git a/include/gui/context_menu.hpp b/include/gui/context_menu.hpp
index b2c221a3..0edcb6c0 100644
--- a/include/gui/context_menu.hpp
+++ b/include/gui/context_menu.hpp
@@ -12,6 +12,7 @@
 #include "IconsForkAwesome.h"
 
 #include <imgui.h>
+#include "imgui_ext.hpp"
 
 #include "core/input/input.hpp"
 #include "core/keybind/keybind.hpp"
@@ -44,7 +45,8 @@ namespace Toolbox::UI {
 
         void addDivider();
 
-        void render(std::optional<std::string> label, _DataT ctx);
+        void render(std::optional<std::string> label, _DataT ctx,
+                    ImGuiHoveredFlags hover_flags = ImGuiHoveredFlags_AllowWhenBlockedByPopup);
 
         void onOpen(open_event_t open) { m_open_event = open; }
 
@@ -83,10 +85,10 @@ namespace Toolbox::UI {
     }
 
     template <typename _DataT>
-    inline void ContextMenu<_DataT>::render(std::optional<std::string> label, _DataT ctx) {
+    inline void ContextMenu<_DataT>::render(std::optional<std::string> label, _DataT ctx, ImGuiHoveredFlags hover_flags) {
         processKeybinds(ctx);
 
-        if (!ImGui::BeginPopupContextItem(label ? label->c_str() : nullptr)) {
+        if (!ImGui::BeginPopupContextItem(label ? label->c_str() : nullptr, 1, hover_flags)) {
             m_was_open = false;
             return;
         }
@@ -96,7 +98,7 @@ namespace Toolbox::UI {
         }
         m_was_open = true;
 
-        size_t prev_opt_index = 0; 
+        size_t prev_opt_index = 0;
 
         for (size_t i = 0; i < m_options.size(); ++i) {
             ContextOp &option = m_options.at(i);
diff --git a/include/gui/imgui_ext.hpp b/include/gui/imgui_ext.hpp
index e3f547c1..37195f09 100644
--- a/include/gui/imgui_ext.hpp
+++ b/include/gui/imgui_ext.hpp
@@ -65,7 +65,8 @@ namespace ImGui {
                           const char *label_end, bool focused);
     bool TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *label,
                           const char *label_end, bool focused, bool *visible);
-
+    bool BeginPopupContextItem(const char *str_id, ImGuiPopupFlags popup_flags,
+                                      ImGuiHoveredFlags hover_flags);
     bool DrawCircle(const ImVec2 &center, float radius, ImU32 color,
                     ImU32 fill_color = IM_COL32_BLACK_TRANS, float thickness = 1.0f);
     bool DrawSquare(const ImVec2 &center, float size, ImU32 color,
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 5217a9df..901485f2 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -96,6 +96,8 @@ namespace Toolbox::UI {
         void actionDeleteIndexes(std::vector<ModelIndex> &indices);
         void actionOpenIndexes(const std::vector<ModelIndex> &indices);
         void actionRenameIndex(const ModelIndex &index);
+        void actionLeftClickIndex(const ModelIndex &view_index, const ModelIndex &child_index,
+                                  bool is_selected);
 
     private:
         fs_path m_project_root;
@@ -113,14 +115,15 @@ namespace Toolbox::UI {
         std::unordered_map<std::string, ImageHandle> m_icon_map;
         ImagePainter m_icon_painter;
 
-        ContextMenu<ModelIndex> m_context_menu;
+        ContextMenu<ModelIndex> m_folder_view_context_menu;
+        ContextMenu<ModelIndex> m_tree_view_context_menu;
         std::vector<ModelIndex> m_selected_indices_ctx;
 
         bool m_is_renaming = false;
         char m_rename_buffer[128];
 
         bool m_delete_without_request = false;
-        bool m_delete_requested     = false;
+        bool m_delete_requested       = false;
     };
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/gui/imgui_ext.cpp b/src/gui/imgui_ext.cpp
index b74429c5..922fe296 100644
--- a/src/gui/imgui_ext.cpp
+++ b/src/gui/imgui_ext.cpp
@@ -1227,6 +1227,24 @@ bool ImGui::TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char *l
     return is_open;
 }
 
+bool ImGui::BeginPopupContextItem(const char *str_id, ImGuiPopupFlags popup_flags, ImGuiHoveredFlags hover_flags) {
+    ImGuiContext &g     = *GImGui;
+    ImGuiWindow *window = g.CurrentWindow;
+    if (window->SkipItems)
+        return false;
+    ImGuiID id =
+        str_id ? window->GetID(str_id)
+               : g.LastItemData.ID;  // If user hasn't passed an ID, we can use the LastItemID.
+                                     // Using LastItemID as a Popup ID won't conflict!
+    IM_ASSERT(id != 0);  // You cannot pass a NULL str_id if the last item has no identifier (e.g. a
+                         // Text() item)
+    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
+    if (IsMouseReleased(mouse_button) && IsItemHovered(hover_flags))
+        OpenPopupEx(id, popup_flags);
+    return BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar |
+                                ImGuiWindowFlags_NoSavedSettings);
+}
+
 bool ImGui::DrawCircle(const ImVec2 &center, float radius, ImU32 color, ImU32 fill_color,
                        float thickness) {
     ImVec2 window_pos     = ImGui::GetWindowPos();
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 74762479..124ff7ed 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -18,7 +18,6 @@ namespace Toolbox::UI {
         renderProjectFolderView();
         renderProjectFolderButton();
         renderProjectFileButton();
-        m_context_menu.render("Project View", m_view_index);
     }
 
     void ProjectViewWindow::renderProjectTreeView() {
@@ -37,6 +36,10 @@ namespace Toolbox::UI {
 
         const ImGuiStyle &style = ImGui::GetStyle();
 
+        bool is_left_click        = Input::GetMouseButtonDown(MouseButton::BUTTON_LEFT);
+        bool is_double_left_click = ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left);
+        bool is_right_click       = Input::GetMouseButtonDown(MouseButton::BUTTON_RIGHT);
+
         if (ImGui::BeginChild("Folder View", {0, 0}, true,
                               ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
             if (m_file_system_model->hasChildren(m_view_index)) {
@@ -50,9 +53,12 @@ namespace Toolbox::UI {
                 ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, {2, 2});
                 ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 3.0f);
 
+                const float box_width   = 76.0f;
+                const float label_width = box_width - style.WindowPadding.x * 4.0f;
+
                 ImVec2 size = ImGui::GetContentRegionAvail();
 
-                size_t x_count = (size_t)(size.x / 80);
+                size_t x_count = (size_t)(size.x / (box_width + style.ItemSpacing.x) + 0.1f);
                 if (x_count == 0) {
                     x_count = 1;
                 }
@@ -89,11 +95,9 @@ namespace Toolbox::UI {
                     ImVec2 text_size   = ImGui::CalcTextSize(text.c_str());
                     ImVec2 rename_size = ImGui::CalcTextSize(m_rename_buffer);
 
-                    const float box_width   = 76.0f;
-                    const float label_width = box_width - style.WindowPadding.x * 4.0f;
-                    const float text_width  = is_selected_rename
-                                                  ? std::min(rename_size.x, label_width)
-                                                  : std::min(text_size.x, label_width);
+                    const float text_width = is_selected_rename
+                                                 ? std::min(rename_size.x, label_width)
+                                                 : std::min(text_size.x, label_width);
 
                     if (ImGui::BeginChild(child_index.getUUID(), {box_width, 100.0f}, true,
                                           ImGuiWindowFlags_ChildWindow |
@@ -106,7 +110,7 @@ namespace Toolbox::UI {
 
                         // Render the label
                         {
-                            if (m_is_renaming && is_selected) {
+                            if (is_selected_rename) {
                                 ImVec2 rename_pos =
                                     pos + ImVec2(style.WindowPadding.x,
                                                  icon_size.y + style.ItemInnerSpacing.y -
@@ -144,10 +148,10 @@ namespace Toolbox::UI {
 
                         // Handle click responses
                         {
-                            any_items_hovered = any_items_hovered || ImGui::IsItemHovered() ||
-                                                ImGui::IsWindowHovered(ImGuiHoveredFlags_None);
+                            any_items_hovered |= ImGui::IsItemHovered() ||
+                                                 ImGui::IsWindowHovered(ImGuiHoveredFlags_None);
                             if (ImGui::IsWindowHovered(ImGuiHoveredFlags_None)) {
-                                if (ImGui::IsMouseDoubleClicked(0)) {
+                                if (is_double_left_click) {
                                     m_is_renaming = false;
                                     if (m_view_proxy.isDirectory(child_index)) {
                                         m_view_index = m_view_proxy.toSourceIndex(child_index);
@@ -155,53 +159,9 @@ namespace Toolbox::UI {
                                         ImGui::PopStyleColor(1);
                                         break;
                                     }
-                                } else if (ImGui::IsMouseClicked(0)) {
+                                } else if (is_left_click) {
                                     m_is_renaming = false;
-                                    if (Input::GetKey(KeyCode::KEY_LEFTCONTROL) ||
-                                        Input::GetKey(KeyCode::KEY_RIGHTCONTROL)) {
-                                        if (is_selected) {
-                                            m_selected_indices.erase(std::remove(
-                                                m_selected_indices.begin(),
-                                                m_selected_indices.end(), source_child_index));
-                                            m_last_selected_index = ModelIndex();
-                                        } else {
-                                            m_selected_indices.push_back(source_child_index);
-                                            m_last_selected_index = source_child_index;
-                                        }
-                                    } else {
-                                        m_selected_indices.clear();
-                                        if (Input::GetKey(KeyCode::KEY_LEFTSHIFT) ||
-                                            Input::GetKey(KeyCode::KEY_RIGHTSHIFT)) {
-                                            if (m_file_system_model->validateIndex(
-                                                    m_last_selected_index)) {
-                                                int64_t this_row = m_view_proxy.getRow(child_index);
-                                                int64_t last_row =
-                                                    m_view_proxy.getRow(m_view_proxy.toProxyIndex(
-                                                        m_last_selected_index));
-                                                if (this_row > last_row) {
-                                                    for (int64_t i = last_row; i <= this_row;
-                                                         ++i) {
-                                                        ModelIndex span_index =
-                                                            m_view_proxy.getIndex(i, 0, view_index);
-                                                        m_selected_indices.push_back(
-                                                            m_view_proxy.toSourceIndex(span_index));
-                                                    }
-                                                } else {
-                                                    for (int64_t i = this_row; i <= last_row; ++i) {
-                                                        ModelIndex span_index =
-                                                            m_view_proxy.getIndex(i, 0, view_index);
-                                                        m_selected_indices.push_back(
-                                                            m_view_proxy.toSourceIndex(span_index));
-                                                    }
-                                                }
-                                            } else {
-                                                m_selected_indices.push_back(source_child_index);
-                                            }
-                                        } else {
-                                            m_selected_indices.push_back(source_child_index);
-                                            m_last_selected_index = source_child_index;
-                                        }
-                                    }
+                                    actionLeftClickIndex(view_index, child_index, is_selected);
                                 }
                             }
                         }
@@ -264,6 +224,10 @@ namespace Toolbox::UI {
             }
         }
         ImGui::EndChild();
+
+        m_folder_view_context_menu.render("Project View", m_view_index,
+                                          ImGuiHoveredFlags_AllowWhenBlockedByPopup |
+                                              ImGuiHoveredFlags_AllowWhenOverlapped);
     }
 
     void ProjectViewWindow::renderProjectFolderButton() {}
@@ -296,12 +260,12 @@ namespace Toolbox::UI {
     void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {}
 
     void ProjectViewWindow::buildContextMenu() {
-        m_context_menu = ContextMenu<ModelIndex>();
+        m_folder_view_context_menu = ContextMenu<ModelIndex>();
 
-        m_context_menu.onOpen(
+        m_folder_view_context_menu.onOpen(
             [this](const ModelIndex &index) { m_selected_indices_ctx = m_selected_indices; });
 
-        m_context_menu.addOption(
+        m_folder_view_context_menu.addOption(
             "Open", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_O}),
             [this]() {
                 return m_selected_indices_ctx.size() > 0 &&
@@ -312,7 +276,7 @@ namespace Toolbox::UI {
             },
             [this](auto) { actionOpenIndexes(m_selected_indices_ctx); });
 
-        m_context_menu.addOption(
+        m_folder_view_context_menu.addOption(
             "Open in Explorer",
             KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTSHIFT, KeyCode::KEY_O}),
             [this]() {
@@ -341,9 +305,9 @@ namespace Toolbox::UI {
                 }
             });
 
-        m_context_menu.addDivider();
+        m_folder_view_context_menu.addDivider();
 
-        m_context_menu.addOption(
+        m_folder_view_context_menu.addOption(
             "Copy Path",
             KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTSHIFT, KeyCode::KEY_C}),
             [this]() { return true; },
@@ -360,19 +324,19 @@ namespace Toolbox::UI {
                 ImGui::SetClipboardText(paths.c_str());
             });
 
-        m_context_menu.addDivider();
+        m_folder_view_context_menu.addDivider();
 
-        m_context_menu.addOption(
+        m_folder_view_context_menu.addOption(
             "Cut", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_X}),
             [this]() { return m_selected_indices_ctx.size() > 0; }, [this](auto) {});
 
-        m_context_menu.addOption(
+        m_folder_view_context_menu.addOption(
             "Copy", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C}),
             [this]() { return m_selected_indices_ctx.size() > 0; }, [this](auto) {});
 
-        m_context_menu.addDivider();
+        m_folder_view_context_menu.addDivider();
 
-        m_context_menu.addOption(
+        m_folder_view_context_menu.addOption(
             "Delete", KeyBind({KeyCode::KEY_DELETE}),
             [this]() { return m_selected_indices_ctx.size() > 0; },
             [this](auto) {
@@ -383,14 +347,14 @@ namespace Toolbox::UI {
                 }
             });
 
-        m_context_menu.addOption(
+        m_folder_view_context_menu.addOption(
             "Rename", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_R}),
             [this]() { return m_selected_indices_ctx.size() == 1; },
             [this](auto) { actionRenameIndex(m_selected_indices_ctx[0]); });
 
-        m_context_menu.addDivider();
+        m_folder_view_context_menu.addDivider();
 
-        m_context_menu.addOption(
+        m_folder_view_context_menu.addOption(
             "New...", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N}),
             [this]() { return m_selected_indices_ctx.size() == 0; },
             [this](const ModelIndex &view_index) {
@@ -423,6 +387,46 @@ namespace Toolbox::UI {
         std::strncpy(m_rename_buffer, file_name.c_str(), IM_ARRAYSIZE(m_rename_buffer));
     }
 
+    void ProjectViewWindow::actionLeftClickIndex(const ModelIndex &view_index,
+                                                 const ModelIndex &child_index, bool is_selected) {
+        ModelIndex source_child_index = m_view_proxy.toSourceIndex(child_index);
+        if (Input::GetKey(KeyCode::KEY_LEFTCONTROL) || Input::GetKey(KeyCode::KEY_RIGHTCONTROL)) {
+            if (is_selected) {
+                m_selected_indices.erase(std::remove(m_selected_indices.begin(),
+                                                     m_selected_indices.end(), source_child_index));
+                m_last_selected_index = ModelIndex();
+            } else {
+                m_selected_indices.push_back(source_child_index);
+                m_last_selected_index = source_child_index;
+            }
+        } else {
+            m_selected_indices.clear();
+            if (Input::GetKey(KeyCode::KEY_LEFTSHIFT) || Input::GetKey(KeyCode::KEY_RIGHTSHIFT)) {
+                if (m_file_system_model->validateIndex(m_last_selected_index)) {
+                    int64_t this_row = m_view_proxy.getRow(child_index);
+                    int64_t last_row =
+                        m_view_proxy.getRow(m_view_proxy.toProxyIndex(m_last_selected_index));
+                    if (this_row > last_row) {
+                        for (int64_t i = last_row; i <= this_row; ++i) {
+                            ModelIndex span_index = m_view_proxy.getIndex(i, 0, view_index);
+                            m_selected_indices.push_back(m_view_proxy.toSourceIndex(span_index));
+                        }
+                    } else {
+                        for (int64_t i = this_row; i <= last_row; ++i) {
+                            ModelIndex span_index = m_view_proxy.getIndex(i, 0, view_index);
+                            m_selected_indices.push_back(m_view_proxy.toSourceIndex(span_index));
+                        }
+                    }
+                } else {
+                    m_selected_indices.push_back(source_child_index);
+                }
+            } else {
+                m_selected_indices.push_back(source_child_index);
+                m_last_selected_index = source_child_index;
+            }
+        }
+    }
+
     bool ProjectViewWindow::isViewedAncestor(const ModelIndex &index) {
         if (m_view_index == m_tree_proxy.toSourceIndex(index)) {
             return true;

From 5ba29d89b484e69a3f4c6f06cd06517790224ab5 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 30 Sep 2024 18:11:36 -0700
Subject: [PATCH 047/129] Allow copy-pasting files into JT on Linux

---
 include/core/clipboard.hpp     |   3 +
 include/model/fsmodel.hpp      |   4 +
 src/core/mimedata/mimedata.cpp |  12 ++-
 src/gui/clipboard.cpp          | 129 ++++++++++++++++++++++++++++++++-
 src/gui/project/window.cpp     |  47 ++++++++++++
 src/model/fsmodel.cpp          |  24 ++++++
 6 files changed, 215 insertions(+), 4 deletions(-)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index 152459e4..15cf5eb8 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -5,6 +5,7 @@
 #include <vector>
 
 #include "core/error.hpp"
+#include "core/mimedata/mimedata.hpp"
 #include "tristate.hpp"
 
 namespace Toolbox {
@@ -37,6 +38,8 @@ namespace Toolbox {
 
         Result<std::string, ClipboardError> getText();
         Result<void, ClipboardError> setText(const std::string &text);
+        Result<std::vector<std::string>, ClipboardError> possibleContentTypes();
+        Result<MimeData, ClipboardError> getContent(const std::string &type);
     };
 
     class DataClipboard {
diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index a005e9b2..7400dea7 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -106,6 +106,8 @@ namespace Toolbox {
         ModelIndex mkdir(const ModelIndex &parent, const std::string &name);
         ModelIndex touch(const ModelIndex &parent, const std::string &name);
         ModelIndex rename(const ModelIndex &file, const std::string &new_name);
+        ModelIndex copy(const fs_path &file_path, const ModelIndex &new_parent,
+                        const std::string &new_name);
 
         bool rmdir(const ModelIndex &index);
         bool remove(const ModelIndex &index);
@@ -158,6 +160,8 @@ namespace Toolbox {
         ModelIndex mkdir_(const ModelIndex &parent, const std::string &name);
         ModelIndex touch_(const ModelIndex &parent, const std::string &name);
         ModelIndex rename_(const ModelIndex &file, const std::string &new_name);
+        ModelIndex copy_(const fs_path &file_path, const ModelIndex &new_parent,
+                         const std::string &new_name);
 
         bool rmdir_(const ModelIndex &index);
         bool remove_(const ModelIndex &index);
diff --git a/src/core/mimedata/mimedata.cpp b/src/core/mimedata/mimedata.cpp
index e9874d27..bde8a1f1 100644
--- a/src/core/mimedata/mimedata.cpp
+++ b/src/core/mimedata/mimedata.cpp
@@ -112,12 +112,18 @@ namespace Toolbox {
     }
 
     [[nodiscard]] std::optional<std::string> MimeData::get_urls() const {
-        TOOLBOX_DEBUG_LOG("URL mimedata unsupported");
-        return {};
+        if (!has_urls()) {
+            return std::nullopt;
+        }
+        const Buffer &data_buf = m_data_map["text/uri-list"];
+        return std::string(data_buf.buf<char>(), data_buf.size());
     }
 
     void MimeData::set_urls(std::string_view data) {
-        TOOLBOX_DEBUG_LOG("URL mimedata unsupported");
+        Buffer _tmp;
+        _tmp.alloc(data.size());
+        std::memcpy(_tmp.buf(), data.data(), data.size());
+        set_data("text/uri-list", std::move(_tmp));
     }
 
     void MimeData::clear() { m_data_map.clear(); }
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index c4f5a711..65bdc1b3 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -2,6 +2,9 @@
 
 #ifdef WIN32
 #include <Windows.h>
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
 #endif
 
 namespace Toolbox {
@@ -75,4 +78,128 @@ namespace Toolbox {
         return {};
     }
 
-}  // namespace Toolbox::UI
\ No newline at end of file
+    Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes(){
+#ifdef TOOLBOX_PLATFORM_LINUX
+        Display *dpy = XOpenDisplay(nullptr);
+        if (!dpy) {
+            return make_clipboard_error<std::vector<std::string>>("Could not open X display");
+        }
+        Atom sel = XInternAtom(dpy, "CLIPBOARD", False);
+        Atom targets = XInternAtom(dpy, "TARGETS", False);
+        Atom target_property = XInternAtom(dpy, "CLIP_TYPES", False);
+        Window root_window = RootWindow(dpy, DefaultScreen(dpy));
+        Window target_window = XCreateSimpleWindow(dpy, root_window, -10, -10, 1, 1, 0, 0, 0);
+        XConvertSelection(dpy, sel, targets, target_property, target_window,
+                          CurrentTime);
+
+        XEvent ev;
+        XSelectionEvent *sev;
+        // This looks pretty dangerous but this is how glfw does it,
+        // and how the examples online do it, so :shrug:
+        while(true){
+            XNextEvent(dpy, &ev);
+            switch (ev.type)
+            {
+            case SelectionNotify:
+                sev = (XSelectionEvent*)&ev.xselection;
+                if (sev->property == None)
+                {
+                    return make_clipboard_error<std::vector<std::string>>("Conversion could not be performed.\n");
+                }
+                else
+                {
+                    std::vector<std::string> types;
+                    unsigned long nitems;
+                    unsigned char *prop_ret = nullptr;
+                    // We won't use these.
+                    Atom _type;
+                    int _di;
+                    unsigned long _dul;
+                    XGetWindowProperty(dpy, target_window, target_property, 0,
+                                       1024 * sizeof(Atom), False, XA_ATOM,
+                                       &_type, &_di, &nitems, &_dul, &prop_ret);
+
+                    Atom *targets = (Atom*)prop_ret;
+                    for(int i = 0; i < nitems; ++i) {
+                        char* an = XGetAtomName(dpy, targets[i]);
+                        types.push_back(std::string(an));
+                        if (an)
+                            XFree(an);
+                    }
+                    XFree(prop_ret);
+                    XDeleteProperty(dpy, target_window, target_property);
+                    return types;
+                }
+                break;
+            }
+        }
+#endif
+        return {};
+    }
+    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type){
+#ifdef TOOLBOX_PLATFORM_LINUX
+        Display *dpy = XOpenDisplay(nullptr);
+        if (!dpy) {
+            return make_clipboard_error<MimeData>("Could not open X display");
+        }
+        Atom requested_type = XInternAtom(dpy, type.c_str(), False);
+        Atom sel = XInternAtom(dpy, "CLIPBOARD", False);
+        Window clipboard_owner = XGetSelectionOwner(dpy, sel);
+        if (clipboard_owner == None) {
+            return make_clipboard_error<MimeData>("Clipboard isn't owned by anyone");
+        }
+        Window root = RootWindow(dpy, DefaultScreen(dpy));
+        Window target_window = XCreateSimpleWindow(dpy, root, -10, -10, 1, 1, 0, 0, 0);
+        Atom target_property = XInternAtom(dpy, "CLIP_CONTENTS", False);
+        XConvertSelection(dpy, sel, requested_type, target_property, target_window, CurrentTime);
+        XEvent ev;
+        XSelectionEvent *sev;
+        // This looks pretty dangerous but this is how glfw does it,
+        // and how the examples online do it, so :shrug:
+        while(true){
+            XNextEvent(dpy, &ev);
+            switch (ev.type)
+            {
+            case SelectionNotify:
+                sev = (XSelectionEvent*)&ev.xselection;
+                if (sev->property == None) {
+                    return make_clipboard_error<MimeData>("Conversion could not be performed.");
+                } else {
+                    Atom type_received;
+                    unsigned long size;
+                    unsigned char *prop_ret = nullptr;
+                    // These are unused
+                    int _di;
+                    unsigned long _dul;
+                    Atom _da;
+
+                    XGetWindowProperty(dpy, target_window, target_property, 0, 0, False,
+                                       AnyPropertyType, &type_received, &_di, &_dul, &size, &prop_ret);
+                    XFree(prop_ret);
+
+                    Atom incr = XInternAtom(dpy, "INCR", False);
+                    if (type_received == incr) {
+                        return make_clipboard_error<MimeData>("Data over 256kb, this isn't supported yet");
+                    }
+                    XGetWindowProperty(dpy, target_window, target_property, 0, size, False,
+                                       AnyPropertyType, &_da, &_di, &_dul, &_dul, &prop_ret);
+                    Buffer data_buffer;
+                    if (!data_buffer.alloc(size)) {
+                        return make_clipboard_error<MimeData>(
+                            "Couldn't allocate buffer of big enough size");
+                    }
+                    std::memcpy(data_buffer.buf(), prop_ret, size);
+                    XFree(prop_ret);
+                    XDeleteProperty(dpy, target_window, target_property);
+
+                    MimeData result;
+                    result.set_data(type, std::move(data_buffer));
+                    return result;
+                }
+            }
+        }
+#endif
+        return {};
+    }
+
+}  // namespace Toolbox::UI
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 124ff7ed..f752fbda 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -259,6 +259,22 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {}
 
+    std::vector<std::string_view> splitLines(std::string_view s) {
+        std::vector<std::string_view> result;
+        size_t last_pos = 0;
+        size_t next_newline_pos = s.find('\n', 0);
+        while (next_newline_pos != std::string::npos) {
+            if (s[last_pos + next_newline_pos - 1] == '\r'){
+                result.push_back(s.substr(last_pos, next_newline_pos - 1));
+            } else {
+                result.push_back(s.substr(last_pos, next_newline_pos));
+            }
+            last_pos = next_newline_pos + 1;
+            next_newline_pos = s.find('\n', last_pos);
+        }
+        return result;
+    }
+
     void ProjectViewWindow::buildContextMenu() {
         m_folder_view_context_menu = ContextMenu<ModelIndex>();
 
@@ -351,6 +367,37 @@ namespace Toolbox::UI {
             "Rename", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_R}),
             [this]() { return m_selected_indices_ctx.size() == 1; },
             [this](auto) { actionRenameIndex(m_selected_indices_ctx[0]); });
+        m_folder_view_context_menu.addOption(
+            "Paste", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V}),
+            [this]() { return m_selected_indices_ctx.size() == 0; },
+            [this](auto) {
+                auto content_types = SystemClipboard::instance().possibleContentTypes();
+                if (!content_types) {
+                    TOOLBOX_ERROR("Couldn't get content types");
+                    return;
+                }
+                if (std::find(content_types.value().begin(), content_types.value().end(),
+                              std::string("text/uri-list")) != content_types.value().end()) {
+                    auto content = SystemClipboard::instance().getContent("text/uri-list");
+                    if (!content) {
+                        TOOLBOX_ERROR("Failed to get content as uri list");
+                        return;
+                    }
+                    auto text = content.value().get_urls();
+                    if (!text) {
+                        TOOLBOX_ERROR("Mime data wouldn't return uri list");
+                        return;
+                    }
+
+                    for (std::string_view src_path_str : splitLines(text.value())) {
+                        if (src_path_str.substr(0, 7) != "file://") {
+                            TOOLBOX_ERROR_V("Can't copy non-local uri {}", src_path_str);
+                        }
+                        fs_path src_path = src_path_str.substr(7);
+                        m_file_system_model->copy(src_path, m_view_index, src_path.filename());
+                    }
+                }
+            });
 
         m_folder_view_context_menu.addDivider();
 
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 4801feb7..2550aa1d 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -230,6 +230,11 @@ namespace Toolbox {
         std::scoped_lock lock(m_mutex);
         return rename_(file, new_name);
     }
+    ModelIndex FileSystemModel::copy(const fs_path &file, const ModelIndex &new_parent,
+                                     const std::string &new_name) {
+        std::scoped_lock lock(m_mutex);
+        return copy_(file, new_parent, new_name);
+    }
 
     ModelIndex FileSystemModel::getIndex(const fs_path &path) const {
         std::scoped_lock lock(m_mutex);
@@ -678,6 +683,25 @@ namespace Toolbox {
                                       parent_data->m_children.end());
         return makeIndex(to, dest_index, parent);
     }
+    ModelIndex FileSystemModel::copy_(const fs_path &file, const ModelIndex &new_parent,
+                                      const std::string &new_name) {
+        if (!validateIndex(new_parent)) {
+            TOOLBOX_ERROR("[FileSystemModel] New parent isn't a valid index!");
+            return ModelIndex();
+        }
+        if (!Filesystem::exists(file)) {
+            TOOLBOX_ERROR_V("[FileSystemModel] \"{}\" is not a directory or file!",
+                            file.string());
+            return ModelIndex();
+        }
+        fs_path to = new_parent.data<_FileSystemIndexData>()->m_path / new_name;
+
+        int dest_index = getRowCount_(new_parent);
+
+        Filesystem::copy(file, to);
+
+        return makeIndex(to, dest_index, new_parent);
+    }
 
     ModelIndex FileSystemModel::getIndex_(const fs_path &path) const {
         if (m_index_map.empty()) {

From 85f8363f6a33d72be71cf2f9d771a45af7104b17 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 30 Sep 2024 18:32:55 -0700
Subject: [PATCH 048/129] get index on copy instead of trying to make a new one

---
 src/model/fsmodel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 2550aa1d..0a65ddde 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -700,7 +700,7 @@ namespace Toolbox {
 
         Filesystem::copy(file, to);
 
-        return makeIndex(to, dest_index, new_parent);
+        return getIndex_(to);
     }
 
     ModelIndex FileSystemModel::getIndex_(const fs_path &path) const {

From 5588e1d12ac53fb664f9bd49f1030acb59c2e2e7 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 30 Sep 2024 20:52:13 -0500
Subject: [PATCH 049/129] Implement Windows open in explorer

---
 include/platform/process.hpp | 6 +++++-
 src/gui/project/window.cpp   | 4 ++--
 src/platform/process.cpp     | 9 +++++++--
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/include/platform/process.hpp b/include/platform/process.hpp
index 75cc8d9a..80b4e8e6 100644
--- a/include/platform/process.hpp
+++ b/include/platform/process.hpp
@@ -5,6 +5,8 @@
 #include <core/core.hpp>
 #include <core/error.hpp>
 
+#include "fsystem.hpp"
+
 #ifdef TOOLBOX_PLATFORM_WINDOWS
 #include <Windows.h>
 #elif defined(TOOLBOX_PLATFORM_LINUX)
@@ -36,7 +38,7 @@ namespace Toolbox::Platform {
         ProcessID m_thread_id      = std::numeric_limits<ProcessID>::max();
     };
 
-    Result<ProcessInformation> CreateExProcess(const std::filesystem::path &program_path,
+    Result<ProcessInformation> CreateExProcess(const fs_path &program_path,
                                                std::string_view cmdargs);
     Result<void> KillExProcess(const ProcessInformation &process,
                                size_t max_wait = std::numeric_limits<ProcessID>::max());
@@ -52,4 +54,6 @@ namespace Toolbox::Platform {
 
     bool SetWindowTransparency(LowWindow window, uint8_t alpha);
 
+    bool OpenFileExplorer(const fs_path &path);
+
 }  // namespace Toolbox::Platform
\ No newline at end of file
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 124ff7ed..85bc6f90 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -287,7 +287,7 @@ namespace Toolbox::UI {
             [this](auto) {
                 if (m_selected_indices_ctx.size() == 0) {
                     // TODO: Implement this interface
-                    // Toolbox::Platform::OpenFileExplorer(path);
+                    Toolbox::Platform::OpenFileExplorer(m_file_system_model->getPath(m_view_index));
                 } else {
                     std::set<fs_path> paths;
                     for (const ModelIndex &item_index : m_selected_indices_ctx) {
@@ -300,7 +300,7 @@ namespace Toolbox::UI {
                     }
                     for (const fs_path &path : paths) {
                         // TODO: Implement this interface
-                        // Toolbox::Platform::OpenFileExplorer(path);
+                        Toolbox::Platform::OpenFileExplorer(path);
                     }
                 }
             });
diff --git a/src/platform/process.cpp b/src/platform/process.cpp
index edb7647e..add53d62 100644
--- a/src/platform/process.cpp
+++ b/src/platform/process.cpp
@@ -51,7 +51,7 @@ namespace Toolbox::Platform {
         }
     }
 
-    Result<ProcessInformation> CreateExProcess(const std::filesystem::path &program_path,
+    Result<ProcessInformation> CreateExProcess(const fs_path &program_path,
                                                std::string_view cmdargs) {
         std::string true_cmdargs =
             std::format("\"{}\" {}", program_path.string().c_str(), cmdargs.data());
@@ -187,10 +187,15 @@ namespace Toolbox::Platform {
         return UpdateWindow(window);
     }
 
+    bool OpenFileExplorer(const fs_path &path) {
+        std::wstring path_str = path.wstring();
+        return (int)ShellExecuteW(NULL, L"open", L"explorer.exe", path_str.c_str(), NULL, SW_SHOW) > 32;
+    }
+
 #elif defined(TOOLBOX_PLATFORM_LINUX)
     std::string GetLastErrorMessage() { return strerror(errno); }
 
-    Result<ProcessInformation> CreateExProcess(const std::filesystem::path &program_path,
+    Result<ProcessInformation> CreateExProcess(const fs_path &program_path,
                                                std::string_view cmdargs) {
         ProcessID pid = fork();  // Fork the current process
         if (pid == -1) {

From 29c874dd1009f449f125b214803735ab38e9c489 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 30 Sep 2024 21:21:53 -0500
Subject: [PATCH 050/129] Fix missing .string() call

---
 src/gui/project/window.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index d09f06c2..90955f5f 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -394,7 +394,7 @@ namespace Toolbox::UI {
                             TOOLBOX_ERROR_V("Can't copy non-local uri {}", src_path_str);
                         }
                         fs_path src_path = src_path_str.substr(7);
-                        m_file_system_model->copy(src_path, m_view_index, src_path.filename());
+                        m_file_system_model->copy(src_path, m_view_index, src_path.filename().string());
                     }
                 }
             });

From 4e51b42df32b1bc4ab8edb3353e6e922e4e1d084 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Tue, 1 Oct 2024 11:29:59 -0700
Subject: [PATCH 051/129] Fix build on linux by stubbing out file explorer

---
 src/platform/process.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/platform/process.cpp b/src/platform/process.cpp
index add53d62..324fb7ad 100644
--- a/src/platform/process.cpp
+++ b/src/platform/process.cpp
@@ -363,5 +363,9 @@ namespace Toolbox::Platform {
             }
         }
     }
+    bool OpenFileExplorer(const fs_path &path) {
+        TOOLBOX_ERROR("Open file explorer currently unsupported on linux");
+        return false;
+    }
 #endif
 }  // namespace Toolbox::Platform

From 3ddfeac7563c4636520662a549eca4d98ee378c2 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Tue, 1 Oct 2024 18:01:23 -0500
Subject: [PATCH 052/129] Add ability to open scene folders from a project
 folder

---
 include/gui/application.hpp    | 19 ++++++--
 include/gui/project/window.hpp |  4 ++
 src/gui/application.cpp        | 19 ++++++++
 src/gui/project/window.cpp     | 82 +++++++++++++++++++++++++++++++---
 4 files changed, 115 insertions(+), 9 deletions(-)

diff --git a/include/gui/application.hpp b/include/gui/application.hpp
index 201c7b42..6bc3c99a 100644
--- a/include/gui/application.hpp
+++ b/include/gui/application.hpp
@@ -55,13 +55,21 @@ namespace Toolbox {
         virtual void onExit() override;
 
         void addWindow(RefPtr<ImWindow> window) {
-            addLayer(window);
-            m_windows.push_back(window);
+            if (!m_windows_processing) {
+                addLayer(window);
+                m_windows.push_back(window);
+            } else {
+                m_windows_to_add.push(window);
+            }
         }
 
         void removeWindow(RefPtr<ImWindow> window) {
-            removeLayer(window);
-            std::erase(m_windows, window);
+            if (!m_windows_processing) {
+                removeLayer(window);
+                std::erase(m_windows, window);
+            } else {
+                m_windows_to_gc.push(window);
+            }
         }
 
         const std::vector<RefPtr<ImWindow>> &getWindows() const & { return m_windows; }
@@ -179,6 +187,9 @@ namespace Toolbox {
 
         GLFWwindow *m_render_window;
         std::vector<RefPtr<ImWindow>> m_windows;
+        std::queue<RefPtr<ImWindow>> m_windows_to_gc;
+        std::queue<RefPtr<ImWindow>> m_windows_to_add;
+        bool m_windows_processing = false;
 
         std::unordered_map<UUID64, bool> m_docked_map;
         ImGuiID m_dockspace_id;
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 901485f2..2bc0b1c3 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -99,6 +99,10 @@ namespace Toolbox::UI {
         void actionLeftClickIndex(const ModelIndex &view_index, const ModelIndex &child_index,
                                   bool is_selected);
 
+        bool actionOpenScene(const ModelIndex &index);
+
+        bool isPathForScene(const ModelIndex &index) const;
+
     private:
         fs_path m_project_root;
 
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 621de2be..8d67258f 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -357,7 +357,26 @@ namespace Toolbox {
 
         // UPDATE LOOP: We update layers here so the ImGui dockspaces can take effect first.
         {
+            m_windows_processing = true;
             CoreApplication::onUpdate(delta_time);
+            m_windows_processing = false;
+            
+            for (size_t i = 0; i < m_windows_to_add.size(); ++i) {
+                RefPtr<ImWindow> window = m_windows_to_add.front();
+                m_windows_to_add.pop();
+
+                addLayer(window);
+                m_windows.push_back(window);
+            }
+
+            for (size_t i = 0; i < m_windows_to_gc.size(); ++i) {
+                RefPtr<ImWindow> window = m_windows_to_gc.front();
+                m_windows_to_gc.pop();
+
+                removeLayer(window);
+                std::erase(m_windows, window);
+            }
+
             gcClosedWindows();
         }
 
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 90955f5f..8b070165 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -1,4 +1,5 @@
 #include "gui/project/window.hpp"
+#include "gui/application.hpp"
 #include "model/fsmodel.hpp"
 
 #include <cmath>
@@ -261,15 +262,15 @@ namespace Toolbox::UI {
 
     std::vector<std::string_view> splitLines(std::string_view s) {
         std::vector<std::string_view> result;
-        size_t last_pos = 0;
+        size_t last_pos         = 0;
         size_t next_newline_pos = s.find('\n', 0);
         while (next_newline_pos != std::string::npos) {
-            if (s[last_pos + next_newline_pos - 1] == '\r'){
+            if (s[last_pos + next_newline_pos - 1] == '\r') {
                 result.push_back(s.substr(last_pos, next_newline_pos - 1));
             } else {
                 result.push_back(s.substr(last_pos, next_newline_pos));
             }
-            last_pos = next_newline_pos + 1;
+            last_pos         = next_newline_pos + 1;
             next_newline_pos = s.find('\n', last_pos);
         }
         return result;
@@ -287,7 +288,7 @@ namespace Toolbox::UI {
                 return m_selected_indices_ctx.size() > 0 &&
                        std::all_of(m_selected_indices_ctx.begin(), m_selected_indices_ctx.end(),
                                    [this](const ModelIndex &index) {
-                                       return m_file_system_model->isFile(index);
+                                       return m_file_system_model->isFile(index) || isPathForScene(index);
                                    });
             },
             [this](auto) { actionOpenIndexes(m_selected_indices_ctx); });
@@ -394,7 +395,8 @@ namespace Toolbox::UI {
                             TOOLBOX_ERROR_V("Can't copy non-local uri {}", src_path_str);
                         }
                         fs_path src_path = src_path_str.substr(7);
-                        m_file_system_model->copy(src_path, m_view_index, src_path.filename().string());
+                        m_file_system_model->copy(src_path, m_view_index,
+                                                  src_path.filename().string());
                     }
                 }
             });
@@ -418,11 +420,16 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::actionOpenIndexes(const std::vector<ModelIndex> &indices) {
         for (auto &item_index : indices) {
+            if (actionOpenScene(item_index)) {
+                continue;
+            }
+
             if (m_file_system_model->isDirectory(item_index)) {
                 m_view_index = item_index;
                 continue;
             }
 
+
             // TODO: Open files based on extension. Can be either internal or external
             // depending on the file type.
         }
@@ -474,6 +481,71 @@ namespace Toolbox::UI {
         }
     }
 
+    bool ProjectViewWindow::actionOpenScene(const ModelIndex &index) {
+        if (!m_file_system_model->validateIndex(index)) {
+            return false;
+        }
+
+        GUIApplication &app = GUIApplication::instance();
+
+        if (m_file_system_model->isDirectory(index)) {
+            // ./scene/
+            fs_path scene_path = m_file_system_model->getPath(index);
+
+            RefPtr<SceneWindow> window = app.createWindow<SceneWindow>("Scene Editor");
+            if (!window->onLoadData(scene_path)) {
+                app.removeWindow(window);
+                return false;
+            }
+
+            return true;
+        } else if (m_file_system_model->isArchive(index)) {
+            TOOLBOX_ERROR("[PROJECT] Archives are not supported yet");
+        } else if (m_file_system_model->isFile(index)) {
+            // ./scene/map/scene.bin
+            fs_path scene_path = m_file_system_model->getPath(index);
+            if (scene_path.filename().string() != "scene.bin") {
+                return false;
+            }
+
+            fs_path scene_folder = scene_path.parent_path().parent_path();
+            if (scene_folder.filename().string() != "scene") {
+                return false;
+            }
+
+            RefPtr<SceneWindow> window = app.createWindow<SceneWindow>("Scene Editor");
+            if (!window->onLoadData(scene_folder)) {
+                app.removeWindow(window);
+                return false;
+            }
+
+            return true;
+        }
+    }
+
+    bool ProjectViewWindow::isPathForScene(const ModelIndex &index) const {
+        if (!m_file_system_model->validateIndex(index)) {
+            return false;
+        }
+
+        if (m_file_system_model->isDirectory(index)) {
+            fs_path scene_path = m_file_system_model->getPath(index);
+            if (scene_path.filename().string() == "scene") {
+                return true;
+            }
+        } else if (m_file_system_model->isFile(index)) {
+            fs_path scene_path = m_file_system_model->getPath(index);
+            if (scene_path.filename().string() == "scene.bin") {
+                fs_path scene_folder = scene_path.parent_path().parent_path();
+                if (scene_folder.filename().string() == "scene") {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     bool ProjectViewWindow::isViewedAncestor(const ModelIndex &index) {
         if (m_view_index == m_tree_proxy.toSourceIndex(index)) {
             return true;

From e095a47668bddbd1a8d556376582ce9dc4f2f2f6 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Tue, 1 Oct 2024 18:48:18 -0500
Subject: [PATCH 053/129] Remove scene open from application open, and optimize
 otherwise

---
 src/gui/application.cpp    | 32 +++++++++-----------------------
 src/gui/project/window.cpp | 17 +++++++++++++++--
 2 files changed, 24 insertions(+), 25 deletions(-)

diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 8d67258f..36be765b 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -266,7 +266,7 @@ namespace Toolbox {
                                                 const std::string &context) {
         auto it = std::find_if(m_windows.begin(), m_windows.end(),
                                [&title, &context](const auto &window) {
-                                   return window->title() == title && window->context() == context;
+                                   return window->name() == title && window->context() == context;
                                });
         return it != m_windows.end() ? *it : nullptr;
     }
@@ -360,7 +360,7 @@ namespace Toolbox {
             m_windows_processing = true;
             CoreApplication::onUpdate(delta_time);
             m_windows_processing = false;
-            
+
             for (size_t i = 0; i < m_windows_to_add.size(); ++i) {
                 RefPtr<ImWindow> window = m_windows_to_add.front();
                 m_windows_to_add.pop();
@@ -450,27 +450,13 @@ namespace Toolbox {
             FileDialog::instance()->close();
             if (FileDialog::instance()->isOk()) {
                 std::filesystem::path selected_path = FileDialog::instance()->getFilenameResult();
-                if (selected_path.filename() == "scene") {
-                    RefPtr<ImWindow> existing_editor =
-                        findWindow("Scene Editor", selected_path.string());
-                    if (existing_editor) {
-                        existing_editor->focus();
-                    } else {
-                        RefPtr<SceneWindow> scene_window =
-                            createWindow<SceneWindow, true>("Scene Editor");
-                        if (!scene_window->onLoadData(selected_path)) {
-                            scene_window->close();
-                        }
-                    }
-                } else {
-                    if (m_project_manager.loadProjectFolder(selected_path)) {
-                        TOOLBOX_INFO_V("Loaded project folder: {}", selected_path.string());
-                        RefPtr<ProjectViewWindow> project_window =
-                            createWindow<ProjectViewWindow>("Project View");
-                        if (!project_window->onLoadData(selected_path)) {
-                            TOOLBOX_ERROR("Failed to open project folder view!");
-                            project_window->close();
-                        }
+                if (m_project_manager.loadProjectFolder(selected_path)) {
+                    TOOLBOX_INFO_V("Loaded project folder: {}", selected_path.string());
+                    RefPtr<ProjectViewWindow> project_window =
+                        createWindow<ProjectViewWindow>("Project View");
+                    if (!project_window->onLoadData(selected_path)) {
+                        TOOLBOX_ERROR("Failed to open project folder view!");
+                        project_window->close();
                     }
                 }
             }
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 8b070165..3426098a 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -288,7 +288,8 @@ namespace Toolbox::UI {
                 return m_selected_indices_ctx.size() > 0 &&
                        std::all_of(m_selected_indices_ctx.begin(), m_selected_indices_ctx.end(),
                                    [this](const ModelIndex &index) {
-                                       return m_file_system_model->isFile(index) || isPathForScene(index);
+                                       return m_file_system_model->isFile(index) ||
+                                              isPathForScene(index);
                                    });
             },
             [this](auto) { actionOpenIndexes(m_selected_indices_ctx); });
@@ -429,7 +430,6 @@ namespace Toolbox::UI {
                 continue;
             }
 
-
             // TODO: Open files based on extension. Can be either internal or external
             // depending on the file type.
         }
@@ -492,6 +492,12 @@ namespace Toolbox::UI {
             // ./scene/
             fs_path scene_path = m_file_system_model->getPath(index);
 
+            RefPtr<ImWindow> existing_editor = app.findWindow("Scene Editor", scene_path.string());
+            if (existing_editor) {
+                existing_editor->focus();
+                return true;
+            }
+
             RefPtr<SceneWindow> window = app.createWindow<SceneWindow>("Scene Editor");
             if (!window->onLoadData(scene_path)) {
                 app.removeWindow(window);
@@ -513,6 +519,13 @@ namespace Toolbox::UI {
                 return false;
             }
 
+            RefPtr<ImWindow> existing_editor =
+                app.findWindow("Scene Editor", scene_folder.string());
+            if (existing_editor) {
+                existing_editor->focus();
+                return true;
+            }
+
             RefPtr<SceneWindow> window = app.createWindow<SceneWindow>("Scene Editor");
             if (!window->onLoadData(scene_folder)) {
                 app.removeWindow(window);

From 059915cd0568ec532e6749993bfedbdb1e90d26d Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Tue, 1 Oct 2024 21:03:58 -0500
Subject: [PATCH 054/129] Allow opening pad folders from project system

---
 include/gui/project/window.hpp |  1 +
 src/gui/project/window.cpp     | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 2bc0b1c3..5bb91445 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -100,6 +100,7 @@ namespace Toolbox::UI {
                                   bool is_selected);
 
         bool actionOpenScene(const ModelIndex &index);
+        bool actionOpenPad(const ModelIndex &index);
 
         bool isPathForScene(const ModelIndex &index) const;
 
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 3426098a..6c62415e 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -421,6 +421,10 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::actionOpenIndexes(const std::vector<ModelIndex> &indices) {
         for (auto &item_index : indices) {
+            if (actionOpenPad(item_index)) {
+                continue;
+            }
+
             if (actionOpenScene(item_index)) {
                 continue;
             }
@@ -536,6 +540,34 @@ namespace Toolbox::UI {
         }
     }
 
+    bool ProjectViewWindow::actionOpenPad(const ModelIndex &index) {
+        if (!m_file_system_model->isDirectory(index)) {
+            return false;
+        }
+
+        GUIApplication &app = GUIApplication::instance();
+
+        // ./scene/map/map/pad/
+        fs_path pad_path = m_file_system_model->getPath(index);
+        if (pad_path.filename().string() != "pad") {
+            return false;
+        }
+
+        RefPtr<ImWindow> existing_editor = app.findWindow("Pad Recorder", pad_path.string());
+        if (existing_editor) {
+            existing_editor->focus();
+            return true;
+        }
+
+        RefPtr<SceneWindow> window = app.createWindow<SceneWindow>("Pad Recorder");
+        if (!window->onLoadData(pad_path)) {
+            app.removeWindow(window);
+            return false;
+        }
+
+        return true;
+    }
+
     bool ProjectViewWindow::isPathForScene(const ModelIndex &index) const {
         if (!m_file_system_model->validateIndex(index)) {
             return false;

From 2deee8dde791e851d934eb4fa9470c5b8fa4b40b Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Thu, 3 Oct 2024 05:44:19 -0500
Subject: [PATCH 055/129] Windows clipboard support progress

---
 include/core/clipboard.hpp         |  18 +-
 include/core/mimedata/mimedata.hpp |   9 -
 src/core/mimedata/mimedata.cpp     |  55 +----
 src/gui/clipboard.cpp              | 338 +++++++++++++++++++++++++----
 src/gui/project/window.cpp         |  14 +-
 5 files changed, 322 insertions(+), 112 deletions(-)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index 15cf5eb8..6e495d94 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -28,7 +28,7 @@ namespace Toolbox {
         ~SystemClipboard();
 
         SystemClipboard(const SystemClipboard &) = delete;
-        SystemClipboard(SystemClipboard &&) = delete;
+        SystemClipboard(SystemClipboard &&)      = delete;
 
     public:
         static SystemClipboard &instance() {
@@ -40,6 +40,20 @@ namespace Toolbox {
         Result<void, ClipboardError> setText(const std::string &text);
         Result<std::vector<std::string>, ClipboardError> possibleContentTypes();
         Result<MimeData, ClipboardError> getContent(const std::string &type);
+
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+    protected:
+        static UINT FormatForMime(std::string_view mimetype);
+        static std::string MimeForFormat(UINT format);
+
+    private:
+        std::unordered_map<std::string, UINT> m_mime_to_format;
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+    protected:
+        static std::string UTIForMime(std::string_view mimetype);
+        static std::string MimeForUTI(std::string_view uti);
+#endif
+
     };
 
     class DataClipboard {
@@ -137,4 +151,4 @@ namespace Toolbox {
         std::vector<_DataT> m_data                      = {};
     };
 
-}  // namespace Toolbox::UI
\ No newline at end of file
+}  // namespace Toolbox
\ No newline at end of file
diff --git a/include/core/mimedata/mimedata.hpp b/include/core/mimedata/mimedata.hpp
index eca76d21..02b99175 100644
--- a/include/core/mimedata/mimedata.hpp
+++ b/include/core/mimedata/mimedata.hpp
@@ -66,15 +66,6 @@ namespace Toolbox {
             return *this;
         }
 
-    protected:
-#ifdef TOOLBOX_PLATFORM_WINDOWS
-        static FORMATETC FormatForMime(std::string_view mimetype);
-        static std::string MimeForFormat(FORMATETC format);
-#elif defined(TOOLBOX_PLATFORM_LINUX)
-        static std::string UTIForMime(std::string_view mimetype);
-        static std::string MimeForUTI(std::string_view uti);
-#endif
-
     private:
         mutable std::unordered_map<std::string, Buffer> m_data_map;
     };
diff --git a/src/core/mimedata/mimedata.cpp b/src/core/mimedata/mimedata.cpp
index bde8a1f1..939df19e 100644
--- a/src/core/mimedata/mimedata.cpp
+++ b/src/core/mimedata/mimedata.cpp
@@ -59,10 +59,11 @@ namespace Toolbox {
         Buffer &data_buf = m_data_map["application/x-color"];
 
         Color::RGBAShader rgba_color;
-        TRY(Deserializer::BytesToObject(data_buf, rgba_color)).error([&rgba_color](const BaseError &error) {
-            UI::LogError(error);
-            rgba_color.setColor(0.0f, 0.0f, 0.0f);
-        });
+        TRY(Deserializer::BytesToObject(data_buf, rgba_color))
+            .error([&rgba_color](const BaseError &error) {
+                UI::LogError(error);
+                rgba_color.setColor(0.0f, 0.0f, 0.0f);
+            });
         return rgba_color;
     }
 
@@ -128,50 +129,4 @@ namespace Toolbox {
 
     void MimeData::clear() { m_data_map.clear(); }
 
-#ifdef TOOLBOX_PLATFORM_WINDOWS
-
-    /* TODO: Change NULL to HTML */
-    static std::unordered_map<u32, std::string> s_format_to_mime = {
-        {CF_UNICODETEXT, "text/plain"            },
-        {CF_TEXT,        "text/plain"            },
-        {CF_NULL,        "text/html"             },
-        {CF_HDROP,       "text/uri-list"         },
-        {CF_DIB,         "application/x-qt-image"}
-    };
-
-    static std::unordered_map<std::string, u32> s_mime_to_format = {
-        {"text/plain",             CF_TEXT },
-        {"text/html",              CF_NULL },
-        {"text/uri-list",          CF_HDROP},
-        {"application/x-qt-image", CF_DIB  },
-    };
-
-    FORMATETC MimeData::FormatForMime(std::string_view mimetype) { return FORMATETC(); }
-
-    std::string MimeData::MimeForFormat(FORMATETC format) { return std::string(); }
-#elif defined(TOOLBOX_PLATFORM_LINUX)
-    static std::unordered_map<std::string, std::string> s_uti_to_mime = {
-        {"public.utf8-plain-text",               "text/plain"            },
-        {"public.utf16-plain-text",              "text/plain"            },
-        {"public.text",                          "text/plain"            },
-        {"public.html",                          "text/html"             },
-        {"public.url",                           "text/uri-list"         },
-        {"public.file-url",                      "text/uri-list"         },
-        {"public.tiff",                          "application/x-qt-image"},
-        {"public.vcard",                         "text/plain"            },
-        {"com.apple.traditional-mac-plain-text", "text/plain"            },
-        {"com.apple.pict",                       "application/x-qt-image"},
-    };
-
-    static std::unordered_map<std::string, std::string> s_mime_to_uti = {
-        {"text/plain",             "public.text"},
-        {"text/html",              "public.html"},
-        {"text/uri-list",          "public.url" },
-        {"application/x-qt-image", "public.tiff"},
-    };
-
-    std::string MimeData::UTIForMime(std::string_view mimetype) { return s_mime_to_uti[std::string(mimetype)]; }
-    std::string MimeData::MimeForUTI(std::string_view uti) { return s_uti_to_mime[std::string(uti)]; }
-#endif
-
 }  // namespace Toolbox
\ No newline at end of file
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 65bdc1b3..17159302 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -1,10 +1,11 @@
 #include "core/clipboard.hpp"
+#include "core/core.hpp"
 
-#ifdef WIN32
+#ifdef TOOLBOX_PLATFORM_WINDOWS
 #include <Windows.h>
 #elif defined(TOOLBOX_PLATFORM_LINUX)
-#include <X11/Xlib.h>
 #include <X11/Xatom.h>
+#include <X11/Xlib.h>
 #endif
 
 namespace Toolbox {
@@ -12,8 +13,8 @@ namespace Toolbox {
     SystemClipboard::SystemClipboard() {}
     SystemClipboard::~SystemClipboard() {}
 
+#ifdef TOOLBOX_PLATFORM_WINDOWS
     Result<std::string, ClipboardError> SystemClipboard::getText() {
-#ifdef WIN32
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<std::string>("Failed to open the clipboard!");
         }
@@ -25,7 +26,8 @@ namespace Toolbox {
 
         const char *text_data = static_cast<const char *>(GlobalLock(clipboard_data));
         if (!text_data) {
-            return make_clipboard_error<std::string>("Failed to retrieve the buffer from the handle!");
+            return make_clipboard_error<std::string>(
+                "Failed to retrieve the buffer from the handle!");
         }
 
         std::string result = text_data;
@@ -39,11 +41,15 @@ namespace Toolbox {
         }
 
         return result;
-#else
-#endif
     }
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+    Result<std::string, ClipboardError> SystemClipboard::getText() {
+        return make_clipboard_error<std::string>("Not implemented yet");
+    }
+#endif
+
+#ifdef TOOLBOX_PLATFORM_WINDOWS
     Result<void, ClipboardError> SystemClipboard::setText(const std::string &text) {
-#ifdef WIN32
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<void>("Failed to open the clipboard!");
         }
@@ -52,7 +58,7 @@ namespace Toolbox {
             return make_clipboard_error<void>("Failed to clear the clipboard!");
         }
 
-        HANDLE data_handle = GlobalAlloc(GMEM_DDESHARE, text.size()+1);
+        HANDLE data_handle = GlobalAlloc(GMEM_DDESHARE, text.size() + 1);
         if (!data_handle) {
             return make_clipboard_error<void>("Failed to alloc new data handle!");
         }
@@ -62,7 +68,7 @@ namespace Toolbox {
             return make_clipboard_error<void>("Failed to retrieve the buffer from the handle!");
         }
 
-        strncpy_s(data_buffer, text.size()+1, text.c_str(), text.size()+1);
+        strncpy_s(data_buffer, text.size() + 1, text.c_str(), text.size() + 1);
 
         if (!GlobalUnlock(data_handle)) {
             return make_clipboard_error<void>("Failed to unlock the data handle!");
@@ -73,41 +79,71 @@ namespace Toolbox {
         if (!CloseClipboard()) {
             return make_clipboard_error<void>("Failed to close the clipboard!");
         }
-#else
-#endif
         return {};
     }
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+    Result<void, ClipboardError> SystemClipboard::setText(const std::string &text) {
+        return make_clipboard_error<void>("Not implemented yet");
+    }
+#endif
+
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+    Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes() {
+        if (!OpenClipboard(nullptr)) {
+            return make_clipboard_error<std::vector<std::string>>("Failed to open the clipboard!");
+        }
+
+        std::vector<std::string> types;
+        UINT format = 0;
+        while ((format = EnumClipboardFormats(format)) != CF_NULL) {
+            std::string the_format = "";
+
+            for (const auto &[mime, custom_fmt] : m_mime_to_format) {
+                if (format == custom_fmt) {
+                    the_format = mime;
+                    break;
+                }
+            }
+
+            if (the_format.empty()) {
+                the_format = MimeForFormat(format);
+            }
+
+            types.push_back(the_format);
+        }
+
+        if (!CloseClipboard()) {
+            return make_clipboard_error<std::vector<std::string>>("Failed to close the clipboard!");
+        }
 
-    Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes(){
-#ifdef TOOLBOX_PLATFORM_LINUX
+        return types;
+    }
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+    Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes() {
         Display *dpy = XOpenDisplay(nullptr);
         if (!dpy) {
             return make_clipboard_error<std::vector<std::string>>("Could not open X display");
         }
-        Atom sel = XInternAtom(dpy, "CLIPBOARD", False);
-        Atom targets = XInternAtom(dpy, "TARGETS", False);
+        Atom sel             = XInternAtom(dpy, "CLIPBOARD", False);
+        Atom targets         = XInternAtom(dpy, "TARGETS", False);
         Atom target_property = XInternAtom(dpy, "CLIP_TYPES", False);
-        Window root_window = RootWindow(dpy, DefaultScreen(dpy));
+        Window root_window   = RootWindow(dpy, DefaultScreen(dpy));
         Window target_window = XCreateSimpleWindow(dpy, root_window, -10, -10, 1, 1, 0, 0, 0);
-        XConvertSelection(dpy, sel, targets, target_property, target_window,
-                          CurrentTime);
+        XConvertSelection(dpy, sel, targets, target_property, target_window, CurrentTime);
 
         XEvent ev;
         XSelectionEvent *sev;
         // This looks pretty dangerous but this is how glfw does it,
         // and how the examples online do it, so :shrug:
-        while(true){
+        while (true) {
             XNextEvent(dpy, &ev);
-            switch (ev.type)
-            {
+            switch (ev.type) {
             case SelectionNotify:
-                sev = (XSelectionEvent*)&ev.xselection;
-                if (sev->property == None)
-                {
-                    return make_clipboard_error<std::vector<std::string>>("Conversion could not be performed.\n");
-                }
-                else
-                {
+                sev = (XSelectionEvent *)&ev.xselection;
+                if (sev->property == None) {
+                    return make_clipboard_error<std::vector<std::string>>(
+                        "Conversion could not be performed.\n");
+                } else {
                     std::vector<std::string> types;
                     unsigned long nitems;
                     unsigned char *prop_ret = nullptr;
@@ -115,13 +151,12 @@ namespace Toolbox {
                     Atom _type;
                     int _di;
                     unsigned long _dul;
-                    XGetWindowProperty(dpy, target_window, target_property, 0,
-                                       1024 * sizeof(Atom), False, XA_ATOM,
-                                       &_type, &_di, &nitems, &_dul, &prop_ret);
+                    XGetWindowProperty(dpy, target_window, target_property, 0, 1024 * sizeof(Atom),
+                                       False, XA_ATOM, &_type, &_di, &nitems, &_dul, &prop_ret);
 
-                    Atom *targets = (Atom*)prop_ret;
-                    for(int i = 0; i < nitems; ++i) {
-                        char* an = XGetAtomName(dpy, targets[i]);
+                    Atom *targets = (Atom *)prop_ret;
+                    for (int i = 0; i < nitems; ++i) {
+                        char *an = XGetAtomName(dpy, targets[i]);
                         types.push_back(std::string(an));
                         if (an)
                             XFree(an);
@@ -133,22 +168,117 @@ namespace Toolbox {
                 break;
             }
         }
-#endif
         return {};
     }
-    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type){
-#ifdef TOOLBOX_PLATFORM_LINUX
+#endif
+
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) {
+        if (!OpenClipboard(nullptr)) {
+            return make_clipboard_error<MimeData>("Failed to open the clipboard!");
+        }
+
+        UINT format = CF_NULL;
+        if (m_mime_to_format.find(type) == m_mime_to_format.end()) {
+            format = FormatForMime(type);
+            if (format == CF_NULL) {
+                m_mime_to_format[type] = RegisterClipboardFormat(type.c_str());
+                format                 = m_mime_to_format[type];
+            }
+        } else {
+            format = m_mime_to_format[type];
+        }
+
+        if (format == CF_NULL) {
+            return make_clipboard_error<MimeData>("Failed to register the clipboard format!");
+        }
+
+        HANDLE clipboard_data = GetClipboardData(format);
+        if (!clipboard_data) {
+            return make_clipboard_error<MimeData>("Failed to retrieve the data handle!");
+        }
+
+        HANDLE data_handle = static_cast<HANDLE>(GlobalLock(clipboard_data));
+        if (!data_handle) {
+            return make_clipboard_error<MimeData>("Failed to retrieve the buffer from the handle!");
+        }
+
+        if (format == CF_TEXT) {
+            const char *text_data = static_cast<const char *>(data_handle);
+            std::string result    = text_data;
+
+            if (!GlobalUnlock(clipboard_data)) {
+                return make_clipboard_error<MimeData>("Failed to unlock the data handle!");
+            }
+
+            if (!CloseClipboard()) {
+                return make_clipboard_error<MimeData>("Failed to close the clipboard!");
+            }
+
+            MimeData mime_data;
+            mime_data.set_text(result);
+            return mime_data;
+        }
+
+        if (format == CF_HDROP) {
+            HDROP hdrop    = static_cast<HDROP>(data_handle);
+            UINT num_files = DragQueryFile(hdrop, 0xFFFFFFFF, nullptr, 0);
+            std::string uri_list;
+            for (UINT i = 0; i < num_files; ++i) {
+                UINT size = DragQueryFile(hdrop, i, nullptr, 0);
+                std::string file(size, '\0');
+                DragQueryFile(hdrop, i, file.data(), size + 1);
+                uri_list += std::format("file:///{}", file);
+                if (i != num_files - 1) {
+                    uri_list += "\r\n";
+                }
+            }
+
+            if (!GlobalUnlock(clipboard_data)) {
+                return make_clipboard_error<MimeData>("Failed to unlock the data handle!");
+            }
+
+            if (!CloseClipboard()) {
+                return make_clipboard_error<MimeData>("Failed to close the clipboard!");
+            }
+
+            MimeData mime_data;
+            mime_data.set_urls(uri_list);
+            return mime_data;
+        }
+
+        if (format == CF_UNICODETEXT) {
+            const wchar_t *text_data = static_cast<const wchar_t *>(data_handle);
+            std::wstring result      = text_data;
+
+            if (!GlobalUnlock(clipboard_data)) {
+                return make_clipboard_error<MimeData>("Failed to unlock the data handle!");
+            }
+
+            if (!CloseClipboard()) {
+                return make_clipboard_error<MimeData>("Failed to close the clipboard!");
+            }
+
+            MimeData mime_data;
+            mime_data.set_text(std::string(result.begin(), result.end()));
+            return mime_data;
+        }
+
+        return make_clipboard_error<MimeData>("Unimplemented MIME type!");
+    }
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) {
         Display *dpy = XOpenDisplay(nullptr);
         if (!dpy) {
             return make_clipboard_error<MimeData>("Could not open X display");
         }
-        Atom requested_type = XInternAtom(dpy, type.c_str(), False);
-        Atom sel = XInternAtom(dpy, "CLIPBOARD", False);
+        Atom requested_type    = XInternAtom(dpy, type.c_str(), False);
+        Atom sel               = XInternAtom(dpy, "CLIPBOARD", False);
         Window clipboard_owner = XGetSelectionOwner(dpy, sel);
         if (clipboard_owner == None) {
             return make_clipboard_error<MimeData>("Clipboard isn't owned by anyone");
         }
-        Window root = RootWindow(dpy, DefaultScreen(dpy));
+        Window root          = RootWindow(dpy, DefaultScreen(dpy));
         Window target_window = XCreateSimpleWindow(dpy, root, -10, -10, 1, 1, 0, 0, 0);
         Atom target_property = XInternAtom(dpy, "CLIP_CONTENTS", False);
         XConvertSelection(dpy, sel, requested_type, target_property, target_window, CurrentTime);
@@ -156,12 +286,11 @@ namespace Toolbox {
         XSelectionEvent *sev;
         // This looks pretty dangerous but this is how glfw does it,
         // and how the examples online do it, so :shrug:
-        while(true){
+        while (true) {
             XNextEvent(dpy, &ev);
-            switch (ev.type)
-            {
+            switch (ev.type) {
             case SelectionNotify:
-                sev = (XSelectionEvent*)&ev.xselection;
+                sev = (XSelectionEvent *)&ev.xselection;
                 if (sev->property == None) {
                     return make_clipboard_error<MimeData>("Conversion could not be performed.");
                 } else {
@@ -174,12 +303,14 @@ namespace Toolbox {
                     Atom _da;
 
                     XGetWindowProperty(dpy, target_window, target_property, 0, 0, False,
-                                       AnyPropertyType, &type_received, &_di, &_dul, &size, &prop_ret);
+                                       AnyPropertyType, &type_received, &_di, &_dul, &size,
+                                       &prop_ret);
                     XFree(prop_ret);
 
                     Atom incr = XInternAtom(dpy, "INCR", False);
                     if (type_received == incr) {
-                        return make_clipboard_error<MimeData>("Data over 256kb, this isn't supported yet");
+                        return make_clipboard_error<MimeData>(
+                            "Data over 256kb, this isn't supported yet");
                     }
                     XGetWindowProperty(dpy, target_window, target_property, 0, size, False,
                                        AnyPropertyType, &_da, &_di, &_dul, &_dul, &prop_ret);
@@ -198,8 +329,119 @@ namespace Toolbox {
                 }
             }
         }
-#endif
         return {};
     }
+#endif
+
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+
+    UINT SystemClipboard::FormatForMime(std::string_view mimetype) {
+        if (mimetype == "text/plain") {
+            return CF_TEXT;
+        }
+
+        if (mimetype == "image/bmp") {
+            return CF_BITMAP;
+        }
+
+        if (mimetype == "image/x-wmf") {
+            return CF_METAFILEPICT;
+        }
+
+        if (mimetype == "application/vnd.ms-excel") {
+            return CF_SYLK;
+        }
+
+        if (mimetype == "image/tiff") {
+            return CF_TIFF;
+        }
+
+        if (mimetype == "audio/riff") {
+            return CF_RIFF;
+        }
+
+        if (mimetype == "audio/wav") {
+            return CF_WAVE;
+        }
+
+        if (mimetype == "text/uri-list") {
+            return CF_HDROP;
+        }
+
+        return CF_NULL;
+    }
+
+    std::string SystemClipboard::MimeForFormat(UINT format) {
+        switch (format) {
+        case CF_TEXT:
+            return "text/plain";
+        case CF_BITMAP:
+            return "image/bmp";
+        case CF_METAFILEPICT:
+            return "image/x-wmf";
+        case CF_SYLK:
+            return "application/vnd.ms-excel";
+        case CF_DIF:
+            return "application/vnd.ms-excel";
+        case CF_TIFF:
+            return "image/tiff";
+        case CF_OEMTEXT:
+            return "text/plain";
+        case CF_DIB:
+            return "";
+        case CF_PALETTE:
+            return "";
+        case CF_PENDATA:
+            return "";
+        case CF_RIFF:
+            return "audio/riff";
+        case CF_WAVE:
+            return "audio/wav";
+        case CF_UNICODETEXT:
+            return "text/plain";
+        case CF_ENHMETAFILE:
+            return "";
+#if (WINVER >= 0x0400)
+        case CF_HDROP:
+            return "text/uri-list";
+        case CF_LOCALE:
+            return "";
+#endif /* WINVER >= 0x0400 */
+#if (WINVER >= 0x0500)
+        case CF_DIBV5:
+            return "";
+#endif /* WINVER >= 0x0500 */
+        default:
+            return "";
+        }
+    }
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+    static std::unordered_map<std::string, std::string> s_uti_to_mime = {
+        {"public.utf8-plain-text",               "text/plain"            },
+        {"public.utf16-plain-text",              "text/plain"            },
+        {"public.text",                          "text/plain"            },
+        {"public.html",                          "text/html"             },
+        {"public.url",                           "text/uri-list"         },
+        {"public.file-url",                      "text/uri-list"         },
+        {"public.tiff",                          "application/x-qt-image"},
+        {"public.vcard",                         "text/plain"            },
+        {"com.apple.traditional-mac-plain-text", "text/plain"            },
+        {"com.apple.pict",                       "application/x-qt-image"},
+    };
+
+    static std::unordered_map<std::string, std::string> s_mime_to_uti = {
+        {"text/plain",             "public.text"},
+        {"text/html",              "public.html"},
+        {"text/uri-list",          "public.url" },
+        {"application/x-qt-image", "public.tiff"},
+    };
+
+    std::string MimeData::UTIForMime(std::string_view mimetype) {
+        return s_mime_to_uti[std::string(mimetype)];
+    }
+    std::string MimeData::MimeForUTI(std::string_view uti) {
+        return s_uti_to_mime[std::string(uti)];
+    }
+#endif
 
-}  // namespace Toolbox::UI
+}  // namespace Toolbox
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 6c62415e..4bb00ff7 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -265,7 +265,7 @@ namespace Toolbox::UI {
         size_t last_pos         = 0;
         size_t next_newline_pos = s.find('\n', 0);
         while (next_newline_pos != std::string::npos) {
-            if (s[last_pos + next_newline_pos - 1] == '\r') {
+            if (s[next_newline_pos - 1] == '\r') {
                 result.push_back(s.substr(last_pos, next_newline_pos - 1));
             } else {
                 result.push_back(s.substr(last_pos, next_newline_pos));
@@ -392,10 +392,18 @@ namespace Toolbox::UI {
                     }
 
                     for (std::string_view src_path_str : splitLines(text.value())) {
-                        if (src_path_str.substr(0, 7) != "file://") {
+                        if (src_path_str.starts_with("file:/")) {
+                            if (src_path_str.starts_with("file:///")) {
+                                src_path_str = src_path_str.substr(8);
+                            } else {
+                                src_path_str = src_path_str.substr(7);
+                            }
+                        } else {
                             TOOLBOX_ERROR_V("Can't copy non-local uri {}", src_path_str);
+                            continue;
                         }
-                        fs_path src_path = src_path_str.substr(7);
+
+                        fs_path src_path = src_path_str;
                         m_file_system_model->copy(src_path, m_view_index,
                                                   src_path.filename().string());
                     }

From ed5adb75453c83df881bfcbd8eefabba55065db6 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Thu, 3 Oct 2024 06:14:48 -0500
Subject: [PATCH 056/129] Fix lil' bugs

---
 src/gui/project/window.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 4bb00ff7..ddb4c1c2 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -273,6 +273,9 @@ namespace Toolbox::UI {
             last_pos         = next_newline_pos + 1;
             next_newline_pos = s.find('\n', last_pos);
         }
+        if (last_pos < s.size()) {
+            result.push_back(s.substr(last_pos));
+        }
         return result;
     }
 
@@ -391,7 +394,8 @@ namespace Toolbox::UI {
                         return;
                     }
 
-                    for (std::string_view src_path_str : splitLines(text.value())) {
+                    std::vector<std::string_view> urls = splitLines(text.value());
+                    for (std::string_view src_path_str : urls) {
                         if (src_path_str.starts_with("file:/")) {
                             if (src_path_str.starts_with("file:///")) {
                                 src_path_str = src_path_str.substr(8);

From 7b9d93381ffabc50bc99dc1fda3c5eaf89d5d01a Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Thu, 3 Oct 2024 10:56:21 -0500
Subject: [PATCH 057/129] Allow for pasting of files on windows and some misc
 changes

---
 include/core/clipboard.hpp     |   5 +-
 src/core/mimedata/mimedata.cpp |   3 +-
 src/gui/clipboard.cpp          | 398 ++++++++++++++++++++-------------
 src/gui/project/window.cpp     |  19 +-
 4 files changed, 265 insertions(+), 160 deletions(-)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index 6e495d94..ccf50fbd 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -36,10 +36,13 @@ namespace Toolbox {
             return s_clipboard;
         }
 
+        Result<std::vector<std::string>, ClipboardError> getAvailableContentFormats() const;
+
         Result<std::string, ClipboardError> getText();
         Result<void, ClipboardError> setText(const std::string &text);
-        Result<std::vector<std::string>, ClipboardError> possibleContentTypes();
+
         Result<MimeData, ClipboardError> getContent(const std::string &type);
+        Result<void, ClipboardError> setContent(const std::string &type, const MimeData &mimedata);
 
 #ifdef TOOLBOX_PLATFORM_WINDOWS
     protected:
diff --git a/src/core/mimedata/mimedata.cpp b/src/core/mimedata/mimedata.cpp
index 939df19e..d26378d3 100644
--- a/src/core/mimedata/mimedata.cpp
+++ b/src/core/mimedata/mimedata.cpp
@@ -122,8 +122,9 @@ namespace Toolbox {
 
     void MimeData::set_urls(std::string_view data) {
         Buffer _tmp;
-        _tmp.alloc(data.size());
+        _tmp.alloc(data.size() + 1);
         std::memcpy(_tmp.buf(), data.data(), data.size());
+        _tmp.get<char>(data.size()) = '\0';
         set_data("text/uri-list", std::move(_tmp));
     }
 
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 17159302..0ba51beb 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -3,6 +3,7 @@
 
 #ifdef TOOLBOX_PLATFORM_WINDOWS
 #include <Windows.h>
+#include <shlobj_core.h>
 #elif defined(TOOLBOX_PLATFORM_LINUX)
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
@@ -14,6 +15,41 @@ namespace Toolbox {
     SystemClipboard::~SystemClipboard() {}
 
 #ifdef TOOLBOX_PLATFORM_WINDOWS
+
+    Result<std::vector<std::string>, ClipboardError>
+    SystemClipboard::getAvailableContentFormats() const {
+        if (!OpenClipboard(nullptr)) {
+            return make_clipboard_error<std::vector<std::string>>("Failed to open the clipboard!");
+        }
+
+        std::vector<std::string> types;
+        UINT format = 0;
+        while ((format = EnumClipboardFormats(format)) != CF_NULL) {
+            std::string the_format = "";
+
+            for (const auto &[mime, custom_fmt] : m_mime_to_format) {
+                if (format == custom_fmt) {
+                    the_format = mime;
+                    break;
+                }
+            }
+
+            if (the_format.empty()) {
+                the_format = MimeForFormat(format);
+            }
+
+            if (!the_format.empty()) {
+                types.push_back(the_format);
+            }
+        }
+
+        if (!CloseClipboard()) {
+            return make_clipboard_error<std::vector<std::string>>("Failed to close the clipboard!");
+        }
+
+        return types;
+    }
+
     Result<std::string, ClipboardError> SystemClipboard::getText() {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<std::string>("Failed to open the clipboard!");
@@ -42,13 +78,7 @@ namespace Toolbox {
 
         return result;
     }
-#elif defined(TOOLBOX_PLATFORM_LINUX)
-    Result<std::string, ClipboardError> SystemClipboard::getText() {
-        return make_clipboard_error<std::string>("Not implemented yet");
-    }
-#endif
 
-#ifdef TOOLBOX_PLATFORM_WINDOWS
     Result<void, ClipboardError> SystemClipboard::setText(const std::string &text) {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<void>("Failed to open the clipboard!");
@@ -81,98 +111,7 @@ namespace Toolbox {
         }
         return {};
     }
-#elif defined(TOOLBOX_PLATFORM_LINUX)
-    Result<void, ClipboardError> SystemClipboard::setText(const std::string &text) {
-        return make_clipboard_error<void>("Not implemented yet");
-    }
-#endif
-
-#ifdef TOOLBOX_PLATFORM_WINDOWS
-    Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes() {
-        if (!OpenClipboard(nullptr)) {
-            return make_clipboard_error<std::vector<std::string>>("Failed to open the clipboard!");
-        }
-
-        std::vector<std::string> types;
-        UINT format = 0;
-        while ((format = EnumClipboardFormats(format)) != CF_NULL) {
-            std::string the_format = "";
-
-            for (const auto &[mime, custom_fmt] : m_mime_to_format) {
-                if (format == custom_fmt) {
-                    the_format = mime;
-                    break;
-                }
-            }
-
-            if (the_format.empty()) {
-                the_format = MimeForFormat(format);
-            }
-
-            types.push_back(the_format);
-        }
-
-        if (!CloseClipboard()) {
-            return make_clipboard_error<std::vector<std::string>>("Failed to close the clipboard!");
-        }
-
-        return types;
-    }
-#elif defined(TOOLBOX_PLATFORM_LINUX)
-    Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes() {
-        Display *dpy = XOpenDisplay(nullptr);
-        if (!dpy) {
-            return make_clipboard_error<std::vector<std::string>>("Could not open X display");
-        }
-        Atom sel             = XInternAtom(dpy, "CLIPBOARD", False);
-        Atom targets         = XInternAtom(dpy, "TARGETS", False);
-        Atom target_property = XInternAtom(dpy, "CLIP_TYPES", False);
-        Window root_window   = RootWindow(dpy, DefaultScreen(dpy));
-        Window target_window = XCreateSimpleWindow(dpy, root_window, -10, -10, 1, 1, 0, 0, 0);
-        XConvertSelection(dpy, sel, targets, target_property, target_window, CurrentTime);
-
-        XEvent ev;
-        XSelectionEvent *sev;
-        // This looks pretty dangerous but this is how glfw does it,
-        // and how the examples online do it, so :shrug:
-        while (true) {
-            XNextEvent(dpy, &ev);
-            switch (ev.type) {
-            case SelectionNotify:
-                sev = (XSelectionEvent *)&ev.xselection;
-                if (sev->property == None) {
-                    return make_clipboard_error<std::vector<std::string>>(
-                        "Conversion could not be performed.\n");
-                } else {
-                    std::vector<std::string> types;
-                    unsigned long nitems;
-                    unsigned char *prop_ret = nullptr;
-                    // We won't use these.
-                    Atom _type;
-                    int _di;
-                    unsigned long _dul;
-                    XGetWindowProperty(dpy, target_window, target_property, 0, 1024 * sizeof(Atom),
-                                       False, XA_ATOM, &_type, &_di, &nitems, &_dul, &prop_ret);
-
-                    Atom *targets = (Atom *)prop_ret;
-                    for (int i = 0; i < nitems; ++i) {
-                        char *an = XGetAtomName(dpy, targets[i]);
-                        types.push_back(std::string(an));
-                        if (an)
-                            XFree(an);
-                    }
-                    XFree(prop_ret);
-                    XDeleteProperty(dpy, target_window, target_property);
-                    return types;
-                }
-                break;
-            }
-        }
-        return {};
-    }
-#endif
 
-#ifdef TOOLBOX_PLATFORM_WINDOWS
     Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<MimeData>("Failed to open the clipboard!");
@@ -266,74 +205,94 @@ namespace Toolbox {
 
         return make_clipboard_error<MimeData>("Unimplemented MIME type!");
     }
-#elif defined(TOOLBOX_PLATFORM_LINUX)
-    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) {
-        Display *dpy = XOpenDisplay(nullptr);
-        if (!dpy) {
-            return make_clipboard_error<MimeData>("Could not open X display");
+
+    Result<void, ClipboardError> SystemClipboard::setContent(const std::string &type,
+                                                             const MimeData &mimedata) {
+        if (!OpenClipboard(nullptr)) {
+            return make_clipboard_error<void>("Failed to open the clipboard!");
         }
-        Atom requested_type    = XInternAtom(dpy, type.c_str(), False);
-        Atom sel               = XInternAtom(dpy, "CLIPBOARD", False);
-        Window clipboard_owner = XGetSelectionOwner(dpy, sel);
-        if (clipboard_owner == None) {
-            return make_clipboard_error<MimeData>("Clipboard isn't owned by anyone");
+
+        if (!EmptyClipboard()) {
+            return make_clipboard_error<void>("Failed to clear the clipboard!");
         }
-        Window root          = RootWindow(dpy, DefaultScreen(dpy));
-        Window target_window = XCreateSimpleWindow(dpy, root, -10, -10, 1, 1, 0, 0, 0);
-        Atom target_property = XInternAtom(dpy, "CLIP_CONTENTS", False);
-        XConvertSelection(dpy, sel, requested_type, target_property, target_window, CurrentTime);
-        XEvent ev;
-        XSelectionEvent *sev;
-        // This looks pretty dangerous but this is how glfw does it,
-        // and how the examples online do it, so :shrug:
-        while (true) {
-            XNextEvent(dpy, &ev);
-            switch (ev.type) {
-            case SelectionNotify:
-                sev = (XSelectionEvent *)&ev.xselection;
-                if (sev->property == None) {
-                    return make_clipboard_error<MimeData>("Conversion could not be performed.");
-                } else {
-                    Atom type_received;
-                    unsigned long size;
-                    unsigned char *prop_ret = nullptr;
-                    // These are unused
-                    int _di;
-                    unsigned long _dul;
-                    Atom _da;
 
-                    XGetWindowProperty(dpy, target_window, target_property, 0, 0, False,
-                                       AnyPropertyType, &type_received, &_di, &_dul, &size,
-                                       &prop_ret);
-                    XFree(prop_ret);
+        std::optional<Buffer> result = mimedata.get_data(type);
+        if (!result) {
+            return make_clipboard_error<void>(
+                std::format("Failed to find MIME data type \"{}\"", type));
+        }
 
-                    Atom incr = XInternAtom(dpy, "INCR", False);
-                    if (type_received == incr) {
-                        return make_clipboard_error<MimeData>(
-                            "Data over 256kb, this isn't supported yet");
-                    }
-                    XGetWindowProperty(dpy, target_window, target_property, 0, size, False,
-                                       AnyPropertyType, &_da, &_di, &_dul, &_dul, &prop_ret);
-                    Buffer data_buffer;
-                    if (!data_buffer.alloc(size)) {
-                        return make_clipboard_error<MimeData>(
-                            "Couldn't allocate buffer of big enough size");
-                    }
-                    std::memcpy(data_buffer.buf(), prop_ret, size);
-                    XFree(prop_ret);
-                    XDeleteProperty(dpy, target_window, target_property);
+        Buffer data_buf = std::move(result.value());
 
-                    MimeData result;
-                    result.set_data(type, std::move(data_buffer));
-                    return result;
+        UINT format = CF_NULL;
+        if (m_mime_to_format.find(type) == m_mime_to_format.end()) {
+            format = FormatForMime(type);
+            if (format == CF_NULL) {
+                m_mime_to_format[type] = RegisterClipboardFormat(type.c_str());
+                format                 = m_mime_to_format[type];
+            }
+        } else {
+            format = m_mime_to_format[type];
+        }
+
+        if (format == CF_NULL) {
+            return make_clipboard_error<void>("Failed to register the clipboard format!");
+        }
+
+        size_t dest_buf_size = data_buf.size();
+        if (format == CF_HDROP) {
+            dest_buf_size *= 2;
+            dest_buf_size += sizeof(DROPFILES);
+        } else if (format == CF_TEXT) {
+            dest_buf_size *= 2;
+        }
+
+        HANDLE data_handle = GlobalAlloc(GMEM_DDESHARE | GMEM_ZEROINIT, dest_buf_size);
+        if (!data_handle) {
+            return make_clipboard_error<void>("Failed to alloc new data handle!");
+        }
+
+        void *data_buffer = static_cast<void *>(GlobalLock(data_handle));
+        if (!data_buffer) {
+            return make_clipboard_error<void>("Failed to retrieve the buffer from the handle!");
+        }
+
+        if (format == CF_HDROP) {
+            DROPFILES *drop_files_buf = static_cast<DROPFILES *>(data_buffer);
+            drop_files_buf->fWide     = TRUE;
+            drop_files_buf->pFiles    = sizeof(DROPFILES);
+
+            wchar_t *path_list_ptr = (wchar_t *)((char *)data_buffer + sizeof(DROPFILES));
+            std::mbstowcs(path_list_ptr, data_buf.buf<char>(), data_buf.size());
+
+            for (size_t i = 0; i < data_buf.size(); ++i) {
+                wchar_t &wchr = path_list_ptr[i];
+                if (wchr == L'\n') {
+                    wchr = L'\0';
                 }
             }
+
+            path_list_ptr[data_buf.size()] = L'\0';
+        } else if (format == CF_TEXT) {
+            wchar_t *path_list_ptr = (wchar_t *)data_buffer;
+            std::mbstowcs(path_list_ptr, data_buf.buf<char>(), data_buf.size());
+            path_list_ptr[data_buf.size()] = L'\0';
+        } else {
+            std::memcpy(data_buffer, data_buf.buf(), data_buf.size());
         }
-        return {};
-    }
-#endif
 
-#ifdef TOOLBOX_PLATFORM_WINDOWS
+        if (!GlobalUnlock(data_handle)) {
+            return make_clipboard_error<void>("Failed to unlock the data handle!");
+        }
+
+        SetClipboardData(format, data_handle);
+
+        if (!CloseClipboard()) {
+            return make_clipboard_error<void>("Failed to close the clipboard!");
+        }
+
+        return Result<void, ClipboardError>();
+    }
 
     UINT SystemClipboard::FormatForMime(std::string_view mimetype) {
         if (mimetype == "text/plain") {
@@ -415,7 +374,134 @@ namespace Toolbox {
             return "";
         }
     }
+
 #elif defined(TOOLBOX_PLATFORM_LINUX)
+    Result<std::vector<std::string>, ClipboardError>
+    SystemClipboard::getAvailableContentFormats() const {
+        Display *dpy = XOpenDisplay(nullptr);
+        if (!dpy) {
+            return make_clipboard_error<std::vector<std::string>>("Could not open X display");
+        }
+        Atom sel             = XInternAtom(dpy, "CLIPBOARD", False);
+        Atom targets         = XInternAtom(dpy, "TARGETS", False);
+        Atom target_property = XInternAtom(dpy, "CLIP_TYPES", False);
+        Window root_window   = RootWindow(dpy, DefaultScreen(dpy));
+        Window target_window = XCreateSimpleWindow(dpy, root_window, -10, -10, 1, 1, 0, 0, 0);
+        XConvertSelection(dpy, sel, targets, target_property, target_window, CurrentTime);
+
+        XEvent ev;
+        XSelectionEvent *sev;
+        // This looks pretty dangerous but this is how glfw does it,
+        // and how the examples online do it, so :shrug:
+        while (true) {
+            XNextEvent(dpy, &ev);
+            switch (ev.type) {
+            case SelectionNotify:
+                sev = (XSelectionEvent *)&ev.xselection;
+                if (sev->property == None) {
+                    return make_clipboard_error<std::vector<std::string>>(
+                        "Conversion could not be performed.\n");
+                } else {
+                    std::vector<std::string> types;
+                    unsigned long nitems;
+                    unsigned char *prop_ret = nullptr;
+                    // We won't use these.
+                    Atom _type;
+                    int _di;
+                    unsigned long _dul;
+                    XGetWindowProperty(dpy, target_window, target_property, 0, 1024 * sizeof(Atom),
+                                       False, XA_ATOM, &_type, &_di, &nitems, &_dul, &prop_ret);
+
+                    Atom *targets = (Atom *)prop_ret;
+                    for (int i = 0; i < nitems; ++i) {
+                        char *an = XGetAtomName(dpy, targets[i]);
+                        types.push_back(std::string(an));
+                        if (an)
+                            XFree(an);
+                    }
+                    XFree(prop_ret);
+                    XDeleteProperty(dpy, target_window, target_property);
+                    return types;
+                }
+                break;
+            }
+        }
+        return {};
+    }
+
+    Result<std::string, ClipboardError> SystemClipboard::getText() {
+        return make_clipboard_error<std::string>("Not implemented yet");
+    }
+
+    Result<void, ClipboardError> SystemClipboard::setText(const std::string &text) {
+        return make_clipboard_error<void>("Not implemented yet");
+    }
+
+    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) {
+        Display *dpy = XOpenDisplay(nullptr);
+        if (!dpy) {
+            return make_clipboard_error<MimeData>("Could not open X display");
+        }
+        Atom requested_type    = XInternAtom(dpy, type.c_str(), False);
+        Atom sel               = XInternAtom(dpy, "CLIPBOARD", False);
+        Window clipboard_owner = XGetSelectionOwner(dpy, sel);
+        if (clipboard_owner == None) {
+            return make_clipboard_error<MimeData>("Clipboard isn't owned by anyone");
+        }
+        Window root          = RootWindow(dpy, DefaultScreen(dpy));
+        Window target_window = XCreateSimpleWindow(dpy, root, -10, -10, 1, 1, 0, 0, 0);
+        Atom target_property = XInternAtom(dpy, "CLIP_CONTENTS", False);
+        XConvertSelection(dpy, sel, requested_type, target_property, target_window, CurrentTime);
+        XEvent ev;
+        XSelectionEvent *sev;
+        // This looks pretty dangerous but this is how glfw does it,
+        // and how the examples online do it, so :shrug:
+        while (true) {
+            XNextEvent(dpy, &ev);
+            switch (ev.type) {
+            case SelectionNotify:
+                sev = (XSelectionEvent *)&ev.xselection;
+                if (sev->property == None) {
+                    return make_clipboard_error<MimeData>("Conversion could not be performed.");
+                } else {
+                    Atom type_received;
+                    unsigned long size;
+                    unsigned char *prop_ret = nullptr;
+                    // These are unused
+                    int _di;
+                    unsigned long _dul;
+                    Atom _da;
+
+                    XGetWindowProperty(dpy, target_window, target_property, 0, 0, False,
+                                       AnyPropertyType, &type_received, &_di, &_dul, &size,
+                                       &prop_ret);
+                    XFree(prop_ret);
+
+                    Atom incr = XInternAtom(dpy, "INCR", False);
+                    if (type_received == incr) {
+                        return make_clipboard_error<MimeData>(
+                            "Data over 256kb, this isn't supported yet");
+                    }
+                    XGetWindowProperty(dpy, target_window, target_property, 0, size, False,
+                                       AnyPropertyType, &_da, &_di, &_dul, &_dul, &prop_ret);
+                    Buffer data_buffer;
+                    if (!data_buffer.alloc(size)) {
+                        return make_clipboard_error<MimeData>(
+                            "Couldn't allocate buffer of big enough size");
+                    }
+                    std::memcpy(data_buffer.buf(), prop_ret, size);
+                    XFree(prop_ret);
+                    XDeleteProperty(dpy, target_window, target_property);
+
+                    MimeData result;
+                    result.set_data(type, std::move(data_buffer));
+                    return result;
+                }
+            }
+        }
+        return {};
+    }
+
     static std::unordered_map<std::string, std::string> s_uti_to_mime = {
         {"public.utf8-plain-text",               "text/plain"            },
         {"public.utf16-plain-text",              "text/plain"            },
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index ddb4c1c2..7747f035 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -353,7 +353,22 @@ namespace Toolbox::UI {
 
         m_folder_view_context_menu.addOption(
             "Copy", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C}),
-            [this]() { return m_selected_indices_ctx.size() > 0; }, [this](auto) {});
+            [this]() { return m_selected_indices_ctx.size() > 0; },
+            [this](auto) {
+                std::string copied_paths;
+                for (const ModelIndex &index : m_selected_indices_ctx) {
+                    copied_paths += m_file_system_model->getPath(index).string();
+                    copied_paths += "\n";
+                }
+
+                MimeData data;
+                data.set_urls(copied_paths);
+
+                auto result = SystemClipboard::instance().setContent("text/uri-list", data);
+                if (!result) {
+                    TOOLBOX_ERROR("[PROJECT] Failed to set contents of clipboard");
+                }
+            });
 
         m_folder_view_context_menu.addDivider();
 
@@ -376,7 +391,7 @@ namespace Toolbox::UI {
             "Paste", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V}),
             [this]() { return m_selected_indices_ctx.size() == 0; },
             [this](auto) {
-                auto content_types = SystemClipboard::instance().possibleContentTypes();
+                auto content_types = SystemClipboard::instance().getAvailableContentFormats();
                 if (!content_types) {
                     TOOLBOX_ERROR("Couldn't get content types");
                     return;

From ddfdb95c999a6330e302f9478243721bdd729777 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 3 Oct 2024 10:42:51 -0700
Subject: [PATCH 058/129] Crappy implementation of pasting out that blocks the
 main thread indefinitely

---
 include/core/clipboard.hpp |   1 +
 src/gui/clipboard.cpp      | 100 +++++++++++++++++++++++++++++++++++++
 src/gui/project/window.cpp |  15 +++++-
 3 files changed, 115 insertions(+), 1 deletion(-)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index 15cf5eb8..03cd91b7 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -40,6 +40,7 @@ namespace Toolbox {
         Result<void, ClipboardError> setText(const std::string &text);
         Result<std::vector<std::string>, ClipboardError> possibleContentTypes();
         Result<MimeData, ClipboardError> getContent(const std::string &type);
+        Result<void, ClipboardError> setContent(const MimeData &content);
     };
 
     class DataClipboard {
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 65bdc1b3..03eb64d3 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -198,6 +198,106 @@ namespace Toolbox {
                 }
             }
         }
+    Result<void, ClipboardError> SystemClipboard::setContent(const MimeData &content) {
+#ifdef TOOLBOX_PLATFORM_LINUX
+        Display *dpy          = XOpenDisplay(nullptr);
+        Atom TIMESTAMP        = XInternAtom(dpy, "TIMESTAMP", False);
+        Atom TARGETS          = XInternAtom(dpy, "TARGETS", False);
+        Atom CLIPBOARD        = XInternAtom(dpy, "CLIPBOARD", False);
+        Atom TEXT_URI         = XInternAtom(dpy, "text/uri-list", False);
+        Atom APP_KDE4_URILIST = XInternAtom(dpy, "application/x-kde4-urilist", False);
+        Atom APP_VND          = XInternAtom(dpy, "application/vnd.portal.filetransfer", False);
+        Atom MULT             = XInternAtom(dpy, "MULTIPLE", False);
+        Atom UTF8             = XInternAtom(dpy, "UTF8_STRING", False);
+        Atom APP_SRCID        = XInternAtom(dpy, "application/x-kde-source-id", False);
+        Window root           = RootWindow(dpy, DefaultScreen(dpy));
+        Window target_window  = XCreateSimpleWindow(dpy, root, -10, -10, 1, 1, 0, 0, 0);
+
+        XSetSelectionOwner(dpy, CLIPBOARD, target_window, CurrentTime);
+
+        while (true) {
+            XEvent event;
+            std::cout << "Waiting on X event... " << std::endl;
+            XNextEvent(dpy, &event);
+            switch (event.type) {
+            case SelectionClear:
+                std::cout << "Lost selection ownership" << std::endl;
+                return {};
+            case SelectionRequest: {
+                XSelectionRequestEvent *request = &event.xselectionrequest;
+                std::cout << "Requestor: " << request->requestor << std::endl;
+                char *target_type = XGetAtomName(dpy, request->target);
+                std::cout << "Target Type: " << target_type << std::endl;
+                char *target_property = XGetAtomName(dpy, request->property);
+                std::cout << "Target Property: " << target_property << std::endl;
+                // const Atom targets[] = {TARGETS, MULT, UTF8, XA_STRING};
+                // const Atom targets[] = {TIMESTAMP,        TARGETS, TEXT_URI,
+                //                         APP_KDE4_URILIST, APP_VND, APP_SRCID};
+                const Atom targets[] = {TARGETS, TEXT_URI};
+                if (request->target == TARGETS) {
+                    std::cout << "Responding with targets:" << std::endl;
+                    for (const Atom &targ : targets) {
+                        char *target = XGetAtomName(dpy, targ);
+                        std::cout << target << std::endl;
+                        if (target)
+                            XFree(target);
+                    }
+                    XChangeProperty(dpy, request->requestor, request->property, XA_ATOM, 32,
+                                    PropModeReplace,
+                                    reinterpret_cast<const unsigned char *>(targets),
+                                    sizeof(targets) / sizeof(targets[0]));
+                    XSelectionEvent response;
+                    response.type      = SelectionNotify;
+                    response.requestor = request->requestor;
+                    response.selection = request->selection;
+                    response.target    = request->target;
+                    response.property  = request->property;
+                    response.time      = request->time;
+
+                    XSendEvent(dpy, request->requestor, True, NoEventMask,
+                               reinterpret_cast<XEvent *>(&response));
+                    continue;
+                } else if (request->target == TEXT_URI) {
+                    std::string urls = content.get_urls().value();
+                    std::cout << "Responding with urls: " << urls << std::endl;
+                    XChangeProperty(
+                        dpy, request->requestor, request->property, TEXT_URI, 8, PropModeReplace,
+                        reinterpret_cast<const unsigned char *>(urls.c_str()), urls.length());
+
+                    XSelectionEvent response;
+                    response.type      = SelectionNotify;
+                    response.requestor = request->requestor;
+                    response.selection = request->selection;
+                    response.target    = request->target;
+                    response.property  = request->property;
+                    response.time      = request->time;
+
+                    XSendEvent(dpy, request->requestor, True, NoEventMask,
+                               reinterpret_cast<XEvent *>(&response));
+                    // return {};
+                } else if (request->target == UTF8) {
+                    std::string test_string = "something";
+                    XChangeProperty(
+                        dpy, request->requestor, request->property, UTF8, 8, PropModeReplace,
+                        reinterpret_cast<const unsigned char *>(test_string.c_str()), test_string.length());
+
+                    XSelectionEvent response;
+                    response.type      = SelectionNotify;
+                    response.requestor = request->requestor;
+                    response.selection = request->selection;
+                    response.target    = request->target;
+                    response.property  = request->property;
+                    response.time      = request->time;
+
+                    XSendEvent(dpy, request->requestor, True, NoEventMask,
+                               reinterpret_cast<XEvent *>(&response));
+                } else {
+                    TOOLBOX_ERROR("Unrecognized request");
+                    return {};
+                }
+            }
+            }
+        }
 #endif
         return {};
     }
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 90955f5f..2ea6d3c9 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -348,7 +348,20 @@ namespace Toolbox::UI {
 
         m_folder_view_context_menu.addOption(
             "Copy", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C}),
-            [this]() { return m_selected_indices_ctx.size() > 0; }, [this](auto) {});
+            [this]() { return m_selected_indices_ctx.size() > 0; }, [this](auto) {
+                std::string paths;
+                if (m_selected_indices_ctx.size() == 0) {
+                    paths = m_file_system_model->getPath(m_view_index).string();
+                } else {
+                    for (const ModelIndex &item_index : m_selected_indices_ctx) {
+                        fs_path path = m_file_system_model->getPath(item_index);
+                        paths += "file://" + path.string() + "\r\n";
+                    }
+                }
+                MimeData data;
+                data.set_urls(paths);
+                SystemClipboard::instance().setContent(data);
+            });
 
         m_folder_view_context_menu.addDivider();
 

From 31b250668f4157841a4afb91b49a5924a428a781 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 3 Oct 2024 10:45:24 -0700
Subject: [PATCH 059/129] Some clang format stuff on my code

---
 src/gui/clipboard.cpp | 66 ++++++++++++++++++++-----------------------
 1 file changed, 30 insertions(+), 36 deletions(-)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 03eb64d3..51333a8c 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -78,36 +78,29 @@ namespace Toolbox {
         return {};
     }
 
-    Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes(){
+    Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes() {
 #ifdef TOOLBOX_PLATFORM_LINUX
-        Display *dpy = XOpenDisplay(nullptr);
-        if (!dpy) {
-            return make_clipboard_error<std::vector<std::string>>("Could not open X display");
-        }
-        Atom sel = XInternAtom(dpy, "CLIPBOARD", False);
-        Atom targets = XInternAtom(dpy, "TARGETS", False);
+        Display *dpy         = XOpenDisplay(nullptr);
+        Atom sel             = XInternAtom(dpy, "CLIPBOARD", False);
+        Atom targets         = XInternAtom(dpy, "TARGETS", False);
         Atom target_property = XInternAtom(dpy, "CLIP_TYPES", False);
-        Window root_window = RootWindow(dpy, DefaultScreen(dpy));
+        Window root_window   = RootWindow(dpy, DefaultScreen(dpy));
         Window target_window = XCreateSimpleWindow(dpy, root_window, -10, -10, 1, 1, 0, 0, 0);
-        XConvertSelection(dpy, sel, targets, target_property, target_window,
-                          CurrentTime);
+        XConvertSelection(dpy, sel, targets, target_property, target_window, CurrentTime);
 
         XEvent ev;
         XSelectionEvent *sev;
         // This looks pretty dangerous but this is how glfw does it,
         // and how the examples online do it, so :shrug:
-        while(true){
+        while (true) {
             XNextEvent(dpy, &ev);
-            switch (ev.type)
-            {
+            switch (ev.type) {
             case SelectionNotify:
-                sev = (XSelectionEvent*)&ev.xselection;
-                if (sev->property == None)
-                {
-                    return make_clipboard_error<std::vector<std::string>>("Conversion could not be performed.\n");
-                }
-                else
-                {
+                sev = (XSelectionEvent *)&ev.xselection;
+                if (sev->property == None) {
+                    return make_clipboard_error<std::vector<std::string>>(
+                        "Conversion could not be performed.\n");
+                } else {
                     std::vector<std::string> types;
                     unsigned long nitems;
                     unsigned char *prop_ret = nullptr;
@@ -115,13 +108,12 @@ namespace Toolbox {
                     Atom _type;
                     int _di;
                     unsigned long _dul;
-                    XGetWindowProperty(dpy, target_window, target_property, 0,
-                                       1024 * sizeof(Atom), False, XA_ATOM,
-                                       &_type, &_di, &nitems, &_dul, &prop_ret);
+                    XGetWindowProperty(dpy, target_window, target_property, 0, 1024 * sizeof(Atom),
+                                       False, XA_ATOM, &_type, &_di, &nitems, &_dul, &prop_ret);
 
-                    Atom *targets = (Atom*)prop_ret;
-                    for(int i = 0; i < nitems; ++i) {
-                        char* an = XGetAtomName(dpy, targets[i]);
+                    Atom *targets = (Atom *)prop_ret;
+                    for (int i = 0; i < nitems; ++i) {
+                        char *an = XGetAtomName(dpy, targets[i]);
                         types.push_back(std::string(an));
                         if (an)
                             XFree(an);
@@ -136,19 +128,19 @@ namespace Toolbox {
 #endif
         return {};
     }
-    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type){
+    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) {
 #ifdef TOOLBOX_PLATFORM_LINUX
         Display *dpy = XOpenDisplay(nullptr);
         if (!dpy) {
             return make_clipboard_error<MimeData>("Could not open X display");
         }
-        Atom requested_type = XInternAtom(dpy, type.c_str(), False);
-        Atom sel = XInternAtom(dpy, "CLIPBOARD", False);
+        Atom requested_type    = XInternAtom(dpy, type.c_str(), False);
+        Atom sel               = XInternAtom(dpy, "CLIPBOARD", False);
         Window clipboard_owner = XGetSelectionOwner(dpy, sel);
         if (clipboard_owner == None) {
             return make_clipboard_error<MimeData>("Clipboard isn't owned by anyone");
         }
-        Window root = RootWindow(dpy, DefaultScreen(dpy));
+        Window root          = RootWindow(dpy, DefaultScreen(dpy));
         Window target_window = XCreateSimpleWindow(dpy, root, -10, -10, 1, 1, 0, 0, 0);
         Atom target_property = XInternAtom(dpy, "CLIP_CONTENTS", False);
         XConvertSelection(dpy, sel, requested_type, target_property, target_window, CurrentTime);
@@ -156,12 +148,11 @@ namespace Toolbox {
         XSelectionEvent *sev;
         // This looks pretty dangerous but this is how glfw does it,
         // and how the examples online do it, so :shrug:
-        while(true){
+        while (true) {
             XNextEvent(dpy, &ev);
-            switch (ev.type)
-            {
+            switch (ev.type) {
             case SelectionNotify:
-                sev = (XSelectionEvent*)&ev.xselection;
+                sev = (XSelectionEvent *)&ev.xselection;
                 if (sev->property == None) {
                     return make_clipboard_error<MimeData>("Conversion could not be performed.");
                 } else {
@@ -174,12 +165,14 @@ namespace Toolbox {
                     Atom _da;
 
                     XGetWindowProperty(dpy, target_window, target_property, 0, 0, False,
-                                       AnyPropertyType, &type_received, &_di, &_dul, &size, &prop_ret);
+                                       AnyPropertyType, &type_received, &_di, &_dul, &size,
+                                       &prop_ret);
                     XFree(prop_ret);
 
                     Atom incr = XInternAtom(dpy, "INCR", False);
                     if (type_received == incr) {
-                        return make_clipboard_error<MimeData>("Data over 256kb, this isn't supported yet");
+                        return make_clipboard_error<MimeData>(
+                            "Data over 256kb, this isn't supported yet");
                     }
                     XGetWindowProperty(dpy, target_window, target_property, 0, size, False,
                                        AnyPropertyType, &_da, &_di, &_dul, &_dul, &prop_ret);
@@ -198,6 +191,7 @@ namespace Toolbox {
                 }
             }
         }
+#endif
     Result<void, ClipboardError> SystemClipboard::setContent(const MimeData &content) {
 #ifdef TOOLBOX_PLATFORM_LINUX
         Display *dpy          = XOpenDisplay(nullptr);

From c6a544b7c4cf157499f10b0a38d9638ef7ea08c5 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 3 Oct 2024 10:46:01 -0700
Subject: [PATCH 060/129] Clean up resources properly

---
 src/gui/clipboard.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 51333a8c..f54226a1 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -98,6 +98,8 @@ namespace Toolbox {
             case SelectionNotify:
                 sev = (XSelectionEvent *)&ev.xselection;
                 if (sev->property == None) {
+                    XDestroyWindow(dpy, target_window);
+                    XCloseDisplay(dpy);
                     return make_clipboard_error<std::vector<std::string>>(
                         "Conversion could not be performed.\n");
                 } else {
@@ -120,11 +122,14 @@ namespace Toolbox {
                     }
                     XFree(prop_ret);
                     XDeleteProperty(dpy, target_window, target_property);
+                    XDestroyWindow(dpy, target_window);
+                    XCloseDisplay(dpy);
                     return types;
                 }
                 break;
             }
         }
+        XCloseDisplay(dpy);
 #endif
         return {};
     }
@@ -154,6 +159,7 @@ namespace Toolbox {
             case SelectionNotify:
                 sev = (XSelectionEvent *)&ev.xselection;
                 if (sev->property == None) {
+                    XCloseDisplay(dpy);
                     return make_clipboard_error<MimeData>("Conversion could not be performed.");
                 } else {
                     Atom type_received;
@@ -178,6 +184,7 @@ namespace Toolbox {
                                        AnyPropertyType, &_da, &_di, &_dul, &_dul, &prop_ret);
                     Buffer data_buffer;
                     if (!data_buffer.alloc(size)) {
+                        XCloseDisplay(dpy);
                         return make_clipboard_error<MimeData>(
                             "Couldn't allocate buffer of big enough size");
                     }
@@ -187,11 +194,16 @@ namespace Toolbox {
 
                     MimeData result;
                     result.set_data(type, std::move(data_buffer));
+                    XCloseDisplay(dpy);
                     return result;
                 }
             }
         }
+        XCloseDisplay(dpy);
 #endif
+        return {};
+    }
+
     Result<void, ClipboardError> SystemClipboard::setContent(const MimeData &content) {
 #ifdef TOOLBOX_PLATFORM_LINUX
         Display *dpy          = XOpenDisplay(nullptr);
@@ -292,6 +304,8 @@ namespace Toolbox {
             }
             }
         }
+        XDestroyWindow(dpy, target_window);
+        XCloseDisplay(dpy);
 #endif
         return {};
     }

From e3615d091e41dca9c4e9d690b396808cee3ed223 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 3 Oct 2024 13:07:41 -0700
Subject: [PATCH 061/129] Pasting without blocking using glfw hooks

But it's suuuuper hacky right now, needs cleanup
---
 include/core/clipboard.hpp |  4 +++
 lib/glfw                   |  2 +-
 src/gui/application.cpp    |  1 +
 src/gui/clipboard.cpp      | 74 +++++++++++++++++++++++++++++++++++++-
 4 files changed, 79 insertions(+), 2 deletions(-)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index 03cd91b7..b401a593 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -41,7 +41,11 @@ namespace Toolbox {
         Result<std::vector<std::string>, ClipboardError> possibleContentTypes();
         Result<MimeData, ClipboardError> getContent(const std::string &type);
         Result<void, ClipboardError> setContent(const MimeData &content);
+#ifdef TOOLBOX_PLATFORM_LINUX
+        MimeData m_clipboard_contents;
+#endif
     };
+    void hookClipboardIntoGLFW(void) ;
 
     class DataClipboard {
     public:
diff --git a/lib/glfw b/lib/glfw
index 8e6c8d7e..70d10e61 160000
--- a/lib/glfw
+++ b/lib/glfw
@@ -1 +1 @@
-Subproject commit 8e6c8d7effc54f8aecd30eda17069588298f4ada
+Subproject commit 70d10e617a664237c14c6b8fd9993aa391522dd8
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 621de2be..61b0537d 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -194,6 +194,7 @@ namespace Toolbox {
         createWindow<LoggingWindow>("Application Log");
 
         determineEnvironmentConflicts();
+        hookClipboardIntoGLFW();
     }
 
     void GUIApplication::onUpdate(TimeStep delta_time) {
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index f54226a1..215e1429 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -3,8 +3,13 @@
 #ifdef WIN32
 #include <Windows.h>
 #elif defined(TOOLBOX_PLATFORM_LINUX)
-#include <X11/Xlib.h>
+#include <GLFW/glfw3.h>
 #include <X11/Xatom.h>
+#include <X11/Xlib.h>
+#define GLFW_EXPOSE_NATIVE_X11
+#include <GLFW/glfw3native.h>
+#include <imgui/imgui.h>
+
 #endif
 
 namespace Toolbox {
@@ -78,6 +83,67 @@ namespace Toolbox {
         return {};
     }
 
+#ifdef TOOLBOX_PLATFORM_LINUX
+    void (*glfwSelectionRequestHandler)(XEvent *);
+    void handleSelectionRequest(XEvent *event) {
+        std::cout << "Handling a selection request from hook" << std::endl;
+        const XSelectionRequestEvent* request = &event->xselectionrequest;
+        Display* dpy = getGLFWDisplay();
+        Atom TEXT_URI         = XInternAtom(dpy, "text/uri-list", False);
+        Atom TARGETS          = XInternAtom(dpy, "TARGETS", False);
+        const Atom targets[] = {TARGETS, TEXT_URI};
+        if (request->target == TARGETS) {
+            std::cout << "Responding with targets:" << std::endl;
+            for (const Atom &targ : targets) {
+                char *target = XGetAtomName(dpy, targ);
+                std::cout << target << std::endl;
+                if (target)
+                    XFree(target);
+            }
+            XChangeProperty(dpy, request->requestor, request->property, XA_ATOM, 32,
+                            PropModeReplace,
+                            reinterpret_cast<const unsigned char *>(targets),
+                            sizeof(targets) / sizeof(targets[0]));
+            XSelectionEvent response;
+            response.type      = SelectionNotify;
+            response.requestor = request->requestor;
+            response.selection = request->selection;
+            response.target    = request->target;
+            response.property  = request->property;
+            response.time      = request->time;
+
+            XSendEvent(dpy, request->requestor, True, NoEventMask,
+                       reinterpret_cast<XEvent *>(&response));
+        } else if (request->target == TEXT_URI) {
+            std::string urls = SystemClipboard::instance().m_clipboard_contents.get_urls().value();
+            std::cout << "Responding with urls: " << urls << std::endl;
+            XChangeProperty(
+                dpy, request->requestor, request->property, TEXT_URI, 8, PropModeReplace,
+                reinterpret_cast<const unsigned char *>(urls.c_str()), urls.length());
+
+            XSelectionEvent response;
+            response.type      = SelectionNotify;
+            response.requestor = request->requestor;
+            response.selection = request->selection;
+            response.target    = request->target;
+            response.property  = request->property;
+            response.time      = request->time;
+
+            XSendEvent(dpy, request->requestor, True, NoEventMask,
+                       reinterpret_cast<XEvent *>(&response));
+        } else {
+            glfwSelectionRequestHandler(event);
+        }
+    }
+    void hookClipboardIntoGLFW(void) {
+        std::cout << "Setting handlers" << std::endl;
+        glfwSelectionRequestHandler = getSelectionRequestHandler();
+        setSelectionRequestHandler(handleSelectionRequest);
+    }
+#else
+    void hookClipboardIntoGLFW(void) {}
+#endif
+
     Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes() {
 #ifdef TOOLBOX_PLATFORM_LINUX
         Display *dpy         = XOpenDisplay(nullptr);
@@ -220,6 +286,12 @@ namespace Toolbox {
         Window target_window  = XCreateSimpleWindow(dpy, root, -10, -10, 1, 1, 0, 0, 0);
 
         XSetSelectionOwner(dpy, CLIPBOARD, target_window, CurrentTime);
+        Atom CLIPBOARD        = XInternAtom(clipboard_display, "CLIPBOARD", False);
+        m_clipboard_contents = content;
+        std::cout << "Setting ourselves as clipboard owners" << std::endl;
+        XSetSelectionOwner(clipboard_display, CLIPBOARD, clipboard_helper_window, CurrentTime);
+        ImGui::SetClipboardText("");
+        return {};
 
         while (true) {
             XEvent event;

From f85749fe527f6a73c7a1d91ef88ae4e16fe49d0e Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 3 Oct 2024 13:14:00 -0700
Subject: [PATCH 062/129] Use glfw display but fresh window for copying in too

---
 src/gui/clipboard.cpp | 150 ++++++------------------------------------
 1 file changed, 20 insertions(+), 130 deletions(-)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 215e1429..b34d2faf 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -14,8 +14,20 @@
 
 namespace Toolbox {
 
+#ifdef WIN32
     SystemClipboard::SystemClipboard() {}
     SystemClipboard::~SystemClipboard() {}
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+    Window clipboard_helper_window;
+    SystemClipboard::SystemClipboard() {
+        Display* dpy = getGLFWDisplay();
+        Window root_window   = RootWindow(dpy, DefaultScreen(dpy));
+        clipboard_helper_window = XCreateSimpleWindow(dpy, root_window, -10, -10, 1, 1, 0, 0, 0);
+    }
+    SystemClipboard::~SystemClipboard() {
+        XDestroyWindow(getGLFWDisplay(), clipboard_helper_window);
+    }
+#endif
 
     Result<std::string, ClipboardError> SystemClipboard::getText() {
 #ifdef WIN32
@@ -86,20 +98,12 @@ namespace Toolbox {
 #ifdef TOOLBOX_PLATFORM_LINUX
     void (*glfwSelectionRequestHandler)(XEvent *);
     void handleSelectionRequest(XEvent *event) {
-        std::cout << "Handling a selection request from hook" << std::endl;
         const XSelectionRequestEvent* request = &event->xselectionrequest;
         Display* dpy = getGLFWDisplay();
         Atom TEXT_URI         = XInternAtom(dpy, "text/uri-list", False);
         Atom TARGETS          = XInternAtom(dpy, "TARGETS", False);
         const Atom targets[] = {TARGETS, TEXT_URI};
         if (request->target == TARGETS) {
-            std::cout << "Responding with targets:" << std::endl;
-            for (const Atom &targ : targets) {
-                char *target = XGetAtomName(dpy, targ);
-                std::cout << target << std::endl;
-                if (target)
-                    XFree(target);
-            }
             XChangeProperty(dpy, request->requestor, request->property, XA_ATOM, 32,
                             PropModeReplace,
                             reinterpret_cast<const unsigned char *>(targets),
@@ -116,7 +120,6 @@ namespace Toolbox {
                        reinterpret_cast<XEvent *>(&response));
         } else if (request->target == TEXT_URI) {
             std::string urls = SystemClipboard::instance().m_clipboard_contents.get_urls().value();
-            std::cout << "Responding with urls: " << urls << std::endl;
             XChangeProperty(
                 dpy, request->requestor, request->property, TEXT_URI, 8, PropModeReplace,
                 reinterpret_cast<const unsigned char *>(urls.c_str()), urls.length());
@@ -136,7 +139,6 @@ namespace Toolbox {
         }
     }
     void hookClipboardIntoGLFW(void) {
-        std::cout << "Setting handlers" << std::endl;
         glfwSelectionRequestHandler = getSelectionRequestHandler();
         setSelectionRequestHandler(handleSelectionRequest);
     }
@@ -146,12 +148,11 @@ namespace Toolbox {
 
     Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes() {
 #ifdef TOOLBOX_PLATFORM_LINUX
-        Display *dpy         = XOpenDisplay(nullptr);
+        Display *dpy         = getGLFWDisplay();
         Atom sel             = XInternAtom(dpy, "CLIPBOARD", False);
         Atom targets         = XInternAtom(dpy, "TARGETS", False);
         Atom target_property = XInternAtom(dpy, "CLIP_TYPES", False);
-        Window root_window   = RootWindow(dpy, DefaultScreen(dpy));
-        Window target_window = XCreateSimpleWindow(dpy, root_window, -10, -10, 1, 1, 0, 0, 0);
+        Window target_window = clipboard_helper_window;
         XConvertSelection(dpy, sel, targets, target_property, target_window, CurrentTime);
 
         XEvent ev;
@@ -164,8 +165,6 @@ namespace Toolbox {
             case SelectionNotify:
                 sev = (XSelectionEvent *)&ev.xselection;
                 if (sev->property == None) {
-                    XDestroyWindow(dpy, target_window);
-                    XCloseDisplay(dpy);
                     return make_clipboard_error<std::vector<std::string>>(
                         "Conversion could not be performed.\n");
                 } else {
@@ -187,9 +186,7 @@ namespace Toolbox {
                             XFree(an);
                     }
                     XFree(prop_ret);
-                    XDeleteProperty(dpy, target_window, target_property);
-                    XDestroyWindow(dpy, target_window);
-                    XCloseDisplay(dpy);
+                    XDeleteProperty(dpy, clipboard_helper_window, target_property);
                     return types;
                 }
                 break;
@@ -201,18 +198,14 @@ namespace Toolbox {
     }
     Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) {
 #ifdef TOOLBOX_PLATFORM_LINUX
-        Display *dpy = XOpenDisplay(nullptr);
-        if (!dpy) {
-            return make_clipboard_error<MimeData>("Could not open X display");
-        }
+        Display *dpy = getGLFWDisplay();
         Atom requested_type    = XInternAtom(dpy, type.c_str(), False);
         Atom sel               = XInternAtom(dpy, "CLIPBOARD", False);
         Window clipboard_owner = XGetSelectionOwner(dpy, sel);
         if (clipboard_owner == None) {
             return make_clipboard_error<MimeData>("Clipboard isn't owned by anyone");
         }
-        Window root          = RootWindow(dpy, DefaultScreen(dpy));
-        Window target_window = XCreateSimpleWindow(dpy, root, -10, -10, 1, 1, 0, 0, 0);
+        Window target_window = clipboard_helper_window;
         Atom target_property = XInternAtom(dpy, "CLIP_CONTENTS", False);
         XConvertSelection(dpy, sel, requested_type, target_property, target_window, CurrentTime);
         XEvent ev;
@@ -225,7 +218,6 @@ namespace Toolbox {
             case SelectionNotify:
                 sev = (XSelectionEvent *)&ev.xselection;
                 if (sev->property == None) {
-                    XCloseDisplay(dpy);
                     return make_clipboard_error<MimeData>("Conversion could not be performed.");
                 } else {
                     Atom type_received;
@@ -250,7 +242,6 @@ namespace Toolbox {
                                        AnyPropertyType, &_da, &_di, &_dul, &_dul, &prop_ret);
                     Buffer data_buffer;
                     if (!data_buffer.alloc(size)) {
-                        XCloseDisplay(dpy);
                         return make_clipboard_error<MimeData>(
                             "Couldn't allocate buffer of big enough size");
                     }
@@ -260,126 +251,25 @@ namespace Toolbox {
 
                     MimeData result;
                     result.set_data(type, std::move(data_buffer));
-                    XCloseDisplay(dpy);
                     return result;
                 }
             }
         }
-        XCloseDisplay(dpy);
 #endif
         return {};
     }
 
     Result<void, ClipboardError> SystemClipboard::setContent(const MimeData &content) {
 #ifdef TOOLBOX_PLATFORM_LINUX
-        Display *dpy          = XOpenDisplay(nullptr);
-        Atom TIMESTAMP        = XInternAtom(dpy, "TIMESTAMP", False);
-        Atom TARGETS          = XInternAtom(dpy, "TARGETS", False);
+        Display* dpy = getGLFWDisplay();
         Atom CLIPBOARD        = XInternAtom(dpy, "CLIPBOARD", False);
-        Atom TEXT_URI         = XInternAtom(dpy, "text/uri-list", False);
-        Atom APP_KDE4_URILIST = XInternAtom(dpy, "application/x-kde4-urilist", False);
-        Atom APP_VND          = XInternAtom(dpy, "application/vnd.portal.filetransfer", False);
-        Atom MULT             = XInternAtom(dpy, "MULTIPLE", False);
-        Atom UTF8             = XInternAtom(dpy, "UTF8_STRING", False);
-        Atom APP_SRCID        = XInternAtom(dpy, "application/x-kde-source-id", False);
-        Window root           = RootWindow(dpy, DefaultScreen(dpy));
-        Window target_window  = XCreateSimpleWindow(dpy, root, -10, -10, 1, 1, 0, 0, 0);
-
-        XSetSelectionOwner(dpy, CLIPBOARD, target_window, CurrentTime);
-        Atom CLIPBOARD        = XInternAtom(clipboard_display, "CLIPBOARD", False);
         m_clipboard_contents = content;
-        std::cout << "Setting ourselves as clipboard owners" << std::endl;
-        XSetSelectionOwner(clipboard_display, CLIPBOARD, clipboard_helper_window, CurrentTime);
+        XSetSelectionOwner(dpy, CLIPBOARD, clipboard_helper_window, CurrentTime);
         ImGui::SetClipboardText("");
         return {};
 
-        while (true) {
-            XEvent event;
-            std::cout << "Waiting on X event... " << std::endl;
-            XNextEvent(dpy, &event);
-            switch (event.type) {
-            case SelectionClear:
-                std::cout << "Lost selection ownership" << std::endl;
-                return {};
-            case SelectionRequest: {
-                XSelectionRequestEvent *request = &event.xselectionrequest;
-                std::cout << "Requestor: " << request->requestor << std::endl;
-                char *target_type = XGetAtomName(dpy, request->target);
-                std::cout << "Target Type: " << target_type << std::endl;
-                char *target_property = XGetAtomName(dpy, request->property);
-                std::cout << "Target Property: " << target_property << std::endl;
-                // const Atom targets[] = {TARGETS, MULT, UTF8, XA_STRING};
-                // const Atom targets[] = {TIMESTAMP,        TARGETS, TEXT_URI,
-                //                         APP_KDE4_URILIST, APP_VND, APP_SRCID};
-                const Atom targets[] = {TARGETS, TEXT_URI};
-                if (request->target == TARGETS) {
-                    std::cout << "Responding with targets:" << std::endl;
-                    for (const Atom &targ : targets) {
-                        char *target = XGetAtomName(dpy, targ);
-                        std::cout << target << std::endl;
-                        if (target)
-                            XFree(target);
-                    }
-                    XChangeProperty(dpy, request->requestor, request->property, XA_ATOM, 32,
-                                    PropModeReplace,
-                                    reinterpret_cast<const unsigned char *>(targets),
-                                    sizeof(targets) / sizeof(targets[0]));
-                    XSelectionEvent response;
-                    response.type      = SelectionNotify;
-                    response.requestor = request->requestor;
-                    response.selection = request->selection;
-                    response.target    = request->target;
-                    response.property  = request->property;
-                    response.time      = request->time;
-
-                    XSendEvent(dpy, request->requestor, True, NoEventMask,
-                               reinterpret_cast<XEvent *>(&response));
-                    continue;
-                } else if (request->target == TEXT_URI) {
-                    std::string urls = content.get_urls().value();
-                    std::cout << "Responding with urls: " << urls << std::endl;
-                    XChangeProperty(
-                        dpy, request->requestor, request->property, TEXT_URI, 8, PropModeReplace,
-                        reinterpret_cast<const unsigned char *>(urls.c_str()), urls.length());
-
-                    XSelectionEvent response;
-                    response.type      = SelectionNotify;
-                    response.requestor = request->requestor;
-                    response.selection = request->selection;
-                    response.target    = request->target;
-                    response.property  = request->property;
-                    response.time      = request->time;
-
-                    XSendEvent(dpy, request->requestor, True, NoEventMask,
-                               reinterpret_cast<XEvent *>(&response));
-                    // return {};
-                } else if (request->target == UTF8) {
-                    std::string test_string = "something";
-                    XChangeProperty(
-                        dpy, request->requestor, request->property, UTF8, 8, PropModeReplace,
-                        reinterpret_cast<const unsigned char *>(test_string.c_str()), test_string.length());
-
-                    XSelectionEvent response;
-                    response.type      = SelectionNotify;
-                    response.requestor = request->requestor;
-                    response.selection = request->selection;
-                    response.target    = request->target;
-                    response.property  = request->property;
-                    response.time      = request->time;
-
-                    XSendEvent(dpy, request->requestor, True, NoEventMask,
-                               reinterpret_cast<XEvent *>(&response));
-                } else {
-                    TOOLBOX_ERROR("Unrecognized request");
-                    return {};
-                }
-            }
-            }
-        }
-        XDestroyWindow(dpy, target_window);
-        XCloseDisplay(dpy);
 #endif
         return {};
     }
 
-}  // namespace Toolbox::UI
+}  // namespace Toolbox

From 059382fc7634e3f515de6a998ff81b1f361a1767 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 3 Oct 2024 16:03:59 -0700
Subject: [PATCH 063/129] Don't rely on a false copy to own selection

---
 src/gui/clipboard.cpp | 24 +++++-------------------
 1 file changed, 5 insertions(+), 19 deletions(-)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index b34d2faf..1f91b439 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -14,20 +14,8 @@
 
 namespace Toolbox {
 
-#ifdef WIN32
     SystemClipboard::SystemClipboard() {}
     SystemClipboard::~SystemClipboard() {}
-#elif defined(TOOLBOX_PLATFORM_LINUX)
-    Window clipboard_helper_window;
-    SystemClipboard::SystemClipboard() {
-        Display* dpy = getGLFWDisplay();
-        Window root_window   = RootWindow(dpy, DefaultScreen(dpy));
-        clipboard_helper_window = XCreateSimpleWindow(dpy, root_window, -10, -10, 1, 1, 0, 0, 0);
-    }
-    SystemClipboard::~SystemClipboard() {
-        XDestroyWindow(getGLFWDisplay(), clipboard_helper_window);
-    }
-#endif
 
     Result<std::string, ClipboardError> SystemClipboard::getText() {
 #ifdef WIN32
@@ -152,7 +140,7 @@ namespace Toolbox {
         Atom sel             = XInternAtom(dpy, "CLIPBOARD", False);
         Atom targets         = XInternAtom(dpy, "TARGETS", False);
         Atom target_property = XInternAtom(dpy, "CLIP_TYPES", False);
-        Window target_window = clipboard_helper_window;
+        Window target_window = getGLFWHelperWindow();
         XConvertSelection(dpy, sel, targets, target_property, target_window, CurrentTime);
 
         XEvent ev;
@@ -186,7 +174,7 @@ namespace Toolbox {
                             XFree(an);
                     }
                     XFree(prop_ret);
-                    XDeleteProperty(dpy, clipboard_helper_window, target_property);
+                    XDeleteProperty(dpy, target_window, target_property);
                     return types;
                 }
                 break;
@@ -205,7 +193,7 @@ namespace Toolbox {
         if (clipboard_owner == None) {
             return make_clipboard_error<MimeData>("Clipboard isn't owned by anyone");
         }
-        Window target_window = clipboard_helper_window;
+        Window target_window = getGLFWHelperWindow();
         Atom target_property = XInternAtom(dpy, "CLIP_CONTENTS", False);
         XConvertSelection(dpy, sel, requested_type, target_property, target_window, CurrentTime);
         XEvent ev;
@@ -262,12 +250,10 @@ namespace Toolbox {
     Result<void, ClipboardError> SystemClipboard::setContent(const MimeData &content) {
 #ifdef TOOLBOX_PLATFORM_LINUX
         Display* dpy = getGLFWDisplay();
+        Window target_window = getGLFWHelperWindow();
         Atom CLIPBOARD        = XInternAtom(dpy, "CLIPBOARD", False);
         m_clipboard_contents = content;
-        XSetSelectionOwner(dpy, CLIPBOARD, clipboard_helper_window, CurrentTime);
-        ImGui::SetClipboardText("");
-        return {};
-
+        XSetSelectionOwner(dpy, CLIPBOARD, target_window, CurrentTime);
 #endif
         return {};
     }

From 9e30f6f7271ab7593f7d3496f38d2c6f3b00723c Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 3 Oct 2024 16:10:25 -0700
Subject: [PATCH 064/129] Const some methods

---
 include/core/clipboard.hpp | 4 ++--
 src/gui/clipboard.cpp      | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index b401a593..b4b696f5 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -38,8 +38,8 @@ namespace Toolbox {
 
         Result<std::string, ClipboardError> getText();
         Result<void, ClipboardError> setText(const std::string &text);
-        Result<std::vector<std::string>, ClipboardError> possibleContentTypes();
-        Result<MimeData, ClipboardError> getContent(const std::string &type);
+        Result<std::vector<std::string>, ClipboardError> possibleContentTypes() const;
+        Result<MimeData, ClipboardError> getContent(const std::string &type) const;
         Result<void, ClipboardError> setContent(const MimeData &content);
 #ifdef TOOLBOX_PLATFORM_LINUX
         MimeData m_clipboard_contents;
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 1f91b439..a9a7c26c 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -134,7 +134,7 @@ namespace Toolbox {
     void hookClipboardIntoGLFW(void) {}
 #endif
 
-    Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes() {
+    Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes() const {
 #ifdef TOOLBOX_PLATFORM_LINUX
         Display *dpy         = getGLFWDisplay();
         Atom sel             = XInternAtom(dpy, "CLIPBOARD", False);
@@ -184,7 +184,7 @@ namespace Toolbox {
 #endif
         return {};
     }
-    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) {
+    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) const {
 #ifdef TOOLBOX_PLATFORM_LINUX
         Display *dpy = getGLFWDisplay();
         Atom requested_type    = XInternAtom(dpy, type.c_str(), False);

From b30cb3fef8fdc031dfed7bac3801e2e316135bad Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 3 Oct 2024 16:44:15 -0700
Subject: [PATCH 065/129] Refactor an allow pasting any mime type

---
 include/core/mimedata/mimedata.hpp |  8 ++++
 src/gui/clipboard.cpp              | 71 +++++++++++++++---------------
 2 files changed, 44 insertions(+), 35 deletions(-)

diff --git a/include/core/mimedata/mimedata.hpp b/include/core/mimedata/mimedata.hpp
index eca76d21..7a7ab897 100644
--- a/include/core/mimedata/mimedata.hpp
+++ b/include/core/mimedata/mimedata.hpp
@@ -29,6 +29,14 @@ namespace Toolbox {
         [[nodiscard]] bool has_format(std::string_view type) const {
             return m_data_map.contains(std::string(type));
         }
+        std::vector<std::string> get_all_formats() const {
+            std::vector<std::string> formats;
+            formats.reserve(m_data_map.size());
+            for (auto &[k, v] : m_data_map) {
+                formats.push_back(k);
+            }
+            return formats;
+        }
 
         [[nodiscard]] bool has_color() const;
         [[nodiscard]] bool has_html() const;
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index a9a7c26c..c18e99a9 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -85,45 +85,46 @@ namespace Toolbox {
 
 #ifdef TOOLBOX_PLATFORM_LINUX
     void (*glfwSelectionRequestHandler)(XEvent *);
+    void sendRequestNotify(XSelecctionRequestEvent *request) {
+        XSelectionEvent response;
+        response.type      = SelectionNotify;
+        response.requestor = request->requestor;
+        response.selection = request->selection;
+        response.target    = request->target;
+        response.property  = request->property;
+        response.time      = request->time;
+
+        XSendEvent(dpy, request->requestor, True, NoEventMask,
+                   reinterpret_cast<XEvent *>(&response));
+    }
     void handleSelectionRequest(XEvent *event) {
-        const XSelectionRequestEvent* request = &event->xselectionrequest;
-        Display* dpy = getGLFWDisplay();
-        Atom TEXT_URI         = XInternAtom(dpy, "text/uri-list", False);
-        Atom TARGETS          = XInternAtom(dpy, "TARGETS", False);
-        const Atom targets[] = {TARGETS, TEXT_URI};
+        MimeData clipboard_contents = SystemClipboard::instance().m_clipboard_contents;
+        const XSelectionRequestEvent *request = &event->xselectionrequest;
+        Display *dpy                          = getGLFWDisplay();
+        Atom TARGETS                          = XInternAtom(dpy, "TARGETS", False);
+        std::vector<Atom> targets             = {TARGETS};
+        for (auto &string_format : clipboardContents.get_all_formats()) {
+            Atom format_atom = XInternAtom(dpy, format.c_str(), False);
+            targets.push_back(format_atom);
+        }
         if (request->target == TARGETS) {
             XChangeProperty(dpy, request->requestor, request->property, XA_ATOM, 32,
-                            PropModeReplace,
-                            reinterpret_cast<const unsigned char *>(targets),
-                            sizeof(targets) / sizeof(targets[0]));
-            XSelectionEvent response;
-            response.type      = SelectionNotify;
-            response.requestor = request->requestor;
-            response.selection = request->selection;
-            response.target    = request->target;
-            response.property  = request->property;
-            response.time      = request->time;
-
-            XSendEvent(dpy, request->requestor, True, NoEventMask,
-                       reinterpret_cast<XEvent *>(&response));
-        } else if (request->target == TEXT_URI) {
-            std::string urls = SystemClipboard::instance().m_clipboard_contents.get_urls().value();
-            XChangeProperty(
-                dpy, request->requestor, request->property, TEXT_URI, 8, PropModeReplace,
-                reinterpret_cast<const unsigned char *>(urls.c_str()), urls.length());
-
-            XSelectionEvent response;
-            response.type      = SelectionNotify;
-            response.requestor = request->requestor;
-            response.selection = request->selection;
-            response.target    = request->target;
-            response.property  = request->property;
-            response.time      = request->time;
-
-            XSendEvent(dpy, request->requestor, True, NoEventMask,
-                       reinterpret_cast<XEvent *>(&response));
+                            PropModeReplace, reinterpret_cast<const unsigned char *>(targets.data()),
+                            targets.size());
+            sendRequestNotify(request);
         } else {
-            glfwSelectionRequestHandler(event);
+            char* requested_target = XGetAtomName(dpy, request->target);
+            auto data = clipboard_contents.get_data(requested_target);
+            if (data && request->property != None) {
+                XChangeProperty(dpy, request->requestor, request->property, request->target,
+                                8 /* is this ever wrong? */, PropModeReplace,
+                                reinterpret_cast<const unsigned char*>data.buf(),
+                                data.size);
+            } else {
+                glfwSelectionRequestHandler(event);
+            }
+            sendRequestNotify(request);
+            XFree(requested_target);
         }
     }
     void hookClipboardIntoGLFW(void) {

From cb6e37ed900447a7f2931c46868d877fced899df Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 3 Oct 2024 16:44:37 -0700
Subject: [PATCH 066/129] Some clangformat stuff

---
 src/gui/clipboard.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index c18e99a9..9aa14180 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -187,7 +187,7 @@ namespace Toolbox {
     }
     Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) const {
 #ifdef TOOLBOX_PLATFORM_LINUX
-        Display *dpy = getGLFWDisplay();
+        Display *dpy           = getGLFWDisplay();
         Atom requested_type    = XInternAtom(dpy, type.c_str(), False);
         Atom sel               = XInternAtom(dpy, "CLIPBOARD", False);
         Window clipboard_owner = XGetSelectionOwner(dpy, sel);
@@ -250,9 +250,9 @@ namespace Toolbox {
 
     Result<void, ClipboardError> SystemClipboard::setContent(const MimeData &content) {
 #ifdef TOOLBOX_PLATFORM_LINUX
-        Display* dpy = getGLFWDisplay();
+        Display *dpy         = getGLFWDisplay();
         Window target_window = getGLFWHelperWindow();
-        Atom CLIPBOARD        = XInternAtom(dpy, "CLIPBOARD", False);
+        Atom CLIPBOARD       = XInternAtom(dpy, "CLIPBOARD", False);
         m_clipboard_contents = content;
         XSetSelectionOwner(dpy, CLIPBOARD, target_window, CurrentTime);
 #endif

From 43d3547f6b2e9c675b3dbadf5169c5443c2286b5 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 4 Oct 2024 02:31:53 -0500
Subject: [PATCH 067/129] Mild refactoring

---
 include/gui/project/window.hpp |   3 +
 src/gui/clipboard.cpp          |   3 +-
 src/gui/project/window.cpp     | 121 ++++++++++++++++++---------------
 3 files changed, 73 insertions(+), 54 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 5bb91445..3430e276 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -96,6 +96,9 @@ namespace Toolbox::UI {
         void actionDeleteIndexes(std::vector<ModelIndex> &indices);
         void actionOpenIndexes(const std::vector<ModelIndex> &indices);
         void actionRenameIndex(const ModelIndex &index);
+        void actionPasteIntoIndex(const ModelIndex &index);
+        void actionCopyIndexes(const std::vector<ModelIndex> &indices);
+
         void actionLeftClickIndex(const ModelIndex &view_index, const ModelIndex &child_index,
                                   bool is_selected);
 
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 0ba51beb..f5d6b96e 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -242,7 +242,7 @@ namespace Toolbox {
         size_t dest_buf_size = data_buf.size();
         if (format == CF_HDROP) {
             dest_buf_size *= 2;
-            dest_buf_size += sizeof(DROPFILES);
+            dest_buf_size += sizeof(DROPFILES) + sizeof(wchar_t);
         } else if (format == CF_TEXT) {
             dest_buf_size *= 2;
         }
@@ -273,6 +273,7 @@ namespace Toolbox {
             }
 
             path_list_ptr[data_buf.size()] = L'\0';
+            path_list_ptr[data_buf.size() + 1] = L'\0';
         } else if (format == CF_TEXT) {
             wchar_t *path_list_ptr = (wchar_t *)data_buffer;
             std::mbstowcs(path_list_ptr, data_buf.buf<char>(), data_buf.size());
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 7747f035..a3005a32 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -223,6 +223,13 @@ namespace Toolbox::UI {
 
                 ImGui::PopStyleVar(5);
             }
+
+            /*std::vector<std::string> formats =
+                SystemClipboard::instance().getAvailableContentFormats().value_or(
+                    std::vector<std::string>());
+            if (std::find(formats.begin(), formats.end(), "text/uri-list") != formats.end()) {
+                
+            }*/
         }
         ImGui::EndChild();
 
@@ -354,21 +361,7 @@ namespace Toolbox::UI {
         m_folder_view_context_menu.addOption(
             "Copy", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C}),
             [this]() { return m_selected_indices_ctx.size() > 0; },
-            [this](auto) {
-                std::string copied_paths;
-                for (const ModelIndex &index : m_selected_indices_ctx) {
-                    copied_paths += m_file_system_model->getPath(index).string();
-                    copied_paths += "\n";
-                }
-
-                MimeData data;
-                data.set_urls(copied_paths);
-
-                auto result = SystemClipboard::instance().setContent("text/uri-list", data);
-                if (!result) {
-                    TOOLBOX_ERROR("[PROJECT] Failed to set contents of clipboard");
-                }
-            });
+            [this](auto) { actionCopyIndexes(m_selected_indices_ctx); });
 
         m_folder_view_context_menu.addDivider();
 
@@ -387,47 +380,11 @@ namespace Toolbox::UI {
             "Rename", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_R}),
             [this]() { return m_selected_indices_ctx.size() == 1; },
             [this](auto) { actionRenameIndex(m_selected_indices_ctx[0]); });
+
         m_folder_view_context_menu.addOption(
             "Paste", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V}),
             [this]() { return m_selected_indices_ctx.size() == 0; },
-            [this](auto) {
-                auto content_types = SystemClipboard::instance().getAvailableContentFormats();
-                if (!content_types) {
-                    TOOLBOX_ERROR("Couldn't get content types");
-                    return;
-                }
-                if (std::find(content_types.value().begin(), content_types.value().end(),
-                              std::string("text/uri-list")) != content_types.value().end()) {
-                    auto content = SystemClipboard::instance().getContent("text/uri-list");
-                    if (!content) {
-                        TOOLBOX_ERROR("Failed to get content as uri list");
-                        return;
-                    }
-                    auto text = content.value().get_urls();
-                    if (!text) {
-                        TOOLBOX_ERROR("Mime data wouldn't return uri list");
-                        return;
-                    }
-
-                    std::vector<std::string_view> urls = splitLines(text.value());
-                    for (std::string_view src_path_str : urls) {
-                        if (src_path_str.starts_with("file:/")) {
-                            if (src_path_str.starts_with("file:///")) {
-                                src_path_str = src_path_str.substr(8);
-                            } else {
-                                src_path_str = src_path_str.substr(7);
-                            }
-                        } else {
-                            TOOLBOX_ERROR_V("Can't copy non-local uri {}", src_path_str);
-                            continue;
-                        }
-
-                        fs_path src_path = src_path_str;
-                        m_file_system_model->copy(src_path, m_view_index,
-                                                  src_path.filename().string());
-                    }
-                }
-            });
+            [this](auto) { actionPasteIntoIndex(m_view_index); });
 
         m_folder_view_context_menu.addDivider();
 
@@ -472,6 +429,64 @@ namespace Toolbox::UI {
         std::strncpy(m_rename_buffer, file_name.c_str(), IM_ARRAYSIZE(m_rename_buffer));
     }
 
+    void ProjectViewWindow::actionPasteIntoIndex(const ModelIndex &index) {
+        auto content_types = SystemClipboard::instance().getAvailableContentFormats();
+        if (!content_types) {
+            TOOLBOX_ERROR("Couldn't get content types");
+            return;
+        }
+
+        if (std::find(content_types.value().begin(), content_types.value().end(),
+                      std::string("text/uri-list")) == content_types.value().end()) {
+            return;
+        }
+
+        auto content = SystemClipboard::instance().getContent("text/uri-list");
+        if (!content) {
+            TOOLBOX_ERROR("Failed to get content as uri list");
+            return;
+        }
+
+        auto text = content.value().get_urls();
+        if (!text) {
+            TOOLBOX_ERROR("Mime data wouldn't return uri list");
+            return;
+        }
+
+        std::vector<std::string_view> urls = splitLines(text.value());
+        for (std::string_view src_path_str : urls) {
+            if (src_path_str.starts_with("file:/")) {
+                if (src_path_str.starts_with("file:///")) {
+                    src_path_str = src_path_str.substr(8);
+                } else {
+                    src_path_str = src_path_str.substr(7);
+                }
+            } else {
+                TOOLBOX_ERROR_V("Can't copy non-local uri {}", src_path_str);
+                continue;
+            }
+
+            fs_path src_path = src_path_str;
+            m_file_system_model->copy(src_path, index, src_path.filename().string());
+        }
+    }
+
+    void ProjectViewWindow::actionCopyIndexes(const std::vector<ModelIndex> &indices) {
+        std::string copied_paths;
+        for (const ModelIndex &index : indices) {
+            copied_paths += m_file_system_model->getPath(index).string();
+            copied_paths += "\n";
+        }
+
+        MimeData data;
+        data.set_urls(copied_paths);
+
+        auto result = SystemClipboard::instance().setContent("text/uri-list", data);
+        if (!result) {
+            TOOLBOX_ERROR("[PROJECT] Failed to set contents of clipboard");
+        }
+    }
+
     void ProjectViewWindow::actionLeftClickIndex(const ModelIndex &view_index,
                                                  const ModelIndex &child_index, bool is_selected) {
         ModelIndex source_child_index = m_view_proxy.toSourceIndex(child_index);

From d75e6991f75147487813facf123bc75e7af9c3d9 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 4 Oct 2024 11:48:45 -0500
Subject: [PATCH 068/129] Enable drag and drop of files from explorer to
 project view

---
 include/core/input/input.hpp    |  2 +-
 include/gui/event/dropevent.hpp | 12 ++++++---
 include/gui/project/window.hpp  |  2 +-
 include/gui/window.hpp          |  2 ++
 src/core/mimedata/mimedata.cpp  |  8 +++---
 src/gui/event/dropevent.cpp     |  7 +++--
 src/gui/project/window.cpp      | 47 +++++++++++++++++----------------
 src/gui/window.cpp              | 32 ++++++++++++++++++++--
 8 files changed, 76 insertions(+), 36 deletions(-)

diff --git a/include/core/input/input.hpp b/include/core/input/input.hpp
index f0ceaca1..f85bc6b2 100644
--- a/include/core/input/input.hpp
+++ b/include/core/input/input.hpp
@@ -23,7 +23,7 @@ namespace Toolbox::Input {
     bool GetMouseButtonDown(MouseButton button);
     bool GetMouseButtonUp(MouseButton button);
 
-    void GetMouseViewportPosition(float &x, float &y);
+    void GetMouseViewportPosition(double &x, double &y);
     void SetMousePosition(double x, double y, bool overwrite_delta = true);
 
     void GetMouseDelta(double &x, double &y);
diff --git a/include/gui/event/dropevent.hpp b/include/gui/event/dropevent.hpp
index e1a9c4fd..3889820d 100644
--- a/include/gui/event/dropevent.hpp
+++ b/include/gui/event/dropevent.hpp
@@ -9,15 +9,19 @@ namespace Toolbox::UI {
     private:
         DropEvent() = default;
 
+    protected:
+        friend class ImWindow;
+
     public:
         DropEvent(const DropEvent &)     = default;
         DropEvent(DropEvent &&) noexcept = default;
 
         DropEvent(const ImVec2 &pos, DropType drop_type, const DragAction &action);
 
-        [[nodiscard]] ImVec2 getGlobalPoint() const noexcept {
-            return m_screen_pos;
-        }
+        DropEvent(const ImVec2 &pos, DropType drop_type, UUID64 source_uuid, UUID64 target_uuid,
+                  MimeData &&data);
+
+        [[nodiscard]] ImVec2 getGlobalPoint() const noexcept { return m_screen_pos; }
 
         [[nodiscard]] const MimeData &getMimeData() const noexcept { return m_mime_data; }
         [[nodiscard]] DropType getDropType() const noexcept { return m_drop_type; }
@@ -30,7 +34,7 @@ namespace Toolbox::UI {
 
     private:
         ImVec2 m_screen_pos;
-        DropType m_drop_type;
+        DropType m_drop_type = DropType::ACTION_NONE;
         MimeData m_mime_data;
         UUID64 m_source_id;
     };
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 3430e276..5c9f6f39 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -96,7 +96,7 @@ namespace Toolbox::UI {
         void actionDeleteIndexes(std::vector<ModelIndex> &indices);
         void actionOpenIndexes(const std::vector<ModelIndex> &indices);
         void actionRenameIndex(const ModelIndex &index);
-        void actionPasteIntoIndex(const ModelIndex &index);
+        void actionPasteIntoIndex(const ModelIndex &index, const MimeData &data);
         void actionCopyIndexes(const std::vector<ModelIndex> &indices);
 
         void actionLeftClickIndex(const ModelIndex &view_index, const ModelIndex &child_index,
diff --git a/include/gui/window.hpp b/include/gui/window.hpp
index eab5e9bd..4cfc759d 100644
--- a/include/gui/window.hpp
+++ b/include/gui/window.hpp
@@ -116,6 +116,8 @@ namespace Toolbox::UI {
         void setLayerSize(const ImVec2 &size) noexcept { ImProcessLayer::setSize(size); }
         void setLayerPos(const ImVec2 &pos) noexcept { ImProcessLayer::setPos(pos); }
 
+        static void privDropCallback(GLFWwindow *window, int path_count, const char *paths[]);
+
         UUID64 m_UUID64;
         ImGuiID m_sibling_id = 0;
 
diff --git a/src/core/mimedata/mimedata.cpp b/src/core/mimedata/mimedata.cpp
index d26378d3..4bef8d12 100644
--- a/src/core/mimedata/mimedata.cpp
+++ b/src/core/mimedata/mimedata.cpp
@@ -22,6 +22,7 @@ namespace Toolbox {
         "image/bmp",
         "image/jpeg",
         "image/png",
+        "image/tiff",
         "image/x-portable-bitmap",
         "image/x-portable-graymap",
         "image/x-portable-pixmap",
@@ -102,13 +103,14 @@ namespace Toolbox {
             return std::nullopt;
         }
         const Buffer &data_buf = m_data_map["text/plain"];
-        return std::string(data_buf.buf<char>(), data_buf.size());
+        return std::string(data_buf.buf<char>(), data_buf.size() - 1);
     }
 
     void MimeData::set_text(std::string_view data) {
         Buffer _tmp;
-        _tmp.alloc(data.size());
+        _tmp.alloc(data.size() + 1);
         std::memcpy(_tmp.buf(), data.data(), data.size());
+        _tmp.get<char>(data.size()) = '\0';
         set_data("text/plain", std::move(_tmp));
     }
 
@@ -117,7 +119,7 @@ namespace Toolbox {
             return std::nullopt;
         }
         const Buffer &data_buf = m_data_map["text/uri-list"];
-        return std::string(data_buf.buf<char>(), data_buf.size());
+        return std::string(data_buf.buf<char>(), data_buf.size() - 1);
     }
 
     void MimeData::set_urls(std::string_view data) {
diff --git a/src/gui/event/dropevent.cpp b/src/gui/event/dropevent.cpp
index facf9a55..f74df1c1 100644
--- a/src/gui/event/dropevent.cpp
+++ b/src/gui/event/dropevent.cpp
@@ -1,9 +1,12 @@
 #include "gui/event/dropevent.hpp"
 
 namespace Toolbox::UI {
+    DropEvent::DropEvent(const ImVec2 &pos, DropType drop_type, UUID64 source_uuid,
+                         UUID64 target_uuid, MimeData &&data)
+        : BaseEvent(target_uuid, EVENT_DROP), m_screen_pos(pos),
+          m_drop_type(drop_type), m_source_id(source_uuid), m_mime_data(std::move(data)) {}
 
-    DropEvent::DropEvent(const ImVec2 &pos, DropType drop_type,
-                         const DragAction &action)
+    DropEvent::DropEvent(const ImVec2 &pos, DropType drop_type, const DragAction &action)
         : BaseEvent(action.getTargetUUID().value(), EVENT_DROP), m_screen_pos(pos),
           m_drop_type(drop_type), m_source_id(action.getSourceUUID()) {}
 
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index a3005a32..a5be77b0 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -265,7 +265,9 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::onDragEvent(RefPtr<DragEvent> ev) {}
 
-    void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {}
+    void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {
+        actionPasteIntoIndex(m_view_index, ev->getMimeData());
+    }
 
     std::vector<std::string_view> splitLines(std::string_view s) {
         std::vector<std::string_view> result;
@@ -273,9 +275,9 @@ namespace Toolbox::UI {
         size_t next_newline_pos = s.find('\n', 0);
         while (next_newline_pos != std::string::npos) {
             if (s[next_newline_pos - 1] == '\r') {
-                result.push_back(s.substr(last_pos, next_newline_pos - 1));
+                result.push_back(s.substr(last_pos, next_newline_pos - last_pos - 1));
             } else {
-                result.push_back(s.substr(last_pos, next_newline_pos));
+                result.push_back(s.substr(last_pos, next_newline_pos - last_pos));
             }
             last_pos         = next_newline_pos + 1;
             next_newline_pos = s.find('\n', last_pos);
@@ -384,7 +386,23 @@ namespace Toolbox::UI {
         m_folder_view_context_menu.addOption(
             "Paste", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V}),
             [this]() { return m_selected_indices_ctx.size() == 0; },
-            [this](auto) { actionPasteIntoIndex(m_view_index); });
+            [this](auto) {
+                auto content_types = SystemClipboard::instance().getAvailableContentFormats();
+                if (!content_types) {
+                    TOOLBOX_ERROR("Couldn't get content types");
+                    return;
+                }
+
+                if (std::find(content_types.value().begin(), content_types.value().end(),
+                              std::string("text/uri-list")) == content_types.value().end()) {
+                    return;
+                }
+
+                MimeData data =
+                    SystemClipboard::instance().getContent("text/uri-list").value_or(MimeData());
+
+                actionPasteIntoIndex(m_view_index, data);
+            });
 
         m_folder_view_context_menu.addDivider();
 
@@ -429,25 +447,8 @@ namespace Toolbox::UI {
         std::strncpy(m_rename_buffer, file_name.c_str(), IM_ARRAYSIZE(m_rename_buffer));
     }
 
-    void ProjectViewWindow::actionPasteIntoIndex(const ModelIndex &index) {
-        auto content_types = SystemClipboard::instance().getAvailableContentFormats();
-        if (!content_types) {
-            TOOLBOX_ERROR("Couldn't get content types");
-            return;
-        }
-
-        if (std::find(content_types.value().begin(), content_types.value().end(),
-                      std::string("text/uri-list")) == content_types.value().end()) {
-            return;
-        }
-
-        auto content = SystemClipboard::instance().getContent("text/uri-list");
-        if (!content) {
-            TOOLBOX_ERROR("Failed to get content as uri list");
-            return;
-        }
-
-        auto text = content.value().get_urls();
+    void ProjectViewWindow::actionPasteIntoIndex(const ModelIndex &index, const MimeData &data) {
+        std::optional<std::string> text = data.get_urls();
         if (!text) {
             TOOLBOX_ERROR("Mime data wouldn't return uri list");
             return;
diff --git a/src/gui/window.cpp b/src/gui/window.cpp
index 64375170..a79832bd 100644
--- a/src/gui/window.cpp
+++ b/src/gui/window.cpp
@@ -1,5 +1,6 @@
 #include "gui/window.hpp"
 #include "gui/application.hpp"
+#include "gui/event/dropevent.hpp"
 #include "gui/util.hpp"
 
 #include <lib/bStream/bstream.h>
@@ -41,8 +42,8 @@ namespace Toolbox::UI {
 
         // Load image data
         {
-            stbi_uc *data =
-                stbi_load_from_memory(result.value().data(), result.value().size(), &width, &height, &channels, 4);
+            stbi_uc *data = stbi_load_from_memory(result.value().data(), result.value().size(),
+                                                  &width, &height, &channels, 4);
 
             data_buf.alloc(static_cast<size_t>(width * height * channels));
             std::memcpy(data_buf.buf<u8>(), data, data_buf.size());
@@ -179,6 +180,13 @@ namespace Toolbox::UI {
             // Render the window
             if (ImGui::Begin(window_name.c_str(), &is_open, flags_)) {
                 ImGuiViewport *viewport = ImGui::GetCurrentWindow()->Viewport;
+                GLFWwindow *window      = static_cast<GLFWwindow *>(viewport->PlatformHandle);
+                if (window) {
+                    TOOLBOX_DEBUG_LOG("Setting window callbacks");
+                    glfwSetWindowUserPointer(window, this);
+                    glfwSetDropCallback(static_cast<GLFWwindow *>(viewport->PlatformHandle),
+                                        privDropCallback);
+                }
 
                 if ((flags_ & ImGuiWindowFlags_NoBackground)) {
                     viewport->Flags |= ImGuiViewportFlags_TransparentFrameBuffer;
@@ -251,4 +259,24 @@ namespace Toolbox::UI {
         return t;
     }
 
+    void ImWindow::privDropCallback(GLFWwindow *window, int path_count, const char *paths[]) {
+        ImWindow *self = static_cast<ImWindow *>(glfwGetWindowUserPointer(window));
+        if (!self) {
+            TOOLBOX_ERROR("[ImWindow] Attempted drop operation on NULL user pointer!");
+        }
+
+        std::string uri_list;
+        for (int i = 0; i < path_count; ++i) {
+            uri_list += std::format("file:///{}\n", paths[i]);
+        }
+
+        double mouse_x, mouse_y;
+        Input::GetMouseViewportPosition(mouse_x, mouse_y);
+
+        MimeData &&data = MimeData();
+        data.set_urls(uri_list);
+        GUIApplication::instance().dispatchEvent<DropEvent, true>(
+            ImVec2(mouse_x, mouse_y), DropType::ACTION_COPY, 0, self->getUUID(), std::move(data));
+    }
+
 }  // namespace Toolbox::UI
\ No newline at end of file

From 4da8577eb4413e79496f86a663ab23a1dffbe54f Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 4 Oct 2024 10:31:36 -0700
Subject: [PATCH 069/129] Add comments to copying-out code

---
 src/gui/clipboard.cpp | 95 +++++++++++++++++++++++++++++++++----------
 1 file changed, 73 insertions(+), 22 deletions(-)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 9aa14180..238c5074 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -84,8 +84,12 @@ namespace Toolbox {
     }
 
 #ifdef TOOLBOX_PLATFORM_LINUX
+    // Storage for a function pointer to the original handler, so that
+    // we can call it if we don't want to handle the event ourselves.
     void (*glfwSelectionRequestHandler)(XEvent *);
-    void sendRequestNotify(XSelecctionRequestEvent *request) {
+    // Sends a notification that we're done responding to a given
+    // request.
+    void sendRequestNotify(Display* dpy, const XSelectionRequestEvent *request) {
         XSelectionEvent response;
         response.type      = SelectionNotify;
         response.requestor = request->requestor;
@@ -97,44 +101,82 @@ namespace Toolbox {
         XSendEvent(dpy, request->requestor, True, NoEventMask,
                    reinterpret_cast<XEvent *>(&response));
     }
+    // Our hook into the GLFW selection event handling code. When we
+    // receive a selection event, either return a list of formats we
+    // support or return the data in our clipboard.
     void handleSelectionRequest(XEvent *event) {
-        MimeData clipboard_contents = SystemClipboard::instance().m_clipboard_contents;
-        const XSelectionRequestEvent *request = &event->xselectionrequest;
+        // Pull the contents of the clipboard from the clipboard
+        // instance. This function can't be a method on that object
+        // because we're going to be passing it as a function pointer
+        // into GLFW, so we have to do everything externally.
+        MimeData clipboard_contents           = SystemClipboard::instance().m_clipboard_contents;
+        // Get the display object from GLFW so we can intern our
+        // strings in its namespace.
         Display *dpy                          = getGLFWDisplay();
+        // Pull out the specific event from the general one.
+        const XSelectionRequestEvent *request = &event->xselectionrequest;
+        // Start our targets array with just the "TARGET" target,
+        // since we'll generate the rest in a loop.
         Atom TARGETS                          = XInternAtom(dpy, "TARGETS", False);
-        std::vector<Atom> targets             = {TARGETS};
-        for (auto &string_format : clipboardContents.get_all_formats()) {
-            Atom format_atom = XInternAtom(dpy, format.c_str(), False);
-            targets.push_back(format_atom);
-        }
+        // If they
         if (request->target == TARGETS) {
-            XChangeProperty(dpy, request->requestor, request->property, XA_ATOM, 32,
-                            PropModeReplace, reinterpret_cast<const unsigned char *>(targets.data()),
-                            targets.size());
-            sendRequestNotify(request);
+            std::vector<Atom> targets             = {TARGETS};
+            // For each format the selection data supports, intern it into
+            // an atom and add it to the targets array.
+            for (auto &string_format : clipboard_contents.get_all_formats()) {
+                Atom format_atom = XInternAtom(dpy, string_format.c_str(), False);
+                targets.push_back(format_atom);
+            }
+            // Put this data as the requested property on the
+            // requested window. XAtoms are 32 bits wide, so specify
+            // that.
+            XChangeProperty(
+                dpy, request->requestor, request->property, XA_ATOM, 32, PropModeReplace,
+                reinterpret_cast<const unsigned char *>(targets.data()), targets.size());
+            // Send a notification that we did the thing.
+            sendRequestNotify(dpy, request);
         } else {
-            char* requested_target = XGetAtomName(dpy, request->target);
-            auto data = clipboard_contents.get_data(requested_target);
+            // If they request anything but TARGETS, assume its a data
+            // format from the clipboard data. Get the string name of
+            // the format, and ask for it from the clipboard contents
+            // mime type.
+            char *requested_target = XGetAtomName(dpy, request->target);
+            auto data              = clipboard_contents.get_data(requested_target);
+            // If the mime data recognized and gave us a response, and
+            // also we have a property to put the response on...
             if (data && request->property != None) {
+                // Then set the property, and notify of a response.
                 XChangeProperty(dpy, request->requestor, request->property, request->target,
                                 8 /* is this ever wrong? */, PropModeReplace,
-                                reinterpret_cast<const unsigned char*>data.buf(),
-                                data.size);
+                                reinterpret_cast<const unsigned char *>(data.value().buf()), data.value().size());
+                sendRequestNotify(dpy, request);
             } else {
+                // If we don't recognize the data, or it's a legacy
+                // client without a property target, then let GLFW
+                // complain about it.
                 glfwSelectionRequestHandler(event);
             }
-            sendRequestNotify(request);
+            // Make sure to free the string that represents the
+            // format.
             XFree(requested_target);
         }
     }
+    // Called on initialization to hook our code into the GLFW
+    // selection code.
     void hookClipboardIntoGLFW(void) {
+        // Get the old handler so that we can invoke it when our
+        // handler doesn't know what to do.
         glfwSelectionRequestHandler = getSelectionRequestHandler();
+        // Set our handler as the new handler.
         setSelectionRequestHandler(handleSelectionRequest);
     }
 #else
+    // On windows we don't need to hook into GLFW for clipboard
+    // functionality, so do nothing.
     void hookClipboardIntoGLFW(void) {}
 #endif
 
+    // Get all possible content types for the system clipboard.
     Result<std::vector<std::string>, ClipboardError> SystemClipboard::possibleContentTypes() const {
 #ifdef TOOLBOX_PLATFORM_LINUX
         Display *dpy         = getGLFWDisplay();
@@ -146,8 +188,9 @@ namespace Toolbox {
 
         XEvent ev;
         XSelectionEvent *sev;
-        // This looks pretty dangerous but this is how glfw does it,
-        // and how the examples online do it, so :shrug:
+        // This unconditional while loop looks pretty dangerous but
+        // this is how glfw does it, and how the examples online do
+        // it, so :shrug:
         while (true) {
             XNextEvent(dpy, &ev);
             switch (ev.type) {
@@ -185,6 +228,7 @@ namespace Toolbox {
 #endif
         return {};
     }
+    // Get the contents of the system clipboard.
     Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) const {
 #ifdef TOOLBOX_PLATFORM_LINUX
         Display *dpy           = getGLFWDisplay();
@@ -199,8 +243,9 @@ namespace Toolbox {
         XConvertSelection(dpy, sel, requested_type, target_property, target_window, CurrentTime);
         XEvent ev;
         XSelectionEvent *sev;
-        // This looks pretty dangerous but this is how glfw does it,
-        // and how the examples online do it, so :shrug:
+        // This unconditional while loop looks pretty dangerous but
+        // this is how glfw does it, and how the examples online do
+        // it, so :shrug:
         while (true) {
             XNextEvent(dpy, &ev);
             switch (ev.type) {
@@ -248,12 +293,18 @@ namespace Toolbox {
         return {};
     }
 
+    // Set the contents of the system clipboard.
     Result<void, ClipboardError> SystemClipboard::setContent(const MimeData &content) {
 #ifdef TOOLBOX_PLATFORM_LINUX
+        // Get the display and helper window from GLFW using our custom hooks.
         Display *dpy         = getGLFWDisplay();
         Window target_window = getGLFWHelperWindow();
-        Atom CLIPBOARD       = XInternAtom(dpy, "CLIPBOARD", False);
+        // Copy the content into the contents member variable.
         m_clipboard_contents = content;
+        // Set ourselves as the owner of the clipboard. We'll do all
+        // the actual data transfer once someone asks us for data, in
+        // our event handling hook.
+        Atom CLIPBOARD       = XInternAtom(dpy, "CLIPBOARD", False);
         XSetSelectionOwner(dpy, CLIPBOARD, target_window, CurrentTime);
 #endif
         return {};

From 297e123a681550f57ac7924d0ae4b5a39ad20b9d Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 4 Oct 2024 10:31:58 -0700
Subject: [PATCH 070/129] OOps don't try to close the GLFW display

---
 src/gui/clipboard.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 238c5074..76026033 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -224,7 +224,6 @@ namespace Toolbox {
                 break;
             }
         }
-        XCloseDisplay(dpy);
 #endif
         return {};
     }

From 5b803ec63f0bc823674ef8360454652b2b261da6 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 4 Oct 2024 12:15:54 -0700
Subject: [PATCH 071/129] Don't print "Setting window callbacks" every frame.

---
 src/gui/window.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/gui/window.cpp b/src/gui/window.cpp
index a79832bd..8ecb176e 100644
--- a/src/gui/window.cpp
+++ b/src/gui/window.cpp
@@ -182,7 +182,6 @@ namespace Toolbox::UI {
                 ImGuiViewport *viewport = ImGui::GetCurrentWindow()->Viewport;
                 GLFWwindow *window      = static_cast<GLFWwindow *>(viewport->PlatformHandle);
                 if (window) {
-                    TOOLBOX_DEBUG_LOG("Setting window callbacks");
                     glfwSetWindowUserPointer(window, this);
                     glfwSetDropCallback(static_cast<GLFWwindow *>(viewport->PlatformHandle),
                                         privDropCallback);

From 195abc02ea4d3aefad1cad020b17d3f9dac5b3bb Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 4 Oct 2024 14:17:01 -0500
Subject: [PATCH 072/129] Drag/drop start work

---
 include/gui/dragdrop/dragaction.hpp  |  7 ++++---
 src/gui/dragdrop/dragdropmanager.cpp | 19 +++++--------------
 src/gui/project/window.cpp           |  7 -------
 3 files changed, 9 insertions(+), 24 deletions(-)

diff --git a/include/gui/dragdrop/dragaction.hpp b/include/gui/dragdrop/dragaction.hpp
index c7ea154c..db25bca2 100644
--- a/include/gui/dragdrop/dragaction.hpp
+++ b/include/gui/dragdrop/dragaction.hpp
@@ -22,7 +22,7 @@ namespace Toolbox::UI {
         [[nodiscard]] ImVec2 getHotSpot() const { return m_hot_spot; }
         [[nodiscard]] const ImageHandle &getImage() { return m_image_handle; }
 
-        [[nodiscard]] const ImGuiPayload *getPayload() const { return m_imgui_payload; }
+        [[nodiscard]] const MimeData &getPayload() const { return m_mime_data; }
         [[nodiscard]] DropType getDefaultDropType() const { m_default_drop_type; }
         [[nodiscard]] DropTypes getSupportedDropTypes() const { return m_supported_drop_types; }
 
@@ -31,13 +31,14 @@ namespace Toolbox::UI {
 
         void setHotSpot(const ImVec2 &absp) { m_hot_spot = absp; }
         void setImage(const ImageHandle &image) { m_image_handle = image; }
-        void setPayload(const ImGuiPayload *payload) { m_imgui_payload = payload; }
+        void setPayload(const MimeData &data) { m_mime_data = data; }
+        void setTargetUUID(const UUID64 &uuid) { m_target_uuid = uuid; }
 
     private:
         ImVec2 m_hot_spot;
         ImageHandle m_image_handle;
 
-        const ImGuiPayload *m_imgui_payload;
+        MimeData m_mime_data;
         DropType m_default_drop_type;
         DropType m_supported_drop_types;
 
diff --git a/src/gui/dragdrop/dragdropmanager.cpp b/src/gui/dragdrop/dragdropmanager.cpp
index fb0318ea..d5bdbae3 100644
--- a/src/gui/dragdrop/dragdropmanager.cpp
+++ b/src/gui/dragdrop/dragdropmanager.cpp
@@ -4,23 +4,14 @@
 #include "core/mimedata/mimedata.hpp"
 #include "gui/dragdrop/dragaction.hpp"
 #include "gui/dragdrop/dropaction.hpp"
+#include "gui/dragdrop/dragdropmanager.hpp"
 
 namespace Toolbox::UI {
-
-    class DragDropManager {
-    public:
-        static DragDropManager &instance() {
-            static DragDropManager _instance;
-            return _instance;
-        }
-
-        void initialize();
         
-        RefPtr<DragAction> createDragAction();
-
+    RefPtr<DragAction> DragDropManager::createDragAction() {
+        return make_referable<DragAction>();
+    }
 
-    protected:
-        DragDropManager() = default;
-    };
+    void DragDropManager::initialize() {}
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index a5be77b0..e88f1b73 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -223,13 +223,6 @@ namespace Toolbox::UI {
 
                 ImGui::PopStyleVar(5);
             }
-
-            /*std::vector<std::string> formats =
-                SystemClipboard::instance().getAvailableContentFormats().value_or(
-                    std::vector<std::string>());
-            if (std::find(formats.begin(), formats.end(), "text/uri-list") != formats.end()) {
-                
-            }*/
         }
         ImGui::EndChild();
 

From 34103758b1160270fdb59adc6d6a72d56d177e9f Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 4 Oct 2024 12:19:28 -0700
Subject: [PATCH 073/129] Oops update remote and commit for glfw for our hooks

---
 .gitmodules | 2 +-
 lib/glfw    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index e818526c..338c7e3e 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -11,7 +11,7 @@
 	url = https://github.com/aiekick/ImGuiFileDialog.git
 [submodule "lib/glfw"]
 	path = lib/glfw
-	url = https://github.com/glfw/glfw.git
+	url = https://github.com/HazardousPeach/glfw.git
 [submodule "lib/libbti"]
 	path = lib/libbti
 	url = https://github.com/HazardousPeach/libbti.git
diff --git a/lib/glfw b/lib/glfw
index 70d10e61..1014db47 160000
--- a/lib/glfw
+++ b/lib/glfw
@@ -1 +1 @@
-Subproject commit 70d10e617a664237c14c6b8fd9993aa391522dd8
+Subproject commit 1014db47dc27708d3f71f790579bc67b79ea4ea5

From af85b3f9a952a95c5d596b64a95190a0872fa993 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 4 Oct 2024 13:12:52 -0700
Subject: [PATCH 074/129] Implement text clipboard on linux

---
 src/gui/clipboard.cpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 56183593..03995385 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -521,11 +521,17 @@ namespace Toolbox {
         return {};
     }
     Result<std::string, ClipboardError> SystemClipboard::getText() const {
-        return make_clipboard_error<std::string>("Not implemented yet");
+        auto data = getContent("text/plain");
+        if (!data || !data.value().has_text()) {
+            return make_clipboard_error<std::string>("No text in clipboard!");
+        }
+        return data.value().get_text().value();
     }
 
     Result<void, ClipboardError> SystemClipboard::setText(const std::string &text) {
-        return make_clipboard_error<void>("Not implemented yet");
+        MimeData data;
+        data.set_text(text);
+        return setContent("text/plain", data);
     }
 
     // Get the contents of the system clipboard.

From 31121b0c8107b407e7900016cabd8d316cadc858 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sat, 5 Oct 2024 11:43:29 -0500
Subject: [PATCH 075/129] Current progress

---
 include/core/application/application.hpp |   2 +-
 include/core/clipboard.hpp               |   2 +-
 include/gui/application.hpp              |   2 +
 include/gui/dragdrop/dragaction.hpp      |   7 +-
 include/gui/dragdrop/dragdropmanager.hpp |  28 +-
 include/gui/dragdrop/dropaction.hpp      |   1 +
 include/gui/dragdrop/target.hpp          |  30 ++
 include/gui/event/dragevent.hpp          |   8 +-
 include/gui/event/dropevent.hpp          |  19 +-
 include/gui/window.hpp                   |  42 ++-
 src/gui/application.cpp                  |  13 +
 src/gui/clipboard.cpp                    |   5 +-
 src/gui/dragdrop/dragdropmanager.cpp     | 149 +++++++++-
 src/gui/dragdrop/target.cpp              | 353 +++++++++++++++++++++++
 src/gui/event/dragevent.cpp              |   6 +-
 src/gui/event/dropevent.cpp              |  10 +-
 src/gui/project/window.cpp               |   3 +-
 src/gui/window.cpp                       |  11 +-
 18 files changed, 639 insertions(+), 52 deletions(-)
 create mode 100644 include/gui/dragdrop/target.hpp
 create mode 100644 src/gui/dragdrop/target.cpp

diff --git a/include/core/application/application.hpp b/include/core/application/application.hpp
index d7a7fc2a..97138190 100644
--- a/include/core/application/application.hpp
+++ b/include/core/application/application.hpp
@@ -59,7 +59,7 @@ namespace Toolbox {
 
         // ------------------------------------------------------
 
-        virtual void onEvent(RefPtr<BaseEvent> ev) override final;
+        virtual void onEvent(RefPtr<BaseEvent> ev) override;
 
         template <typename _Event, bool _Queue, typename... _Args>
         void dispatchEvent(_Args &&...args) {
diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index e6c97a5a..468b1b1c 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -50,7 +50,7 @@ namespace Toolbox {
         static std::string MimeForFormat(UINT format);
 
     private:
-        std::unordered_map<std::string, UINT> m_mime_to_format;
+        mutable std::unordered_map<std::string, UINT> m_mime_to_format;
 #elif defined(TOOLBOX_PLATFORM_LINUX)
         // The reason this isn't private/protected is actually kind of
         // dumb. It needs to be accessed by handleSelectionRequest,
diff --git a/include/gui/application.hpp b/include/gui/application.hpp
index 6bc3c99a..2f985241 100644
--- a/include/gui/application.hpp
+++ b/include/gui/application.hpp
@@ -54,6 +54,8 @@ namespace Toolbox {
         virtual void onUpdate(TimeStep delta_time) override;
         virtual void onExit() override;
 
+        void onEvent(RefPtr<BaseEvent> ev) override;
+
         void addWindow(RefPtr<ImWindow> window) {
             if (!m_windows_processing) {
                 addLayer(window);
diff --git a/include/gui/dragdrop/dragaction.hpp b/include/gui/dragdrop/dragaction.hpp
index db25bca2..1c88210b 100644
--- a/include/gui/dragdrop/dragaction.hpp
+++ b/include/gui/dragdrop/dragaction.hpp
@@ -27,20 +27,21 @@ namespace Toolbox::UI {
         [[nodiscard]] DropTypes getSupportedDropTypes() const { return m_supported_drop_types; }
 
         [[nodiscard]] UUID64 getSourceUUID() const { return m_source_uuid; }
-        [[nodiscard]] std::optional<UUID64> getTargetUUID() const { return m_source_uuid; }
+        [[nodiscard]] std::optional<UUID64> getTargetUUID() const { return m_target_uuid; }
 
         void setHotSpot(const ImVec2 &absp) { m_hot_spot = absp; }
         void setImage(const ImageHandle &image) { m_image_handle = image; }
         void setPayload(const MimeData &data) { m_mime_data = data; }
         void setTargetUUID(const UUID64 &uuid) { m_target_uuid = uuid; }
+        void setSupportedDropTypes(DropTypes types) { m_supported_drop_types = types; }
 
     private:
         ImVec2 m_hot_spot;
         ImageHandle m_image_handle;
 
         MimeData m_mime_data;
-        DropType m_default_drop_type;
-        DropType m_supported_drop_types;
+        DropType m_default_drop_type = DropType::ACTION_MOVE;
+        DropTypes m_supported_drop_types = DropType::ACTION_COPY | DropType::ACTION_MOVE;
 
         UUID64 m_source_uuid;
         std::optional<UUID64> m_target_uuid;
diff --git a/include/gui/dragdrop/dragdropmanager.hpp b/include/gui/dragdrop/dragdropmanager.hpp
index fb0318ea..3ff69423 100644
--- a/include/gui/dragdrop/dragdropmanager.hpp
+++ b/include/gui/dragdrop/dragdropmanager.hpp
@@ -5,6 +5,14 @@
 #include "gui/dragdrop/dragaction.hpp"
 #include "gui/dragdrop/dropaction.hpp"
 
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+#include <Windows.h>
+#include <objidl.h>
+#include <shlobj.h>
+#include <shobjidl.h>
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+#endif
+
 namespace Toolbox::UI {
 
     class DragDropManager {
@@ -14,13 +22,27 @@ namespace Toolbox::UI {
             return _instance;
         }
 
-        void initialize();
+        bool initialize();
+        void shutdown();
         
-        RefPtr<DragAction> createDragAction();
-
+        RefPtr<DragAction> createDragAction(UUID64 source_uuid, MimeData &&data);
+        RefPtr<DragAction> getCurrentDragAction() const { return m_current_drag_action; }
+        void destroyDragAction(RefPtr<DragAction> action);
 
     protected:
         DragDropManager() = default;
+
+        Result<void, BaseError> createSystemDragDropSource(MimeData &&data);
+        Result<void, BaseError> destroySystemDragDropSource();
+
+    private:
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+        IDataObject *m_data_object = nullptr;
+        IDropSource *m_drop_source = nullptr;
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+#endif
+
+         RefPtr<DragAction> m_current_drag_action;
     };
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/gui/dragdrop/dropaction.hpp b/include/gui/dragdrop/dropaction.hpp
index 8b33a906..b38c8f1f 100644
--- a/include/gui/dragdrop/dropaction.hpp
+++ b/include/gui/dragdrop/dropaction.hpp
@@ -14,6 +14,7 @@ namespace Toolbox::UI {
         // Windows only
         ACTION_TARGET_MOVE = 0x8002,
     };
+    TOOLBOX_BITWISE_ENUM(DropType);
 
     using DropTypes = DropType;
 
diff --git a/include/gui/dragdrop/target.hpp b/include/gui/dragdrop/target.hpp
new file mode 100644
index 00000000..76ca2a70
--- /dev/null
+++ b/include/gui/dragdrop/target.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "gui/dragdrop/dragaction.hpp"
+#include "gui/dragdrop/dropaction.hpp"
+#include "platform/process.hpp"
+
+namespace Toolbox::UI {
+
+    class IDragDropTargetDelegate {
+    public:
+        virtual ~IDragDropTargetDelegate() = default;
+
+        // void * for circular ref
+        virtual void setImWindow(void *window) = 0;
+
+        virtual void onDragEnter(RefPtr<DragAction> action) = 0;
+        virtual void onDragLeave(RefPtr<DragAction> action) = 0;
+        virtual void onDragMove(RefPtr<DragAction> action)  = 0;
+        virtual void onDrop(RefPtr<DragAction> action)      = 0;
+
+        virtual bool initializeForWindow(Platform::LowWindow window) = 0;
+        virtual void shutdownForWindow(Platform::LowWindow window)   = 0;
+    };
+
+    class DragDropTargetFactory {
+    public:
+         static RefPtr<IDragDropTargetDelegate> createDragDropTargetDelegate();
+    };
+
+}  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/gui/event/dragevent.hpp b/include/gui/event/dragevent.hpp
index 76a67fcd..258036fd 100644
--- a/include/gui/event/dragevent.hpp
+++ b/include/gui/event/dragevent.hpp
@@ -13,15 +13,15 @@ namespace Toolbox::UI {
         DragEvent(const DragEvent &)     = default;
         DragEvent(DragEvent &&) noexcept = default;
 
-        DragEvent(TypeID type, float pos_x, float pos_y, DragAction &&action);
+        DragEvent(TypeID type, float pos_x, float pos_y, RefPtr<DragAction> action);
 
         [[nodiscard]] void getGlobalPoint(float &x, float &y) const noexcept {
             x = m_screen_pos_x;
             y = m_screen_pos_y;
         }
 
-        [[nodiscard]] DragAction &getDragAction() noexcept { return m_drag_action; }
-        [[nodiscard]] UUID64 getSourceId() const noexcept { return m_drag_action.getSourceUUID(); }
+        [[nodiscard]] RefPtr<DragAction> getDragAction() const noexcept { return m_drag_action; }
+        [[nodiscard]] UUID64 getSourceId() const noexcept { return m_drag_action->getSourceUUID(); }
 
         ScopePtr<ISmartResource> clone(bool deep) const override;
 
@@ -31,7 +31,7 @@ namespace Toolbox::UI {
     private:
         float m_screen_pos_x;
         float m_screen_pos_y;
-        DragAction m_drag_action;
+        RefPtr<DragAction> m_drag_action;
     };
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/gui/event/dropevent.hpp b/include/gui/event/dropevent.hpp
index 3889820d..5db48e99 100644
--- a/include/gui/event/dropevent.hpp
+++ b/include/gui/event/dropevent.hpp
@@ -16,16 +16,17 @@ namespace Toolbox::UI {
         DropEvent(const DropEvent &)     = default;
         DropEvent(DropEvent &&) noexcept = default;
 
-        DropEvent(const ImVec2 &pos, DropType drop_type, const DragAction &action);
-
-        DropEvent(const ImVec2 &pos, DropType drop_type, UUID64 source_uuid, UUID64 target_uuid,
-                  MimeData &&data);
+        DropEvent(const ImVec2 &pos, RefPtr<DragAction> action);
 
         [[nodiscard]] ImVec2 getGlobalPoint() const noexcept { return m_screen_pos; }
 
-        [[nodiscard]] const MimeData &getMimeData() const noexcept { return m_mime_data; }
-        [[nodiscard]] DropType getDropType() const noexcept { return m_drop_type; }
-        [[nodiscard]] UUID64 getSourceId() const noexcept { return m_source_id; }
+        [[nodiscard]] const MimeData &getMimeData() const noexcept { return m_drag_action->getPayload(); }
+        [[nodiscard]] DropTypes getSupportedDropTypes() const noexcept {
+            return m_drag_action->getSupportedDropTypes() != DropType::ACTION_NONE
+                       ? m_drag_action->getSupportedDropTypes()
+                       : m_drag_action->getDefaultDropType();
+        }
+        [[nodiscard]] UUID64 getSourceId() const noexcept { return m_drag_action->getSourceUUID(); }
 
         ScopePtr<ISmartResource> clone(bool deep) const override;
 
@@ -34,9 +35,7 @@ namespace Toolbox::UI {
 
     private:
         ImVec2 m_screen_pos;
-        DropType m_drop_type = DropType::ACTION_NONE;
-        MimeData m_mime_data;
-        UUID64 m_source_id;
+        RefPtr<DragAction> m_drag_action;
     };
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/gui/window.hpp b/include/gui/window.hpp
index 4cfc759d..087b6b90 100644
--- a/include/gui/window.hpp
+++ b/include/gui/window.hpp
@@ -16,9 +16,11 @@
 #include "serial.hpp"
 #include "smart_resource.hpp"
 #include "unique.hpp"
+
 #include <imgui.h>
 #include <imgui_internal.h>
 
+#include "gui/dragdrop/target.hpp"
 #include "gui/layer/imlayer.hpp"
 
 namespace Toolbox::UI {
@@ -31,26 +33,44 @@ namespace Toolbox::UI {
         virtual void onRenderBody(TimeStep delta_time) {}
 
     public:
-        explicit ImWindow(const std::string &name) : ImProcessLayer(name) {}
+        explicit ImWindow(const std::string &name) : ImProcessLayer(name) {
+            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
+            m_drop_delegate->setImWindow(this);
+        }
         ImWindow(const std::string &name, std::optional<ImVec2> default_size)
-            : ImProcessLayer(name), m_default_size(default_size) {}
+            : ImProcessLayer(name), m_default_size(default_size) {
+            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
+            m_drop_delegate->setImWindow(this);
+        }
         ImWindow(const std::string &name, std::optional<ImVec2> min_size,
                  std::optional<ImVec2> max_size)
-            : ImProcessLayer(name), m_min_size(min_size), m_max_size(max_size) {}
+            : ImProcessLayer(name), m_min_size(min_size), m_max_size(max_size) {
+            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
+            m_drop_delegate->setImWindow(this);
+        }
         ImWindow(const std::string &name, std::optional<ImVec2> default_size,
                  std::optional<ImVec2> min_size, std::optional<ImVec2> max_size)
             : ImProcessLayer(name), m_default_size(default_size), m_min_size(min_size),
-              m_max_size(max_size) {}
+              m_max_size(max_size) {
+            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
+            m_drop_delegate->setImWindow(this);
+        }
         ImWindow(const std::string &name, std::optional<ImVec2> default_size,
                  std::optional<ImVec2> min_size, std::optional<ImVec2> max_size,
                  ImGuiWindowClass window_class)
             : ImProcessLayer(name), m_default_size(default_size), m_min_size(min_size),
-              m_max_size(max_size), m_window_class(window_class) {}
+              m_max_size(max_size), m_window_class(window_class) {
+            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
+            m_drop_delegate->setImWindow(this);
+        }
         ImWindow(const std::string &name, std::optional<ImVec2> default_size,
                  std::optional<ImVec2> min_size, std::optional<ImVec2> max_size,
                  ImGuiWindowClass window_class, ImGuiWindowFlags flags)
             : ImProcessLayer(name), m_default_size(default_size), m_min_size(min_size),
-              m_max_size(max_size), m_window_class(window_class), m_flags(flags) {}
+              m_max_size(max_size), m_window_class(window_class), m_flags(flags) {
+            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
+            m_drop_delegate->setImWindow(this);
+        }
 
         virtual ~ImWindow() = default;
 
@@ -132,18 +152,20 @@ namespace Toolbox::UI {
         std::optional<ImVec2> m_max_size     = {};
 
     private:
-        ImGuiID m_dockspace_id   = std::numeric_limits<ImGuiID>::max();
+        ImGuiID m_dockspace_id = std::numeric_limits<ImGuiID>::max();
 
         bool m_is_docking_set_up = false;
         bool m_is_resized        = false;
         bool m_is_repositioned   = false;
 
-        bool m_is_new_icon       = false;
-        ImVec2 m_icon_size       = {};
-        Buffer m_icon_data       = {};
+        bool m_is_new_icon = false;
+        ImVec2 m_icon_size = {};
+        Buffer m_icon_data = {};
 
         ImVec2 m_next_size = {};
         ImVec2 m_next_pos  = {};
+
+        RefPtr<IDragDropTargetDelegate> m_drop_delegate = nullptr;
     };
 
     inline std::string ImWindowComponentTitle(const ImWindow &window_layer,
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 1e3b129f..98d90db7 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -22,6 +22,7 @@
 #include "core/input/input.hpp"
 #include "dolphin/hook.hpp"
 #include "gui/application.hpp"
+#include "gui/dragdrop/dragdropmanager.hpp"
 #include "gui/font.hpp"
 #include "gui/imgui_ext.hpp"
 #include "gui/logging/errors.hpp"
@@ -169,6 +170,8 @@ namespace Toolbox {
         platform_io.Platform_CreateWindow = ImGui_ImplGlfw_CreateWindow_Ex;
         platform_io.Renderer_RenderWindow = ImGui_ImplOpenGL3_RenderWindow_Ex;
 
+        DragDropManager::instance().initialize();
+
         if (!m_settings_manager.initialize()) {
             TOOLBOX_ERROR("[INIT] Failed to initialize settings manager!");
         }
@@ -254,9 +257,19 @@ namespace Toolbox {
         m_dolphin_communicator.tKill(true);
         m_task_communicator.tKill(true);
 
+        DragDropManager::instance().shutdown();
+
         NFD_Quit();
     }
 
+    void GUIApplication::onEvent(RefPtr<BaseEvent> ev) {
+        CoreApplication::onEvent(ev);
+        if (ev->getType() == EVENT_DROP) {
+            DragDropManager::instance().destroyDragAction(
+                DragDropManager::instance().getCurrentDragAction());
+        }
+    }
+
     RefPtr<ImWindow> GUIApplication::findWindow(UUID64 uuid) {
         auto it = std::find_if(m_windows.begin(), m_windows.end(),
                                [&uuid](const auto &window) { return window->getUUID() == uuid; });
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 56183593..1c802c5a 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -10,7 +10,6 @@
 #include <X11/Xlib.h>
 #define GLFW_EXPOSE_NATIVE_X11
 #include <GLFW/glfw3native.h>
-
 #endif
 
 namespace Toolbox {
@@ -54,7 +53,7 @@ namespace Toolbox {
         return types;
     }
 
-    Result<std::string, ClipboardError> SystemClipboard::getText() {
+    Result<std::string, ClipboardError> SystemClipboard::getText() const {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<std::string>("Failed to open the clipboard!");
         }
@@ -116,7 +115,7 @@ namespace Toolbox {
         return {};
     }
 
-    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) {
+    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) const {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<MimeData>("Failed to open the clipboard!");
         }
diff --git a/src/gui/dragdrop/dragdropmanager.cpp b/src/gui/dragdrop/dragdropmanager.cpp
index d5bdbae3..5b9a238d 100644
--- a/src/gui/dragdrop/dragdropmanager.cpp
+++ b/src/gui/dragdrop/dragdropmanager.cpp
@@ -1,17 +1,156 @@
 #pragma once
 
+#include "gui/dragdrop/dragdropmanager.hpp"
+#include "core/clipboard.hpp"
 #include "core/memory.hpp"
 #include "core/mimedata/mimedata.hpp"
 #include "gui/dragdrop/dragaction.hpp"
 #include "gui/dragdrop/dropaction.hpp"
-#include "gui/dragdrop/dragdropmanager.hpp"
+
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+#include <Windows.h>
+#include <objidl.h>
+#include <shlobj.h>
+#include <shobjidl.h>
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+#endif
+
+static std::vector<std::string_view> splitLines(std::string_view s) {
+    std::vector<std::string_view> result;
+    size_t last_pos         = 0;
+    size_t next_newline_pos = s.find('\n', 0);
+    while (next_newline_pos != std::string::npos) {
+        if (s[next_newline_pos - 1] == '\r') {
+            result.push_back(s.substr(last_pos, next_newline_pos - last_pos - 1));
+        } else {
+            result.push_back(s.substr(last_pos, next_newline_pos - last_pos));
+        }
+        last_pos         = next_newline_pos + 1;
+        next_newline_pos = s.find('\n', last_pos);
+    }
+    if (last_pos < s.size()) {
+        if (s[s.size() - 1] == '\r') {
+            result.push_back(s.substr(last_pos, s.size() - last_pos - 1));
+        } else {
+            result.push_back(s.substr(last_pos));
+        }
+    }
+    return result;
+}
 
 namespace Toolbox::UI {
-        
-    RefPtr<DragAction> DragDropManager::createDragAction() {
-        return make_referable<DragAction>();
+
+    RefPtr<DragAction> DragDropManager::createDragAction(UUID64 source_uuid, MimeData &&data) {
+        m_current_drag_action = make_referable<DragAction>(source_uuid);
+        m_current_drag_action->setPayload(data);
+        return m_current_drag_action;
+    }
+
+    void DragDropManager::destroyDragAction(RefPtr<DragAction> action) {
+        m_current_drag_action.reset();
+    }
+
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+    bool DragDropManager::initialize() { return OleInitialize(nullptr) >= 0; }
+
+    void DragDropManager::shutdown() { OleUninitialize(); }
+
+    Result<void, BaseError> DragDropManager::createSystemDragDropSource(MimeData &&data) {
+        std::vector<std::string> formats =
+            SystemClipboard::instance().getAvailableContentFormats().value_or(
+                std::vector<std::string>());
+
+        if (std::find(formats.begin(), formats.end(), "text/uri-list") == formats.end()) {
+            return make_error<void>("DRAG_DROP", "No paths available in mimedata");
+        }
+
+        std::string paths = data.get_urls().value_or("");
+
+        std::vector<PIDLIST_ABSOLUTE> pidls;
+        std::vector<std::string_view> lines = splitLines(paths);
+
+        size_t next_newline_pos = 0;
+        for (const std::string_view &line : lines) {
+            if (line.empty()) {
+                continue;
+            }
+
+            std::wstring wpath = std::wstring(line.begin(), line.end());
+
+            PIDLIST_ABSOLUTE pidl = ILCreateFromPathW(wpath.c_str());
+            if (pidl == NULL) {
+                for (PIDLIST_ABSOLUTE pidl : pidls) {
+                    ILFree(pidl);
+                }
+                return make_error<void>("DRAG_DROP", "Failed to create PIDL from path");
+            }
+
+            pidls.push_back(pidl);
+        }
+
+        IDataObject *data_object = nullptr;
+        {
+            HRESULT hr = SHCreateDataObject(NULL, static_cast<UINT>(pidls.size()), (PCIDLIST_ABSOLUTE *)pidls.data(),
+                                            nullptr, IID_IDataObject, (void **)&data_object);
+
+            for (PIDLIST_ABSOLUTE pidl : pidls) {
+                ILFree(pidl);
+            }
+
+            if (FAILED(hr)) {
+                return make_error<void>("DRAG_DROP", "Failed to create data object");
+            }
+        }
+
+        IDropSource *drop_source = nullptr;
+        {
+            HRESULT hr = CoCreateInstance(CLSID_DragDropHelper, nullptr, CLSCTX_INPROC_SERVER,
+                                          IID_IDropSource, (void **)&drop_source);
+            if (FAILED(hr)) {
+                data_object->Release();
+                return make_error<void>("DRAG_DROP", "Failed to create drop source");
+            }
+        }
+
+        DWORD effect;
+        {
+            HRESULT hr = DoDragDrop(data_object, drop_source, DROPEFFECT_COPY, &effect);
+            if (FAILED(hr)) {
+                drop_source->Release();
+                data_object->Release();
+                return make_error<void>("DRAG_DROP", "Failed to perform drag drop operation");
+            }
+        }
+
+        m_data_object = data_object;
+        m_drop_source = drop_source;
+        return {};
+    }
+
+    Result<void, BaseError> DragDropManager::destroySystemDragDropSource() {
+        if (m_data_object) {
+            m_data_object->Release();
+        }
+        if (m_drop_source) {
+            m_drop_source->Release();
+        }
+        return {};
+    }
+
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+
+    bool DragDropManager::initialize() { return false; }
+
+    void DragDropManager::shutdown() {}
+
+    Result<void, BaseError> DragDropManager::createSystemDragDropSource(MimeData &&data) {
+        return {};
+    }
+
+    Result<void, BaseError> DragDropManager::destroySystemDragDropSource() {
+        return {};
     }
 
-    void DragDropManager::initialize() {}
+#endif
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/gui/dragdrop/target.cpp b/src/gui/dragdrop/target.cpp
new file mode 100644
index 00000000..85ef9d9e
--- /dev/null
+++ b/src/gui/dragdrop/target.cpp
@@ -0,0 +1,353 @@
+#include "gui/dragdrop/target.hpp"
+#include "gui/application.hpp"
+#include "gui/dragdrop/dragdropmanager.hpp"
+#include "gui/event/dragevent.hpp"
+#include "gui/event/dropevent.hpp"
+#include "gui/window.hpp"
+
+namespace Toolbox::UI {
+
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+
+#include <Windows.h>
+#include <objidl.h>
+#include <shlobj.h>
+#include <shobjidl.h>
+
+    static MimeData createMimeDataFromDataObject(IDataObject *pDataObj) {
+        IEnumFORMATETC *enum_format_etc = nullptr;
+        {
+            HRESULT hr = pDataObj->EnumFormatEtc(DATADIR_GET, &enum_format_etc);
+            if (FAILED(hr)) {
+                TOOLBOX_ERROR_V("Failed to enumerate data formats: {}", hr);
+                return MimeData();
+            }
+        }
+
+        MimeData mime_data;
+
+        FORMATETC format_etc;
+        while (enum_format_etc->Next(1, &format_etc, nullptr) == S_OK) {
+            if (format_etc.cfFormat == CF_HDROP) {
+                STGMEDIUM stg_medium;
+                {
+                    HRESULT hr = pDataObj->GetData(&format_etc, &stg_medium);
+                    if (FAILED(hr)) {
+                        TOOLBOX_ERROR_V("Failed to get data for format: {}", hr);
+                        return MimeData();
+                    }
+                }
+
+                std::string uri_paths;
+
+                HDROP hdrop = (HDROP)GlobalLock(stg_medium.hGlobal);
+
+                if (hdrop) {
+                    UINT num_files = DragQueryFile(hdrop, 0xFFFFFFFF, nullptr, 0);
+                    for (UINT i = 0; i < num_files; ++i) {
+                        TCHAR file_path[MAX_PATH];
+                        if (UINT length = DragQueryFile(hdrop, i, file_path, MAX_PATH)) {
+                            uri_paths +=
+                                std::format("file:///{}\n", std::string(file_path, length));
+                        }
+                    }
+                }
+
+                GlobalUnlock(stg_medium.hGlobal);
+
+                mime_data.set_urls(uri_paths);
+            } else if (format_etc.cfFormat == CF_UNICODETEXT) {
+                STGMEDIUM stg_medium;
+                {
+                    HRESULT hr = pDataObj->GetData(&format_etc, &stg_medium);
+                    if (FAILED(hr)) {
+                        TOOLBOX_ERROR_V("Failed to get data for format: {}", hr);
+                        return MimeData();
+                    }
+                }
+
+                std::string text_data;
+
+                if ((format_etc.tymed & TYMED_HGLOBAL) == TYMED_HGLOBAL) {
+                    LPWSTR text = (LPWSTR)GlobalLock(stg_medium.hGlobal);
+                    if (text) {
+                        std::wstring wdata = std::wstring(text);
+                        text_data          = std::string(wdata.begin(), wdata.end());
+                        GlobalUnlock(stg_medium.hGlobal);
+                    }
+                }
+
+                mime_data.set_text(text_data);
+            } else if (format_etc.cfFormat == CF_TEXT) {
+                STGMEDIUM stg_medium;
+                {
+                    HRESULT hr = pDataObj->GetData(&format_etc, &stg_medium);
+                    if (FAILED(hr)) {
+                        TOOLBOX_ERROR_V("Failed to get data for format: {}", hr);
+                        return MimeData();
+                    }
+                }
+
+                std::string text_data;
+
+                if (format_etc.tymed == TYMED_HGLOBAL) {
+                    LPSTR text = (LPSTR)GlobalLock(stg_medium.hGlobal);
+                    if (text) {
+                        text_data = text;
+                        GlobalUnlock(stg_medium.hGlobal);
+                    }
+                }
+
+                mime_data.set_text(text_data);
+            }
+        }
+
+        return mime_data;
+    }
+
+    class WindowsDragDropTargetDelegate;
+
+    class WindowsDragDropTarget : public IDropTarget {
+    public:
+        WindowsDragDropTarget(WindowsDragDropTargetDelegate *delegate)
+            : m_delegate(delegate), m_refCount() {}
+
+        ~WindowsDragDropTarget() = default;
+
+        // IUnknown Methods
+        HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject) override {
+            if (riid == IID_IUnknown || riid == IID_IDropTarget) {
+                *ppvObject = static_cast<IDropTarget *>(this);
+                AddRef();
+                return S_OK;
+            }
+            *ppvObject = nullptr;
+            return E_NOINTERFACE;
+        }
+
+        ULONG STDMETHODCALLTYPE AddRef() override { return InterlockedIncrement(&m_refCount); }
+
+        ULONG STDMETHODCALLTYPE Release() override {
+            ULONG refCount = InterlockedDecrement(&m_refCount);
+            if (refCount == 0) {
+                delete this;
+            }
+            return refCount;
+        }
+
+        // IDropTarget
+        HRESULT STDMETHODCALLTYPE DragEnter(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt,
+                                            DWORD *pdwEffect) override;
+        HRESULT STDMETHODCALLTYPE DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override;
+        HRESULT STDMETHODCALLTYPE DragLeave() override;
+        HRESULT STDMETHODCALLTYPE Drop(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt,
+                                       DWORD *pdwEffect) override;
+
+    private:
+        WindowsDragDropTargetDelegate *m_delegate = nullptr;
+        LONG m_refCount;  // Reference count for COM object
+    };
+
+    class WindowsDragDropTargetDelegate : public IDragDropTargetDelegate {
+    public:
+        friend class WindowsDragDropTarget;
+
+        WindowsDragDropTargetDelegate()           = default;
+        ~WindowsDragDropTargetDelegate() override { delete m_target; }
+
+        void setImWindow(void *window) override { m_window = static_cast<ImWindow *>(window); }
+
+        void onDragEnter(RefPtr<DragAction> action) override;
+        void onDragLeave(RefPtr<DragAction> action) override;
+        void onDragMove(RefPtr<DragAction> action) override;
+        void onDrop(RefPtr<DragAction> action) override;
+
+        bool initializeForWindow(Platform::LowWindow window) override;
+        void shutdownForWindow(Platform::LowWindow window) override;
+
+    private:
+        Platform::LowWindow m_window_handle = nullptr;
+        ImWindow *m_window                  = nullptr;
+        WindowsDragDropTarget *m_target     = nullptr;
+    };
+
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+    class LinuxDragDropTargetDelegate : public IDragDropTargetDelegate {
+    public:
+        LinuxDragDropTargetDelegate() {}
+        ~LinuxDragDropTargetDelegate() override = default;
+
+        void setImWindow(void *window) override { m_window = static_cast<ImWindow *>(window); }
+
+        void onDragEnter(RefPtr<DragAction> action) override;
+        void onDragLeave(RefPtr<DragAction> action) override;
+        void onDragMove(RefPtr<DragAction> action) override;
+        void onDrop(RefPtr<DragAction> action) override;
+
+        bool initializeForWindow(Platform::LowWindow window) override;
+        void shutdownForWindow(Platform::LowWindow window) override;
+
+    private:
+        Platform::LowWindow m_window_handle = nullptr;
+        ImWindow *m_window                  = nullptr;
+    };
+#endif
+
+    RefPtr<IDragDropTargetDelegate> DragDropTargetFactory::createDragDropTargetDelegate() {
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+        return make_referable<WindowsDragDropTargetDelegate>();
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+        return make_referable<LinuxDragDropTargetDelegate>();
+#else
+        return nullptr;
+#endif
+    }
+
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+
+    HRESULT __stdcall WindowsDragDropTarget::DragEnter(IDataObject *pDataObj, DWORD grfKeyState,
+                                                       POINTL pt, DWORD *pdwEffect) {
+        RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction();
+        if (!action) {
+            MimeData mime_data = createMimeDataFromDataObject(pDataObj);
+            action = DragDropManager::instance().createDragAction(0,
+                                                                  std::move(mime_data));
+        }
+
+        action->setHotSpot(ImVec2(pt.x, pt.y));
+        action->setTargetUUID(m_delegate->m_window->getUUID());
+
+        DropTypes supported_drop_types = DropType::ACTION_NONE;
+        if ((*pdwEffect & DROPEFFECT_COPY)) {
+            supported_drop_types |= DropType::ACTION_COPY;
+        }
+        if ((*pdwEffect & DROPEFFECT_MOVE)) {
+            supported_drop_types |= DropType::ACTION_MOVE;
+        }
+        if ((*pdwEffect & DROPEFFECT_LINK)) {
+            supported_drop_types |= DropType::ACTION_LINK;
+        }
+        action->setSupportedDropTypes(supported_drop_types);
+
+        m_delegate->onDragEnter(action);
+        return S_OK;
+    }
+
+    HRESULT __stdcall WindowsDragDropTarget::DragOver(DWORD grfKeyState, POINTL pt,
+                                                      DWORD *pdwEffect) {
+        RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction();
+        action->setHotSpot(ImVec2(pt.x, pt.y));
+        action->setTargetUUID(m_delegate->m_window->getUUID());
+        m_delegate->onDragMove(action);
+        return S_OK;
+    }
+
+    HRESULT __stdcall WindowsDragDropTarget::DragLeave() {
+        RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction();
+        action->setTargetUUID(0);
+        m_delegate->onDragLeave(action);
+        return S_OK;
+    }
+
+    HRESULT __stdcall WindowsDragDropTarget::Drop(IDataObject *pDataObj, DWORD grfKeyState,
+                                                  POINTL pt, DWORD *pdwEffect) {
+        RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction();
+        if (!action) {
+            MimeData mime_data = createMimeDataFromDataObject(pDataObj);
+            action = DragDropManager::instance().createDragAction(0, std::move(mime_data));
+        }
+
+        action->setHotSpot(ImVec2(pt.x, pt.y));
+        action->setTargetUUID(m_delegate->m_window->getUUID());
+
+        DropTypes supported_drop_types = DropType::ACTION_NONE;
+        if ((*pdwEffect & DROPEFFECT_COPY)) {
+            supported_drop_types |= DropType::ACTION_COPY;
+        }
+        if ((*pdwEffect & DROPEFFECT_MOVE)) {
+            supported_drop_types |= DropType::ACTION_MOVE;
+        }
+        if ((*pdwEffect & DROPEFFECT_LINK)) {
+            supported_drop_types |= DropType::ACTION_LINK;
+        }
+        action->setSupportedDropTypes(supported_drop_types);
+
+        m_delegate->onDrop(action);
+        return S_OK;
+    }
+
+    void WindowsDragDropTargetDelegate::onDragEnter(RefPtr<DragAction> action) {
+        double mouse_x, mouse_y;
+        Input::GetMouseViewportPosition(mouse_x, mouse_y);
+
+        GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_ENTER, mouse_x,
+                                                                  mouse_y, action);
+    }
+
+    void WindowsDragDropTargetDelegate::onDragLeave(RefPtr<DragAction> action) {
+        double mouse_x, mouse_y;
+        Input::GetMouseViewportPosition(mouse_x, mouse_y);
+
+        GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_LEAVE, mouse_x,
+                                                                  mouse_y, action);
+    }
+
+    void WindowsDragDropTargetDelegate::onDragMove(RefPtr<DragAction> action) {
+        double mouse_x, mouse_y;
+        Input::GetMouseViewportPosition(mouse_x, mouse_y);
+
+        GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_MOVE, mouse_x, mouse_y,
+                                                                  action);
+    }
+
+    void WindowsDragDropTargetDelegate::onDrop(RefPtr<DragAction> action) {
+        double mouse_x, mouse_y;
+        Input::GetMouseViewportPosition(mouse_x, mouse_y);
+
+        GUIApplication::instance().dispatchEvent<DropEvent, true>(ImVec2(mouse_x, mouse_y), action);
+    }
+
+    bool WindowsDragDropTargetDelegate::initializeForWindow(Platform::LowWindow window) {
+        if (window == m_window_handle) {
+            return window != NULL;
+        }
+
+        if (m_window_handle != NULL) {
+            RevokeDragDrop(m_window_handle);
+        }
+
+        m_target = new WindowsDragDropTarget(this);
+
+        HRESULT hr = RegisterDragDrop(window, m_target);
+        if (FAILED(hr)) {
+            TOOLBOX_ERROR("Failed to register drag drop target");
+            return false;
+        }
+
+        m_window_handle = window;
+        return true;
+    }
+
+    void WindowsDragDropTargetDelegate::shutdownForWindow(Platform::LowWindow window) {
+        if (!window) {
+            return;
+        }
+
+        RevokeDragDrop(window);
+    }
+
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+
+    void LinuxDragDropTargetDelegate::onDragEnter(RefPtr<DragAction> action) {}
+
+    void LinuxDragDropTargetDelegate::onDragLeave(RefPtr<DragAction> action) {}
+
+    void LinuxDragDropTargetDelegate::onDragMove(RefPtr<DragAction> action) {}
+
+    void LinuxDragDropTargetDelegate::onDrop(RefPtr<DragAction> action) {}
+
+    bool LinuxDragDropTargetDelegate::initializeWindow(Platform::LowWindow window) { return false; }
+
+#endif
+
+}  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/gui/event/dragevent.cpp b/src/gui/event/dragevent.cpp
index 7f5611b3..0b5ef8f5 100644
--- a/src/gui/event/dragevent.cpp
+++ b/src/gui/event/dragevent.cpp
@@ -2,9 +2,9 @@
 
 namespace Toolbox::UI {
 
-    DragEvent::DragEvent(TypeID type, float pos_x, float pos_y, DragAction &&action)
-        : BaseEvent(action.getTargetUUID().value(), type), m_screen_pos_x(pos_x),
-          m_screen_pos_y(pos_y), m_drag_action(std::move(action)) {}
+    DragEvent::DragEvent(TypeID type, float pos_x, float pos_y, RefPtr<DragAction> action)
+        : BaseEvent(action->getTargetUUID().value(), type), m_screen_pos_x(pos_x),
+          m_screen_pos_y(pos_y), m_drag_action(action) {}
 
     ScopePtr<ISmartResource> DragEvent::clone(bool deep) const {
         return make_scoped<DragEvent>(*this);
diff --git a/src/gui/event/dropevent.cpp b/src/gui/event/dropevent.cpp
index f74df1c1..ebbed48d 100644
--- a/src/gui/event/dropevent.cpp
+++ b/src/gui/event/dropevent.cpp
@@ -1,14 +1,10 @@
 #include "gui/event/dropevent.hpp"
 
 namespace Toolbox::UI {
-    DropEvent::DropEvent(const ImVec2 &pos, DropType drop_type, UUID64 source_uuid,
-                         UUID64 target_uuid, MimeData &&data)
-        : BaseEvent(target_uuid, EVENT_DROP), m_screen_pos(pos),
-          m_drop_type(drop_type), m_source_id(source_uuid), m_mime_data(std::move(data)) {}
 
-    DropEvent::DropEvent(const ImVec2 &pos, DropType drop_type, const DragAction &action)
-        : BaseEvent(action.getTargetUUID().value(), EVENT_DROP), m_screen_pos(pos),
-          m_drop_type(drop_type), m_source_id(action.getSourceUUID()) {}
+    DropEvent::DropEvent(const ImVec2 &pos, RefPtr<DragAction> action)
+        : BaseEvent(action->getTargetUUID().value(), EVENT_DROP), m_screen_pos(pos),
+          m_drag_action(action) {}
 
     ScopePtr<ISmartResource> DropEvent::clone(bool deep) const {
         return make_scoped<DropEvent>(*this);
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index e25854f2..0d487e56 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -260,6 +260,7 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {
         actionPasteIntoIndex(m_view_index, ev->getMimeData());
+        ev->accept();
     }
 
     std::vector<std::string_view> splitLines(std::string_view s) {
@@ -479,7 +480,7 @@ namespace Toolbox::UI {
 #ifdef TOOLBOX_PLATFORM_LINUX
             copied_paths += "file://";
 #elif defined TOOLBOX_PLATFORM_WINDOWS
-            copied_paths += "file:///"
+            copied_paths += "file:///";
 #endif
             copied_paths += m_file_system_model->getPath(index).string();
 #ifdef TOOLBOX_PLATFORM_LINUX
diff --git a/src/gui/window.cpp b/src/gui/window.cpp
index 8ecb176e..695a4230 100644
--- a/src/gui/window.cpp
+++ b/src/gui/window.cpp
@@ -1,5 +1,6 @@
 #include "gui/window.hpp"
 #include "gui/application.hpp"
+#include "gui/dragdrop/dragdropmanager.hpp"
 #include "gui/event/dropevent.hpp"
 #include "gui/util.hpp"
 
@@ -12,6 +13,9 @@
 #include <iconv.h>
 #include <stb/stb_image.h>
 
+#define GLFW_EXPOSE_NATIVE_WIN32
+#include <glfw/glfw3native.h>
+
 namespace Toolbox::UI {
 
     void ImWindow::onRenderDockspace() {
@@ -185,6 +189,7 @@ namespace Toolbox::UI {
                     glfwSetWindowUserPointer(window, this);
                     glfwSetDropCallback(static_cast<GLFWwindow *>(viewport->PlatformHandle),
                                         privDropCallback);
+                    m_drop_delegate->initializeForWindow((Platform::LowWindow)glfwGetWin32Window(window));
                 }
 
                 if ((flags_ & ImGuiWindowFlags_NoBackground)) {
@@ -262,6 +267,7 @@ namespace Toolbox::UI {
         ImWindow *self = static_cast<ImWindow *>(glfwGetWindowUserPointer(window));
         if (!self) {
             TOOLBOX_ERROR("[ImWindow] Attempted drop operation on NULL user pointer!");
+            return;
         }
 
         std::string uri_list;
@@ -274,8 +280,11 @@ namespace Toolbox::UI {
 
         MimeData &&data = MimeData();
         data.set_urls(uri_list);
+
+        RefPtr<DragAction> action = DragDropManager::instance().createDragAction(self->getUUID(), std::move(data));
+
         GUIApplication::instance().dispatchEvent<DropEvent, true>(
-            ImVec2(mouse_x, mouse_y), DropType::ACTION_COPY, 0, self->getUUID(), std::move(data));
+            ImVec2(mouse_x, mouse_y), action);
     }
 
 }  // namespace Toolbox::UI
\ No newline at end of file

From c713484853af8d7236a462c4d739190fea90aa50 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sat, 5 Oct 2024 12:21:47 -0500
Subject: [PATCH 076/129] More progress, gotta fix size and position updates

---
 include/gui/application.hpp     |   4 ++
 include/gui/dragdrop/target.hpp |   5 +-
 include/gui/window.hpp          |  32 ++--------
 src/gui/application.cpp         |   9 +++
 src/gui/dragdrop/target.cpp     | 102 ++++++++++++++++++++------------
 src/gui/window.cpp              |   6 +-
 6 files changed, 88 insertions(+), 70 deletions(-)

diff --git a/include/gui/application.hpp b/include/gui/application.hpp
index 2f985241..aceaf1da 100644
--- a/include/gui/application.hpp
+++ b/include/gui/application.hpp
@@ -138,6 +138,8 @@ namespace Toolbox {
         ProjectManager &getProjectManager() { return m_project_manager; }
         const ProjectManager &getProjectManager() const { return m_project_manager; }
         
+        bool registerDragDropTarget(Platform::LowWindow window);
+        void deregisterDragDropTarget(Platform::LowWindow window);
 
         void registerDolphinOverlay(UUID64 scene_uuid, const std::string &name,
                                     SceneWindow::render_layer_cb cb);
@@ -193,6 +195,8 @@ namespace Toolbox {
         std::queue<RefPtr<ImWindow>> m_windows_to_add;
         bool m_windows_processing = false;
 
+        ScopePtr<IDragDropTargetDelegate> m_drag_drop_target_delegate;
+
         std::unordered_map<UUID64, bool> m_docked_map;
         ImGuiID m_dockspace_id;
         bool m_dockspace_built;
diff --git a/include/gui/dragdrop/target.hpp b/include/gui/dragdrop/target.hpp
index 76ca2a70..25192404 100644
--- a/include/gui/dragdrop/target.hpp
+++ b/include/gui/dragdrop/target.hpp
@@ -10,9 +10,6 @@ namespace Toolbox::UI {
     public:
         virtual ~IDragDropTargetDelegate() = default;
 
-        // void * for circular ref
-        virtual void setImWindow(void *window) = 0;
-
         virtual void onDragEnter(RefPtr<DragAction> action) = 0;
         virtual void onDragLeave(RefPtr<DragAction> action) = 0;
         virtual void onDragMove(RefPtr<DragAction> action)  = 0;
@@ -24,7 +21,7 @@ namespace Toolbox::UI {
 
     class DragDropTargetFactory {
     public:
-         static RefPtr<IDragDropTargetDelegate> createDragDropTargetDelegate();
+         static ScopePtr<IDragDropTargetDelegate> createDragDropTargetDelegate();
     };
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/gui/window.hpp b/include/gui/window.hpp
index 087b6b90..7ab8559f 100644
--- a/include/gui/window.hpp
+++ b/include/gui/window.hpp
@@ -33,44 +33,26 @@ namespace Toolbox::UI {
         virtual void onRenderBody(TimeStep delta_time) {}
 
     public:
-        explicit ImWindow(const std::string &name) : ImProcessLayer(name) {
-            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
-            m_drop_delegate->setImWindow(this);
-        }
+        explicit ImWindow(const std::string &name) : ImProcessLayer(name) {}
         ImWindow(const std::string &name, std::optional<ImVec2> default_size)
-            : ImProcessLayer(name), m_default_size(default_size) {
-            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
-            m_drop_delegate->setImWindow(this);
-        }
+            : ImProcessLayer(name), m_default_size(default_size) {}
         ImWindow(const std::string &name, std::optional<ImVec2> min_size,
                  std::optional<ImVec2> max_size)
-            : ImProcessLayer(name), m_min_size(min_size), m_max_size(max_size) {
-            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
-            m_drop_delegate->setImWindow(this);
-        }
+            : ImProcessLayer(name), m_min_size(min_size), m_max_size(max_size) {}
         ImWindow(const std::string &name, std::optional<ImVec2> default_size,
                  std::optional<ImVec2> min_size, std::optional<ImVec2> max_size)
             : ImProcessLayer(name), m_default_size(default_size), m_min_size(min_size),
-              m_max_size(max_size) {
-            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
-            m_drop_delegate->setImWindow(this);
-        }
+              m_max_size(max_size) {}
         ImWindow(const std::string &name, std::optional<ImVec2> default_size,
                  std::optional<ImVec2> min_size, std::optional<ImVec2> max_size,
                  ImGuiWindowClass window_class)
             : ImProcessLayer(name), m_default_size(default_size), m_min_size(min_size),
-              m_max_size(max_size), m_window_class(window_class) {
-            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
-            m_drop_delegate->setImWindow(this);
-        }
+              m_max_size(max_size), m_window_class(window_class) {}
         ImWindow(const std::string &name, std::optional<ImVec2> default_size,
                  std::optional<ImVec2> min_size, std::optional<ImVec2> max_size,
                  ImGuiWindowClass window_class, ImGuiWindowFlags flags)
             : ImProcessLayer(name), m_default_size(default_size), m_min_size(min_size),
-              m_max_size(max_size), m_window_class(window_class), m_flags(flags) {
-            m_drop_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
-            m_drop_delegate->setImWindow(this);
-        }
+              m_max_size(max_size), m_window_class(window_class), m_flags(flags) {}
 
         virtual ~ImWindow() = default;
 
@@ -164,8 +146,6 @@ namespace Toolbox::UI {
 
         ImVec2 m_next_size = {};
         ImVec2 m_next_pos  = {};
-
-        RefPtr<IDragDropTargetDelegate> m_drop_delegate = nullptr;
     };
 
     inline std::string ImWindowComponentTitle(const ImWindow &window_layer,
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 98d90db7..4bdef572 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -171,6 +171,7 @@ namespace Toolbox {
         platform_io.Renderer_RenderWindow = ImGui_ImplOpenGL3_RenderWindow_Ex;
 
         DragDropManager::instance().initialize();
+        m_drag_drop_target_delegate = DragDropTargetFactory::createDragDropTargetDelegate();
 
         if (!m_settings_manager.initialize()) {
             TOOLBOX_ERROR("[INIT] Failed to initialize settings manager!");
@@ -292,6 +293,14 @@ namespace Toolbox {
         return result;
     }
 
+    bool GUIApplication::registerDragDropTarget(Platform::LowWindow window) {
+        return m_drag_drop_target_delegate->initializeForWindow(window);
+    }
+
+    void GUIApplication::deregisterDragDropTarget(Platform::LowWindow window) {
+        m_drag_drop_target_delegate->shutdownForWindow(window);
+    }
+
     void GUIApplication::registerDolphinOverlay(UUID64 scene_uuid, const std::string &name,
                                                 SceneWindow::render_layer_cb cb) {
         RefPtr<SceneWindow> scene_window = ref_cast<SceneWindow>(findWindow(scene_uuid));
diff --git a/src/gui/dragdrop/target.cpp b/src/gui/dragdrop/target.cpp
index 85ef9d9e..714ec20c 100644
--- a/src/gui/dragdrop/target.cpp
+++ b/src/gui/dragdrop/target.cpp
@@ -7,6 +7,19 @@
 
 namespace Toolbox::UI {
 
+    static UUID64 searchDropTarget(const ImVec2 &mouse_pos) {
+        std::vector<RefPtr<ImWindow>> windows = GUIApplication::instance().getWindows();
+
+        for (RefPtr<ImWindow> window : windows) {
+            ImRect rect = {window->getPos(), window->getPos() + window->getSize()};
+            if (rect.Contains(mouse_pos)) {
+                return window->getUUID();
+            }
+        }
+
+        return 0;
+    }
+
 #ifdef TOOLBOX_PLATFORM_WINDOWS
 
 #include <Windows.h>
@@ -90,7 +103,7 @@ namespace Toolbox::UI {
 
                 std::string text_data;
 
-                if (format_etc.tymed == TYMED_HGLOBAL) {
+                if ((format_etc.tymed & TYMED_HGLOBAL) == TYMED_HGLOBAL) {
                     LPSTR text = (LPSTR)GlobalLock(stg_medium.hGlobal);
                     if (text) {
                         text_data = text;
@@ -109,11 +122,16 @@ namespace Toolbox::UI {
 
     class WindowsDragDropTarget : public IDropTarget {
     public:
-        WindowsDragDropTarget(WindowsDragDropTargetDelegate *delegate)
-            : m_delegate(delegate), m_refCount() {}
+        WindowsDragDropTarget(WindowsDragDropTargetDelegate *delegate, Platform::LowWindow window)
+            : m_delegate(delegate), m_window_handle(window), m_refCount() {}
 
         ~WindowsDragDropTarget() = default;
 
+        Platform::LowWindow GetWindowHandle() const { return m_window_handle; }
+
+        HRESULT Initialize() { return RegisterDragDrop(m_window_handle, this); }
+        HRESULT Shutdown() { return RevokeDragDrop(m_window_handle); }
+
         // IUnknown Methods
         HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject) override {
             if (riid == IID_IUnknown || riid == IID_IDropTarget) {
@@ -145,6 +163,7 @@ namespace Toolbox::UI {
 
     private:
         WindowsDragDropTargetDelegate *m_delegate = nullptr;
+        Platform::LowWindow m_window_handle       = nullptr;
         LONG m_refCount;  // Reference count for COM object
     };
 
@@ -152,10 +171,8 @@ namespace Toolbox::UI {
     public:
         friend class WindowsDragDropTarget;
 
-        WindowsDragDropTargetDelegate()           = default;
-        ~WindowsDragDropTargetDelegate() override { delete m_target; }
-
-        void setImWindow(void *window) override { m_window = static_cast<ImWindow *>(window); }
+        WindowsDragDropTargetDelegate() = default;
+        ~WindowsDragDropTargetDelegate() override { m_targets.clear(); }
 
         void onDragEnter(RefPtr<DragAction> action) override;
         void onDragLeave(RefPtr<DragAction> action) override;
@@ -166,9 +183,7 @@ namespace Toolbox::UI {
         void shutdownForWindow(Platform::LowWindow window) override;
 
     private:
-        Platform::LowWindow m_window_handle = nullptr;
-        ImWindow *m_window                  = nullptr;
-        WindowsDragDropTarget *m_target     = nullptr;
+        std::vector<WindowsDragDropTarget *> m_targets = {};
     };
 
 #elif defined(TOOLBOX_PLATFORM_LINUX)
@@ -177,8 +192,6 @@ namespace Toolbox::UI {
         LinuxDragDropTargetDelegate() {}
         ~LinuxDragDropTargetDelegate() override = default;
 
-        void setImWindow(void *window) override { m_window = static_cast<ImWindow *>(window); }
-
         void onDragEnter(RefPtr<DragAction> action) override;
         void onDragLeave(RefPtr<DragAction> action) override;
         void onDragMove(RefPtr<DragAction> action) override;
@@ -189,15 +202,14 @@ namespace Toolbox::UI {
 
     private:
         Platform::LowWindow m_window_handle = nullptr;
-        ImWindow *m_window                  = nullptr;
     };
 #endif
 
-    RefPtr<IDragDropTargetDelegate> DragDropTargetFactory::createDragDropTargetDelegate() {
+    ScopePtr<IDragDropTargetDelegate> DragDropTargetFactory::createDragDropTargetDelegate() {
 #ifdef TOOLBOX_PLATFORM_WINDOWS
-        return make_referable<WindowsDragDropTargetDelegate>();
+        return make_scoped<WindowsDragDropTargetDelegate>();
 #elif defined(TOOLBOX_PLATFORM_LINUX)
-        return make_referable<LinuxDragDropTargetDelegate>();
+        return make_scoped<LinuxDragDropTargetDelegate>();
 #else
         return nullptr;
 #endif
@@ -210,12 +222,10 @@ namespace Toolbox::UI {
         RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction();
         if (!action) {
             MimeData mime_data = createMimeDataFromDataObject(pDataObj);
-            action = DragDropManager::instance().createDragAction(0,
-                                                                  std::move(mime_data));
+            action = DragDropManager::instance().createDragAction(0, std::move(mime_data));
         }
 
         action->setHotSpot(ImVec2(pt.x, pt.y));
-        action->setTargetUUID(m_delegate->m_window->getUUID());
 
         DropTypes supported_drop_types = DropType::ACTION_NONE;
         if ((*pdwEffect & DROPEFFECT_COPY)) {
@@ -237,14 +247,12 @@ namespace Toolbox::UI {
                                                       DWORD *pdwEffect) {
         RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction();
         action->setHotSpot(ImVec2(pt.x, pt.y));
-        action->setTargetUUID(m_delegate->m_window->getUUID());
         m_delegate->onDragMove(action);
         return S_OK;
     }
 
     HRESULT __stdcall WindowsDragDropTarget::DragLeave() {
         RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction();
-        action->setTargetUUID(0);
         m_delegate->onDragLeave(action);
         return S_OK;
     }
@@ -258,7 +266,6 @@ namespace Toolbox::UI {
         }
 
         action->setHotSpot(ImVec2(pt.x, pt.y));
-        action->setTargetUUID(m_delegate->m_window->getUUID());
 
         DropTypes supported_drop_types = DropType::ACTION_NONE;
         if ((*pdwEffect & DROPEFFECT_COPY)) {
@@ -280,6 +287,9 @@ namespace Toolbox::UI {
         double mouse_x, mouse_y;
         Input::GetMouseViewportPosition(mouse_x, mouse_y);
 
+        ImVec2 mouse_pos = ImVec2(mouse_x, mouse_y);
+        action->setTargetUUID(searchDropTarget(mouse_pos));
+
         GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_ENTER, mouse_x,
                                                                   mouse_y, action);
     }
@@ -288,6 +298,9 @@ namespace Toolbox::UI {
         double mouse_x, mouse_y;
         Input::GetMouseViewportPosition(mouse_x, mouse_y);
 
+        ImVec2 mouse_pos = ImVec2(mouse_x, mouse_y);
+        action->setTargetUUID(searchDropTarget(mouse_pos));
+
         GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_LEAVE, mouse_x,
                                                                   mouse_y, action);
     }
@@ -296,6 +309,9 @@ namespace Toolbox::UI {
         double mouse_x, mouse_y;
         Input::GetMouseViewportPosition(mouse_x, mouse_y);
 
+        ImVec2 mouse_pos = ImVec2(mouse_x, mouse_y);
+        action->setTargetUUID(searchDropTarget(mouse_pos));
+
         GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_MOVE, mouse_x, mouse_y,
                                                                   action);
     }
@@ -304,36 +320,48 @@ namespace Toolbox::UI {
         double mouse_x, mouse_y;
         Input::GetMouseViewportPosition(mouse_x, mouse_y);
 
-        GUIApplication::instance().dispatchEvent<DropEvent, true>(ImVec2(mouse_x, mouse_y), action);
+        ImVec2 mouse_pos = ImVec2(mouse_x, mouse_y);
+        action->setTargetUUID(searchDropTarget(mouse_pos));
+
+        GUIApplication::instance().dispatchEvent<DropEvent, true>(mouse_pos, action);
     }
 
     bool WindowsDragDropTargetDelegate::initializeForWindow(Platform::LowWindow window) {
-        if (window == m_window_handle) {
-            return window != NULL;
+        if (std::find_if(m_targets.begin(), m_targets.end(),
+                         [window](WindowsDragDropTarget *target) {
+                             return target->GetWindowHandle() == window;
+                         }) != m_targets.end()) {
+            return true;
         }
 
-        if (m_window_handle != NULL) {
-            RevokeDragDrop(m_window_handle);
-        }
-
-        m_target = new WindowsDragDropTarget(this);
-
-        HRESULT hr = RegisterDragDrop(window, m_target);
-        if (FAILED(hr)) {
-            TOOLBOX_ERROR("Failed to register drag drop target");
+        WindowsDragDropTarget *target = new WindowsDragDropTarget(this, window);
+        if (FAILED(target->Initialize())) {
+            TOOLBOX_ERROR("Failed to initialize drag drop target");
+            delete target;
             return false;
         }
 
-        m_window_handle = window;
+        m_targets.push_back(target);
         return true;
     }
 
     void WindowsDragDropTargetDelegate::shutdownForWindow(Platform::LowWindow window) {
-        if (!window) {
+
+        auto target_it = std::find_if(m_targets.begin(), m_targets.end(),
+                                      [window](WindowsDragDropTarget *target) {
+                                          return target->GetWindowHandle() == window;
+                                      });
+        if (target_it == m_targets.end()) {
             return;
         }
 
-        RevokeDragDrop(window);
+        WindowsDragDropTarget *target = *target_it;
+        if (FAILED(target->Shutdown())) {
+            TOOLBOX_ERROR("Failed to shutdown drag drop target");
+        }
+
+        m_targets.erase(target_it);
+        delete target;
     }
 
 #elif defined(TOOLBOX_PLATFORM_LINUX)
diff --git a/src/gui/window.cpp b/src/gui/window.cpp
index 695a4230..158a2cef 100644
--- a/src/gui/window.cpp
+++ b/src/gui/window.cpp
@@ -187,9 +187,9 @@ namespace Toolbox::UI {
                 GLFWwindow *window      = static_cast<GLFWwindow *>(viewport->PlatformHandle);
                 if (window) {
                     glfwSetWindowUserPointer(window, this);
-                    glfwSetDropCallback(static_cast<GLFWwindow *>(viewport->PlatformHandle),
-                                        privDropCallback);
-                    m_drop_delegate->initializeForWindow((Platform::LowWindow)glfwGetWin32Window(window));
+                    /*glfwSetDropCallback(static_cast<GLFWwindow *>(viewport->PlatformHandle),
+                                        privDropCallback);*/
+                    GUIApplication::instance().registerDragDropTarget((Platform::LowWindow)glfwGetWin32Window(window));
                 }
 
                 if ((flags_ & ImGuiWindowFlags_NoBackground)) {

From 608daaa8b49021fa4d6a44ee3de54fded95dff46 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sat, 5 Oct 2024 16:22:34 -0500
Subject: [PATCH 077/129] Fix compile errors

---
 include/core/clipboard.hpp | 2 +-
 src/gui/clipboard.cpp      | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index e6c97a5a..468b1b1c 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -50,7 +50,7 @@ namespace Toolbox {
         static std::string MimeForFormat(UINT format);
 
     private:
-        std::unordered_map<std::string, UINT> m_mime_to_format;
+        mutable std::unordered_map<std::string, UINT> m_mime_to_format;
 #elif defined(TOOLBOX_PLATFORM_LINUX)
         // The reason this isn't private/protected is actually kind of
         // dumb. It needs to be accessed by handleSelectionRequest,
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 03995385..d15f6f01 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -54,7 +54,7 @@ namespace Toolbox {
         return types;
     }
 
-    Result<std::string, ClipboardError> SystemClipboard::getText() {
+    Result<std::string, ClipboardError> SystemClipboard::getText() const {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<std::string>("Failed to open the clipboard!");
         }
@@ -116,7 +116,7 @@ namespace Toolbox {
         return {};
     }
 
-    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) {
+    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) const {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<MimeData>("Failed to open the clipboard!");
         }

From 9ae5a8ad7bb1d88cff7113b8663b48c46fe17695 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sat, 5 Oct 2024 23:05:01 -0500
Subject: [PATCH 078/129] Improve size/pos update logic and practically finish
 windows integration

---
 include/gui/window.hpp      | 15 ++++----
 src/gui/dragdrop/target.cpp |  4 +++
 src/gui/project/window.cpp  |  9 +++--
 src/gui/window.cpp          | 68 ++++++++++++++++++++++++++-----------
 4 files changed, 65 insertions(+), 31 deletions(-)

diff --git a/include/gui/window.hpp b/include/gui/window.hpp
index 7ab8559f..221ddff1 100644
--- a/include/gui/window.hpp
+++ b/include/gui/window.hpp
@@ -73,14 +73,8 @@ namespace Toolbox::UI {
             return flags_;
         }
 
-        [[nodiscard]] void setSize(const ImVec2 &size) noexcept override {
-            m_next_size  = size;
-            m_is_resized = true;
-        }
-        [[nodiscard]] void setPos(const ImVec2 &pos) noexcept override {
-            m_next_pos        = pos;
-            m_is_repositioned = true;
-        }
+        void setSize(const ImVec2 &size) noexcept override;
+        void setPos(const ImVec2 &pos) noexcept override;
 
         void setIcon(const std::string &icon_name);
         void setIcon(Buffer &&icon_data, const ImVec2 &icon_size);
@@ -144,8 +138,13 @@ namespace Toolbox::UI {
         ImVec2 m_icon_size = {};
         Buffer m_icon_data = {};
 
+        ImVec2 m_prev_size = {};
+        ImVec2 m_prev_pos  = {};
+
         ImVec2 m_next_size = {};
         ImVec2 m_next_pos  = {};
+
+        bool m_first_render = true;
     };
 
     inline std::string ImWindowComponentTitle(const ImWindow &window_layer,
diff --git a/src/gui/dragdrop/target.cpp b/src/gui/dragdrop/target.cpp
index 714ec20c..3b41eff8 100644
--- a/src/gui/dragdrop/target.cpp
+++ b/src/gui/dragdrop/target.cpp
@@ -41,6 +41,10 @@ namespace Toolbox::UI {
 
         FORMATETC format_etc;
         while (enum_format_etc->Next(1, &format_etc, nullptr) == S_OK) {
+            if ((format_etc.dwAspect & DVASPECT_CONTENT) == 0) {
+                continue;
+            }
+
             if (format_etc.cfFormat == CF_HDROP) {
                 STGMEDIUM stg_medium;
                 {
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 0d487e56..f922eb58 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -248,9 +248,12 @@ namespace Toolbox::UI {
         return true;
     }
 
-    void ProjectViewWindow::onAttach() { buildContextMenu(); }
+    void ProjectViewWindow::onAttach() {
+        ImWindow::onAttach();
+        buildContextMenu();
+    }
 
-    void ProjectViewWindow::onDetach() {}
+    void ProjectViewWindow::onDetach() { ImWindow::onDetach(); }
 
     void ProjectViewWindow::onImGuiUpdate(TimeStep delta_time) {}
 
@@ -277,7 +280,7 @@ namespace Toolbox::UI {
             next_newline_pos = s.find('\n', last_pos);
         }
         if (last_pos < s.size()) {
-            if (s[s.size()-1] == '\r') {
+            if (s[s.size() - 1] == '\r') {
                 result.push_back(s.substr(last_pos, s.size() - last_pos - 1));
             } else {
                 result.push_back(s.substr(last_pos));
diff --git a/src/gui/window.cpp b/src/gui/window.cpp
index 158a2cef..70eb4a29 100644
--- a/src/gui/window.cpp
+++ b/src/gui/window.cpp
@@ -32,6 +32,21 @@ namespace Toolbox::UI {
         }
     }
 
+    void ImWindow::setSize(const ImVec2 &size) noexcept {
+        if (size == getSize()) {
+            return;
+        }
+        GUIApplication::instance().dispatchEvent<WindowEvent, true>(getUUID(), EVENT_WINDOW_RESIZE,
+                                                                    size);
+    }
+    void ImWindow::setPos(const ImVec2 &pos) noexcept {
+        if (pos == getPos()) {
+            return;
+        }
+        GUIApplication::instance().dispatchEvent<WindowEvent, true>(getUUID(), EVENT_WINDOW_MOVE,
+                                                                    pos);
+    }
+
     void ImWindow::setIcon(const std::string &icon_name) {
         ResourceManager &res_manager = GUIApplication::instance().getResourceManager();
         UUID64 icon_dir              = res_manager.getResourcePathUUID("Images/Icons");
@@ -140,8 +155,8 @@ namespace Toolbox::UI {
         bool was_open    = is_open;
 
         if (is_open) {
-            ImVec2 pos  = getPos();
-            ImVec2 size = getSize();
+            m_prev_pos  = getPos();
+            m_prev_size = getSize();
 
             ImVec2 default_min = {0, 0};
             ImVec2 default_max = {FLT_MAX, FLT_MAX};
@@ -159,30 +174,20 @@ namespace Toolbox::UI {
                 flags_ |= ImGuiWindowFlags_UnsavedDocument;
             }
 
-            // Establish window constraints
-            if (window) {
-                if (size != m_next_size && m_is_resized) {
-                    if (m_next_size.x >= 0.0f && m_next_size.y >= 0.0f) {
-                        ImGui::SetNextWindowSize(size);
-                        GUIApplication::instance().dispatchEvent<WindowEvent, true>(
-                            getUUID(), EVENT_WINDOW_RESIZE, m_next_size);
-                    }
-                    m_is_resized = false;
-                }
-                if (pos != m_next_pos && m_is_repositioned) {
-                    ImGui::SetNextWindowPos(m_next_pos);
-                    GUIApplication::instance().dispatchEvent<WindowEvent, true>(
-                        getUUID(), EVENT_WINDOW_MOVE, m_next_pos);
-                    m_is_repositioned = false;
-                }
-            }
-
             if ((flags_ & ImGuiWindowFlags_NoBackground)) {
                 ImGui::SetNextWindowBgAlpha(0.0f);
             }
 
             // Render the window
             if (ImGui::Begin(window_name.c_str(), &is_open, flags_)) {
+                if (m_first_render) {
+                    m_prev_pos  = ImGui::GetWindowPos();
+                    m_prev_size = ImGui::GetWindowSize();
+                    setSize(m_prev_size);
+                    setPos(m_prev_pos);
+                    m_first_render = false;
+                }
+
                 ImGuiViewport *viewport = ImGui::GetCurrentWindow()->Viewport;
                 GLFWwindow *window      = static_cast<GLFWwindow *>(viewport->PlatformHandle);
                 if (window) {
@@ -208,6 +213,23 @@ namespace Toolbox::UI {
             ImGui::End();
         }
 
+        // Establish window constraints
+        if (window) {
+            if (window->Size != m_prev_size) {
+                if (m_next_size.x >= 0.0f && m_next_size.y >= 0.0f) {
+                    GUIApplication::instance().dispatchEvent<WindowEvent, true>(
+                        getUUID(), EVENT_WINDOW_RESIZE, window->Size);
+                }
+                ImGui::SetWindowSize(window, m_prev_size, ImGuiCond_Always);
+            }
+
+            if (window->Pos != m_prev_pos) {
+                GUIApplication::instance().dispatchEvent<WindowEvent, true>(
+                    getUUID(), EVENT_WINDOW_MOVE, window->Pos);
+                ImGui::SetWindowPos(window, m_prev_pos, ImGuiCond_Always);
+            }
+        }
+
         // Handle open/close and focus/defocus
         if (is_open) {
             if (!was_open) {
@@ -233,6 +255,12 @@ namespace Toolbox::UI {
     void ImWindow::onWindowEvent(RefPtr<WindowEvent> ev) {
         ImProcessLayer::onWindowEvent(ev);
         switch (ev->getType()) {
+        case EVENT_WINDOW_MOVE: {
+            ImVec2 win_pos = ev->getGlobalPoint();
+            setLayerPos(win_pos);
+            ev->accept();
+            break;
+        }
         case EVENT_WINDOW_RESIZE: {
             ImVec2 win_size = ev->getSize();
             if (m_min_size) {

From d69f01ec856f1fce9a118881f80c4d5ec485b595 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Sun, 6 Oct 2024 22:05:26 -0500
Subject: [PATCH 079/129] Stablize much of drag/drop functionality

---
 include/core/input/input.hpp             |   9 +-
 include/gui/dragdrop/dragaction.hpp      |   6 +-
 include/gui/dragdrop/dragdropmanager.hpp |   5 +-
 include/gui/layer/imlayer.hpp            |   8 +-
 include/gui/window.hpp                   |   8 +-
 include/platform/process.hpp             |   1 +
 src/core/input/input.cpp                 | 116 +++++++++++++++++------
 src/gui/application.cpp                  |  30 ++++++
 src/gui/dragdrop/target.cpp              |  90 +++++++++++++-----
 src/gui/event/dragevent.cpp              |   2 +-
 src/gui/event/dropevent.cpp              |   2 +-
 src/gui/project/window.cpp               |  16 +++-
 src/gui/window.cpp                       |  38 ++------
 src/platform/process.cpp                 |  45 +++++++++
 14 files changed, 280 insertions(+), 96 deletions(-)

diff --git a/include/core/input/input.hpp b/include/core/input/input.hpp
index f85bc6b2..2e069b3e 100644
--- a/include/core/input/input.hpp
+++ b/include/core/input/input.hpp
@@ -19,11 +19,14 @@ namespace Toolbox::Input {
     bool GetKeyUp(KeyCode key);
 
     MouseButtons GetPressedMouseButtons();
-    bool GetMouseButton(MouseButton button);
-    bool GetMouseButtonDown(MouseButton button);
-    bool GetMouseButtonUp(MouseButton button);
+    bool GetMouseButton(MouseButton button, bool include_external = false);
+    bool GetMouseButtonDown(MouseButton button, bool include_external = false);
+    bool GetMouseButtonUp(MouseButton button, bool include_external = false);
 
+    // This gets the mouse position only when within a GLFW window
     void GetMouseViewportPosition(double &x, double &y);
+    // This gets the mouse position even when outside the window
+    void GetMousePosition(double &x, double &y);
     void SetMousePosition(double x, double y, bool overwrite_delta = true);
 
     void GetMouseDelta(double &x, double &y);
diff --git a/include/gui/dragdrop/dragaction.hpp b/include/gui/dragdrop/dragaction.hpp
index 1c88210b..68193bae 100644
--- a/include/gui/dragdrop/dragaction.hpp
+++ b/include/gui/dragdrop/dragaction.hpp
@@ -27,7 +27,7 @@ namespace Toolbox::UI {
         [[nodiscard]] DropTypes getSupportedDropTypes() const { return m_supported_drop_types; }
 
         [[nodiscard]] UUID64 getSourceUUID() const { return m_source_uuid; }
-        [[nodiscard]] std::optional<UUID64> getTargetUUID() const { return m_target_uuid; }
+        [[nodiscard]] UUID64 getTargetUUID() const { return m_target_uuid; }
 
         void setHotSpot(const ImVec2 &absp) { m_hot_spot = absp; }
         void setImage(const ImageHandle &image) { m_image_handle = image; }
@@ -43,8 +43,8 @@ namespace Toolbox::UI {
         DropType m_default_drop_type = DropType::ACTION_MOVE;
         DropTypes m_supported_drop_types = DropType::ACTION_COPY | DropType::ACTION_MOVE;
 
-        UUID64 m_source_uuid;
-        std::optional<UUID64> m_target_uuid;
+        UUID64 m_source_uuid = 0;
+        UUID64 m_target_uuid = 0;
     };
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/gui/dragdrop/dragdropmanager.hpp b/include/gui/dragdrop/dragdropmanager.hpp
index 3ff69423..130aca77 100644
--- a/include/gui/dragdrop/dragdropmanager.hpp
+++ b/include/gui/dragdrop/dragdropmanager.hpp
@@ -25,6 +25,8 @@ namespace Toolbox::UI {
         bool initialize();
         void shutdown();
         
+        void setSystemAction(bool is_system) { m_is_system_action = is_system; }
+
         RefPtr<DragAction> createDragAction(UUID64 source_uuid, MimeData &&data);
         RefPtr<DragAction> getCurrentDragAction() const { return m_current_drag_action; }
         void destroyDragAction(RefPtr<DragAction> action);
@@ -42,7 +44,8 @@ namespace Toolbox::UI {
 #elif defined(TOOLBOX_PLATFORM_LINUX)
 #endif
 
-         RefPtr<DragAction> m_current_drag_action;
+        RefPtr<DragAction> m_current_drag_action;
+        bool m_is_system_action = false;
     };
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/gui/layer/imlayer.hpp b/include/gui/layer/imlayer.hpp
index 0b67d2a1..312d59c2 100644
--- a/include/gui/layer/imlayer.hpp
+++ b/include/gui/layer/imlayer.hpp
@@ -49,11 +49,11 @@ namespace Toolbox::UI {
         virtual void onImGuiPostUpdate(TimeStep delta_time) {}
 
         // Event callbacks
-        virtual void onContextMenuEvent(RefPtr<ContextMenuEvent> ev) {}
-        virtual void onDragEvent(RefPtr<DragEvent> ev) {}
-        virtual void onDropEvent(RefPtr<DropEvent> ev) {}
+        virtual void onContextMenuEvent(RefPtr<ContextMenuEvent> ev) { ev->ignore(); }
+        virtual void onDragEvent(RefPtr<DragEvent> ev) { ev->ignore(); }
+        virtual void onDropEvent(RefPtr<DropEvent> ev) { ev->ignore(); }
         virtual void onFocusEvent(RefPtr<BaseEvent> ev);
-        virtual void onMouseEvent(RefPtr<MouseEvent> ev) {}
+        virtual void onMouseEvent(RefPtr<MouseEvent> ev) { ev->ignore(); }
         virtual void onWindowEvent(RefPtr<WindowEvent> ev);
 
     private:
diff --git a/include/gui/window.hpp b/include/gui/window.hpp
index 221ddff1..ffc8693f 100644
--- a/include/gui/window.hpp
+++ b/include/gui/window.hpp
@@ -89,6 +89,9 @@ namespace Toolbox::UI {
         // Returns the supported file type, or empty if designed for a folder.
         [[nodiscard]] virtual std::vector<std::string> extensions() const { return {}; }
 
+        int getZOrder() const { return m_z_order; }
+        int getImOrder() const { return m_im_order; }
+
         void close();
         void defocus();
         void focus();
@@ -112,8 +115,6 @@ namespace Toolbox::UI {
         void setLayerSize(const ImVec2 &size) noexcept { ImProcessLayer::setSize(size); }
         void setLayerPos(const ImVec2 &pos) noexcept { ImProcessLayer::setPos(pos); }
 
-        static void privDropCallback(GLFWwindow *window, int path_count, const char *paths[]);
-
         UUID64 m_UUID64;
         ImGuiID m_sibling_id = 0;
 
@@ -145,6 +146,9 @@ namespace Toolbox::UI {
         ImVec2 m_next_pos  = {};
 
         bool m_first_render = true;
+
+        int m_z_order = -1;
+        int m_im_order = -1;
     };
 
     inline std::string ImWindowComponentTitle(const ImWindow &window_layer,
diff --git a/include/platform/process.hpp b/include/platform/process.hpp
index 80b4e8e6..2e0e9dbe 100644
--- a/include/platform/process.hpp
+++ b/include/platform/process.hpp
@@ -48,6 +48,7 @@ namespace Toolbox::Platform {
 
     std::string GetWindowTitle(LowWindow window);
     bool GetWindowClientRect(LowWindow window, int &x, int &y, int &width, int &height);
+    bool GetWindowZOrder(LowWindow window, int &zorder);
 
     bool ForceWindowToFront(LowWindow window);
     bool ForceWindowToFront(LowWindow window, LowWindow target);
diff --git a/src/core/input/input.cpp b/src/core/input/input.cpp
index 5d03cf37..537d4082 100644
--- a/src/core/input/input.cpp
+++ b/src/core/input/input.cpp
@@ -10,6 +10,7 @@
 #include <imgui.h>
 #include <imgui_impl_glfw.h>
 
+#include "core/core.hpp"
 #include "core/input/input.hpp"
 
 // Internals
@@ -23,6 +24,9 @@ namespace {
 
     using namespace Toolbox::Input;
 
+    static double s_mouse_position_glfw_x = 0;
+    static double s_mouse_position_glfw_y = 0;
+
     static double s_mouse_position_x = 0;
     static double s_mouse_position_y = 0;
 
@@ -40,17 +44,21 @@ namespace {
     static bool s_keys_down[c_keys_max]      = {false};
     static bool s_prev_keys_down[c_keys_max] = {false};
 
+    static bool s_mouse_buttons_down_glfw[c_buttons_max]      = {false};
+    static bool s_prev_mouse_buttons_down_glfw[c_buttons_max] = {false};
+
     static bool s_mouse_buttons_down[c_buttons_max]      = {false};
     static bool s_prev_mouse_buttons_down[c_buttons_max] = {false};
 
-    static bool GetKeyState(Toolbox::Input::KeyCode key) { return s_keys_down[raw_enum(key)]; }
-    static void SetKeyState(Toolbox::Input::KeyCode key, bool state) { s_keys_down[raw_enum(key)] = state; }
-
-    static bool GetMouseButtonState(MouseButton button) {
-        return s_mouse_buttons_down[raw_enum(button)];
+    static void SetKeyState(Toolbox::Input::KeyCode key, bool state) {
+        s_keys_down[raw_enum(key)] = state;
     }
-    static void SetMouseButtonState(MouseButton button, bool state) {
+
+    static void SetMouseButtonState(MouseButton button, bool state, bool as_external) {
         s_mouse_buttons_down[raw_enum(button)] = state;
+        if (!as_external) {
+            s_mouse_buttons_down_glfw[raw_enum(button)] = state;
+        }
     }
 
 }  // namespace
@@ -98,8 +106,7 @@ namespace Toolbox::Input {
     bool GetKey(KeyCode key) { return s_keys_down[raw_enum(key)]; }
 
     bool GetKeyDown(KeyCode key) {
-        bool is_down =
-            s_keys_down[raw_enum(key)] && !s_prev_keys_down[raw_enum(key)];
+        bool is_down = s_keys_down[raw_enum(key)] && !s_prev_keys_down[raw_enum(key)];
         return is_down;
     }
 
@@ -117,19 +124,37 @@ namespace Toolbox::Input {
         return buttons;
     }
 
-    bool GetMouseButton(MouseButton button) { return s_mouse_buttons_down[raw_enum(button)]; }
+    bool GetMouseButton(MouseButton button, bool include_external) {
+        return include_external ? s_mouse_buttons_down[raw_enum(button)]
+                                : s_mouse_buttons_down_glfw[raw_enum(button)];
+    }
 
-    bool GetMouseButtonDown(MouseButton button) {
-        return s_mouse_buttons_down[raw_enum(button)] &&
-               !s_prev_mouse_buttons_down[raw_enum(button)];
+    bool GetMouseButtonDown(MouseButton button, bool include_external) {
+        if (include_external) {
+            return s_mouse_buttons_down[raw_enum(button)] &&
+                   !s_prev_mouse_buttons_down[raw_enum(button)];
+        } else {
+            return s_mouse_buttons_down_glfw[raw_enum(button)] &&
+                   !s_prev_mouse_buttons_down_glfw[raw_enum(button)];
+        }
     }
 
-    bool GetMouseButtonUp(MouseButton button) {
-        return s_prev_mouse_buttons_down[raw_enum(button)] &&
-               !s_mouse_buttons_down[raw_enum(button)];
+    bool GetMouseButtonUp(MouseButton button, bool include_external) {
+        if (include_external) {
+            return s_prev_mouse_buttons_down[raw_enum(button)] &&
+                   !s_mouse_buttons_down[raw_enum(button)];
+        } else {
+            return s_prev_mouse_buttons_down_glfw[raw_enum(button)] &&
+                   !s_mouse_buttons_down_glfw[raw_enum(button)];
+        }
     }
 
     void GetMouseViewportPosition(double &x, double &y) {
+        x = s_mouse_position_glfw_x;
+        y = s_mouse_position_glfw_y;
+    }
+
+    void GetMousePosition(double &x, double &y) {
         x = s_mouse_position_x;
         y = s_mouse_position_y;
     }
@@ -150,9 +175,9 @@ namespace Toolbox::Input {
         if (!overwrite_delta) {
             SetMouseWrapped(true);
         }
-#if WIN32
+#ifdef TOOLBOX_PLATFORM_WINDOWS
         SetCursorPos((int)pos_x, (int)pos_y);
-#elif __linux__
+#elif defined(TOOLBOX_PLATFORM_LINUX)
         Display *display = XOpenDisplay(0);
         if (display == nullptr)
             return;
@@ -171,6 +196,38 @@ namespace Toolbox::Input {
     void SetMouseWrapped(bool wrapped) { s_mouse_wrapped = wrapped; }
 
     void UpdateInputState() {
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+        POINT point;
+        GetCursorPos(&point);
+        s_mouse_position_x = point.x;
+        s_mouse_position_y = point.y;
+
+        // Poll mouse inputs
+        for (int i = 0; i < c_buttons_max; i++) {
+            int states[3]           = {VK_LBUTTON, VK_RBUTTON, VK_MBUTTON};
+            s_mouse_buttons_down[i] = GetAsyncKeyState(states[i]) & 0x8000;
+        }
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+        // TODO: Check that this actually works
+
+        Display *display = XOpenDisplay(0);
+        if (display == nullptr)
+            return;
+
+        Window root = DefaultRootWindow(display);
+        Window child;
+        int root_x, root_y, win_x, win_y;
+        unsigned int mask;
+        XQueryPointer(display, root, &root, &child, &root_x, &root_y, &win_x, &win_y, &mask);
+
+        s_mouse_position_x = win_x;
+        s_mouse_position_y = win_y;
+
+        // Poll mouse inputs
+        for (int i = 0; i < c_buttons_max; i++) {
+        }
+#endif
+
         if (!s_mouse_wrapped) {
             s_mouse_delta_x = s_mouse_position_x - s_prev_mouse_position_x;
             s_mouse_delta_y = s_mouse_position_y - s_prev_mouse_position_y;
@@ -180,10 +237,14 @@ namespace Toolbox::Input {
     }
 
     void PostUpdateInputState() {
-        for (int i = 0; i < c_keys_max; i++)
-            s_prev_keys_down[i] = s_keys_down[i];
-        for (int i = 0; i < c_buttons_max; i++)
-            s_prev_mouse_buttons_down[i] = s_mouse_buttons_down[i];
+        /*TOOLBOX_DEBUG_LOG_V("PostUpdateInputState: LBUT: [P {}, N {}], LBUT_GLFW: [P {}, N {}]",
+                            s_prev_mouse_buttons_down[0], s_mouse_buttons_down[0],
+                            s_prev_mouse_buttons_down_glfw[0], s_mouse_buttons_down_glfw[0]);*/
+
+        std::memcpy(s_prev_mouse_buttons_down_glfw, s_mouse_buttons_down_glfw,
+                    sizeof(s_mouse_buttons_down_glfw));
+        std::memcpy(s_prev_mouse_buttons_down, s_mouse_buttons_down, sizeof(s_mouse_buttons_down));
+        std::memcpy(s_prev_keys_down, s_keys_down, sizeof(s_keys_down));
 
         s_prev_mouse_position_x = s_mouse_position_x;
         s_prev_mouse_position_y = s_mouse_position_y;
@@ -208,8 +269,8 @@ namespace Toolbox::Input {
         int win_x, win_y;
         glfwGetWindowPos(window, &win_x, &win_y);
 
-        s_mouse_position_x = win_x + xpos;
-        s_mouse_position_y = win_y + ypos;
+        s_mouse_position_glfw_x = xpos;
+        s_mouse_position_glfw_y = ypos;
 
         ImGui_ImplGlfw_CursorPosCallback(window, xpos, ypos);
     }
@@ -218,10 +279,11 @@ namespace Toolbox::Input {
         if (button >= c_buttons_max)
             return;
 
-        if (action == GLFW_PRESS)
-            s_mouse_buttons_down[button] = true;
-        else if (action == GLFW_RELEASE)
-            s_mouse_buttons_down[button] = false;
+        if (action == GLFW_PRESS) {
+            SetMouseButtonState(static_cast<MouseButton>(button), true, false);
+        } else if (action == GLFW_RELEASE) {
+            SetMouseButtonState(static_cast<MouseButton>(button), false, false);
+        }
 
         ImGui_ImplGlfw_MouseButtonCallback(window, button, action, mods);
     }
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 4bdef572..68bc09a9 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -265,9 +265,39 @@ namespace Toolbox {
 
     void GUIApplication::onEvent(RefPtr<BaseEvent> ev) {
         CoreApplication::onEvent(ev);
+
         if (ev->getType() == EVENT_DROP) {
             DragDropManager::instance().destroyDragAction(
                 DragDropManager::instance().getCurrentDragAction());
+        } else if (ev->getType() == EVENT_DRAG_MOVE || ev->getType() == EVENT_DRAG_ENTER ||
+                   ev->getType() == EVENT_DRAG_LEAVE) {
+            if (!Input::GetMouseButton(MouseButton::BUTTON_LEFT, true)) {
+                DragDropManager::instance().destroyDragAction(
+                    DragDropManager::instance().getCurrentDragAction());
+            }
+        }
+
+        switch (ev->getType()) {
+        case EVENT_DRAG_ENTER:
+        case EVENT_DRAG_MOVE: {
+            if (!Input::GetMouseButton(MouseButton::BUTTON_LEFT, true)) {
+                DragDropManager::instance().destroyDragAction(
+                    DragDropManager::instance().getCurrentDragAction());
+            }
+            break;
+        }
+        case EVENT_DRAG_LEAVE: {
+            if (!Input::GetMouseButton(MouseButton::BUTTON_LEFT, true)) {
+                DragDropManager::instance().destroyDragAction(
+                    DragDropManager::instance().getCurrentDragAction());
+            } else {
+                RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction();
+                if (action) {
+                    action->setTargetUUID(0);
+                }
+            }
+            break;
+        }
         }
     }
 
diff --git a/src/gui/dragdrop/target.cpp b/src/gui/dragdrop/target.cpp
index 3b41eff8..bb1f6d44 100644
--- a/src/gui/dragdrop/target.cpp
+++ b/src/gui/dragdrop/target.cpp
@@ -10,14 +10,27 @@ namespace Toolbox::UI {
     static UUID64 searchDropTarget(const ImVec2 &mouse_pos) {
         std::vector<RefPtr<ImWindow>> windows = GUIApplication::instance().getWindows();
 
+        UUID64 target_uuid  = 0;
+        int target_z_order  = std::numeric_limits<int>::max();
+        int target_im_index = std::numeric_limits<int>::min();
+
         for (RefPtr<ImWindow> window : windows) {
             ImRect rect = {window->getPos(), window->getPos() + window->getSize()};
             if (rect.Contains(mouse_pos)) {
-                return window->getUUID();
+                if (window->getZOrder() < target_z_order) {
+                    target_uuid     = window->getUUID();
+                    target_z_order  = window->getZOrder();
+                    target_im_index = window->getImOrder();
+                } else if (window->getZOrder() == target_z_order) {
+                    if (window->getImOrder() >= target_im_index) {
+                        target_uuid     = window->getUUID();
+                        target_im_index = window->getImOrder();
+                    }
+                }
             }
         }
 
-        return 0;
+        return target_uuid;
     }
 
 #ifdef TOOLBOX_PLATFORM_WINDOWS
@@ -188,6 +201,8 @@ namespace Toolbox::UI {
 
     private:
         std::vector<WindowsDragDropTarget *> m_targets = {};
+
+        bool m_block_implicit_drag_events = false;
     };
 
 #elif defined(TOOLBOX_PLATFORM_LINUX)
@@ -225,8 +240,10 @@ namespace Toolbox::UI {
                                                        POINTL pt, DWORD *pdwEffect) {
         RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction();
         if (!action) {
+            DragDropManager::instance().setSystemAction(true);
             MimeData mime_data = createMimeDataFromDataObject(pDataObj);
             action = DragDropManager::instance().createDragAction(0, std::move(mime_data));
+            DragDropManager::instance().setSystemAction(false);
         }
 
         action->setHotSpot(ImVec2(pt.x, pt.y));
@@ -288,46 +305,69 @@ namespace Toolbox::UI {
     }
 
     void WindowsDragDropTargetDelegate::onDragEnter(RefPtr<DragAction> action) {
-        double mouse_x, mouse_y;
-        Input::GetMouseViewportPosition(mouse_x, mouse_y);
+        ImVec2 mouse_pos = action->getHotSpot();
+        UUID64 prev_uuid = action->getTargetUUID();
+        UUID64 new_uuid  = searchDropTarget(mouse_pos);
 
-        ImVec2 mouse_pos = ImVec2(mouse_x, mouse_y);
-        action->setTargetUUID(searchDropTarget(mouse_pos));
+        if (prev_uuid != new_uuid && prev_uuid != 0) {
+            GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_LEAVE, mouse_pos.x,
+                                                                      mouse_pos.y, action);
+        }
+
+        action->setTargetUUID(new_uuid);
 
-        GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_ENTER, mouse_x,
-                                                                  mouse_y, action);
+        if (new_uuid != 0) {
+            GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_ENTER, mouse_pos.x,
+                                                                      mouse_pos.y, action);
+        }
     }
 
     void WindowsDragDropTargetDelegate::onDragLeave(RefPtr<DragAction> action) {
-        double mouse_x, mouse_y;
-        Input::GetMouseViewportPosition(mouse_x, mouse_y);
+        ImVec2 mouse_pos = action->getHotSpot();
 
-        ImVec2 mouse_pos = ImVec2(mouse_x, mouse_y);
-        action->setTargetUUID(searchDropTarget(mouse_pos));
+        if (action->getTargetUUID() != 0) {
+            GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_LEAVE, mouse_pos.x,
+                                                                      mouse_pos.y, action);
+        }
 
-        GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_LEAVE, mouse_x,
-                                                                  mouse_y, action);
+        m_block_implicit_drag_events = true;
     }
 
     void WindowsDragDropTargetDelegate::onDragMove(RefPtr<DragAction> action) {
-        double mouse_x, mouse_y;
-        Input::GetMouseViewportPosition(mouse_x, mouse_y);
+        ImVec2 mouse_pos = action->getHotSpot();
+        UUID64 prev_uuid = action->getTargetUUID();
+        UUID64 new_uuid = searchDropTarget(mouse_pos);
+
+        if (prev_uuid != new_uuid) {
+            if (!m_block_implicit_drag_events && prev_uuid != 0) {
+                GUIApplication::instance().dispatchEvent<DragEvent, true>(
+                    EVENT_DRAG_LEAVE, mouse_pos.x, mouse_pos.y, action);
+            }
 
-        ImVec2 mouse_pos = ImVec2(mouse_x, mouse_y);
-        action->setTargetUUID(searchDropTarget(mouse_pos));
+            m_block_implicit_drag_events = false;
+            action->setTargetUUID(new_uuid);
 
-        GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_MOVE, mouse_x, mouse_y,
-                                                                  action);
+            if (new_uuid != 0) {
+                GUIApplication::instance().dispatchEvent<DragEvent, true>(
+                    EVENT_DRAG_ENTER, mouse_pos.x, mouse_pos.y, action);
+            }
+        }
+
+        if (new_uuid != 0) {
+            GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_MOVE, mouse_pos.x,
+                                                                      mouse_pos.y, action);
+        }
     }
 
     void WindowsDragDropTargetDelegate::onDrop(RefPtr<DragAction> action) {
-        double mouse_x, mouse_y;
-        Input::GetMouseViewportPosition(mouse_x, mouse_y);
+        ImVec2 mouse_pos = action->getHotSpot();
 
-        ImVec2 mouse_pos = ImVec2(mouse_x, mouse_y);
-        action->setTargetUUID(searchDropTarget(mouse_pos));
+        UUID64 new_uuid = searchDropTarget(mouse_pos);
+        action->setTargetUUID(new_uuid);
 
-        GUIApplication::instance().dispatchEvent<DropEvent, true>(mouse_pos, action);
+        if (new_uuid != 0) {
+            GUIApplication::instance().dispatchEvent<DropEvent, true>(mouse_pos, action);
+        }
     }
 
     bool WindowsDragDropTargetDelegate::initializeForWindow(Platform::LowWindow window) {
diff --git a/src/gui/event/dragevent.cpp b/src/gui/event/dragevent.cpp
index 0b5ef8f5..fd9f2dd4 100644
--- a/src/gui/event/dragevent.cpp
+++ b/src/gui/event/dragevent.cpp
@@ -3,7 +3,7 @@
 namespace Toolbox::UI {
 
     DragEvent::DragEvent(TypeID type, float pos_x, float pos_y, RefPtr<DragAction> action)
-        : BaseEvent(action->getTargetUUID().value(), type), m_screen_pos_x(pos_x),
+        : BaseEvent(action->getTargetUUID(), type), m_screen_pos_x(pos_x),
           m_screen_pos_y(pos_y), m_drag_action(action) {}
 
     ScopePtr<ISmartResource> DragEvent::clone(bool deep) const {
diff --git a/src/gui/event/dropevent.cpp b/src/gui/event/dropevent.cpp
index ebbed48d..cc733117 100644
--- a/src/gui/event/dropevent.cpp
+++ b/src/gui/event/dropevent.cpp
@@ -3,7 +3,7 @@
 namespace Toolbox::UI {
 
     DropEvent::DropEvent(const ImVec2 &pos, RefPtr<DragAction> action)
-        : BaseEvent(action->getTargetUUID().value(), EVENT_DROP), m_screen_pos(pos),
+        : BaseEvent(action->getTargetUUID(), EVENT_DROP), m_screen_pos(pos),
           m_drag_action(action) {}
 
     ScopePtr<ISmartResource> DropEvent::clone(bool deep) const {
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index f922eb58..e0e3db1f 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -259,7 +259,21 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::onContextMenuEvent(RefPtr<ContextMenuEvent> ev) {}
 
-    void ProjectViewWindow::onDragEvent(RefPtr<DragEvent> ev) {}
+    void ProjectViewWindow::onDragEvent(RefPtr<DragEvent> ev) {
+        float x, y;
+        ev->getGlobalPoint(x, y);
+
+        if (ev->getType() == EVENT_DRAG_ENTER) {
+            TOOLBOX_DEBUG_LOG("Drag enter");
+            ev->accept();
+        } else if (ev->getType() == EVENT_DRAG_LEAVE) {
+            TOOLBOX_DEBUG_LOG("Drag leave");
+            ev->accept();
+        } else if (ev->getType() == EVENT_DRAG_MOVE) {
+            TOOLBOX_DEBUG_LOG_V("Drag move ({}, {})", x, y);
+            ev->accept();
+        }
+    }
 
     void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {
         actionPasteIntoIndex(m_view_index, ev->getMimeData());
diff --git a/src/gui/window.cpp b/src/gui/window.cpp
index 70eb4a29..5d8f8bbf 100644
--- a/src/gui/window.cpp
+++ b/src/gui/window.cpp
@@ -13,9 +13,6 @@
 #include <iconv.h>
 #include <stb/stb_image.h>
 
-#define GLFW_EXPOSE_NATIVE_WIN32
-#include <glfw/glfw3native.h>
-
 namespace Toolbox::UI {
 
     void ImWindow::onRenderDockspace() {
@@ -180,6 +177,11 @@ namespace Toolbox::UI {
 
             // Render the window
             if (ImGui::Begin(window_name.c_str(), &is_open, flags_)) {
+                ImGuiWindow *im_window = ImGui::GetCurrentWindow();
+                if (im_window) {
+                    m_im_order = im_window->BeginOrderWithinContext;
+                }
+
                 if (m_first_render) {
                     m_prev_pos  = ImGui::GetWindowPos();
                     m_prev_size = ImGui::GetWindowSize();
@@ -194,7 +196,11 @@ namespace Toolbox::UI {
                     glfwSetWindowUserPointer(window, this);
                     /*glfwSetDropCallback(static_cast<GLFWwindow *>(viewport->PlatformHandle),
                                         privDropCallback);*/
-                    GUIApplication::instance().registerDragDropTarget((Platform::LowWindow)glfwGetWin32Window(window));
+                    Platform::LowWindow low_window = (Platform::LowWindow)viewport->PlatformHandleRaw;
+                    if (!Platform::GetWindowZOrder(low_window, m_z_order)) {
+                        m_z_order = -1;
+                    }
+                    GUIApplication::instance().registerDragDropTarget(low_window);
                 }
 
                 if ((flags_ & ImGuiWindowFlags_NoBackground)) {
@@ -291,28 +297,4 @@ namespace Toolbox::UI {
         return t;
     }
 
-    void ImWindow::privDropCallback(GLFWwindow *window, int path_count, const char *paths[]) {
-        ImWindow *self = static_cast<ImWindow *>(glfwGetWindowUserPointer(window));
-        if (!self) {
-            TOOLBOX_ERROR("[ImWindow] Attempted drop operation on NULL user pointer!");
-            return;
-        }
-
-        std::string uri_list;
-        for (int i = 0; i < path_count; ++i) {
-            uri_list += std::format("file:///{}\n", paths[i]);
-        }
-
-        double mouse_x, mouse_y;
-        Input::GetMouseViewportPosition(mouse_x, mouse_y);
-
-        MimeData &&data = MimeData();
-        data.set_urls(uri_list);
-
-        RefPtr<DragAction> action = DragDropManager::instance().createDragAction(self->getUUID(), std::move(data));
-
-        GUIApplication::instance().dispatchEvent<DropEvent, true>(
-            ImVec2(mouse_x, mouse_y), action);
-    }
-
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/platform/process.cpp b/src/platform/process.cpp
index 324fb7ad..17538a08 100644
--- a/src/platform/process.cpp
+++ b/src/platform/process.cpp
@@ -168,6 +168,48 @@ namespace Toolbox::Platform {
         return true;
     }
 
+    // Structure to store child windows and their z-order
+    struct WindowInfo {
+        HWND hwnd;
+        int zOrder;
+    };
+
+    BOOL CALLBACK EnumWindowsForZProc(HWND hwnd, LPARAM lParam) {
+        std::vector<WindowInfo> *windows = reinterpret_cast<std::vector<WindowInfo> *>(lParam);
+
+        // Add the child window to the vector
+        WindowInfo info;
+        info.hwnd   = hwnd;
+        info.zOrder = windows->size();  // The index represents the Z-order among child windows
+        windows->push_back(info);
+
+        return TRUE;  // Continue enumeration
+    }
+
+    bool GetWindowZOrder(LowWindow window, int &zorder) {
+        std::vector<WindowInfo> windows;
+        windows.reserve(1024);
+
+        // Get the parent window of the window
+        HWND parent = GetParent(window);
+        if (parent == NULL) {
+            EnumWindows(EnumWindowsForZProc, reinterpret_cast<LPARAM>(&windows));
+        } else {
+            // Enumerate the child windows of the parent window
+            EnumChildWindows(parent, EnumWindowsForZProc, reinterpret_cast<LPARAM>(&windows));
+        }
+
+        // Find the Z-order of the window among the child windows
+        for (size_t i = 0; i < windows.size(); i++) {
+            if (windows[i].hwnd == window) {
+                zorder = windows[i].zOrder;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     bool ForceWindowToFront(LowWindow window) {
         return SetWindowPos(window, HWND_TOPMOST, 0, 0, 0, 0,
                             SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
@@ -287,6 +329,9 @@ namespace Toolbox::Platform {
         XFreeStringList(stringList);
         return stringList[0];
     }
+    bool GetWindowZOrder(LowWindow window, int &zorder) {
+        return false;
+    }
     bool ForceWindowToFront(LowWindow window) {
         Display* display = XOpenDisplay(0);
         return XRaiseWindow(display, (Window)window);

From c2bd344f11841c86e3c2923cefca007aaab440b7 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 7 Oct 2024 00:27:10 -0500
Subject: [PATCH 080/129] Establish a very basic drag render

---
 .gitignore                               |  3 +-
 include/gui/application.hpp              |  2 +
 include/gui/dragdrop/dragaction.hpp      |  8 +--
 include/gui/dragdrop/dragdropmanager.hpp |  2 +-
 include/gui/image/imagepainter.hpp       |  2 +
 include/platform/process.hpp             |  1 +
 src/gui/application.cpp                  | 62 ++++++++++++++++++++++++
 src/gui/dragdrop/target.cpp              | 52 ++++++++++++++++----
 src/gui/image/imagepainter.cpp           | 11 +++++
 src/platform/process.cpp                 | 14 +++++-
 10 files changed, 140 insertions(+), 17 deletions(-)

diff --git a/.gitignore b/.gitignore
index a460bf85..470633de 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,4 +33,5 @@
 
 # Visual Studio
 .vs/*
-out/*
\ No newline at end of file
+out/*
+/enc_temp_folder
diff --git a/include/gui/application.hpp b/include/gui/application.hpp
index aceaf1da..b9d882e5 100644
--- a/include/gui/application.hpp
+++ b/include/gui/application.hpp
@@ -196,6 +196,8 @@ namespace Toolbox {
         bool m_windows_processing = false;
 
         ScopePtr<IDragDropTargetDelegate> m_drag_drop_target_delegate;
+        ImGuiViewport *m_drag_drop_viewport = nullptr;
+        bool m_await_drag_drop_destroy      = false;
 
         std::unordered_map<UUID64, bool> m_docked_map;
         ImGuiID m_dockspace_id;
diff --git a/include/gui/dragdrop/dragaction.hpp b/include/gui/dragdrop/dragaction.hpp
index 68193bae..a23fe281 100644
--- a/include/gui/dragdrop/dragaction.hpp
+++ b/include/gui/dragdrop/dragaction.hpp
@@ -19,8 +19,8 @@ namespace Toolbox::UI {
         DragAction(const DragAction &) = default;
         DragAction(DragAction &&)      = default;
 
-        [[nodiscard]] ImVec2 getHotSpot() const { return m_hot_spot; }
-        [[nodiscard]] const ImageHandle &getImage() { return m_image_handle; }
+        [[nodiscard]] const ImVec2 &getHotSpot() const { return m_hot_spot; }
+        [[nodiscard]] RefPtr<const ImageHandle> getImage() { return m_image_handle; }
 
         [[nodiscard]] const MimeData &getPayload() const { return m_mime_data; }
         [[nodiscard]] DropType getDefaultDropType() const { m_default_drop_type; }
@@ -30,14 +30,14 @@ namespace Toolbox::UI {
         [[nodiscard]] UUID64 getTargetUUID() const { return m_target_uuid; }
 
         void setHotSpot(const ImVec2 &absp) { m_hot_spot = absp; }
-        void setImage(const ImageHandle &image) { m_image_handle = image; }
+        void setImage(RefPtr<const ImageHandle> image) { m_image_handle = image; }
         void setPayload(const MimeData &data) { m_mime_data = data; }
         void setTargetUUID(const UUID64 &uuid) { m_target_uuid = uuid; }
         void setSupportedDropTypes(DropTypes types) { m_supported_drop_types = types; }
 
     private:
         ImVec2 m_hot_spot;
-        ImageHandle m_image_handle;
+        RefPtr<const ImageHandle> m_image_handle;
 
         MimeData m_mime_data;
         DropType m_default_drop_type = DropType::ACTION_MOVE;
diff --git a/include/gui/dragdrop/dragdropmanager.hpp b/include/gui/dragdrop/dragdropmanager.hpp
index 130aca77..e698686d 100644
--- a/include/gui/dragdrop/dragdropmanager.hpp
+++ b/include/gui/dragdrop/dragdropmanager.hpp
@@ -24,7 +24,7 @@ namespace Toolbox::UI {
 
         bool initialize();
         void shutdown();
-        
+
         void setSystemAction(bool is_system) { m_is_system_action = is_system; }
 
         RefPtr<DragAction> createDragAction(UUID64 source_uuid, MimeData &&data);
diff --git a/include/gui/image/imagepainter.hpp b/include/gui/image/imagepainter.hpp
index dad78b0c..9f9d0247 100644
--- a/include/gui/image/imagepainter.hpp
+++ b/include/gui/image/imagepainter.hpp
@@ -24,6 +24,8 @@ namespace Toolbox::UI {
         bool render(const ImageHandle &image, const ImVec2 &size) const;
         bool render(const ImageHandle &image, const ImVec2 &pos, const ImVec2 &size) const;
 
+        bool renderOverlay(const ImageHandle &image, const ImVec2 &pos, const ImVec2 &size) const;
+
     private:
         ImVec2 m_uv0 = {0, 0};
         ImVec2 m_uv1 = {1, 1};
diff --git a/include/platform/process.hpp b/include/platform/process.hpp
index 2e0e9dbe..d3e3e52d 100644
--- a/include/platform/process.hpp
+++ b/include/platform/process.hpp
@@ -54,6 +54,7 @@ namespace Toolbox::Platform {
     bool ForceWindowToFront(LowWindow window, LowWindow target);
 
     bool SetWindowTransparency(LowWindow window, uint8_t alpha);
+    bool SetWindowClickThrough(LowWindow window, bool click_through);
 
     bool OpenFileExplorer(const fs_path &path);
 
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 68bc09a9..01e5ae84 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -433,6 +433,68 @@ namespace Toolbox {
             gcClosedWindows();
         }
 
+        // Render drag icon
+        {
+            if (m_await_drag_drop_destroy) {
+                DragDropManager::instance().destroyDragAction(
+                    DragDropManager::instance().getCurrentDragAction());
+                m_await_drag_drop_destroy = false;
+            }
+
+            if (DragDropManager::instance().getCurrentDragAction() &&
+                Input::GetMouseButtonUp(MouseButton::BUTTON_LEFT, true)) {
+                m_await_drag_drop_destroy = true;
+            }
+
+            if (RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction()) {
+                double x, y;
+                Input::GetMousePosition(x, y);
+
+                action->setHotSpot({(float)x, (float)y});
+
+                if (RefPtr<const ImageHandle> image = action->getImage()) {
+                    const ImVec2 &hotspot = action->getHotSpot();
+
+                    ImGuiViewportP *viewport =
+                        ImGui::FindHoveredViewportFromPlatformWindowStack(hotspot);
+                    if (viewport) {
+                        const ImVec2 size = {96, 96};
+                        const ImVec2 pos  = {hotspot.x - size.x / 2.0f, hotspot.y - size.y / 1.1f};
+
+                        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
+                        // ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 5.0f);
+                        ImGui::PushStyleColor(ImGuiCol_WindowBg,
+                                              ImGui::GetStyleColorVec4(ImGuiCol_HeaderHovered));
+
+                        ImGui::SetNextWindowBgAlpha(1.0f);
+                        ImGui::SetNextWindowPos(pos);
+                        ImGui::SetNextWindowSize(size);
+                        if (ImGui::Begin("###Drag Icon", nullptr,
+                                         ImGuiWindowFlags_NoDecoration |
+                                             ImGuiWindowFlags_NoInputs)) {
+                            ImagePainter painter;
+                            painter.renderOverlay(*action->getImage(), pos, size);
+
+                            if (ImGuiWindow *win = ImGui::GetCurrentWindow()) {
+                                if (win->Viewport != ImGui::GetMainViewport()) {
+                                    Platform::SetWindowClickThrough(
+                                        (Platform::LowWindow)win->Viewport->PlatformHandleRaw,
+                                        true);
+                                    m_drag_drop_viewport = win->Viewport;
+                                } else {
+                                    m_drag_drop_viewport = nullptr;
+                                }
+                            }
+                        }
+                        ImGui::End();
+
+                        ImGui::PopStyleColor(1);
+                        ImGui::PopStyleVar(1);
+                    }
+                }
+            }
+        }
+
         // Render imgui frame
         {
             ImGui::Render();
diff --git a/src/gui/dragdrop/target.cpp b/src/gui/dragdrop/target.cpp
index bb1f6d44..8f8f0f8c 100644
--- a/src/gui/dragdrop/target.cpp
+++ b/src/gui/dragdrop/target.cpp
@@ -309,23 +309,41 @@ namespace Toolbox::UI {
         UUID64 prev_uuid = action->getTargetUUID();
         UUID64 new_uuid  = searchDropTarget(mouse_pos);
 
-        if (prev_uuid != new_uuid && prev_uuid != 0) {
-            GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_LEAVE, mouse_pos.x,
-                                                                      mouse_pos.y, action);
-        }
+        ResourceManager &resource_manager = GUIApplication::instance().getResourceManager();
+        RefPtr<const ImageHandle> image =
+            resource_manager
+                .getImageHandle("toolbox.png", resource_manager.getResourcePathUUID("Images/Icons"))
+                .value_or(nullptr);
+        action->setImage(image);
 
-        action->setTargetUUID(new_uuid);
+        if (prev_uuid != new_uuid) {
+            if (prev_uuid != 0) {
+                GUIApplication::instance().dispatchEvent<DragEvent, true>(
+                    EVENT_DRAG_LEAVE, mouse_pos.x, mouse_pos.y, action);
+            }
 
-        if (new_uuid != 0) {
-            GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_ENTER, mouse_pos.x,
-                                                                      mouse_pos.y, action);
+            action->setTargetUUID(new_uuid);
+
+            if (new_uuid != 0) {
+                GUIApplication::instance().dispatchEvent<DragEvent, true>(
+                    EVENT_DRAG_ENTER, mouse_pos.x, mouse_pos.y, action);
+            }
         }
     }
 
     void WindowsDragDropTargetDelegate::onDragLeave(RefPtr<DragAction> action) {
         ImVec2 mouse_pos = action->getHotSpot();
+        UUID64 prev_uuid = action->getTargetUUID();
+        UUID64 new_uuid  = searchDropTarget(mouse_pos);
 
-        if (action->getTargetUUID() != 0) {
+        ResourceManager &resource_manager = GUIApplication::instance().getResourceManager();
+        RefPtr<const ImageHandle> image =
+            resource_manager
+                .getImageHandle("toolbox.png", resource_manager.getResourcePathUUID("Images/Icons"))
+                .value_or(nullptr);
+        action->setImage(image);
+
+        if (prev_uuid != new_uuid && prev_uuid != 0) {
             GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_LEAVE, mouse_pos.x,
                                                                       mouse_pos.y, action);
         }
@@ -336,7 +354,14 @@ namespace Toolbox::UI {
     void WindowsDragDropTargetDelegate::onDragMove(RefPtr<DragAction> action) {
         ImVec2 mouse_pos = action->getHotSpot();
         UUID64 prev_uuid = action->getTargetUUID();
-        UUID64 new_uuid = searchDropTarget(mouse_pos);
+        UUID64 new_uuid  = searchDropTarget(mouse_pos);
+
+        ResourceManager &resource_manager = GUIApplication::instance().getResourceManager();
+        RefPtr<const ImageHandle> image =
+            resource_manager
+                .getImageHandle("toolbox.png", resource_manager.getResourcePathUUID("Images/Icons"))
+                .value_or(nullptr);
+        action->setImage(image);
 
         if (prev_uuid != new_uuid) {
             if (!m_block_implicit_drag_events && prev_uuid != 0) {
@@ -362,6 +387,13 @@ namespace Toolbox::UI {
     void WindowsDragDropTargetDelegate::onDrop(RefPtr<DragAction> action) {
         ImVec2 mouse_pos = action->getHotSpot();
 
+        ResourceManager &resource_manager = GUIApplication::instance().getResourceManager();
+        RefPtr<const ImageHandle> image =
+            resource_manager
+                .getImageHandle("toolbox.png", resource_manager.getResourcePathUUID("Images/Icons"))
+                .value_or(nullptr);
+        action->setImage(image);
+
         UUID64 new_uuid = searchDropTarget(mouse_pos);
         action->setTargetUUID(new_uuid);
 
diff --git a/src/gui/image/imagepainter.cpp b/src/gui/image/imagepainter.cpp
index dfb86a99..64cc8aa0 100644
--- a/src/gui/image/imagepainter.cpp
+++ b/src/gui/image/imagepainter.cpp
@@ -25,4 +25,15 @@ namespace Toolbox::UI {
         return true;
     }
 
+    bool ImagePainter::renderOverlay(const ImageHandle &image, const ImVec2 &pos,
+                                     const ImVec2 &size) const {
+        if (!image) {
+            return false;
+        }
+        ImDrawList *draw_list = ImGui::GetForegroundDrawList();
+        draw_list->AddImage((ImTextureID)image.m_image_handle, pos, pos + size, m_uv0, m_uv1,
+                                     ImGui::ColorConvertFloat4ToU32(m_border_color));
+        return true;
+    }
+
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/platform/process.cpp b/src/platform/process.cpp
index 17538a08..5cf6b5b0 100644
--- a/src/platform/process.cpp
+++ b/src/platform/process.cpp
@@ -221,7 +221,7 @@ namespace Toolbox::Platform {
     }
 
     bool SetWindowTransparency(LowWindow window, uint8_t alpha) {
-        SetWindowLongPtr(window, GWL_STYLE, WS_EX_LAYERED);
+        SetWindowLongPtr(window, GWL_STYLE, GetWindowLongPtr(window, GWL_STYLE) | WS_EX_LAYERED);
         SetLayeredWindowAttributes(window, RGB(0, 0, 0), 255, LWA_ALPHA);
         if (!ShowWindow(window, SW_SHOW)) {
             return false;
@@ -229,6 +229,18 @@ namespace Toolbox::Platform {
         return UpdateWindow(window);
     }
 
+    bool SetWindowClickThrough(LowWindow window, bool click_through) {
+        LONG_PTR style = GetWindowLongPtr(window, GWL_EXSTYLE);
+        if (click_through) {
+            style |= WS_EX_LAYERED;
+            style |= WS_EX_TRANSPARENT;
+        } else {
+            style &= ~WS_EX_LAYERED;
+            style &= ~WS_EX_TRANSPARENT;
+        }
+        return SetWindowLongPtr(window, GWL_EXSTYLE, style) >= 0;
+    }
+
     bool OpenFileExplorer(const fs_path &path) {
         std::wstring path_str = path.wstring();
         return (int)ShellExecuteW(NULL, L"open", L"explorer.exe", path_str.c_str(), NULL, SW_SHOW) > 32;

From 046c91c2c73ecd0b9a870c5f079ff23454d26466 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 7 Oct 2024 00:47:07 -0500
Subject: [PATCH 081/129] Fix include problems

---
 src/core/input/input.cpp | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/core/input/input.cpp b/src/core/input/input.cpp
index 537d4082..2438cc70 100644
--- a/src/core/input/input.cpp
+++ b/src/core/input/input.cpp
@@ -1,17 +1,20 @@
-#if WIN32
+#include "core/core.hpp"
+#include "core/input/input.hpp"
+
+#include <GLFW/glfw3.h>
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+
+#include <cstring>
+
+#ifdef TOOLBOX_PLATFORM_WINDOWS
 #include <Windows.h>
-#elif __linux__
+#elif defined(TOOLBOX_PLATFORM_LINUX)
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #else
 #error "Unsupported OS"
 #endif
-#include <GLFW/glfw3.h>
-#include <imgui.h>
-#include <imgui_impl_glfw.h>
-
-#include "core/core.hpp"
-#include "core/input/input.hpp"
 
 // Internals
 

From 808ab5e9791a3c58b7bf75cd49e0675544bb24f9 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 7 Oct 2024 01:17:41 -0500
Subject: [PATCH 082/129] Fix declaration errors

---
 src/gui/dragdrop/target.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/gui/dragdrop/target.cpp b/src/gui/dragdrop/target.cpp
index 8f8f0f8c..c8e943e1 100644
--- a/src/gui/dragdrop/target.cpp
+++ b/src/gui/dragdrop/target.cpp
@@ -450,7 +450,9 @@ namespace Toolbox::UI {
 
     void LinuxDragDropTargetDelegate::onDrop(RefPtr<DragAction> action) {}
 
-    bool LinuxDragDropTargetDelegate::initializeWindow(Platform::LowWindow window) { return false; }
+    bool LinuxDragDropTargetDelegate::initializeForWindow(Platform::LowWindow window) { return false; }
+
+    void LinuxDragDropTargetDelegate::shutdownForWindow(Platform::LowWindow window) {}
 
 #endif
 

From 24e3a2c3e2958237c978e1758b12cca36293a4df Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 7 Oct 2024 01:35:55 -0500
Subject: [PATCH 083/129] Provide stub implementations for Linux

---
 src/platform/process.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/platform/process.cpp b/src/platform/process.cpp
index 5cf6b5b0..7d17f783 100644
--- a/src/platform/process.cpp
+++ b/src/platform/process.cpp
@@ -353,6 +353,11 @@ namespace Toolbox::Platform {
         // target, but I don't know how to do that.
         return ForceWindowToFront(window);
     }
+
+    bool SetWindowTransparency(LowWindow window, uint8_t alpha) { return false; }
+
+    bool SetWindowClickThrough(LowWindow window, bool click_through) { return false; }
+
     bool GetWindowClientRect(LowWindow window, int &x, int &y, int &width, int &height) {
         XWindowAttributes attribs;
         Display* display = XOpenDisplay(0);

From ce69974fbe0994d8b152f505d72e0dd93068b22e Mon Sep 17 00:00:00 2001
From: JoshuaMK <60854312+JoshuaMKW@users.noreply.github.com>
Date: Tue, 8 Oct 2024 20:22:14 -0500
Subject: [PATCH 084/129] Basic image manipulation algorithms (#35)

---
 include/core/memory.hpp        |     2 +
 include/gui/stb_image.h        |  7987 ---------------------
 include/image/imagebuilder.hpp |    33 +
 include/image/imagedata.hpp    |    56 +
 include/image/imagehandle.hpp  |     4 +
 include/resource/resource.hpp  |     5 +
 lib/stb/stb_image.h            |  8509 +++++++++++++++++++++++
 lib/stb/stb_image_resize2.h    | 11576 +++++++++++++++++++++++++++++++
 lib/stb/stb_image_write.h      |  2398 +++++++
 src/gui/application.cpp        |     6 +-
 src/gui/dragdrop/target.cpp    |    36 +-
 src/gui/pad/window.cpp         |     2 +-
 src/gui/scene/billboard.cpp    |     2 +-
 src/image/imagebuilder.cpp     |   353 +
 src/image/imagedata.cpp        |    52 +
 src/image/imagehandle.cpp      |    12 +-
 src/resource/resource.cpp      |    66 +
 17 files changed, 23072 insertions(+), 8027 deletions(-)
 delete mode 100644 include/gui/stb_image.h
 create mode 100644 include/image/imagebuilder.hpp
 create mode 100644 include/image/imagedata.hpp
 create mode 100644 lib/stb/stb_image.h
 create mode 100644 lib/stb/stb_image_resize2.h
 create mode 100644 lib/stb/stb_image_write.h
 create mode 100644 src/image/imagebuilder.cpp
 create mode 100644 src/image/imagedata.cpp

diff --git a/include/core/memory.hpp b/include/core/memory.hpp
index d6c7e27e..877bece2 100644
--- a/include/core/memory.hpp
+++ b/include/core/memory.hpp
@@ -73,6 +73,8 @@ namespace Toolbox {
         void free() {
             if (m_buf && m_owns_buf) {
                 delete[] m_buf;
+                m_buf = nullptr;
+                m_owns_buf = false;
             }
             m_size = 0;
         }
diff --git a/include/gui/stb_image.h b/include/gui/stb_image.h
deleted file mode 100644
index 5e807a0a..00000000
--- a/include/gui/stb_image.h
+++ /dev/null
@@ -1,7987 +0,0 @@
-/* stb_image - v2.28 - public domain image loader - http://nothings.org/stb
-                                  no warranty implied; use at your own risk
-
-   Do this:
-      #define STB_IMAGE_IMPLEMENTATION
-   before you include this file in *one* C or C++ file to create the implementation.
-
-   // i.e. it should look like this:
-   #include ...
-   #include ...
-   #include ...
-   #define STB_IMAGE_IMPLEMENTATION
-   #include "stb_image.h"
-
-   You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
-   And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
-
-
-   QUICK NOTES:
-      Primarily of interest to game developers and other people who can
-          avoid problematic images and only need the trivial interface
-
-      JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
-      PNG 1/2/4/8/16-bit-per-channel
-
-      TGA (not sure what subset, if a subset)
-      BMP non-1bpp, non-RLE
-      PSD (composited view only, no extra channels, 8/16 bit-per-channel)
-
-      GIF (*comp always reports as 4-channel)
-      HDR (radiance rgbE format)
-      PIC (Softimage PIC)
-      PNM (PPM and PGM binary only)
-
-      Animated GIF still needs a proper API, but here's one way to do it:
-          http://gist.github.com/urraka/685d9a6340b26b830d49
-
-      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
-      - decode from arbitrary I/O callbacks
-      - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
-
-   Full documentation under "DOCUMENTATION" below.
-
-
-LICENSE
-
-  See end of file for license information.
-
-RECENT REVISION HISTORY:
-
-      2.28  (2023-01-29) many error fixes, security errors, just tons of stuff
-      2.27  (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes
-      2.26  (2020-07-13) many minor fixes
-      2.25  (2020-02-02) fix warnings
-      2.24  (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically
-      2.23  (2019-08-11) fix clang static analysis warning
-      2.22  (2019-03-04) gif fixes, fix warnings
-      2.21  (2019-02-25) fix typo in comment
-      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
-      2.19  (2018-02-11) fix warning
-      2.18  (2018-01-30) fix warnings
-      2.17  (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
-      2.16  (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
-      2.15  (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
-      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
-      2.13  (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
-      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
-      2.11  (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
-                         RGB-format JPEG; remove white matting in PSD;
-                         allocate large structures on the stack;
-                         correct channel count for PNG & BMP
-      2.10  (2016-01-22) avoid warning introduced in 2.09
-      2.09  (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
-
-   See end of file for full revision history.
-
-
- ============================    Contributors    =========================
-
- Image formats                          Extensions, features
-    Sean Barrett (jpeg, png, bmp)          Jetro Lauha (stbi_info)
-    Nicolas Schulz (hdr, psd)              Martin "SpartanJ" Golini (stbi_info)
-    Jonathan Dummer (tga)                  James "moose2000" Brown (iPhone PNG)
-    Jean-Marc Lienher (gif)                Ben "Disch" Wenger (io callbacks)
-    Tom Seddon (pic)                       Omar Cornut (1/2/4-bit PNG)
-    Thatcher Ulrich (psd)                  Nicolas Guillemot (vertical flip)
-    Ken Miller (pgm, ppm)                  Richard Mitton (16-bit PSD)
-    github:urraka (animated gif)           Junggon Kim (PNM comments)
-    Christopher Forseth (animated gif)     Daniel Gibson (16-bit TGA)
-                                           socks-the-fox (16-bit PNG)
-                                           Jeremy Sawicki (handle all ImageNet JPGs)
- Optimizations & bugfixes                  Mikhail Morozov (1-bit BMP)
-    Fabian "ryg" Giesen                    Anael Seghezzi (is-16-bit query)
-    Arseny Kapoulkine                      Simon Breuss (16-bit PNM)
-    John-Mark Allen
-    Carmelo J Fdez-Aguera
-
- Bug & warning fixes
-    Marc LeBlanc            David Woo          Guillaume George     Martins Mozeiko
-    Christpher Lloyd        Jerry Jansson      Joseph Thomson       Blazej Dariusz Roszkowski
-    Phil Jordan                                Dave Moore           Roy Eltham
-    Hayaki Saito            Nathan Reed        Won Chun
-    Luke Graham             Johan Duparc       Nick Verigakis       the Horde3D community
-    Thomas Ruf              Ronny Chevalier                         github:rlyeh
-    Janez Zemva             John Bartholomew   Michal Cichon        github:romigrou
-    Jonathan Blow           Ken Hamada         Tero Hanninen        github:svdijk
-    Eugene Golushkov        Laurent Gomila     Cort Stratton        github:snagar
-    Aruelien Pocheville     Sergio Gonzalez    Thibault Reuille     github:Zelex
-    Cass Everitt            Ryamond Barbiero                        github:grim210
-    Paul Du Bois            Engin Manap        Aldo Culquicondor    github:sammyhw
-    Philipp Wiesemann       Dale Weiler        Oriol Ferrer Mesia   github:phprus
-    Josh Tobin              Neil Bickford      Matthew Gregan       github:poppolopoppo
-    Julian Raschke          Gregory Mullen     Christian Floisand   github:darealshinji
-    Baldur Karlsson         Kevin Schmidt      JR Smith             github:Michaelangel007
-                            Brad Weinberger    Matvey Cherevko      github:mosra
-    Luca Sas                Alexander Veselov  Zack Middleton       [reserved]
-    Ryan C. Gordon          [reserved]                              [reserved]
-                     DO NOT ADD YOUR NAME HERE
-
-                     Jacko Dirks
-
-  To add your name to the credits, pick a random blank space in the middle and fill it.
-  80% of merge conflicts on stb PRs are due to people adding their name at the end
-  of the credits.
-*/
-
-#ifndef STBI_INCLUDE_STB_IMAGE_H
-#define STBI_INCLUDE_STB_IMAGE_H
-
-// DOCUMENTATION
-//
-// Limitations:
-//    - no 12-bit-per-channel JPEG
-//    - no JPEGs with arithmetic coding
-//    - GIF always returns *comp=4
-//
-// Basic usage (see HDR discussion below for HDR usage):
-//    int x,y,n;
-//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
-//    // ... process data if not NULL ...
-//    // ... x = width, y = height, n = # 8-bit components per pixel ...
-//    // ... replace '0' with '1'..'4' to force that many components per pixel
-//    // ... but 'n' will always be the number that it would have been if you said 0
-//    stbi_image_free(data);
-//
-// Standard parameters:
-//    int *x                 -- outputs image width in pixels
-//    int *y                 -- outputs image height in pixels
-//    int *channels_in_file  -- outputs # of image components in image file
-//    int desired_channels   -- if non-zero, # of image components requested in result
-//
-// The return value from an image loader is an 'unsigned char *' which points
-// to the pixel data, or NULL on an allocation failure or if the image is
-// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
-// with each pixel consisting of N interleaved 8-bit components; the first
-// pixel pointed to is top-left-most in the image. There is no padding between
-// image scanlines or between pixels, regardless of format. The number of
-// components N is 'desired_channels' if desired_channels is non-zero, or
-// *channels_in_file otherwise. If desired_channels is non-zero,
-// *channels_in_file has the number of components that _would_ have been
-// output otherwise. E.g. if you set desired_channels to 4, you will always
-// get RGBA output, but you can check *channels_in_file to see if it's trivially
-// opaque because e.g. there were only 3 channels in the source image.
-//
-// An output image with N components has the following components interleaved
-// in this order in each pixel:
-//
-//     N=#comp     components
-//       1           grey
-//       2           grey, alpha
-//       3           red, green, blue
-//       4           red, green, blue, alpha
-//
-// If image loading fails for any reason, the return value will be NULL,
-// and *x, *y, *channels_in_file will be unchanged. The function
-// stbi_failure_reason() can be queried for an extremely brief, end-user
-// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS
-// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
-// more user-friendly ones.
-//
-// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
-//
-// To query the width, height and component count of an image without having to
-// decode the full file, you can use the stbi_info family of functions:
-//
-//   int x,y,n,ok;
-//   ok = stbi_info(filename, &x, &y, &n);
-//   // returns ok=1 and sets x, y, n if image is a supported format,
-//   // 0 otherwise.
-//
-// Note that stb_image pervasively uses ints in its public API for sizes,
-// including sizes of memory buffers. This is now part of the API and thus
-// hard to change without causing breakage. As a result, the various image
-// loaders all have certain limits on image size; these differ somewhat
-// by format but generally boil down to either just under 2GB or just under
-// 1GB. When the decoded image would be larger than this, stb_image decoding
-// will fail.
-//
-// Additionally, stb_image will reject image files that have any of their
-// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS,
-// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit,
-// the only way to have an image with such dimensions load correctly
-// is for it to have a rather extreme aspect ratio. Either way, the
-// assumption here is that such larger images are likely to be malformed
-// or malicious. If you do need to load an image with individual dimensions
-// larger than that, and it still fits in the overall size limit, you can
-// #define STBI_MAX_DIMENSIONS on your own to be something larger.
-//
-// ===========================================================================
-//
-// UNICODE:
-//
-//   If compiling for Windows and you wish to use Unicode filenames, compile
-//   with
-//       #define STBI_WINDOWS_UTF8
-//   and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
-//   Windows wchar_t filenames to utf8.
-//
-// ===========================================================================
-//
-// Philosophy
-//
-// stb libraries are designed with the following priorities:
-//
-//    1. easy to use
-//    2. easy to maintain
-//    3. good performance
-//
-// Sometimes I let "good performance" creep up in priority over "easy to maintain",
-// and for best performance I may provide less-easy-to-use APIs that give higher
-// performance, in addition to the easy-to-use ones. Nevertheless, it's important
-// to keep in mind that from the standpoint of you, a client of this library,
-// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
-//
-// Some secondary priorities arise directly from the first two, some of which
-// provide more explicit reasons why performance can't be emphasized.
-//
-//    - Portable ("ease of use")
-//    - Small source code footprint ("easy to maintain")
-//    - No dependencies ("ease of use")
-//
-// ===========================================================================
-//
-// I/O callbacks
-//
-// I/O callbacks allow you to read from arbitrary sources, like packaged
-// files or some other source. Data read from callbacks are processed
-// through a small internal buffer (currently 128 bytes) to try to reduce
-// overhead.
-//
-// The three functions you must define are "read" (reads some bytes of data),
-// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
-//
-// ===========================================================================
-//
-// SIMD support
-//
-// The JPEG decoder will try to automatically use SIMD kernels on x86 when
-// supported by the compiler. For ARM Neon support, you must explicitly
-// request it.
-//
-// (The old do-it-yourself SIMD API is no longer supported in the current
-// code.)
-//
-// On x86, SSE2 will automatically be used when available based on a run-time
-// test; if not, the generic C versions are used as a fall-back. On ARM targets,
-// the typical path is to have separate builds for NEON and non-NEON devices
-// (at least this is true for iOS and Android). Therefore, the NEON support is
-// toggled by a build flag: define STBI_NEON to get NEON loops.
-//
-// If for some reason you do not want to use any of SIMD code, or if
-// you have issues compiling it, you can disable it entirely by
-// defining STBI_NO_SIMD.
-//
-// ===========================================================================
-//
-// HDR image support   (disable by defining STBI_NO_HDR)
-//
-// stb_image supports loading HDR images in general, and currently the Radiance
-// .HDR file format specifically. You can still load any file through the existing
-// interface; if you attempt to load an HDR file, it will be automatically remapped
-// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
-// both of these constants can be reconfigured through this interface:
-//
-//     stbi_hdr_to_ldr_gamma(2.2f);
-//     stbi_hdr_to_ldr_scale(1.0f);
-//
-// (note, do not use _inverse_ constants; stbi_image will invert them
-// appropriately).
-//
-// Additionally, there is a new, parallel interface for loading files as
-// (linear) floats to preserve the full dynamic range:
-//
-//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
-//
-// If you load LDR images through this interface, those images will
-// be promoted to floating point values, run through the inverse of
-// constants corresponding to the above:
-//
-//     stbi_ldr_to_hdr_scale(1.0f);
-//     stbi_ldr_to_hdr_gamma(2.2f);
-//
-// Finally, given a filename (or an open file or memory block--see header
-// file for details) containing image data, you can query for the "most
-// appropriate" interface to use (that is, whether the image is HDR or
-// not), using:
-//
-//     stbi_is_hdr(char *filename);
-//
-// ===========================================================================
-//
-// iPhone PNG support:
-//
-// We optionally support converting iPhone-formatted PNGs (which store
-// premultiplied BGRA) back to RGB, even though they're internally encoded
-// differently. To enable this conversion, call
-// stbi_convert_iphone_png_to_rgb(1).
-//
-// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
-// pixel to remove any premultiplied alpha *only* if the image file explicitly
-// says there's premultiplied data (currently only happens in iPhone images,
-// and only if iPhone convert-to-rgb processing is on).
-//
-// ===========================================================================
-//
-// ADDITIONAL CONFIGURATION
-//
-//  - You can suppress implementation of any of the decoders to reduce
-//    your code footprint by #defining one or more of the following
-//    symbols before creating the implementation.
-//
-//        STBI_NO_JPEG
-//        STBI_NO_PNG
-//        STBI_NO_BMP
-//        STBI_NO_PSD
-//        STBI_NO_TGA
-//        STBI_NO_GIF
-//        STBI_NO_HDR
-//        STBI_NO_PIC
-//        STBI_NO_PNM   (.ppm and .pgm)
-//
-//  - You can request *only* certain decoders and suppress all other ones
-//    (this will be more forward-compatible, as addition of new decoders
-//    doesn't require you to disable them explicitly):
-//
-//        STBI_ONLY_JPEG
-//        STBI_ONLY_PNG
-//        STBI_ONLY_BMP
-//        STBI_ONLY_PSD
-//        STBI_ONLY_TGA
-//        STBI_ONLY_GIF
-//        STBI_ONLY_HDR
-//        STBI_ONLY_PIC
-//        STBI_ONLY_PNM   (.ppm and .pgm)
-//
-//   - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
-//     want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
-//
-//  - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater
-//    than that size (in either width or height) without further processing.
-//    This is to let programs in the wild set an upper bound to prevent
-//    denial-of-service attacks on untrusted data, as one could generate a
-//    valid image of gigantic dimensions and force stb_image to allocate a
-//    huge block of memory and spend disproportionate time decoding it. By
-//    default this is set to (1 << 24), which is 16777216, but that's still
-//    very big.
-
-#ifndef STBI_NO_STDIO
-#include <stdio.h>
-#endif // STBI_NO_STDIO
-
-#define STBI_VERSION 1
-
-enum
-{
-   STBI_default = 0, // only used for desired_channels
-
-   STBI_grey       = 1,
-   STBI_grey_alpha = 2,
-   STBI_rgb        = 3,
-   STBI_rgb_alpha  = 4
-};
-
-#include <stdlib.h>
-typedef unsigned char stbi_uc;
-typedef unsigned short stbi_us;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef STBIDEF
-#ifdef STB_IMAGE_STATIC
-#define STBIDEF static
-#else
-#define STBIDEF extern
-#endif
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// PRIMARY API - works on images of any type
-//
-
-//
-// load image by filename, open file, or memory buffer
-//
-
-typedef struct
-{
-   int      (*read)  (void *user,char *data,int size);   // fill 'data' with 'size' bytes.  return number of bytes actually read
-   void     (*skip)  (void *user,int n);                 // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
-   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data
-} stbi_io_callbacks;
-
-////////////////////////////////////
-//
-// 8-bits-per-channel interface
-//
-
-STBIDEF stbi_uc *stbi_load_from_memory   (stbi_uc           const *buffer, int len   , int *x, int *y, int *channels_in_file, int desired_channels);
-STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk  , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
-
-#ifndef STBI_NO_STDIO
-STBIDEF stbi_uc *stbi_load            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
-STBIDEF stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
-// for stbi_load_from_file, file pointer is left pointing immediately after image
-#endif
-
-#ifndef STBI_NO_GIF
-STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
-#endif
-
-#ifdef STBI_WINDOWS_UTF8
-STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
-#endif
-
-////////////////////////////////////
-//
-// 16-bits-per-channel interface
-//
-
-STBIDEF stbi_us *stbi_load_16_from_memory   (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
-STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
-
-#ifndef STBI_NO_STDIO
-STBIDEF stbi_us *stbi_load_16          (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
-STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
-#endif
-
-////////////////////////////////////
-//
-// float-per-channel interface
-//
-#ifndef STBI_NO_LINEAR
-   STBIDEF float *stbi_loadf_from_memory     (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
-   STBIDEF float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y,  int *channels_in_file, int desired_channels);
-
-   #ifndef STBI_NO_STDIO
-   STBIDEF float *stbi_loadf            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
-   STBIDEF float *stbi_loadf_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
-   #endif
-#endif
-
-#ifndef STBI_NO_HDR
-   STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma);
-   STBIDEF void   stbi_hdr_to_ldr_scale(float scale);
-#endif // STBI_NO_HDR
-
-#ifndef STBI_NO_LINEAR
-   STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma);
-   STBIDEF void   stbi_ldr_to_hdr_scale(float scale);
-#endif // STBI_NO_LINEAR
-
-// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
-STBIDEF int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
-STBIDEF int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
-#ifndef STBI_NO_STDIO
-STBIDEF int      stbi_is_hdr          (char const *filename);
-STBIDEF int      stbi_is_hdr_from_file(FILE *f);
-#endif // STBI_NO_STDIO
-
-
-// get a VERY brief reason for failure
-// on most compilers (and ALL modern mainstream compilers) this is threadsafe
-STBIDEF const char *stbi_failure_reason  (void);
-
-// free the loaded image -- this is just free()
-STBIDEF void     stbi_image_free      (void *retval_from_stbi_load);
-
-// get image dimensions & components without fully decoding
-STBIDEF int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
-STBIDEF int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
-STBIDEF int      stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
-STBIDEF int      stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);
-
-#ifndef STBI_NO_STDIO
-STBIDEF int      stbi_info               (char const *filename,     int *x, int *y, int *comp);
-STBIDEF int      stbi_info_from_file     (FILE *f,                  int *x, int *y, int *comp);
-STBIDEF int      stbi_is_16_bit          (char const *filename);
-STBIDEF int      stbi_is_16_bit_from_file(FILE *f);
-#endif
-
-
-
-// for image formats that explicitly notate that they have premultiplied alpha,
-// we just return the colors as stored in the file. set this flag to force
-// unpremultiplication. results are undefined if the unpremultiply overflow.
-STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
-
-// indicate whether we should process iphone images back to canonical format,
-// or just pass them through "as-is"
-STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
-
-// flip the image vertically, so the first pixel in the output array is the bottom left
-STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
-
-// as above, but only applies to images loaded on the thread that calls the function
-// this function is only available if your compiler supports thread-local variables;
-// calling it will fail to link if your compiler doesn't
-STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply);
-STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert);
-STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);
-
-// ZLIB client - used by PNG, available for other purposes
-
-STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
-STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
-STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
-STBIDEF int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
-
-STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
-STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-//
-//
-////   end header file   /////////////////////////////////////////////////////
-#endif // STBI_INCLUDE_STB_IMAGE_H
-
-#ifdef STB_IMAGE_IMPLEMENTATION
-
-#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
-  || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
-  || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
-  || defined(STBI_ONLY_ZLIB)
-   #ifndef STBI_ONLY_JPEG
-   #define STBI_NO_JPEG
-   #endif
-   #ifndef STBI_ONLY_PNG
-   #define STBI_NO_PNG
-   #endif
-   #ifndef STBI_ONLY_BMP
-   #define STBI_NO_BMP
-   #endif
-   #ifndef STBI_ONLY_PSD
-   #define STBI_NO_PSD
-   #endif
-   #ifndef STBI_ONLY_TGA
-   #define STBI_NO_TGA
-   #endif
-   #ifndef STBI_ONLY_GIF
-   #define STBI_NO_GIF
-   #endif
-   #ifndef STBI_ONLY_HDR
-   #define STBI_NO_HDR
-   #endif
-   #ifndef STBI_ONLY_PIC
-   #define STBI_NO_PIC
-   #endif
-   #ifndef STBI_ONLY_PNM
-   #define STBI_NO_PNM
-   #endif
-#endif
-
-#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
-#define STBI_NO_ZLIB
-#endif
-
-
-#include <stdarg.h>
-#include <stddef.h> // ptrdiff_t on osx
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-
-#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
-#include <math.h>  // ldexp, pow
-#endif
-
-#ifndef STBI_NO_STDIO
-#include <stdio.h>
-#endif
-
-#ifndef STBI_ASSERT
-#include <assert.h>
-#define STBI_ASSERT(x) assert(x)
-#endif
-
-#ifdef __cplusplus
-#define STBI_EXTERN extern "C"
-#else
-#define STBI_EXTERN extern
-#endif
-
-
-#ifndef _MSC_VER
-   #ifdef __cplusplus
-   #define stbi_inline inline
-   #else
-   #define stbi_inline
-   #endif
-#else
-   #define stbi_inline __forceinline
-#endif
-
-#ifndef STBI_NO_THREAD_LOCALS
-   #if defined(__cplusplus) &&  __cplusplus >= 201103L
-      #define STBI_THREAD_LOCAL       thread_local
-   #elif defined(__GNUC__) && __GNUC__ < 5
-      #define STBI_THREAD_LOCAL       __thread
-   #elif defined(_MSC_VER)
-      #define STBI_THREAD_LOCAL       __declspec(thread)
-   #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
-      #define STBI_THREAD_LOCAL       _Thread_local
-   #endif
-
-   #ifndef STBI_THREAD_LOCAL
-      #if defined(__GNUC__)
-        #define STBI_THREAD_LOCAL       __thread
-      #endif
-   #endif
-#endif
-
-#if defined(_MSC_VER) || defined(__SYMBIAN32__)
-typedef unsigned short stbi__uint16;
-typedef   signed short stbi__int16;
-typedef unsigned int   stbi__uint32;
-typedef   signed int   stbi__int32;
-#else
-#include <stdint.h>
-typedef uint16_t stbi__uint16;
-typedef int16_t  stbi__int16;
-typedef uint32_t stbi__uint32;
-typedef int32_t  stbi__int32;
-#endif
-
-// should produce compiler error if size is wrong
-typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
-
-#ifdef _MSC_VER
-#define STBI_NOTUSED(v)  (void)(v)
-#else
-#define STBI_NOTUSED(v)  (void)sizeof(v)
-#endif
-
-#ifdef _MSC_VER
-#define STBI_HAS_LROTL
-#endif
-
-#ifdef STBI_HAS_LROTL
-   #define stbi_lrot(x,y)  _lrotl(x,y)
-#else
-   #define stbi_lrot(x,y)  (((x) << (y)) | ((x) >> (-(y) & 31)))
-#endif
-
-#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
-// ok
-#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
-// ok
-#else
-#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
-#endif
-
-#ifndef STBI_MALLOC
-#define STBI_MALLOC(sz)           malloc(sz)
-#define STBI_REALLOC(p,newsz)     realloc(p,newsz)
-#define STBI_FREE(p)              free(p)
-#endif
-
-#ifndef STBI_REALLOC_SIZED
-#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
-#endif
-
-// x86/x64 detection
-#if defined(__x86_64__) || defined(_M_X64)
-#define STBI__X64_TARGET
-#elif defined(__i386) || defined(_M_IX86)
-#define STBI__X86_TARGET
-#endif
-
-#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
-// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
-// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
-// but previous attempts to provide the SSE2 functions with runtime
-// detection caused numerous issues. The way architecture extensions are
-// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
-// New behavior: if compiled with -msse2, we use SSE2 without any
-// detection; if not, we don't use it at all.
-#define STBI_NO_SIMD
-#endif
-
-#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
-// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
-//
-// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
-// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
-// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
-// simultaneously enabling "-mstackrealign".
-//
-// See https://github.com/nothings/stb/issues/81 for more information.
-//
-// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
-// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
-#define STBI_NO_SIMD
-#endif
-
-#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
-#define STBI_SSE2
-#include <emmintrin.h>
-
-#ifdef _MSC_VER
-
-#if _MSC_VER >= 1400  // not VC6
-#include <intrin.h> // __cpuid
-static int stbi__cpuid3(void)
-{
-   int info[4];
-   __cpuid(info,1);
-   return info[3];
-}
-#else
-static int stbi__cpuid3(void)
-{
-   int res;
-   __asm {
-      mov  eax,1
-      cpuid
-      mov  res,edx
-   }
-   return res;
-}
-#endif
-
-#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
-
-#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
-static int stbi__sse2_available(void)
-{
-   int info3 = stbi__cpuid3();
-   return ((info3 >> 26) & 1) != 0;
-}
-#endif
-
-#else // assume GCC-style if not VC++
-#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
-
-#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
-static int stbi__sse2_available(void)
-{
-   // If we're even attempting to compile this on GCC/Clang, that means
-   // -msse2 is on, which means the compiler is allowed to use SSE2
-   // instructions at will, and so are we.
-   return 1;
-}
-#endif
-
-#endif
-#endif
-
-// ARM NEON
-#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
-#undef STBI_NEON
-#endif
-
-#ifdef STBI_NEON
-#include <arm_neon.h>
-#ifdef _MSC_VER
-#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
-#else
-#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
-#endif
-#endif
-
-#ifndef STBI_SIMD_ALIGN
-#define STBI_SIMD_ALIGN(type, name) type name
-#endif
-
-#ifndef STBI_MAX_DIMENSIONS
-#define STBI_MAX_DIMENSIONS (1 << 24)
-#endif
-
-///////////////////////////////////////////////
-//
-//  stbi__context struct and start_xxx functions
-
-// stbi__context structure is our basic context used by all images, so it
-// contains all the IO context, plus some basic image information
-typedef struct
-{
-   stbi__uint32 img_x, img_y;
-   int img_n, img_out_n;
-
-   stbi_io_callbacks io;
-   void *io_user_data;
-
-   int read_from_callbacks;
-   int buflen;
-   stbi_uc buffer_start[128];
-   int callback_already_read;
-
-   stbi_uc *img_buffer, *img_buffer_end;
-   stbi_uc *img_buffer_original, *img_buffer_original_end;
-} stbi__context;
-
-
-static void stbi__refill_buffer(stbi__context *s);
-
-// initialize a memory-decode context
-static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
-{
-   s->io.read = NULL;
-   s->read_from_callbacks = 0;
-   s->callback_already_read = 0;
-   s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
-   s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
-}
-
-// initialize a callback-based context
-static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
-{
-   s->io = *c;
-   s->io_user_data = user;
-   s->buflen = sizeof(s->buffer_start);
-   s->read_from_callbacks = 1;
-   s->callback_already_read = 0;
-   s->img_buffer = s->img_buffer_original = s->buffer_start;
-   stbi__refill_buffer(s);
-   s->img_buffer_original_end = s->img_buffer_end;
-}
-
-#ifndef STBI_NO_STDIO
-
-static int stbi__stdio_read(void *user, char *data, int size)
-{
-   return (int) fread(data,1,size,(FILE*) user);
-}
-
-static void stbi__stdio_skip(void *user, int n)
-{
-   int ch;
-   fseek((FILE*) user, n, SEEK_CUR);
-   ch = fgetc((FILE*) user);  /* have to read a byte to reset feof()'s flag */
-   if (ch != EOF) {
-      ungetc(ch, (FILE *) user);  /* push byte back onto stream if valid. */
-   }
-}
-
-static int stbi__stdio_eof(void *user)
-{
-   return feof((FILE*) user) || ferror((FILE *) user);
-}
-
-static stbi_io_callbacks stbi__stdio_callbacks =
-{
-   stbi__stdio_read,
-   stbi__stdio_skip,
-   stbi__stdio_eof,
-};
-
-static void stbi__start_file(stbi__context *s, FILE *f)
-{
-   stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
-}
-
-//static void stop_file(stbi__context *s) { }
-
-#endif // !STBI_NO_STDIO
-
-static void stbi__rewind(stbi__context *s)
-{
-   // conceptually rewind SHOULD rewind to the beginning of the stream,
-   // but we just rewind to the beginning of the initial buffer, because
-   // we only use it after doing 'test', which only ever looks at at most 92 bytes
-   s->img_buffer = s->img_buffer_original;
-   s->img_buffer_end = s->img_buffer_original_end;
-}
-
-enum
-{
-   STBI_ORDER_RGB,
-   STBI_ORDER_BGR
-};
-
-typedef struct
-{
-   int bits_per_channel;
-   int num_channels;
-   int channel_order;
-} stbi__result_info;
-
-#ifndef STBI_NO_JPEG
-static int      stbi__jpeg_test(stbi__context *s);
-static void    *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
-static int      stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_PNG
-static int      stbi__png_test(stbi__context *s);
-static void    *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
-static int      stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
-static int      stbi__png_is16(stbi__context *s);
-#endif
-
-#ifndef STBI_NO_BMP
-static int      stbi__bmp_test(stbi__context *s);
-static void    *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
-static int      stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_TGA
-static int      stbi__tga_test(stbi__context *s);
-static void    *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
-static int      stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_PSD
-static int      stbi__psd_test(stbi__context *s);
-static void    *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);
-static int      stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
-static int      stbi__psd_is16(stbi__context *s);
-#endif
-
-#ifndef STBI_NO_HDR
-static int      stbi__hdr_test(stbi__context *s);
-static float   *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
-static int      stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_PIC
-static int      stbi__pic_test(stbi__context *s);
-static void    *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
-static int      stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_GIF
-static int      stbi__gif_test(stbi__context *s);
-static void    *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
-static void    *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
-static int      stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
-#endif
-
-#ifndef STBI_NO_PNM
-static int      stbi__pnm_test(stbi__context *s);
-static void    *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
-static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
-static int      stbi__pnm_is16(stbi__context *s);
-#endif
-
-static
-#ifdef STBI_THREAD_LOCAL
-STBI_THREAD_LOCAL
-#endif
-const char *stbi__g_failure_reason;
-
-STBIDEF const char *stbi_failure_reason(void)
-{
-   return stbi__g_failure_reason;
-}
-
-#ifndef STBI_NO_FAILURE_STRINGS
-static int stbi__err(const char *str)
-{
-   stbi__g_failure_reason = str;
-   return 0;
-}
-#endif
-
-static void *stbi__malloc(size_t size)
-{
-    return STBI_MALLOC(size);
-}
-
-// stb_image uses ints pervasively, including for offset calculations.
-// therefore the largest decoded image size we can support with the
-// current code, even on 64-bit targets, is INT_MAX. this is not a
-// significant limitation for the intended use case.
-//
-// we do, however, need to make sure our size calculations don't
-// overflow. hence a few helper functions for size calculations that
-// multiply integers together, making sure that they're non-negative
-// and no overflow occurs.
-
-// return 1 if the sum is valid, 0 on overflow.
-// negative terms are considered invalid.
-static int stbi__addsizes_valid(int a, int b)
-{
-   if (b < 0) return 0;
-   // now 0 <= b <= INT_MAX, hence also
-   // 0 <= INT_MAX - b <= INTMAX.
-   // And "a + b <= INT_MAX" (which might overflow) is the
-   // same as a <= INT_MAX - b (no overflow)
-   return a <= INT_MAX - b;
-}
-
-// returns 1 if the product is valid, 0 on overflow.
-// negative factors are considered invalid.
-static int stbi__mul2sizes_valid(int a, int b)
-{
-   if (a < 0 || b < 0) return 0;
-   if (b == 0) return 1; // mul-by-0 is always safe
-   // portable way to check for no overflows in a*b
-   return a <= INT_MAX/b;
-}
-
-#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
-// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
-static int stbi__mad2sizes_valid(int a, int b, int add)
-{
-   return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
-}
-#endif
-
-// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
-static int stbi__mad3sizes_valid(int a, int b, int c, int add)
-{
-   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
-      stbi__addsizes_valid(a*b*c, add);
-}
-
-// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
-#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
-static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
-{
-   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
-      stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
-}
-#endif
-
-#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
-// mallocs with size overflow checking
-static void *stbi__malloc_mad2(int a, int b, int add)
-{
-   if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
-   return stbi__malloc(a*b + add);
-}
-#endif
-
-static void *stbi__malloc_mad3(int a, int b, int c, int add)
-{
-   if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
-   return stbi__malloc(a*b*c + add);
-}
-
-#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
-static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
-{
-   if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
-   return stbi__malloc(a*b*c*d + add);
-}
-#endif
-
-// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.
-static int stbi__addints_valid(int a, int b)
-{
-   if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow
-   if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.
-   return a <= INT_MAX - b;
-}
-
-// returns 1 if the product of two signed shorts is valid, 0 on overflow.
-static int stbi__mul2shorts_valid(short a, short b)
-{
-   if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow
-   if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid
-   if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN
-   return a >= SHRT_MIN / b;
-}
-
-// stbi__err - error
-// stbi__errpf - error returning pointer to float
-// stbi__errpuc - error returning pointer to unsigned char
-
-#ifdef STBI_NO_FAILURE_STRINGS
-   #define stbi__err(x,y)  0
-#elif defined(STBI_FAILURE_USERMSG)
-   #define stbi__err(x,y)  stbi__err(y)
-#else
-   #define stbi__err(x,y)  stbi__err(x)
-#endif
-
-#define stbi__errpf(x,y)   ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
-#define stbi__errpuc(x,y)  ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
-
-STBIDEF void stbi_image_free(void *retval_from_stbi_load)
-{
-   STBI_FREE(retval_from_stbi_load);
-}
-
-#ifndef STBI_NO_LINEAR
-static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
-#endif
-
-#ifndef STBI_NO_HDR
-static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp);
-#endif
-
-static int stbi__vertically_flip_on_load_global = 0;
-
-STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
-{
-   stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
-}
-
-#ifndef STBI_THREAD_LOCAL
-#define stbi__vertically_flip_on_load  stbi__vertically_flip_on_load_global
-#else
-static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
-
-STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
-{
-   stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
-   stbi__vertically_flip_on_load_set = 1;
-}
-
-#define stbi__vertically_flip_on_load  (stbi__vertically_flip_on_load_set       \
-                                         ? stbi__vertically_flip_on_load_local  \
-                                         : stbi__vertically_flip_on_load_global)
-#endif // STBI_THREAD_LOCAL
-
-static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
-{
-   memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
-   ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
-   ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
-   ri->num_channels = 0;
-
-   // test the formats with a very explicit header first (at least a FOURCC
-   // or distinctive magic number first)
-   #ifndef STBI_NO_PNG
-   if (stbi__png_test(s))  return stbi__png_load(s,x,y,comp,req_comp, ri);
-   #endif
-   #ifndef STBI_NO_BMP
-   if (stbi__bmp_test(s))  return stbi__bmp_load(s,x,y,comp,req_comp, ri);
-   #endif
-   #ifndef STBI_NO_GIF
-   if (stbi__gif_test(s))  return stbi__gif_load(s,x,y,comp,req_comp, ri);
-   #endif
-   #ifndef STBI_NO_PSD
-   if (stbi__psd_test(s))  return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
-   #else
-   STBI_NOTUSED(bpc);
-   #endif
-   #ifndef STBI_NO_PIC
-   if (stbi__pic_test(s))  return stbi__pic_load(s,x,y,comp,req_comp, ri);
-   #endif
-
-   // then the formats that can end up attempting to load with just 1 or 2
-   // bytes matching expectations; these are prone to false positives, so
-   // try them later
-   #ifndef STBI_NO_JPEG
-   if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
-   #endif
-   #ifndef STBI_NO_PNM
-   if (stbi__pnm_test(s))  return stbi__pnm_load(s,x,y,comp,req_comp, ri);
-   #endif
-
-   #ifndef STBI_NO_HDR
-   if (stbi__hdr_test(s)) {
-      float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
-      return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
-   }
-   #endif
-
-   #ifndef STBI_NO_TGA
-   // test tga last because it's a crappy test!
-   if (stbi__tga_test(s))
-      return stbi__tga_load(s,x,y,comp,req_comp, ri);
-   #endif
-
-   return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
-}
-
-static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
-{
-   int i;
-   int img_len = w * h * channels;
-   stbi_uc *reduced;
-
-   reduced = (stbi_uc *) stbi__malloc(img_len);
-   if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
-
-   for (i = 0; i < img_len; ++i)
-      reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
-
-   STBI_FREE(orig);
-   return reduced;
-}
-
-static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
-{
-   int i;
-   int img_len = w * h * channels;
-   stbi__uint16 *enlarged;
-
-   enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
-   if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
-
-   for (i = 0; i < img_len; ++i)
-      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
-
-   STBI_FREE(orig);
-   return enlarged;
-}
-
-static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
-{
-   int row;
-   size_t bytes_per_row = (size_t)w * bytes_per_pixel;
-   stbi_uc temp[2048];
-   stbi_uc *bytes = (stbi_uc *)image;
-
-   for (row = 0; row < (h>>1); row++) {
-      stbi_uc *row0 = bytes + row*bytes_per_row;
-      stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
-      // swap row0 with row1
-      size_t bytes_left = bytes_per_row;
-      while (bytes_left) {
-         size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
-         memcpy(temp, row0, bytes_copy);
-         memcpy(row0, row1, bytes_copy);
-         memcpy(row1, temp, bytes_copy);
-         row0 += bytes_copy;
-         row1 += bytes_copy;
-         bytes_left -= bytes_copy;
-      }
-   }
-}
-
-#ifndef STBI_NO_GIF
-static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
-{
-   int slice;
-   int slice_size = w * h * bytes_per_pixel;
-
-   stbi_uc *bytes = (stbi_uc *)image;
-   for (slice = 0; slice < z; ++slice) {
-      stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
-      bytes += slice_size;
-   }
-}
-#endif
-
-static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__result_info ri;
-   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
-
-   if (result == NULL)
-      return NULL;
-
-   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
-   STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
-
-   if (ri.bits_per_channel != 8) {
-      result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
-      ri.bits_per_channel = 8;
-   }
-
-   // @TODO: move stbi__convert_format to here
-
-   if (stbi__vertically_flip_on_load) {
-      int channels = req_comp ? req_comp : *comp;
-      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
-   }
-
-   return (unsigned char *) result;
-}
-
-static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__result_info ri;
-   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
-
-   if (result == NULL)
-      return NULL;
-
-   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
-   STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
-
-   if (ri.bits_per_channel != 16) {
-      result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
-      ri.bits_per_channel = 16;
-   }
-
-   // @TODO: move stbi__convert_format16 to here
-   // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
-
-   if (stbi__vertically_flip_on_load) {
-      int channels = req_comp ? req_comp : *comp;
-      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
-   }
-
-   return (stbi__uint16 *) result;
-}
-
-#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
-static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
-{
-   if (stbi__vertically_flip_on_load && result != NULL) {
-      int channels = req_comp ? req_comp : *comp;
-      stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
-   }
-}
-#endif
-
-#ifndef STBI_NO_STDIO
-
-#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
-STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
-STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
-#endif
-
-#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
-STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
-{
-	return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
-}
-#endif
-
-static FILE *stbi__fopen(char const *filename, char const *mode)
-{
-   FILE *f;
-#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
-   wchar_t wMode[64];
-   wchar_t wFilename[1024];
-	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
-      return 0;
-
-	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
-      return 0;
-
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-	if (0 != _wfopen_s(&f, wFilename, wMode))
-		f = 0;
-#else
-   f = _wfopen(wFilename, wMode);
-#endif
-
-#elif defined(_MSC_VER) && _MSC_VER >= 1400
-   if (0 != fopen_s(&f, filename, mode))
-      f=0;
-#else
-   f = fopen(filename, mode);
-#endif
-   return f;
-}
-
-
-STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   FILE *f = stbi__fopen(filename, "rb");
-   unsigned char *result;
-   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
-   result = stbi_load_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *result;
-   stbi__context s;
-   stbi__start_file(&s,f);
-   result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
-   if (result) {
-      // need to 'unget' all the characters in the IO buffer
-      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
-   }
-   return result;
-}
-
-STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__uint16 *result;
-   stbi__context s;
-   stbi__start_file(&s,f);
-   result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
-   if (result) {
-      // need to 'unget' all the characters in the IO buffer
-      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
-   }
-   return result;
-}
-
-STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   FILE *f = stbi__fopen(filename, "rb");
-   stbi__uint16 *result;
-   if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
-   result = stbi_load_from_file_16(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-
-#endif //!STBI_NO_STDIO
-
-STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
-{
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
-}
-
-STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
-{
-   stbi__context s;
-   stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
-   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
-}
-
-STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
-}
-
-STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__context s;
-   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
-   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
-}
-
-#ifndef STBI_NO_GIF
-STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
-{
-   unsigned char *result;
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-
-   result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
-   if (stbi__vertically_flip_on_load) {
-      stbi__vertical_flip_slices( result, *x, *y, *z, *comp );
-   }
-
-   return result;
-}
-#endif
-
-#ifndef STBI_NO_LINEAR
-static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
-{
-   unsigned char *data;
-   #ifndef STBI_NO_HDR
-   if (stbi__hdr_test(s)) {
-      stbi__result_info ri;
-      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
-      if (hdr_data)
-         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
-      return hdr_data;
-   }
-   #endif
-   data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
-   if (data)
-      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
-   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
-}
-
-STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-   return stbi__loadf_main(&s,x,y,comp,req_comp);
-}
-
-STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__context s;
-   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
-   return stbi__loadf_main(&s,x,y,comp,req_comp);
-}
-
-#ifndef STBI_NO_STDIO
-STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
-{
-   float *result;
-   FILE *f = stbi__fopen(filename, "rb");
-   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
-   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
-   fclose(f);
-   return result;
-}
-
-STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
-{
-   stbi__context s;
-   stbi__start_file(&s,f);
-   return stbi__loadf_main(&s,x,y,comp,req_comp);
-}
-#endif // !STBI_NO_STDIO
-
-#endif // !STBI_NO_LINEAR
-
-// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
-// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
-// reports false!
-
-STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
-{
-   #ifndef STBI_NO_HDR
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-   return stbi__hdr_test(&s);
-   #else
-   STBI_NOTUSED(buffer);
-   STBI_NOTUSED(len);
-   return 0;
-   #endif
-}
-
-#ifndef STBI_NO_STDIO
-STBIDEF int      stbi_is_hdr          (char const *filename)
-{
-   FILE *f = stbi__fopen(filename, "rb");
-   int result=0;
-   if (f) {
-      result = stbi_is_hdr_from_file(f);
-      fclose(f);
-   }
-   return result;
-}
-
-STBIDEF int stbi_is_hdr_from_file(FILE *f)
-{
-   #ifndef STBI_NO_HDR
-   long pos = ftell(f);
-   int res;
-   stbi__context s;
-   stbi__start_file(&s,f);
-   res = stbi__hdr_test(&s);
-   fseek(f, pos, SEEK_SET);
-   return res;
-   #else
-   STBI_NOTUSED(f);
-   return 0;
-   #endif
-}
-#endif // !STBI_NO_STDIO
-
-STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
-{
-   #ifndef STBI_NO_HDR
-   stbi__context s;
-   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
-   return stbi__hdr_test(&s);
-   #else
-   STBI_NOTUSED(clbk);
-   STBI_NOTUSED(user);
-   return 0;
-   #endif
-}
-
-#ifndef STBI_NO_LINEAR
-static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
-
-STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
-STBIDEF void   stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
-#endif
-
-static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
-
-STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
-STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Common code used by all image loaders
-//
-
-enum
-{
-   STBI__SCAN_load=0,
-   STBI__SCAN_type,
-   STBI__SCAN_header
-};
-
-static void stbi__refill_buffer(stbi__context *s)
-{
-   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
-   s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
-   if (n == 0) {
-      // at end of file, treat same as if from memory, but need to handle case
-      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
-      s->read_from_callbacks = 0;
-      s->img_buffer = s->buffer_start;
-      s->img_buffer_end = s->buffer_start+1;
-      *s->img_buffer = 0;
-   } else {
-      s->img_buffer = s->buffer_start;
-      s->img_buffer_end = s->buffer_start + n;
-   }
-}
-
-stbi_inline static stbi_uc stbi__get8(stbi__context *s)
-{
-   if (s->img_buffer < s->img_buffer_end)
-      return *s->img_buffer++;
-   if (s->read_from_callbacks) {
-      stbi__refill_buffer(s);
-      return *s->img_buffer++;
-   }
-   return 0;
-}
-
-#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
-// nothing
-#else
-stbi_inline static int stbi__at_eof(stbi__context *s)
-{
-   if (s->io.read) {
-      if (!(s->io.eof)(s->io_user_data)) return 0;
-      // if feof() is true, check if buffer = end
-      // special case: we've only got the special 0 character at the end
-      if (s->read_from_callbacks == 0) return 1;
-   }
-
-   return s->img_buffer >= s->img_buffer_end;
-}
-#endif
-
-#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
-// nothing
-#else
-static void stbi__skip(stbi__context *s, int n)
-{
-   if (n == 0) return;  // already there!
-   if (n < 0) {
-      s->img_buffer = s->img_buffer_end;
-      return;
-   }
-   if (s->io.read) {
-      int blen = (int) (s->img_buffer_end - s->img_buffer);
-      if (blen < n) {
-         s->img_buffer = s->img_buffer_end;
-         (s->io.skip)(s->io_user_data, n - blen);
-         return;
-      }
-   }
-   s->img_buffer += n;
-}
-#endif
-
-#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
-// nothing
-#else
-static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
-{
-   if (s->io.read) {
-      int blen = (int) (s->img_buffer_end - s->img_buffer);
-      if (blen < n) {
-         int res, count;
-
-         memcpy(buffer, s->img_buffer, blen);
-
-         count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
-         res = (count == (n-blen));
-         s->img_buffer = s->img_buffer_end;
-         return res;
-      }
-   }
-
-   if (s->img_buffer+n <= s->img_buffer_end) {
-      memcpy(buffer, s->img_buffer, n);
-      s->img_buffer += n;
-      return 1;
-   } else
-      return 0;
-}
-#endif
-
-#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
-// nothing
-#else
-static int stbi__get16be(stbi__context *s)
-{
-   int z = stbi__get8(s);
-   return (z << 8) + stbi__get8(s);
-}
-#endif
-
-#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
-// nothing
-#else
-static stbi__uint32 stbi__get32be(stbi__context *s)
-{
-   stbi__uint32 z = stbi__get16be(s);
-   return (z << 16) + stbi__get16be(s);
-}
-#endif
-
-#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
-// nothing
-#else
-static int stbi__get16le(stbi__context *s)
-{
-   int z = stbi__get8(s);
-   return z + (stbi__get8(s) << 8);
-}
-#endif
-
-#ifndef STBI_NO_BMP
-static stbi__uint32 stbi__get32le(stbi__context *s)
-{
-   stbi__uint32 z = stbi__get16le(s);
-   z += (stbi__uint32)stbi__get16le(s) << 16;
-   return z;
-}
-#endif
-
-#define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))  // truncate int to byte without warnings
-
-#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
-// nothing
-#else
-//////////////////////////////////////////////////////////////////////////////
-//
-//  generic converter from built-in img_n to req_comp
-//    individual types do this automatically as much as possible (e.g. jpeg
-//    does all cases internally since it needs to colorspace convert anyway,
-//    and it never has alpha, so very few cases ). png can automatically
-//    interleave an alpha=255 channel, but falls back to this for other cases
-//
-//  assume data buffer is malloced, so malloc a new one and free that one
-//  only failure mode is malloc failing
-
-static stbi_uc stbi__compute_y(int r, int g, int b)
-{
-   return (stbi_uc) (((r*77) + (g*150) +  (29*b)) >> 8);
-}
-#endif
-
-#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
-// nothing
-#else
-static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
-{
-   int i,j;
-   unsigned char *good;
-
-   if (req_comp == img_n) return data;
-   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
-
-   good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
-   if (good == NULL) {
-      STBI_FREE(data);
-      return stbi__errpuc("outofmem", "Out of memory");
-   }
-
-   for (j=0; j < (int) y; ++j) {
-      unsigned char *src  = data + j * x * img_n   ;
-      unsigned char *dest = good + j * x * req_comp;
-
-      #define STBI__COMBO(a,b)  ((a)*8+(b))
-      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
-      // convert source image with img_n components to one with req_comp components;
-      // avoid switch per pixel, so use switch per scanline and massive macros
-      switch (STBI__COMBO(img_n, req_comp)) {
-         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255;                                     } break;
-         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
-         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255;                     } break;
-         STBI__CASE(2,1) { dest[0]=src[0];                                                  } break;
-         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
-         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                  } break;
-         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255;        } break;
-         STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255;    } break;
-         STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
-         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                    } break;
-         default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
-      }
-      #undef STBI__CASE
-   }
-
-   STBI_FREE(data);
-   return good;
-}
-#endif
-
-#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
-// nothing
-#else
-static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
-{
-   return (stbi__uint16) (((r*77) + (g*150) +  (29*b)) >> 8);
-}
-#endif
-
-#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
-// nothing
-#else
-static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
-{
-   int i,j;
-   stbi__uint16 *good;
-
-   if (req_comp == img_n) return data;
-   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
-
-   good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
-   if (good == NULL) {
-      STBI_FREE(data);
-      return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
-   }
-
-   for (j=0; j < (int) y; ++j) {
-      stbi__uint16 *src  = data + j * x * img_n   ;
-      stbi__uint16 *dest = good + j * x * req_comp;
-
-      #define STBI__COMBO(a,b)  ((a)*8+(b))
-      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
-      // convert source image with img_n components to one with req_comp components;
-      // avoid switch per pixel, so use switch per scanline and massive macros
-      switch (STBI__COMBO(img_n, req_comp)) {
-         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff;                                     } break;
-         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
-         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff;                     } break;
-         STBI__CASE(2,1) { dest[0]=src[0];                                                     } break;
-         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
-         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                     } break;
-         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff;        } break;
-         STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
-         STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
-         STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
-         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                       } break;
-         default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");
-      }
-      #undef STBI__CASE
-   }
-
-   STBI_FREE(data);
-   return good;
-}
-#endif
-
-#ifndef STBI_NO_LINEAR
-static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
-{
-   int i,k,n;
-   float *output;
-   if (!data) return NULL;
-   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
-   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
-   // compute number of non-alpha components
-   if (comp & 1) n = comp; else n = comp-1;
-   for (i=0; i < x*y; ++i) {
-      for (k=0; k < n; ++k) {
-         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
-      }
-   }
-   if (n < comp) {
-      for (i=0; i < x*y; ++i) {
-         output[i*comp + n] = data[i*comp + n]/255.0f;
-      }
-   }
-   STBI_FREE(data);
-   return output;
-}
-#endif
-
-#ifndef STBI_NO_HDR
-#define stbi__float2int(x)   ((int) (x))
-static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)
-{
-   int i,k,n;
-   stbi_uc *output;
-   if (!data) return NULL;
-   output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
-   if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
-   // compute number of non-alpha components
-   if (comp & 1) n = comp; else n = comp-1;
-   for (i=0; i < x*y; ++i) {
-      for (k=0; k < n; ++k) {
-         float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
-         if (z < 0) z = 0;
-         if (z > 255) z = 255;
-         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
-      }
-      if (k < comp) {
-         float z = data[i*comp+k] * 255 + 0.5f;
-         if (z < 0) z = 0;
-         if (z > 255) z = 255;
-         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
-      }
-   }
-   STBI_FREE(data);
-   return output;
-}
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//  "baseline" JPEG/JFIF decoder
-//
-//    simple implementation
-//      - doesn't support delayed output of y-dimension
-//      - simple interface (only one output format: 8-bit interleaved RGB)
-//      - doesn't try to recover corrupt jpegs
-//      - doesn't allow partial loading, loading multiple at once
-//      - still fast on x86 (copying globals into locals doesn't help x86)
-//      - allocates lots of intermediate memory (full size of all components)
-//        - non-interleaved case requires this anyway
-//        - allows good upsampling (see next)
-//    high-quality
-//      - upsampled channels are bilinearly interpolated, even across blocks
-//      - quality integer IDCT derived from IJG's 'slow'
-//    performance
-//      - fast huffman; reasonable integer IDCT
-//      - some SIMD kernels for common paths on targets with SSE2/NEON
-//      - uses a lot of intermediate memory, could cache poorly
-
-#ifndef STBI_NO_JPEG
-
-// huffman decoding acceleration
-#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
-
-typedef struct
-{
-   stbi_uc  fast[1 << FAST_BITS];
-   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
-   stbi__uint16 code[256];
-   stbi_uc  values[256];
-   stbi_uc  size[257];
-   unsigned int maxcode[18];
-   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
-} stbi__huffman;
-
-typedef struct
-{
-   stbi__context *s;
-   stbi__huffman huff_dc[4];
-   stbi__huffman huff_ac[4];
-   stbi__uint16 dequant[4][64];
-   stbi__int16 fast_ac[4][1 << FAST_BITS];
-
-// sizes for components, interleaved MCUs
-   int img_h_max, img_v_max;
-   int img_mcu_x, img_mcu_y;
-   int img_mcu_w, img_mcu_h;
-
-// definition of jpeg image component
-   struct
-   {
-      int id;
-      int h,v;
-      int tq;
-      int hd,ha;
-      int dc_pred;
-
-      int x,y,w2,h2;
-      stbi_uc *data;
-      void *raw_data, *raw_coeff;
-      stbi_uc *linebuf;
-      short   *coeff;   // progressive only
-      int      coeff_w, coeff_h; // number of 8x8 coefficient blocks
-   } img_comp[4];
-
-   stbi__uint32   code_buffer; // jpeg entropy-coded buffer
-   int            code_bits;   // number of valid bits
-   unsigned char  marker;      // marker seen while filling entropy buffer
-   int            nomore;      // flag if we saw a marker so must stop
-
-   int            progressive;
-   int            spec_start;
-   int            spec_end;
-   int            succ_high;
-   int            succ_low;
-   int            eob_run;
-   int            jfif;
-   int            app14_color_transform; // Adobe APP14 tag
-   int            rgb;
-
-   int scan_n, order[4];
-   int restart_interval, todo;
-
-// kernels
-   void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
-   void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
-   stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
-} stbi__jpeg;
-
-static int stbi__build_huffman(stbi__huffman *h, int *count)
-{
-   int i,j,k=0;
-   unsigned int code;
-   // build size list for each symbol (from JPEG spec)
-   for (i=0; i < 16; ++i) {
-      for (j=0; j < count[i]; ++j) {
-         h->size[k++] = (stbi_uc) (i+1);
-         if(k >= 257) return stbi__err("bad size list","Corrupt JPEG");
-      }
-   }
-   h->size[k] = 0;
-
-   // compute actual symbols (from jpeg spec)
-   code = 0;
-   k = 0;
-   for(j=1; j <= 16; ++j) {
-      // compute delta to add to code to compute symbol id
-      h->delta[j] = k - code;
-      if (h->size[k] == j) {
-         while (h->size[k] == j)
-            h->code[k++] = (stbi__uint16) (code++);
-         if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");
-      }
-      // compute largest code + 1 for this size, preshifted as needed later
-      h->maxcode[j] = code << (16-j);
-      code <<= 1;
-   }
-   h->maxcode[j] = 0xffffffff;
-
-   // build non-spec acceleration table; 255 is flag for not-accelerated
-   memset(h->fast, 255, 1 << FAST_BITS);
-   for (i=0; i < k; ++i) {
-      int s = h->size[i];
-      if (s <= FAST_BITS) {
-         int c = h->code[i] << (FAST_BITS-s);
-         int m = 1 << (FAST_BITS-s);
-         for (j=0; j < m; ++j) {
-            h->fast[c+j] = (stbi_uc) i;
-         }
-      }
-   }
-   return 1;
-}
-
-// build a table that decodes both magnitude and value of small ACs in
-// one go.
-static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
-{
-   int i;
-   for (i=0; i < (1 << FAST_BITS); ++i) {
-      stbi_uc fast = h->fast[i];
-      fast_ac[i] = 0;
-      if (fast < 255) {
-         int rs = h->values[fast];
-         int run = (rs >> 4) & 15;
-         int magbits = rs & 15;
-         int len = h->size[fast];
-
-         if (magbits && len + magbits <= FAST_BITS) {
-            // magnitude code followed by receive_extend code
-            int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
-            int m = 1 << (magbits - 1);
-            if (k < m) k += (~0U << magbits) + 1;
-            // if the result is small enough, we can fit it in fast_ac table
-            if (k >= -128 && k <= 127)
-               fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
-         }
-      }
-   }
-}
-
-static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
-{
-   do {
-      unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
-      if (b == 0xff) {
-         int c = stbi__get8(j->s);
-         while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
-         if (c != 0) {
-            j->marker = (unsigned char) c;
-            j->nomore = 1;
-            return;
-         }
-      }
-      j->code_buffer |= b << (24 - j->code_bits);
-      j->code_bits += 8;
-   } while (j->code_bits <= 24);
-}
-
-// (1 << n) - 1
-static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
-
-// decode a jpeg huffman value from the bitstream
-stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
-{
-   unsigned int temp;
-   int c,k;
-
-   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
-
-   // look at the top FAST_BITS and determine what symbol ID it is,
-   // if the code is <= FAST_BITS
-   c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
-   k = h->fast[c];
-   if (k < 255) {
-      int s = h->size[k];
-      if (s > j->code_bits)
-         return -1;
-      j->code_buffer <<= s;
-      j->code_bits -= s;
-      return h->values[k];
-   }
-
-   // naive test is to shift the code_buffer down so k bits are
-   // valid, then test against maxcode. To speed this up, we've
-   // preshifted maxcode left so that it has (16-k) 0s at the
-   // end; in other words, regardless of the number of bits, it
-   // wants to be compared against something shifted to have 16;
-   // that way we don't need to shift inside the loop.
-   temp = j->code_buffer >> 16;
-   for (k=FAST_BITS+1 ; ; ++k)
-      if (temp < h->maxcode[k])
-         break;
-   if (k == 17) {
-      // error! code not found
-      j->code_bits -= 16;
-      return -1;
-   }
-
-   if (k > j->code_bits)
-      return -1;
-
-   // convert the huffman code to the symbol id
-   c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
-   if(c < 0 || c >= 256) // symbol id out of bounds!
-       return -1;
-   STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
-
-   // convert the id to a symbol
-   j->code_bits -= k;
-   j->code_buffer <<= k;
-   return h->values[c];
-}
-
-// bias[n] = (-1<<n) + 1
-static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
-
-// combined JPEG 'receive' and JPEG 'extend', since baseline
-// always extends everything it receives.
-stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
-{
-   unsigned int k;
-   int sgn;
-   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
-   if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
-
-   sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)
-   k = stbi_lrot(j->code_buffer, n);
-   j->code_buffer = k & ~stbi__bmask[n];
-   k &= stbi__bmask[n];
-   j->code_bits -= n;
-   return k + (stbi__jbias[n] & (sgn - 1));
-}
-
-// get some unsigned bits
-stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
-{
-   unsigned int k;
-   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
-   if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
-   k = stbi_lrot(j->code_buffer, n);
-   j->code_buffer = k & ~stbi__bmask[n];
-   k &= stbi__bmask[n];
-   j->code_bits -= n;
-   return k;
-}
-
-stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
-{
-   unsigned int k;
-   if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
-   if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing
-   k = j->code_buffer;
-   j->code_buffer <<= 1;
-   --j->code_bits;
-   return k & 0x80000000;
-}
-
-// given a value that's at position X in the zigzag stream,
-// where does it appear in the 8x8 matrix coded as row-major?
-static const stbi_uc stbi__jpeg_dezigzag[64+15] =
-{
-    0,  1,  8, 16,  9,  2,  3, 10,
-   17, 24, 32, 25, 18, 11,  4,  5,
-   12, 19, 26, 33, 40, 48, 41, 34,
-   27, 20, 13,  6,  7, 14, 21, 28,
-   35, 42, 49, 56, 57, 50, 43, 36,
-   29, 22, 15, 23, 30, 37, 44, 51,
-   58, 59, 52, 45, 38, 31, 39, 46,
-   53, 60, 61, 54, 47, 55, 62, 63,
-   // let corrupt input sample past end
-   63, 63, 63, 63, 63, 63, 63, 63,
-   63, 63, 63, 63, 63, 63, 63
-};
-
-// decode one 64-entry block--
-static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
-{
-   int diff,dc,k;
-   int t;
-
-   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
-   t = stbi__jpeg_huff_decode(j, hdc);
-   if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG");
-
-   // 0 all the ac values now so we can do it 32-bits at a time
-   memset(data,0,64*sizeof(data[0]));
-
-   diff = t ? stbi__extend_receive(j, t) : 0;
-   if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG");
-   dc = j->img_comp[b].dc_pred + diff;
-   j->img_comp[b].dc_pred = dc;
-   if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
-   data[0] = (short) (dc * dequant[0]);
-
-   // decode AC components, see JPEG spec
-   k = 1;
-   do {
-      unsigned int zig;
-      int c,r,s;
-      if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
-      c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
-      r = fac[c];
-      if (r) { // fast-AC path
-         k += (r >> 4) & 15; // run
-         s = r & 15; // combined length
-         if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
-         j->code_buffer <<= s;
-         j->code_bits -= s;
-         // decode into unzigzag'd location
-         zig = stbi__jpeg_dezigzag[k++];
-         data[zig] = (short) ((r >> 8) * dequant[zig]);
-      } else {
-         int rs = stbi__jpeg_huff_decode(j, hac);
-         if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
-         s = rs & 15;
-         r = rs >> 4;
-         if (s == 0) {
-            if (rs != 0xf0) break; // end block
-            k += 16;
-         } else {
-            k += r;
-            // decode into unzigzag'd location
-            zig = stbi__jpeg_dezigzag[k++];
-            data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
-         }
-      }
-   } while (k < 64);
-   return 1;
-}
-
-static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
-{
-   int diff,dc;
-   int t;
-   if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
-
-   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
-
-   if (j->succ_high == 0) {
-      // first scan for DC coefficient, must be first
-      memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
-      t = stbi__jpeg_huff_decode(j, hdc);
-      if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
-      diff = t ? stbi__extend_receive(j, t) : 0;
-
-      if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG");
-      dc = j->img_comp[b].dc_pred + diff;
-      j->img_comp[b].dc_pred = dc;
-      if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
-      data[0] = (short) (dc * (1 << j->succ_low));
-   } else {
-      // refinement scan for DC coefficient
-      if (stbi__jpeg_get_bit(j))
-         data[0] += (short) (1 << j->succ_low);
-   }
-   return 1;
-}
-
-// @OPTIMIZE: store non-zigzagged during the decode passes,
-// and only de-zigzag when dequantizing
-static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
-{
-   int k;
-   if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
-
-   if (j->succ_high == 0) {
-      int shift = j->succ_low;
-
-      if (j->eob_run) {
-         --j->eob_run;
-         return 1;
-      }
-
-      k = j->spec_start;
-      do {
-         unsigned int zig;
-         int c,r,s;
-         if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
-         c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
-         r = fac[c];
-         if (r) { // fast-AC path
-            k += (r >> 4) & 15; // run
-            s = r & 15; // combined length
-            if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
-            j->code_buffer <<= s;
-            j->code_bits -= s;
-            zig = stbi__jpeg_dezigzag[k++];
-            data[zig] = (short) ((r >> 8) * (1 << shift));
-         } else {
-            int rs = stbi__jpeg_huff_decode(j, hac);
-            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
-            s = rs & 15;
-            r = rs >> 4;
-            if (s == 0) {
-               if (r < 15) {
-                  j->eob_run = (1 << r);
-                  if (r)
-                     j->eob_run += stbi__jpeg_get_bits(j, r);
-                  --j->eob_run;
-                  break;
-               }
-               k += 16;
-            } else {
-               k += r;
-               zig = stbi__jpeg_dezigzag[k++];
-               data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift));
-            }
-         }
-      } while (k <= j->spec_end);
-   } else {
-      // refinement scan for these AC coefficients
-
-      short bit = (short) (1 << j->succ_low);
-
-      if (j->eob_run) {
-         --j->eob_run;
-         for (k = j->spec_start; k <= j->spec_end; ++k) {
-            short *p = &data[stbi__jpeg_dezigzag[k]];
-            if (*p != 0)
-               if (stbi__jpeg_get_bit(j))
-                  if ((*p & bit)==0) {
-                     if (*p > 0)
-                        *p += bit;
-                     else
-                        *p -= bit;
-                  }
-         }
-      } else {
-         k = j->spec_start;
-         do {
-            int r,s;
-            int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
-            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
-            s = rs & 15;
-            r = rs >> 4;
-            if (s == 0) {
-               if (r < 15) {
-                  j->eob_run = (1 << r) - 1;
-                  if (r)
-                     j->eob_run += stbi__jpeg_get_bits(j, r);
-                  r = 64; // force end of block
-               } else {
-                  // r=15 s=0 should write 16 0s, so we just do
-                  // a run of 15 0s and then write s (which is 0),
-                  // so we don't have to do anything special here
-               }
-            } else {
-               if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
-               // sign bit
-               if (stbi__jpeg_get_bit(j))
-                  s = bit;
-               else
-                  s = -bit;
-            }
-
-            // advance by r
-            while (k <= j->spec_end) {
-               short *p = &data[stbi__jpeg_dezigzag[k++]];
-               if (*p != 0) {
-                  if (stbi__jpeg_get_bit(j))
-                     if ((*p & bit)==0) {
-                        if (*p > 0)
-                           *p += bit;
-                        else
-                           *p -= bit;
-                     }
-               } else {
-                  if (r == 0) {
-                     *p = (short) s;
-                     break;
-                  }
-                  --r;
-               }
-            }
-         } while (k <= j->spec_end);
-      }
-   }
-   return 1;
-}
-
-// take a -128..127 value and stbi__clamp it and convert to 0..255
-stbi_inline static stbi_uc stbi__clamp(int x)
-{
-   // trick to use a single test to catch both cases
-   if ((unsigned int) x > 255) {
-      if (x < 0) return 0;
-      if (x > 255) return 255;
-   }
-   return (stbi_uc) x;
-}
-
-#define stbi__f2f(x)  ((int) (((x) * 4096 + 0.5)))
-#define stbi__fsh(x)  ((x) * 4096)
-
-// derived from jidctint -- DCT_ISLOW
-#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
-   int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
-   p2 = s2;                                    \
-   p3 = s6;                                    \
-   p1 = (p2+p3) * stbi__f2f(0.5411961f);       \
-   t2 = p1 + p3*stbi__f2f(-1.847759065f);      \
-   t3 = p1 + p2*stbi__f2f( 0.765366865f);      \
-   p2 = s0;                                    \
-   p3 = s4;                                    \
-   t0 = stbi__fsh(p2+p3);                      \
-   t1 = stbi__fsh(p2-p3);                      \
-   x0 = t0+t3;                                 \
-   x3 = t0-t3;                                 \
-   x1 = t1+t2;                                 \
-   x2 = t1-t2;                                 \
-   t0 = s7;                                    \
-   t1 = s5;                                    \
-   t2 = s3;                                    \
-   t3 = s1;                                    \
-   p3 = t0+t2;                                 \
-   p4 = t1+t3;                                 \
-   p1 = t0+t3;                                 \
-   p2 = t1+t2;                                 \
-   p5 = (p3+p4)*stbi__f2f( 1.175875602f);      \
-   t0 = t0*stbi__f2f( 0.298631336f);           \
-   t1 = t1*stbi__f2f( 2.053119869f);           \
-   t2 = t2*stbi__f2f( 3.072711026f);           \
-   t3 = t3*stbi__f2f( 1.501321110f);           \
-   p1 = p5 + p1*stbi__f2f(-0.899976223f);      \
-   p2 = p5 + p2*stbi__f2f(-2.562915447f);      \
-   p3 = p3*stbi__f2f(-1.961570560f);           \
-   p4 = p4*stbi__f2f(-0.390180644f);           \
-   t3 += p1+p4;                                \
-   t2 += p2+p3;                                \
-   t1 += p2+p4;                                \
-   t0 += p1+p3;
-
-static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
-{
-   int i,val[64],*v=val;
-   stbi_uc *o;
-   short *d = data;
-
-   // columns
-   for (i=0; i < 8; ++i,++d, ++v) {
-      // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
-      if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
-           && d[40]==0 && d[48]==0 && d[56]==0) {
-         //    no shortcut                 0     seconds
-         //    (1|2|3|4|5|6|7)==0          0     seconds
-         //    all separate               -0.047 seconds
-         //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds
-         int dcterm = d[0]*4;
-         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
-      } else {
-         STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
-         // constants scaled things up by 1<<12; let's bring them back
-         // down, but keep 2 extra bits of precision
-         x0 += 512; x1 += 512; x2 += 512; x3 += 512;
-         v[ 0] = (x0+t3) >> 10;
-         v[56] = (x0-t3) >> 10;
-         v[ 8] = (x1+t2) >> 10;
-         v[48] = (x1-t2) >> 10;
-         v[16] = (x2+t1) >> 10;
-         v[40] = (x2-t1) >> 10;
-         v[24] = (x3+t0) >> 10;
-         v[32] = (x3-t0) >> 10;
-      }
-   }
-
-   for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
-      // no fast case since the first 1D IDCT spread components out
-      STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
-      // constants scaled things up by 1<<12, plus we had 1<<2 from first
-      // loop, plus horizontal and vertical each scale by sqrt(8) so together
-      // we've got an extra 1<<3, so 1<<17 total we need to remove.
-      // so we want to round that, which means adding 0.5 * 1<<17,
-      // aka 65536. Also, we'll end up with -128 to 127 that we want
-      // to encode as 0..255 by adding 128, so we'll add that before the shift
-      x0 += 65536 + (128<<17);
-      x1 += 65536 + (128<<17);
-      x2 += 65536 + (128<<17);
-      x3 += 65536 + (128<<17);
-      // tried computing the shifts into temps, or'ing the temps to see
-      // if any were out of range, but that was slower
-      o[0] = stbi__clamp((x0+t3) >> 17);
-      o[7] = stbi__clamp((x0-t3) >> 17);
-      o[1] = stbi__clamp((x1+t2) >> 17);
-      o[6] = stbi__clamp((x1-t2) >> 17);
-      o[2] = stbi__clamp((x2+t1) >> 17);
-      o[5] = stbi__clamp((x2-t1) >> 17);
-      o[3] = stbi__clamp((x3+t0) >> 17);
-      o[4] = stbi__clamp((x3-t0) >> 17);
-   }
-}
-
-#ifdef STBI_SSE2
-// sse2 integer IDCT. not the fastest possible implementation but it
-// produces bit-identical results to the generic C version so it's
-// fully "transparent".
-static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
-{
-   // This is constructed to match our regular (generic) integer IDCT exactly.
-   __m128i row0, row1, row2, row3, row4, row5, row6, row7;
-   __m128i tmp;
-
-   // dot product constant: even elems=x, odd elems=y
-   #define dct_const(x,y)  _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
-
-   // out(0) = c0[even]*x + c0[odd]*y   (c0, x, y 16-bit, out 32-bit)
-   // out(1) = c1[even]*x + c1[odd]*y
-   #define dct_rot(out0,out1, x,y,c0,c1) \
-      __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
-      __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
-      __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
-      __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
-      __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
-      __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
-
-   // out = in << 12  (in 16-bit, out 32-bit)
-   #define dct_widen(out, in) \
-      __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
-      __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
-
-   // wide add
-   #define dct_wadd(out, a, b) \
-      __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
-      __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
-
-   // wide sub
-   #define dct_wsub(out, a, b) \
-      __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
-      __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
-
-   // butterfly a/b, add bias, then shift by "s" and pack
-   #define dct_bfly32o(out0, out1, a,b,bias,s) \
-      { \
-         __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
-         __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
-         dct_wadd(sum, abiased, b); \
-         dct_wsub(dif, abiased, b); \
-         out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
-         out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
-      }
-
-   // 8-bit interleave step (for transposes)
-   #define dct_interleave8(a, b) \
-      tmp = a; \
-      a = _mm_unpacklo_epi8(a, b); \
-      b = _mm_unpackhi_epi8(tmp, b)
-
-   // 16-bit interleave step (for transposes)
-   #define dct_interleave16(a, b) \
-      tmp = a; \
-      a = _mm_unpacklo_epi16(a, b); \
-      b = _mm_unpackhi_epi16(tmp, b)
-
-   #define dct_pass(bias,shift) \
-      { \
-         /* even part */ \
-         dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
-         __m128i sum04 = _mm_add_epi16(row0, row4); \
-         __m128i dif04 = _mm_sub_epi16(row0, row4); \
-         dct_widen(t0e, sum04); \
-         dct_widen(t1e, dif04); \
-         dct_wadd(x0, t0e, t3e); \
-         dct_wsub(x3, t0e, t3e); \
-         dct_wadd(x1, t1e, t2e); \
-         dct_wsub(x2, t1e, t2e); \
-         /* odd part */ \
-         dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
-         dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
-         __m128i sum17 = _mm_add_epi16(row1, row7); \
-         __m128i sum35 = _mm_add_epi16(row3, row5); \
-         dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
-         dct_wadd(x4, y0o, y4o); \
-         dct_wadd(x5, y1o, y5o); \
-         dct_wadd(x6, y2o, y5o); \
-         dct_wadd(x7, y3o, y4o); \
-         dct_bfly32o(row0,row7, x0,x7,bias,shift); \
-         dct_bfly32o(row1,row6, x1,x6,bias,shift); \
-         dct_bfly32o(row2,row5, x2,x5,bias,shift); \
-         dct_bfly32o(row3,row4, x3,x4,bias,shift); \
-      }
-
-   __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
-   __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
-   __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
-   __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
-   __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
-   __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
-   __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
-   __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
-
-   // rounding biases in column/row passes, see stbi__idct_block for explanation.
-   __m128i bias_0 = _mm_set1_epi32(512);
-   __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
-
-   // load
-   row0 = _mm_load_si128((const __m128i *) (data + 0*8));
-   row1 = _mm_load_si128((const __m128i *) (data + 1*8));
-   row2 = _mm_load_si128((const __m128i *) (data + 2*8));
-   row3 = _mm_load_si128((const __m128i *) (data + 3*8));
-   row4 = _mm_load_si128((const __m128i *) (data + 4*8));
-   row5 = _mm_load_si128((const __m128i *) (data + 5*8));
-   row6 = _mm_load_si128((const __m128i *) (data + 6*8));
-   row7 = _mm_load_si128((const __m128i *) (data + 7*8));
-
-   // column pass
-   dct_pass(bias_0, 10);
-
-   {
-      // 16bit 8x8 transpose pass 1
-      dct_interleave16(row0, row4);
-      dct_interleave16(row1, row5);
-      dct_interleave16(row2, row6);
-      dct_interleave16(row3, row7);
-
-      // transpose pass 2
-      dct_interleave16(row0, row2);
-      dct_interleave16(row1, row3);
-      dct_interleave16(row4, row6);
-      dct_interleave16(row5, row7);
-
-      // transpose pass 3
-      dct_interleave16(row0, row1);
-      dct_interleave16(row2, row3);
-      dct_interleave16(row4, row5);
-      dct_interleave16(row6, row7);
-   }
-
-   // row pass
-   dct_pass(bias_1, 17);
-
-   {
-      // pack
-      __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
-      __m128i p1 = _mm_packus_epi16(row2, row3);
-      __m128i p2 = _mm_packus_epi16(row4, row5);
-      __m128i p3 = _mm_packus_epi16(row6, row7);
-
-      // 8bit 8x8 transpose pass 1
-      dct_interleave8(p0, p2); // a0e0a1e1...
-      dct_interleave8(p1, p3); // c0g0c1g1...
-
-      // transpose pass 2
-      dct_interleave8(p0, p1); // a0c0e0g0...
-      dct_interleave8(p2, p3); // b0d0f0h0...
-
-      // transpose pass 3
-      dct_interleave8(p0, p2); // a0b0c0d0...
-      dct_interleave8(p1, p3); // a4b4c4d4...
-
-      // store
-      _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
-      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
-   }
-
-#undef dct_const
-#undef dct_rot
-#undef dct_widen
-#undef dct_wadd
-#undef dct_wsub
-#undef dct_bfly32o
-#undef dct_interleave8
-#undef dct_interleave16
-#undef dct_pass
-}
-
-#endif // STBI_SSE2
-
-#ifdef STBI_NEON
-
-// NEON integer IDCT. should produce bit-identical
-// results to the generic C version.
-static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
-{
-   int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
-
-   int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
-   int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
-   int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
-   int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
-   int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
-   int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
-   int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
-   int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
-   int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
-   int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
-   int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
-   int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
-
-#define dct_long_mul(out, inq, coeff) \
-   int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
-   int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
-
-#define dct_long_mac(out, acc, inq, coeff) \
-   int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
-   int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
-
-#define dct_widen(out, inq) \
-   int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
-   int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
-
-// wide add
-#define dct_wadd(out, a, b) \
-   int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
-   int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
-
-// wide sub
-#define dct_wsub(out, a, b) \
-   int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
-   int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
-
-// butterfly a/b, then shift using "shiftop" by "s" and pack
-#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
-   { \
-      dct_wadd(sum, a, b); \
-      dct_wsub(dif, a, b); \
-      out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
-      out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
-   }
-
-#define dct_pass(shiftop, shift) \
-   { \
-      /* even part */ \
-      int16x8_t sum26 = vaddq_s16(row2, row6); \
-      dct_long_mul(p1e, sum26, rot0_0); \
-      dct_long_mac(t2e, p1e, row6, rot0_1); \
-      dct_long_mac(t3e, p1e, row2, rot0_2); \
-      int16x8_t sum04 = vaddq_s16(row0, row4); \
-      int16x8_t dif04 = vsubq_s16(row0, row4); \
-      dct_widen(t0e, sum04); \
-      dct_widen(t1e, dif04); \
-      dct_wadd(x0, t0e, t3e); \
-      dct_wsub(x3, t0e, t3e); \
-      dct_wadd(x1, t1e, t2e); \
-      dct_wsub(x2, t1e, t2e); \
-      /* odd part */ \
-      int16x8_t sum15 = vaddq_s16(row1, row5); \
-      int16x8_t sum17 = vaddq_s16(row1, row7); \
-      int16x8_t sum35 = vaddq_s16(row3, row5); \
-      int16x8_t sum37 = vaddq_s16(row3, row7); \
-      int16x8_t sumodd = vaddq_s16(sum17, sum35); \
-      dct_long_mul(p5o, sumodd, rot1_0); \
-      dct_long_mac(p1o, p5o, sum17, rot1_1); \
-      dct_long_mac(p2o, p5o, sum35, rot1_2); \
-      dct_long_mul(p3o, sum37, rot2_0); \
-      dct_long_mul(p4o, sum15, rot2_1); \
-      dct_wadd(sump13o, p1o, p3o); \
-      dct_wadd(sump24o, p2o, p4o); \
-      dct_wadd(sump23o, p2o, p3o); \
-      dct_wadd(sump14o, p1o, p4o); \
-      dct_long_mac(x4, sump13o, row7, rot3_0); \
-      dct_long_mac(x5, sump24o, row5, rot3_1); \
-      dct_long_mac(x6, sump23o, row3, rot3_2); \
-      dct_long_mac(x7, sump14o, row1, rot3_3); \
-      dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
-      dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
-      dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
-      dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
-   }
-
-   // load
-   row0 = vld1q_s16(data + 0*8);
-   row1 = vld1q_s16(data + 1*8);
-   row2 = vld1q_s16(data + 2*8);
-   row3 = vld1q_s16(data + 3*8);
-   row4 = vld1q_s16(data + 4*8);
-   row5 = vld1q_s16(data + 5*8);
-   row6 = vld1q_s16(data + 6*8);
-   row7 = vld1q_s16(data + 7*8);
-
-   // add DC bias
-   row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
-
-   // column pass
-   dct_pass(vrshrn_n_s32, 10);
-
-   // 16bit 8x8 transpose
-   {
-// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
-// whether compilers actually get this is another story, sadly.
-#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
-#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
-#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
-
-      // pass 1
-      dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
-      dct_trn16(row2, row3);
-      dct_trn16(row4, row5);
-      dct_trn16(row6, row7);
-
-      // pass 2
-      dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
-      dct_trn32(row1, row3);
-      dct_trn32(row4, row6);
-      dct_trn32(row5, row7);
-
-      // pass 3
-      dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
-      dct_trn64(row1, row5);
-      dct_trn64(row2, row6);
-      dct_trn64(row3, row7);
-
-#undef dct_trn16
-#undef dct_trn32
-#undef dct_trn64
-   }
-
-   // row pass
-   // vrshrn_n_s32 only supports shifts up to 16, we need
-   // 17. so do a non-rounding shift of 16 first then follow
-   // up with a rounding shift by 1.
-   dct_pass(vshrn_n_s32, 16);
-
-   {
-      // pack and round
-      uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
-      uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
-      uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
-      uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
-      uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
-      uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
-      uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
-      uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
-
-      // again, these can translate into one instruction, but often don't.
-#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
-#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
-#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
-
-      // sadly can't use interleaved stores here since we only write
-      // 8 bytes to each scan line!
-
-      // 8x8 8-bit transpose pass 1
-      dct_trn8_8(p0, p1);
-      dct_trn8_8(p2, p3);
-      dct_trn8_8(p4, p5);
-      dct_trn8_8(p6, p7);
-
-      // pass 2
-      dct_trn8_16(p0, p2);
-      dct_trn8_16(p1, p3);
-      dct_trn8_16(p4, p6);
-      dct_trn8_16(p5, p7);
-
-      // pass 3
-      dct_trn8_32(p0, p4);
-      dct_trn8_32(p1, p5);
-      dct_trn8_32(p2, p6);
-      dct_trn8_32(p3, p7);
-
-      // store
-      vst1_u8(out, p0); out += out_stride;
-      vst1_u8(out, p1); out += out_stride;
-      vst1_u8(out, p2); out += out_stride;
-      vst1_u8(out, p3); out += out_stride;
-      vst1_u8(out, p4); out += out_stride;
-      vst1_u8(out, p5); out += out_stride;
-      vst1_u8(out, p6); out += out_stride;
-      vst1_u8(out, p7);
-
-#undef dct_trn8_8
-#undef dct_trn8_16
-#undef dct_trn8_32
-   }
-
-#undef dct_long_mul
-#undef dct_long_mac
-#undef dct_widen
-#undef dct_wadd
-#undef dct_wsub
-#undef dct_bfly32o
-#undef dct_pass
-}
-
-#endif // STBI_NEON
-
-#define STBI__MARKER_none  0xff
-// if there's a pending marker from the entropy stream, return that
-// otherwise, fetch from the stream and get a marker. if there's no
-// marker, return 0xff, which is never a valid marker value
-static stbi_uc stbi__get_marker(stbi__jpeg *j)
-{
-   stbi_uc x;
-   if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
-   x = stbi__get8(j->s);
-   if (x != 0xff) return STBI__MARKER_none;
-   while (x == 0xff)
-      x = stbi__get8(j->s); // consume repeated 0xff fill bytes
-   return x;
-}
-
-// in each scan, we'll have scan_n components, and the order
-// of the components is specified by order[]
-#define STBI__RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
-
-// after a restart interval, stbi__jpeg_reset the entropy decoder and
-// the dc prediction
-static void stbi__jpeg_reset(stbi__jpeg *j)
-{
-   j->code_bits = 0;
-   j->code_buffer = 0;
-   j->nomore = 0;
-   j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;
-   j->marker = STBI__MARKER_none;
-   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
-   j->eob_run = 0;
-   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
-   // since we don't even allow 1<<30 pixels
-}
-
-static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
-{
-   stbi__jpeg_reset(z);
-   if (!z->progressive) {
-      if (z->scan_n == 1) {
-         int i,j;
-         STBI_SIMD_ALIGN(short, data[64]);
-         int n = z->order[0];
-         // non-interleaved data, we just need to process one block at a time,
-         // in trivial scanline order
-         // number of blocks to do just depends on how many actual "pixels" this
-         // component has, independent of interleaved MCU blocking and such
-         int w = (z->img_comp[n].x+7) >> 3;
-         int h = (z->img_comp[n].y+7) >> 3;
-         for (j=0; j < h; ++j) {
-            for (i=0; i < w; ++i) {
-               int ha = z->img_comp[n].ha;
-               if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
-               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
-               // every data block is an MCU, so countdown the restart interval
-               if (--z->todo <= 0) {
-                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
-                  // if it's NOT a restart, then just bail, so we get corrupt data
-                  // rather than no data
-                  if (!STBI__RESTART(z->marker)) return 1;
-                  stbi__jpeg_reset(z);
-               }
-            }
-         }
-         return 1;
-      } else { // interleaved
-         int i,j,k,x,y;
-         STBI_SIMD_ALIGN(short, data[64]);
-         for (j=0; j < z->img_mcu_y; ++j) {
-            for (i=0; i < z->img_mcu_x; ++i) {
-               // scan an interleaved mcu... process scan_n components in order
-               for (k=0; k < z->scan_n; ++k) {
-                  int n = z->order[k];
-                  // scan out an mcu's worth of this component; that's just determined
-                  // by the basic H and V specified for the component
-                  for (y=0; y < z->img_comp[n].v; ++y) {
-                     for (x=0; x < z->img_comp[n].h; ++x) {
-                        int x2 = (i*z->img_comp[n].h + x)*8;
-                        int y2 = (j*z->img_comp[n].v + y)*8;
-                        int ha = z->img_comp[n].ha;
-                        if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
-                        z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
-                     }
-                  }
-               }
-               // after all interleaved components, that's an interleaved MCU,
-               // so now count down the restart interval
-               if (--z->todo <= 0) {
-                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
-                  if (!STBI__RESTART(z->marker)) return 1;
-                  stbi__jpeg_reset(z);
-               }
-            }
-         }
-         return 1;
-      }
-   } else {
-      if (z->scan_n == 1) {
-         int i,j;
-         int n = z->order[0];
-         // non-interleaved data, we just need to process one block at a time,
-         // in trivial scanline order
-         // number of blocks to do just depends on how many actual "pixels" this
-         // component has, independent of interleaved MCU blocking and such
-         int w = (z->img_comp[n].x+7) >> 3;
-         int h = (z->img_comp[n].y+7) >> 3;
-         for (j=0; j < h; ++j) {
-            for (i=0; i < w; ++i) {
-               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
-               if (z->spec_start == 0) {
-                  if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
-                     return 0;
-               } else {
-                  int ha = z->img_comp[n].ha;
-                  if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
-                     return 0;
-               }
-               // every data block is an MCU, so countdown the restart interval
-               if (--z->todo <= 0) {
-                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
-                  if (!STBI__RESTART(z->marker)) return 1;
-                  stbi__jpeg_reset(z);
-               }
-            }
-         }
-         return 1;
-      } else { // interleaved
-         int i,j,k,x,y;
-         for (j=0; j < z->img_mcu_y; ++j) {
-            for (i=0; i < z->img_mcu_x; ++i) {
-               // scan an interleaved mcu... process scan_n components in order
-               for (k=0; k < z->scan_n; ++k) {
-                  int n = z->order[k];
-                  // scan out an mcu's worth of this component; that's just determined
-                  // by the basic H and V specified for the component
-                  for (y=0; y < z->img_comp[n].v; ++y) {
-                     for (x=0; x < z->img_comp[n].h; ++x) {
-                        int x2 = (i*z->img_comp[n].h + x);
-                        int y2 = (j*z->img_comp[n].v + y);
-                        short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
-                        if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
-                           return 0;
-                     }
-                  }
-               }
-               // after all interleaved components, that's an interleaved MCU,
-               // so now count down the restart interval
-               if (--z->todo <= 0) {
-                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
-                  if (!STBI__RESTART(z->marker)) return 1;
-                  stbi__jpeg_reset(z);
-               }
-            }
-         }
-         return 1;
-      }
-   }
-}
-
-static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
-{
-   int i;
-   for (i=0; i < 64; ++i)
-      data[i] *= dequant[i];
-}
-
-static void stbi__jpeg_finish(stbi__jpeg *z)
-{
-   if (z->progressive) {
-      // dequantize and idct the data
-      int i,j,n;
-      for (n=0; n < z->s->img_n; ++n) {
-         int w = (z->img_comp[n].x+7) >> 3;
-         int h = (z->img_comp[n].y+7) >> 3;
-         for (j=0; j < h; ++j) {
-            for (i=0; i < w; ++i) {
-               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
-               stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
-               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
-            }
-         }
-      }
-   }
-}
-
-static int stbi__process_marker(stbi__jpeg *z, int m)
-{
-   int L;
-   switch (m) {
-      case STBI__MARKER_none: // no marker found
-         return stbi__err("expected marker","Corrupt JPEG");
-
-      case 0xDD: // DRI - specify restart interval
-         if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
-         z->restart_interval = stbi__get16be(z->s);
-         return 1;
-
-      case 0xDB: // DQT - define quantization table
-         L = stbi__get16be(z->s)-2;
-         while (L > 0) {
-            int q = stbi__get8(z->s);
-            int p = q >> 4, sixteen = (p != 0);
-            int t = q & 15,i;
-            if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");
-            if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
-
-            for (i=0; i < 64; ++i)
-               z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
-            L -= (sixteen ? 129 : 65);
-         }
-         return L==0;
-
-      case 0xC4: // DHT - define huffman table
-         L = stbi__get16be(z->s)-2;
-         while (L > 0) {
-            stbi_uc *v;
-            int sizes[16],i,n=0;
-            int q = stbi__get8(z->s);
-            int tc = q >> 4;
-            int th = q & 15;
-            if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
-            for (i=0; i < 16; ++i) {
-               sizes[i] = stbi__get8(z->s);
-               n += sizes[i];
-            }
-            if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values!
-            L -= 17;
-            if (tc == 0) {
-               if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
-               v = z->huff_dc[th].values;
-            } else {
-               if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
-               v = z->huff_ac[th].values;
-            }
-            for (i=0; i < n; ++i)
-               v[i] = stbi__get8(z->s);
-            if (tc != 0)
-               stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
-            L -= n;
-         }
-         return L==0;
-   }
-
-   // check for comment block or APP blocks
-   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
-      L = stbi__get16be(z->s);
-      if (L < 2) {
-         if (m == 0xFE)
-            return stbi__err("bad COM len","Corrupt JPEG");
-         else
-            return stbi__err("bad APP len","Corrupt JPEG");
-      }
-      L -= 2;
-
-      if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
-         static const unsigned char tag[5] = {'J','F','I','F','\0'};
-         int ok = 1;
-         int i;
-         for (i=0; i < 5; ++i)
-            if (stbi__get8(z->s) != tag[i])
-               ok = 0;
-         L -= 5;
-         if (ok)
-            z->jfif = 1;
-      } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
-         static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
-         int ok = 1;
-         int i;
-         for (i=0; i < 6; ++i)
-            if (stbi__get8(z->s) != tag[i])
-               ok = 0;
-         L -= 6;
-         if (ok) {
-            stbi__get8(z->s); // version
-            stbi__get16be(z->s); // flags0
-            stbi__get16be(z->s); // flags1
-            z->app14_color_transform = stbi__get8(z->s); // color transform
-            L -= 6;
-         }
-      }
-
-      stbi__skip(z->s, L);
-      return 1;
-   }
-
-   return stbi__err("unknown marker","Corrupt JPEG");
-}
-
-// after we see SOS
-static int stbi__process_scan_header(stbi__jpeg *z)
-{
-   int i;
-   int Ls = stbi__get16be(z->s);
-   z->scan_n = stbi__get8(z->s);
-   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");
-   if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
-   for (i=0; i < z->scan_n; ++i) {
-      int id = stbi__get8(z->s), which;
-      int q = stbi__get8(z->s);
-      for (which = 0; which < z->s->img_n; ++which)
-         if (z->img_comp[which].id == id)
-            break;
-      if (which == z->s->img_n) return 0; // no match
-      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
-      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
-      z->order[i] = which;
-   }
-
-   {
-      int aa;
-      z->spec_start = stbi__get8(z->s);
-      z->spec_end   = stbi__get8(z->s); // should be 63, but might be 0
-      aa = stbi__get8(z->s);
-      z->succ_high = (aa >> 4);
-      z->succ_low  = (aa & 15);
-      if (z->progressive) {
-         if (z->spec_start > 63 || z->spec_end > 63  || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
-            return stbi__err("bad SOS", "Corrupt JPEG");
-      } else {
-         if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
-         if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
-         z->spec_end = 63;
-      }
-   }
-
-   return 1;
-}
-
-static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
-{
-   int i;
-   for (i=0; i < ncomp; ++i) {
-      if (z->img_comp[i].raw_data) {
-         STBI_FREE(z->img_comp[i].raw_data);
-         z->img_comp[i].raw_data = NULL;
-         z->img_comp[i].data = NULL;
-      }
-      if (z->img_comp[i].raw_coeff) {
-         STBI_FREE(z->img_comp[i].raw_coeff);
-         z->img_comp[i].raw_coeff = 0;
-         z->img_comp[i].coeff = 0;
-      }
-      if (z->img_comp[i].linebuf) {
-         STBI_FREE(z->img_comp[i].linebuf);
-         z->img_comp[i].linebuf = NULL;
-      }
-   }
-   return why;
-}
-
-static int stbi__process_frame_header(stbi__jpeg *z, int scan)
-{
-   stbi__context *s = z->s;
-   int Lf,p,i,q, h_max=1,v_max=1,c;
-   Lf = stbi__get16be(s);         if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
-   p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
-   s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
-   s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
-   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
-   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
-   c = stbi__get8(s);
-   if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
-   s->img_n = c;
-   for (i=0; i < c; ++i) {
-      z->img_comp[i].data = NULL;
-      z->img_comp[i].linebuf = NULL;
-   }
-
-   if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");
-
-   z->rgb = 0;
-   for (i=0; i < s->img_n; ++i) {
-      static const unsigned char rgb[3] = { 'R', 'G', 'B' };
-      z->img_comp[i].id = stbi__get8(s);
-      if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
-         ++z->rgb;
-      q = stbi__get8(s);
-      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");
-      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");
-      z->img_comp[i].tq = stbi__get8(s);  if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
-   }
-
-   if (scan != STBI__SCAN_load) return 1;
-
-   if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");
-
-   for (i=0; i < s->img_n; ++i) {
-      if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
-      if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
-   }
-
-   // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios
-   // and I've never seen a non-corrupted JPEG file actually use them
-   for (i=0; i < s->img_n; ++i) {
-      if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG");
-      if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG");
-   }
-
-   // compute interleaved mcu info
-   z->img_h_max = h_max;
-   z->img_v_max = v_max;
-   z->img_mcu_w = h_max * 8;
-   z->img_mcu_h = v_max * 8;
-   // these sizes can't be more than 17 bits
-   z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
-   z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
-
-   for (i=0; i < s->img_n; ++i) {
-      // number of effective pixels (e.g. for non-interleaved MCU)
-      z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
-      z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
-      // to simplify generation, we'll allocate enough memory to decode
-      // the bogus oversized data from using interleaved MCUs and their
-      // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
-      // discard the extra data until colorspace conversion
-      //
-      // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
-      // so these muls can't overflow with 32-bit ints (which we require)
-      z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
-      z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
-      z->img_comp[i].coeff = 0;
-      z->img_comp[i].raw_coeff = 0;
-      z->img_comp[i].linebuf = NULL;
-      z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
-      if (z->img_comp[i].raw_data == NULL)
-         return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
-      // align blocks for idct using mmx/sse
-      z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
-      if (z->progressive) {
-         // w2, h2 are multiples of 8 (see above)
-         z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
-         z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
-         z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
-         if (z->img_comp[i].raw_coeff == NULL)
-            return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
-         z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
-      }
-   }
-
-   return 1;
-}
-
-// use comparisons since in some cases we handle more than one case (e.g. SOF)
-#define stbi__DNL(x)         ((x) == 0xdc)
-#define stbi__SOI(x)         ((x) == 0xd8)
-#define stbi__EOI(x)         ((x) == 0xd9)
-#define stbi__SOF(x)         ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
-#define stbi__SOS(x)         ((x) == 0xda)
-
-#define stbi__SOF_progressive(x)   ((x) == 0xc2)
-
-static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
-{
-   int m;
-   z->jfif = 0;
-   z->app14_color_transform = -1; // valid values are 0,1,2
-   z->marker = STBI__MARKER_none; // initialize cached marker to empty
-   m = stbi__get_marker(z);
-   if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
-   if (scan == STBI__SCAN_type) return 1;
-   m = stbi__get_marker(z);
-   while (!stbi__SOF(m)) {
-      if (!stbi__process_marker(z,m)) return 0;
-      m = stbi__get_marker(z);
-      while (m == STBI__MARKER_none) {
-         // some files have extra padding after their blocks, so ok, we'll scan
-         if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
-         m = stbi__get_marker(z);
-      }
-   }
-   z->progressive = stbi__SOF_progressive(m);
-   if (!stbi__process_frame_header(z, scan)) return 0;
-   return 1;
-}
-
-static int stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)
-{
-   // some JPEGs have junk at end, skip over it but if we find what looks
-   // like a valid marker, resume there
-   while (!stbi__at_eof(j->s)) {
-      int x = stbi__get8(j->s);
-      while (x == 255) { // might be a marker
-         if (stbi__at_eof(j->s)) return STBI__MARKER_none;
-         x = stbi__get8(j->s);
-         if (x != 0x00 && x != 0xff) {
-            // not a stuffed zero or lead-in to another marker, looks
-            // like an actual marker, return it
-            return x;
-         }
-         // stuffed zero has x=0 now which ends the loop, meaning we go
-         // back to regular scan loop.
-         // repeated 0xff keeps trying to read the next byte of the marker.
-      }
-   }
-   return STBI__MARKER_none;
-}
-
-// decode image to YCbCr format
-static int stbi__decode_jpeg_image(stbi__jpeg *j)
-{
-   int m;
-   for (m = 0; m < 4; m++) {
-      j->img_comp[m].raw_data = NULL;
-      j->img_comp[m].raw_coeff = NULL;
-   }
-   j->restart_interval = 0;
-   if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
-   m = stbi__get_marker(j);
-   while (!stbi__EOI(m)) {
-      if (stbi__SOS(m)) {
-         if (!stbi__process_scan_header(j)) return 0;
-         if (!stbi__parse_entropy_coded_data(j)) return 0;
-         if (j->marker == STBI__MARKER_none ) {
-         j->marker = stbi__skip_jpeg_junk_at_end(j);
-            // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
-         }
-         m = stbi__get_marker(j);
-         if (STBI__RESTART(m))
-            m = stbi__get_marker(j);
-      } else if (stbi__DNL(m)) {
-         int Ld = stbi__get16be(j->s);
-         stbi__uint32 NL = stbi__get16be(j->s);
-         if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
-         if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
-         m = stbi__get_marker(j);
-      } else {
-         if (!stbi__process_marker(j, m)) return 1;
-         m = stbi__get_marker(j);
-      }
-   }
-   if (j->progressive)
-      stbi__jpeg_finish(j);
-   return 1;
-}
-
-// static jfif-centered resampling (across block boundaries)
-
-typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
-                                    int w, int hs);
-
-#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
-
-static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   STBI_NOTUSED(out);
-   STBI_NOTUSED(in_far);
-   STBI_NOTUSED(w);
-   STBI_NOTUSED(hs);
-   return in_near;
-}
-
-static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   // need to generate two samples vertically for every one in input
-   int i;
-   STBI_NOTUSED(hs);
-   for (i=0; i < w; ++i)
-      out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
-   return out;
-}
-
-static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   // need to generate two samples horizontally for every one in input
-   int i;
-   stbi_uc *input = in_near;
-
-   if (w == 1) {
-      // if only one sample, can't do any interpolation
-      out[0] = out[1] = input[0];
-      return out;
-   }
-
-   out[0] = input[0];
-   out[1] = stbi__div4(input[0]*3 + input[1] + 2);
-   for (i=1; i < w-1; ++i) {
-      int n = 3*input[i]+2;
-      out[i*2+0] = stbi__div4(n+input[i-1]);
-      out[i*2+1] = stbi__div4(n+input[i+1]);
-   }
-   out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
-   out[i*2+1] = input[w-1];
-
-   STBI_NOTUSED(in_far);
-   STBI_NOTUSED(hs);
-
-   return out;
-}
-
-#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
-
-static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   // need to generate 2x2 samples for every one in input
-   int i,t0,t1;
-   if (w == 1) {
-      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
-      return out;
-   }
-
-   t1 = 3*in_near[0] + in_far[0];
-   out[0] = stbi__div4(t1+2);
-   for (i=1; i < w; ++i) {
-      t0 = t1;
-      t1 = 3*in_near[i]+in_far[i];
-      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
-      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
-   }
-   out[w*2-1] = stbi__div4(t1+2);
-
-   STBI_NOTUSED(hs);
-
-   return out;
-}
-
-#if defined(STBI_SSE2) || defined(STBI_NEON)
-static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   // need to generate 2x2 samples for every one in input
-   int i=0,t0,t1;
-
-   if (w == 1) {
-      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
-      return out;
-   }
-
-   t1 = 3*in_near[0] + in_far[0];
-   // process groups of 8 pixels for as long as we can.
-   // note we can't handle the last pixel in a row in this loop
-   // because we need to handle the filter boundary conditions.
-   for (; i < ((w-1) & ~7); i += 8) {
-#if defined(STBI_SSE2)
-      // load and perform the vertical filtering pass
-      // this uses 3*x + y = 4*x + (y - x)
-      __m128i zero  = _mm_setzero_si128();
-      __m128i farb  = _mm_loadl_epi64((__m128i *) (in_far + i));
-      __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
-      __m128i farw  = _mm_unpacklo_epi8(farb, zero);
-      __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
-      __m128i diff  = _mm_sub_epi16(farw, nearw);
-      __m128i nears = _mm_slli_epi16(nearw, 2);
-      __m128i curr  = _mm_add_epi16(nears, diff); // current row
-
-      // horizontal filter works the same based on shifted vers of current
-      // row. "prev" is current row shifted right by 1 pixel; we need to
-      // insert the previous pixel value (from t1).
-      // "next" is current row shifted left by 1 pixel, with first pixel
-      // of next block of 8 pixels added in.
-      __m128i prv0 = _mm_slli_si128(curr, 2);
-      __m128i nxt0 = _mm_srli_si128(curr, 2);
-      __m128i prev = _mm_insert_epi16(prv0, t1, 0);
-      __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
-
-      // horizontal filter, polyphase implementation since it's convenient:
-      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
-      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
-      // note the shared term.
-      __m128i bias  = _mm_set1_epi16(8);
-      __m128i curs = _mm_slli_epi16(curr, 2);
-      __m128i prvd = _mm_sub_epi16(prev, curr);
-      __m128i nxtd = _mm_sub_epi16(next, curr);
-      __m128i curb = _mm_add_epi16(curs, bias);
-      __m128i even = _mm_add_epi16(prvd, curb);
-      __m128i odd  = _mm_add_epi16(nxtd, curb);
-
-      // interleave even and odd pixels, then undo scaling.
-      __m128i int0 = _mm_unpacklo_epi16(even, odd);
-      __m128i int1 = _mm_unpackhi_epi16(even, odd);
-      __m128i de0  = _mm_srli_epi16(int0, 4);
-      __m128i de1  = _mm_srli_epi16(int1, 4);
-
-      // pack and write output
-      __m128i outv = _mm_packus_epi16(de0, de1);
-      _mm_storeu_si128((__m128i *) (out + i*2), outv);
-#elif defined(STBI_NEON)
-      // load and perform the vertical filtering pass
-      // this uses 3*x + y = 4*x + (y - x)
-      uint8x8_t farb  = vld1_u8(in_far + i);
-      uint8x8_t nearb = vld1_u8(in_near + i);
-      int16x8_t diff  = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
-      int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
-      int16x8_t curr  = vaddq_s16(nears, diff); // current row
-
-      // horizontal filter works the same based on shifted vers of current
-      // row. "prev" is current row shifted right by 1 pixel; we need to
-      // insert the previous pixel value (from t1).
-      // "next" is current row shifted left by 1 pixel, with first pixel
-      // of next block of 8 pixels added in.
-      int16x8_t prv0 = vextq_s16(curr, curr, 7);
-      int16x8_t nxt0 = vextq_s16(curr, curr, 1);
-      int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
-      int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
-
-      // horizontal filter, polyphase implementation since it's convenient:
-      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
-      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
-      // note the shared term.
-      int16x8_t curs = vshlq_n_s16(curr, 2);
-      int16x8_t prvd = vsubq_s16(prev, curr);
-      int16x8_t nxtd = vsubq_s16(next, curr);
-      int16x8_t even = vaddq_s16(curs, prvd);
-      int16x8_t odd  = vaddq_s16(curs, nxtd);
-
-      // undo scaling and round, then store with even/odd phases interleaved
-      uint8x8x2_t o;
-      o.val[0] = vqrshrun_n_s16(even, 4);
-      o.val[1] = vqrshrun_n_s16(odd,  4);
-      vst2_u8(out + i*2, o);
-#endif
-
-      // "previous" value for next iter
-      t1 = 3*in_near[i+7] + in_far[i+7];
-   }
-
-   t0 = t1;
-   t1 = 3*in_near[i] + in_far[i];
-   out[i*2] = stbi__div16(3*t1 + t0 + 8);
-
-   for (++i; i < w; ++i) {
-      t0 = t1;
-      t1 = 3*in_near[i]+in_far[i];
-      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
-      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
-   }
-   out[w*2-1] = stbi__div4(t1+2);
-
-   STBI_NOTUSED(hs);
-
-   return out;
-}
-#endif
-
-static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
-{
-   // resample with nearest-neighbor
-   int i,j;
-   STBI_NOTUSED(in_far);
-   for (i=0; i < w; ++i)
-      for (j=0; j < hs; ++j)
-         out[i*hs+j] = in_near[i];
-   return out;
-}
-
-// this is a reduced-precision calculation of YCbCr-to-RGB introduced
-// to make sure the code produces the same results in both SIMD and scalar
-#define stbi__float2fixed(x)  (((int) ((x) * 4096.0f + 0.5f)) << 8)
-static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
-{
-   int i;
-   for (i=0; i < count; ++i) {
-      int y_fixed = (y[i] << 20) + (1<<19); // rounding
-      int r,g,b;
-      int cr = pcr[i] - 128;
-      int cb = pcb[i] - 128;
-      r = y_fixed +  cr* stbi__float2fixed(1.40200f);
-      g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
-      b = y_fixed                                     +   cb* stbi__float2fixed(1.77200f);
-      r >>= 20;
-      g >>= 20;
-      b >>= 20;
-      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
-      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
-      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
-      out[0] = (stbi_uc)r;
-      out[1] = (stbi_uc)g;
-      out[2] = (stbi_uc)b;
-      out[3] = 255;
-      out += step;
-   }
-}
-
-#if defined(STBI_SSE2) || defined(STBI_NEON)
-static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
-{
-   int i = 0;
-
-#ifdef STBI_SSE2
-   // step == 3 is pretty ugly on the final interleave, and i'm not convinced
-   // it's useful in practice (you wouldn't use it for textures, for example).
-   // so just accelerate step == 4 case.
-   if (step == 4) {
-      // this is a fairly straightforward implementation and not super-optimized.
-      __m128i signflip  = _mm_set1_epi8(-0x80);
-      __m128i cr_const0 = _mm_set1_epi16(   (short) ( 1.40200f*4096.0f+0.5f));
-      __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
-      __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
-      __m128i cb_const1 = _mm_set1_epi16(   (short) ( 1.77200f*4096.0f+0.5f));
-      __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
-      __m128i xw = _mm_set1_epi16(255); // alpha channel
-
-      for (; i+7 < count; i += 8) {
-         // load
-         __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
-         __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
-         __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
-         __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
-         __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
-
-         // unpack to short (and left-shift cr, cb by 8)
-         __m128i yw  = _mm_unpacklo_epi8(y_bias, y_bytes);
-         __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
-         __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
-
-         // color transform
-         __m128i yws = _mm_srli_epi16(yw, 4);
-         __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
-         __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
-         __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
-         __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
-         __m128i rws = _mm_add_epi16(cr0, yws);
-         __m128i gwt = _mm_add_epi16(cb0, yws);
-         __m128i bws = _mm_add_epi16(yws, cb1);
-         __m128i gws = _mm_add_epi16(gwt, cr1);
-
-         // descale
-         __m128i rw = _mm_srai_epi16(rws, 4);
-         __m128i bw = _mm_srai_epi16(bws, 4);
-         __m128i gw = _mm_srai_epi16(gws, 4);
-
-         // back to byte, set up for transpose
-         __m128i brb = _mm_packus_epi16(rw, bw);
-         __m128i gxb = _mm_packus_epi16(gw, xw);
-
-         // transpose to interleave channels
-         __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
-         __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
-         __m128i o0 = _mm_unpacklo_epi16(t0, t1);
-         __m128i o1 = _mm_unpackhi_epi16(t0, t1);
-
-         // store
-         _mm_storeu_si128((__m128i *) (out + 0), o0);
-         _mm_storeu_si128((__m128i *) (out + 16), o1);
-         out += 32;
-      }
-   }
-#endif
-
-#ifdef STBI_NEON
-   // in this version, step=3 support would be easy to add. but is there demand?
-   if (step == 4) {
-      // this is a fairly straightforward implementation and not super-optimized.
-      uint8x8_t signflip = vdup_n_u8(0x80);
-      int16x8_t cr_const0 = vdupq_n_s16(   (short) ( 1.40200f*4096.0f+0.5f));
-      int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
-      int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
-      int16x8_t cb_const1 = vdupq_n_s16(   (short) ( 1.77200f*4096.0f+0.5f));
-
-      for (; i+7 < count; i += 8) {
-         // load
-         uint8x8_t y_bytes  = vld1_u8(y + i);
-         uint8x8_t cr_bytes = vld1_u8(pcr + i);
-         uint8x8_t cb_bytes = vld1_u8(pcb + i);
-         int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
-         int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
-
-         // expand to s16
-         int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
-         int16x8_t crw = vshll_n_s8(cr_biased, 7);
-         int16x8_t cbw = vshll_n_s8(cb_biased, 7);
-
-         // color transform
-         int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
-         int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
-         int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
-         int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
-         int16x8_t rws = vaddq_s16(yws, cr0);
-         int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
-         int16x8_t bws = vaddq_s16(yws, cb1);
-
-         // undo scaling, round, convert to byte
-         uint8x8x4_t o;
-         o.val[0] = vqrshrun_n_s16(rws, 4);
-         o.val[1] = vqrshrun_n_s16(gws, 4);
-         o.val[2] = vqrshrun_n_s16(bws, 4);
-         o.val[3] = vdup_n_u8(255);
-
-         // store, interleaving r/g/b/a
-         vst4_u8(out, o);
-         out += 8*4;
-      }
-   }
-#endif
-
-   for (; i < count; ++i) {
-      int y_fixed = (y[i] << 20) + (1<<19); // rounding
-      int r,g,b;
-      int cr = pcr[i] - 128;
-      int cb = pcb[i] - 128;
-      r = y_fixed + cr* stbi__float2fixed(1.40200f);
-      g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
-      b = y_fixed                                   +   cb* stbi__float2fixed(1.77200f);
-      r >>= 20;
-      g >>= 20;
-      b >>= 20;
-      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
-      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
-      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
-      out[0] = (stbi_uc)r;
-      out[1] = (stbi_uc)g;
-      out[2] = (stbi_uc)b;
-      out[3] = 255;
-      out += step;
-   }
-}
-#endif
-
-// set up the kernels
-static void stbi__setup_jpeg(stbi__jpeg *j)
-{
-   j->idct_block_kernel = stbi__idct_block;
-   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
-   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
-
-#ifdef STBI_SSE2
-   if (stbi__sse2_available()) {
-      j->idct_block_kernel = stbi__idct_simd;
-      j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
-      j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
-   }
-#endif
-
-#ifdef STBI_NEON
-   j->idct_block_kernel = stbi__idct_simd;
-   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
-   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
-#endif
-}
-
-// clean up the temporary component buffers
-static void stbi__cleanup_jpeg(stbi__jpeg *j)
-{
-   stbi__free_jpeg_components(j, j->s->img_n, 0);
-}
-
-typedef struct
-{
-   resample_row_func resample;
-   stbi_uc *line0,*line1;
-   int hs,vs;   // expansion factor in each axis
-   int w_lores; // horizontal pixels pre-expansion
-   int ystep;   // how far through vertical expansion we are
-   int ypos;    // which pre-expansion row we're on
-} stbi__resample;
-
-// fast 0..255 * 0..255 => 0..255 rounded multiplication
-static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
-{
-   unsigned int t = x*y + 128;
-   return (stbi_uc) ((t + (t >>8)) >> 8);
-}
-
-static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
-{
-   int n, decode_n, is_rgb;
-   z->s->img_n = 0; // make stbi__cleanup_jpeg safe
-
-   // validate req_comp
-   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
-
-   // load a jpeg image from whichever source, but leave in YCbCr format
-   if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
-
-   // determine actual number of components to generate
-   n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
-
-   is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
-
-   if (z->s->img_n == 3 && n < 3 && !is_rgb)
-      decode_n = 1;
-   else
-      decode_n = z->s->img_n;
-
-   // nothing to do if no components requested; check this now to avoid
-   // accessing uninitialized coutput[0] later
-   if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; }
-
-   // resample and color-convert
-   {
-      int k;
-      unsigned int i,j;
-      stbi_uc *output;
-      stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
-
-      stbi__resample res_comp[4];
-
-      for (k=0; k < decode_n; ++k) {
-         stbi__resample *r = &res_comp[k];
-
-         // allocate line buffer big enough for upsampling off the edges
-         // with upsample factor of 4
-         z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
-         if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
-
-         r->hs      = z->img_h_max / z->img_comp[k].h;
-         r->vs      = z->img_v_max / z->img_comp[k].v;
-         r->ystep   = r->vs >> 1;
-         r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
-         r->ypos    = 0;
-         r->line0   = r->line1 = z->img_comp[k].data;
-
-         if      (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
-         else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
-         else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
-         else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
-         else                               r->resample = stbi__resample_row_generic;
-      }
-
-      // can't error after this so, this is safe
-      output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
-      if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
-
-      // now go ahead and resample
-      for (j=0; j < z->s->img_y; ++j) {
-         stbi_uc *out = output + n * z->s->img_x * j;
-         for (k=0; k < decode_n; ++k) {
-            stbi__resample *r = &res_comp[k];
-            int y_bot = r->ystep >= (r->vs >> 1);
-            coutput[k] = r->resample(z->img_comp[k].linebuf,
-                                     y_bot ? r->line1 : r->line0,
-                                     y_bot ? r->line0 : r->line1,
-                                     r->w_lores, r->hs);
-            if (++r->ystep >= r->vs) {
-               r->ystep = 0;
-               r->line0 = r->line1;
-               if (++r->ypos < z->img_comp[k].y)
-                  r->line1 += z->img_comp[k].w2;
-            }
-         }
-         if (n >= 3) {
-            stbi_uc *y = coutput[0];
-            if (z->s->img_n == 3) {
-               if (is_rgb) {
-                  for (i=0; i < z->s->img_x; ++i) {
-                     out[0] = y[i];
-                     out[1] = coutput[1][i];
-                     out[2] = coutput[2][i];
-                     out[3] = 255;
-                     out += n;
-                  }
-               } else {
-                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
-               }
-            } else if (z->s->img_n == 4) {
-               if (z->app14_color_transform == 0) { // CMYK
-                  for (i=0; i < z->s->img_x; ++i) {
-                     stbi_uc m = coutput[3][i];
-                     out[0] = stbi__blinn_8x8(coutput[0][i], m);
-                     out[1] = stbi__blinn_8x8(coutput[1][i], m);
-                     out[2] = stbi__blinn_8x8(coutput[2][i], m);
-                     out[3] = 255;
-                     out += n;
-                  }
-               } else if (z->app14_color_transform == 2) { // YCCK
-                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
-                  for (i=0; i < z->s->img_x; ++i) {
-                     stbi_uc m = coutput[3][i];
-                     out[0] = stbi__blinn_8x8(255 - out[0], m);
-                     out[1] = stbi__blinn_8x8(255 - out[1], m);
-                     out[2] = stbi__blinn_8x8(255 - out[2], m);
-                     out += n;
-                  }
-               } else { // YCbCr + alpha?  Ignore the fourth channel for now
-                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
-               }
-            } else
-               for (i=0; i < z->s->img_x; ++i) {
-                  out[0] = out[1] = out[2] = y[i];
-                  out[3] = 255; // not used if n==3
-                  out += n;
-               }
-         } else {
-            if (is_rgb) {
-               if (n == 1)
-                  for (i=0; i < z->s->img_x; ++i)
-                     *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
-               else {
-                  for (i=0; i < z->s->img_x; ++i, out += 2) {
-                     out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
-                     out[1] = 255;
-                  }
-               }
-            } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
-               for (i=0; i < z->s->img_x; ++i) {
-                  stbi_uc m = coutput[3][i];
-                  stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
-                  stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
-                  stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
-                  out[0] = stbi__compute_y(r, g, b);
-                  out[1] = 255;
-                  out += n;
-               }
-            } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
-               for (i=0; i < z->s->img_x; ++i) {
-                  out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
-                  out[1] = 255;
-                  out += n;
-               }
-            } else {
-               stbi_uc *y = coutput[0];
-               if (n == 1)
-                  for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
-               else
-                  for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
-            }
-         }
-      }
-      stbi__cleanup_jpeg(z);
-      *out_x = z->s->img_x;
-      *out_y = z->s->img_y;
-      if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
-      return output;
-   }
-}
-
-static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
-{
-   unsigned char* result;
-   stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
-   if (!j) return stbi__errpuc("outofmem", "Out of memory");
-   memset(j, 0, sizeof(stbi__jpeg));
-   STBI_NOTUSED(ri);
-   j->s = s;
-   stbi__setup_jpeg(j);
-   result = load_jpeg_image(j, x,y,comp,req_comp);
-   STBI_FREE(j);
-   return result;
-}
-
-static int stbi__jpeg_test(stbi__context *s)
-{
-   int r;
-   stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
-   if (!j) return stbi__err("outofmem", "Out of memory");
-   memset(j, 0, sizeof(stbi__jpeg));
-   j->s = s;
-   stbi__setup_jpeg(j);
-   r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
-   stbi__rewind(s);
-   STBI_FREE(j);
-   return r;
-}
-
-static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
-{
-   if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
-      stbi__rewind( j->s );
-      return 0;
-   }
-   if (x) *x = j->s->img_x;
-   if (y) *y = j->s->img_y;
-   if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
-   return 1;
-}
-
-static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   int result;
-   stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
-   if (!j) return stbi__err("outofmem", "Out of memory");
-   memset(j, 0, sizeof(stbi__jpeg));
-   j->s = s;
-   result = stbi__jpeg_info_raw(j, x, y, comp);
-   STBI_FREE(j);
-   return result;
-}
-#endif
-
-// public domain zlib decode    v0.2  Sean Barrett 2006-11-18
-//    simple implementation
-//      - all input must be provided in an upfront buffer
-//      - all output is written to a single output buffer (can malloc/realloc)
-//    performance
-//      - fast huffman
-
-#ifndef STBI_NO_ZLIB
-
-// fast-way is faster to check than jpeg huffman, but slow way is slower
-#define STBI__ZFAST_BITS  9 // accelerate all cases in default tables
-#define STBI__ZFAST_MASK  ((1 << STBI__ZFAST_BITS) - 1)
-#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet
-
-// zlib-style huffman encoding
-// (jpegs packs from left, zlib from right, so can't share code)
-typedef struct
-{
-   stbi__uint16 fast[1 << STBI__ZFAST_BITS];
-   stbi__uint16 firstcode[16];
-   int maxcode[17];
-   stbi__uint16 firstsymbol[16];
-   stbi_uc  size[STBI__ZNSYMS];
-   stbi__uint16 value[STBI__ZNSYMS];
-} stbi__zhuffman;
-
-stbi_inline static int stbi__bitreverse16(int n)
-{
-  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
-  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
-  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
-  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
-  return n;
-}
-
-stbi_inline static int stbi__bit_reverse(int v, int bits)
-{
-   STBI_ASSERT(bits <= 16);
-   // to bit reverse n bits, reverse 16 and shift
-   // e.g. 11 bits, bit reverse and shift away 5
-   return stbi__bitreverse16(v) >> (16-bits);
-}
-
-static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
-{
-   int i,k=0;
-   int code, next_code[16], sizes[17];
-
-   // DEFLATE spec for generating codes
-   memset(sizes, 0, sizeof(sizes));
-   memset(z->fast, 0, sizeof(z->fast));
-   for (i=0; i < num; ++i)
-      ++sizes[sizelist[i]];
-   sizes[0] = 0;
-   for (i=1; i < 16; ++i)
-      if (sizes[i] > (1 << i))
-         return stbi__err("bad sizes", "Corrupt PNG");
-   code = 0;
-   for (i=1; i < 16; ++i) {
-      next_code[i] = code;
-      z->firstcode[i] = (stbi__uint16) code;
-      z->firstsymbol[i] = (stbi__uint16) k;
-      code = (code + sizes[i]);
-      if (sizes[i])
-         if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
-      z->maxcode[i] = code << (16-i); // preshift for inner loop
-      code <<= 1;
-      k += sizes[i];
-   }
-   z->maxcode[16] = 0x10000; // sentinel
-   for (i=0; i < num; ++i) {
-      int s = sizelist[i];
-      if (s) {
-         int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
-         stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
-         z->size [c] = (stbi_uc     ) s;
-         z->value[c] = (stbi__uint16) i;
-         if (s <= STBI__ZFAST_BITS) {
-            int j = stbi__bit_reverse(next_code[s],s);
-            while (j < (1 << STBI__ZFAST_BITS)) {
-               z->fast[j] = fastv;
-               j += (1 << s);
-            }
-         }
-         ++next_code[s];
-      }
-   }
-   return 1;
-}
-
-// zlib-from-memory implementation for PNG reading
-//    because PNG allows splitting the zlib stream arbitrarily,
-//    and it's annoying structurally to have PNG call ZLIB call PNG,
-//    we require PNG read all the IDATs and combine them into a single
-//    memory buffer
-
-typedef struct
-{
-   stbi_uc *zbuffer, *zbuffer_end;
-   int num_bits;
-   stbi__uint32 code_buffer;
-
-   char *zout;
-   char *zout_start;
-   char *zout_end;
-   int   z_expandable;
-
-   stbi__zhuffman z_length, z_distance;
-} stbi__zbuf;
-
-stbi_inline static int stbi__zeof(stbi__zbuf *z)
-{
-   return (z->zbuffer >= z->zbuffer_end);
-}
-
-stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
-{
-   return stbi__zeof(z) ? 0 : *z->zbuffer++;
-}
-
-static void stbi__fill_bits(stbi__zbuf *z)
-{
-   do {
-      if (z->code_buffer >= (1U << z->num_bits)) {
-        z->zbuffer = z->zbuffer_end;  /* treat this as EOF so we fail. */
-        return;
-      }
-      z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
-      z->num_bits += 8;
-   } while (z->num_bits <= 24);
-}
-
-stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
-{
-   unsigned int k;
-   if (z->num_bits < n) stbi__fill_bits(z);
-   k = z->code_buffer & ((1 << n) - 1);
-   z->code_buffer >>= n;
-   z->num_bits -= n;
-   return k;
-}
-
-static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
-{
-   int b,s,k;
-   // not resolved by fast table, so compute it the slow way
-   // use jpeg approach, which requires MSbits at top
-   k = stbi__bit_reverse(a->code_buffer, 16);
-   for (s=STBI__ZFAST_BITS+1; ; ++s)
-      if (k < z->maxcode[s])
-         break;
-   if (s >= 16) return -1; // invalid code!
-   // code size is s, so:
-   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
-   if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere!
-   if (z->size[b] != s) return -1;  // was originally an assert, but report failure instead.
-   a->code_buffer >>= s;
-   a->num_bits -= s;
-   return z->value[b];
-}
-
-stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
-{
-   int b,s;
-   if (a->num_bits < 16) {
-      if (stbi__zeof(a)) {
-         return -1;   /* report error for unexpected end of data. */
-      }
-      stbi__fill_bits(a);
-   }
-   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
-   if (b) {
-      s = b >> 9;
-      a->code_buffer >>= s;
-      a->num_bits -= s;
-      return b & 511;
-   }
-   return stbi__zhuffman_decode_slowpath(a, z);
-}
-
-static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
-{
-   char *q;
-   unsigned int cur, limit, old_limit;
-   z->zout = zout;
-   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
-   cur   = (unsigned int) (z->zout - z->zout_start);
-   limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
-   if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
-   while (cur + n > limit) {
-      if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
-      limit *= 2;
-   }
-   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
-   STBI_NOTUSED(old_limit);
-   if (q == NULL) return stbi__err("outofmem", "Out of memory");
-   z->zout_start = q;
-   z->zout       = q + cur;
-   z->zout_end   = q + limit;
-   return 1;
-}
-
-static const int stbi__zlength_base[31] = {
-   3,4,5,6,7,8,9,10,11,13,
-   15,17,19,23,27,31,35,43,51,59,
-   67,83,99,115,131,163,195,227,258,0,0 };
-
-static const int stbi__zlength_extra[31]=
-{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
-
-static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
-257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
-
-static const int stbi__zdist_extra[32] =
-{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
-
-static int stbi__parse_huffman_block(stbi__zbuf *a)
-{
-   char *zout = a->zout;
-   for(;;) {
-      int z = stbi__zhuffman_decode(a, &a->z_length);
-      if (z < 256) {
-         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
-         if (zout >= a->zout_end) {
-            if (!stbi__zexpand(a, zout, 1)) return 0;
-            zout = a->zout;
-         }
-         *zout++ = (char) z;
-      } else {
-         stbi_uc *p;
-         int len,dist;
-         if (z == 256) {
-            a->zout = zout;
-            return 1;
-         }
-         if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data
-         z -= 257;
-         len = stbi__zlength_base[z];
-         if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
-         z = stbi__zhuffman_decode(a, &a->z_distance);
-         if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data
-         dist = stbi__zdist_base[z];
-         if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
-         if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
-         if (zout + len > a->zout_end) {
-            if (!stbi__zexpand(a, zout, len)) return 0;
-            zout = a->zout;
-         }
-         p = (stbi_uc *) (zout - dist);
-         if (dist == 1) { // run of one byte; common in images.
-            stbi_uc v = *p;
-            if (len) { do *zout++ = v; while (--len); }
-         } else {
-            if (len) { do *zout++ = *p++; while (--len); }
-         }
-      }
-   }
-}
-
-static int stbi__compute_huffman_codes(stbi__zbuf *a)
-{
-   static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
-   stbi__zhuffman z_codelength;
-   stbi_uc lencodes[286+32+137];//padding for maximum single op
-   stbi_uc codelength_sizes[19];
-   int i,n;
-
-   int hlit  = stbi__zreceive(a,5) + 257;
-   int hdist = stbi__zreceive(a,5) + 1;
-   int hclen = stbi__zreceive(a,4) + 4;
-   int ntot  = hlit + hdist;
-
-   memset(codelength_sizes, 0, sizeof(codelength_sizes));
-   for (i=0; i < hclen; ++i) {
-      int s = stbi__zreceive(a,3);
-      codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
-   }
-   if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
-
-   n = 0;
-   while (n < ntot) {
-      int c = stbi__zhuffman_decode(a, &z_codelength);
-      if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");
-      if (c < 16)
-         lencodes[n++] = (stbi_uc) c;
-      else {
-         stbi_uc fill = 0;
-         if (c == 16) {
-            c = stbi__zreceive(a,2)+3;
-            if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
-            fill = lencodes[n-1];
-         } else if (c == 17) {
-            c = stbi__zreceive(a,3)+3;
-         } else if (c == 18) {
-            c = stbi__zreceive(a,7)+11;
-         } else {
-            return stbi__err("bad codelengths", "Corrupt PNG");
-         }
-         if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
-         memset(lencodes+n, fill, c);
-         n += c;
-      }
-   }
-   if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");
-   if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
-   if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
-   return 1;
-}
-
-static int stbi__parse_uncompressed_block(stbi__zbuf *a)
-{
-   stbi_uc header[4];
-   int len,nlen,k;
-   if (a->num_bits & 7)
-      stbi__zreceive(a, a->num_bits & 7); // discard
-   // drain the bit-packed data into header
-   k = 0;
-   while (a->num_bits > 0) {
-      header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
-      a->code_buffer >>= 8;
-      a->num_bits -= 8;
-   }
-   if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");
-   // now fill header the normal way
-   while (k < 4)
-      header[k++] = stbi__zget8(a);
-   len  = header[1] * 256 + header[0];
-   nlen = header[3] * 256 + header[2];
-   if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
-   if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
-   if (a->zout + len > a->zout_end)
-      if (!stbi__zexpand(a, a->zout, len)) return 0;
-   memcpy(a->zout, a->zbuffer, len);
-   a->zbuffer += len;
-   a->zout += len;
-   return 1;
-}
-
-static int stbi__parse_zlib_header(stbi__zbuf *a)
-{
-   int cmf   = stbi__zget8(a);
-   int cm    = cmf & 15;
-   /* int cinfo = cmf >> 4; */
-   int flg   = stbi__zget8(a);
-   if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
-   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
-   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
-   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
-   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
-   return 1;
-}
-
-static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =
-{
-   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
-   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
-   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
-   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
-   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8
-};
-static const stbi_uc stbi__zdefault_distance[32] =
-{
-   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
-};
-/*
-Init algorithm:
-{
-   int i;   // use <= to match clearly with spec
-   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
-   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
-   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
-   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;
-
-   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
-}
-*/
-
-static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
-{
-   int final, type;
-   if (parse_header)
-      if (!stbi__parse_zlib_header(a)) return 0;
-   a->num_bits = 0;
-   a->code_buffer = 0;
-   do {
-      final = stbi__zreceive(a,1);
-      type = stbi__zreceive(a,2);
-      if (type == 0) {
-         if (!stbi__parse_uncompressed_block(a)) return 0;
-      } else if (type == 3) {
-         return 0;
-      } else {
-         if (type == 1) {
-            // use fixed code lengths
-            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , STBI__ZNSYMS)) return 0;
-            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
-         } else {
-            if (!stbi__compute_huffman_codes(a)) return 0;
-         }
-         if (!stbi__parse_huffman_block(a)) return 0;
-      }
-   } while (!final);
-   return 1;
-}
-
-static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
-{
-   a->zout_start = obuf;
-   a->zout       = obuf;
-   a->zout_end   = obuf + olen;
-   a->z_expandable = exp;
-
-   return stbi__parse_zlib(a, parse_header);
-}
-
-STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
-{
-   stbi__zbuf a;
-   char *p = (char *) stbi__malloc(initial_size);
-   if (p == NULL) return NULL;
-   a.zbuffer = (stbi_uc *) buffer;
-   a.zbuffer_end = (stbi_uc *) buffer + len;
-   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      STBI_FREE(a.zout_start);
-      return NULL;
-   }
-}
-
-STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
-{
-   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
-}
-
-STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
-{
-   stbi__zbuf a;
-   char *p = (char *) stbi__malloc(initial_size);
-   if (p == NULL) return NULL;
-   a.zbuffer = (stbi_uc *) buffer;
-   a.zbuffer_end = (stbi_uc *) buffer + len;
-   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      STBI_FREE(a.zout_start);
-      return NULL;
-   }
-}
-
-STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
-{
-   stbi__zbuf a;
-   a.zbuffer = (stbi_uc *) ibuffer;
-   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
-   if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
-      return (int) (a.zout - a.zout_start);
-   else
-      return -1;
-}
-
-STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
-{
-   stbi__zbuf a;
-   char *p = (char *) stbi__malloc(16384);
-   if (p == NULL) return NULL;
-   a.zbuffer = (stbi_uc *) buffer;
-   a.zbuffer_end = (stbi_uc *) buffer+len;
-   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
-      if (outlen) *outlen = (int) (a.zout - a.zout_start);
-      return a.zout_start;
-   } else {
-      STBI_FREE(a.zout_start);
-      return NULL;
-   }
-}
-
-STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
-{
-   stbi__zbuf a;
-   a.zbuffer = (stbi_uc *) ibuffer;
-   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
-   if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
-      return (int) (a.zout - a.zout_start);
-   else
-      return -1;
-}
-#endif
-
-// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18
-//    simple implementation
-//      - only 8-bit samples
-//      - no CRC checking
-//      - allocates lots of intermediate memory
-//        - avoids problem of streaming data between subsystems
-//        - avoids explicit window management
-//    performance
-//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding
-
-#ifndef STBI_NO_PNG
-typedef struct
-{
-   stbi__uint32 length;
-   stbi__uint32 type;
-} stbi__pngchunk;
-
-static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
-{
-   stbi__pngchunk c;
-   c.length = stbi__get32be(s);
-   c.type   = stbi__get32be(s);
-   return c;
-}
-
-static int stbi__check_png_header(stbi__context *s)
-{
-   static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
-   int i;
-   for (i=0; i < 8; ++i)
-      if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
-   return 1;
-}
-
-typedef struct
-{
-   stbi__context *s;
-   stbi_uc *idata, *expanded, *out;
-   int depth;
-} stbi__png;
-
-
-enum {
-   STBI__F_none=0,
-   STBI__F_sub=1,
-   STBI__F_up=2,
-   STBI__F_avg=3,
-   STBI__F_paeth=4,
-   // synthetic filters used for first scanline to avoid needing a dummy row of 0s
-   STBI__F_avg_first,
-   STBI__F_paeth_first
-};
-
-static stbi_uc first_row_filter[5] =
-{
-   STBI__F_none,
-   STBI__F_sub,
-   STBI__F_none,
-   STBI__F_avg_first,
-   STBI__F_paeth_first
-};
-
-static int stbi__paeth(int a, int b, int c)
-{
-   int p = a + b - c;
-   int pa = abs(p-a);
-   int pb = abs(p-b);
-   int pc = abs(p-c);
-   if (pa <= pb && pa <= pc) return a;
-   if (pb <= pc) return b;
-   return c;
-}
-
-static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
-
-// create the png data from post-deflated data
-static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
-{
-   int bytes = (depth == 16? 2 : 1);
-   stbi__context *s = a->s;
-   stbi__uint32 i,j,stride = x*out_n*bytes;
-   stbi__uint32 img_len, img_width_bytes;
-   int k;
-   int img_n = s->img_n; // copy it into a local for later
-
-   int output_bytes = out_n*bytes;
-   int filter_bytes = img_n*bytes;
-   int width = x;
-
-   STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
-   a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
-   if (!a->out) return stbi__err("outofmem", "Out of memory");
-
-   if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
-   img_width_bytes = (((img_n * x * depth) + 7) >> 3);
-   img_len = (img_width_bytes + 1) * y;
-
-   // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
-   // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
-   // so just check for raw_len < img_len always.
-   if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
-
-   for (j=0; j < y; ++j) {
-      stbi_uc *cur = a->out + stride*j;
-      stbi_uc *prior;
-      int filter = *raw++;
-
-      if (filter > 4)
-         return stbi__err("invalid filter","Corrupt PNG");
-
-      if (depth < 8) {
-         if (img_width_bytes > x) return stbi__err("invalid width","Corrupt PNG");
-         cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place
-         filter_bytes = 1;
-         width = img_width_bytes;
-      }
-      prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above
-
-      // if first row, use special filter that doesn't sample previous row
-      if (j == 0) filter = first_row_filter[filter];
-
-      // handle first byte explicitly
-      for (k=0; k < filter_bytes; ++k) {
-         switch (filter) {
-            case STBI__F_none       : cur[k] = raw[k]; break;
-            case STBI__F_sub        : cur[k] = raw[k]; break;
-            case STBI__F_up         : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
-            case STBI__F_avg        : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
-            case STBI__F_paeth      : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;
-            case STBI__F_avg_first  : cur[k] = raw[k]; break;
-            case STBI__F_paeth_first: cur[k] = raw[k]; break;
-         }
-      }
-
-      if (depth == 8) {
-         if (img_n != out_n)
-            cur[img_n] = 255; // first pixel
-         raw += img_n;
-         cur += out_n;
-         prior += out_n;
-      } else if (depth == 16) {
-         if (img_n != out_n) {
-            cur[filter_bytes]   = 255; // first pixel top byte
-            cur[filter_bytes+1] = 255; // first pixel bottom byte
-         }
-         raw += filter_bytes;
-         cur += output_bytes;
-         prior += output_bytes;
-      } else {
-         raw += 1;
-         cur += 1;
-         prior += 1;
-      }
-
-      // this is a little gross, so that we don't switch per-pixel or per-component
-      if (depth < 8 || img_n == out_n) {
-         int nk = (width - 1)*filter_bytes;
-         #define STBI__CASE(f) \
-             case f:     \
-                for (k=0; k < nk; ++k)
-         switch (filter) {
-            // "none" filter turns into a memcpy here; make that explicit.
-            case STBI__F_none:         memcpy(cur, raw, nk); break;
-            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;
-            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
-            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;
-            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;
-            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;
-            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break;
-         }
-         #undef STBI__CASE
-         raw += nk;
-      } else {
-         STBI_ASSERT(img_n+1 == out_n);
-         #define STBI__CASE(f) \
-             case f:     \
-                for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
-                   for (k=0; k < filter_bytes; ++k)
-         switch (filter) {
-            STBI__CASE(STBI__F_none)         { cur[k] = raw[k]; } break;
-            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;
-            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
-            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;
-            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;
-            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;
-            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break;
-         }
-         #undef STBI__CASE
-
-         // the loop above sets the high byte of the pixels' alpha, but for
-         // 16 bit png files we also need the low byte set. we'll do that here.
-         if (depth == 16) {
-            cur = a->out + stride*j; // start at the beginning of the row again
-            for (i=0; i < x; ++i,cur+=output_bytes) {
-               cur[filter_bytes+1] = 255;
-            }
-         }
-      }
-   }
-
-   // we make a separate pass to expand bits to pixels; for performance,
-   // this could run two scanlines behind the above code, so it won't
-   // intefere with filtering but will still be in the cache.
-   if (depth < 8) {
-      for (j=0; j < y; ++j) {
-         stbi_uc *cur = a->out + stride*j;
-         stbi_uc *in  = a->out + stride*j + x*out_n - img_width_bytes;
-         // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit
-         // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop
-         stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
-
-         // note that the final byte might overshoot and write more data than desired.
-         // we can allocate enough data that this never writes out of memory, but it
-         // could also overwrite the next scanline. can it overwrite non-empty data
-         // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.
-         // so we need to explicitly clamp the final ones
-
-         if (depth == 4) {
-            for (k=x*img_n; k >= 2; k-=2, ++in) {
-               *cur++ = scale * ((*in >> 4)       );
-               *cur++ = scale * ((*in     ) & 0x0f);
-            }
-            if (k > 0) *cur++ = scale * ((*in >> 4)       );
-         } else if (depth == 2) {
-            for (k=x*img_n; k >= 4; k-=4, ++in) {
-               *cur++ = scale * ((*in >> 6)       );
-               *cur++ = scale * ((*in >> 4) & 0x03);
-               *cur++ = scale * ((*in >> 2) & 0x03);
-               *cur++ = scale * ((*in     ) & 0x03);
-            }
-            if (k > 0) *cur++ = scale * ((*in >> 6)       );
-            if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
-            if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
-         } else if (depth == 1) {
-            for (k=x*img_n; k >= 8; k-=8, ++in) {
-               *cur++ = scale * ((*in >> 7)       );
-               *cur++ = scale * ((*in >> 6) & 0x01);
-               *cur++ = scale * ((*in >> 5) & 0x01);
-               *cur++ = scale * ((*in >> 4) & 0x01);
-               *cur++ = scale * ((*in >> 3) & 0x01);
-               *cur++ = scale * ((*in >> 2) & 0x01);
-               *cur++ = scale * ((*in >> 1) & 0x01);
-               *cur++ = scale * ((*in     ) & 0x01);
-            }
-            if (k > 0) *cur++ = scale * ((*in >> 7)       );
-            if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
-            if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
-            if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
-            if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
-            if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
-            if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
-         }
-         if (img_n != out_n) {
-            int q;
-            // insert alpha = 255
-            cur = a->out + stride*j;
-            if (img_n == 1) {
-               for (q=x-1; q >= 0; --q) {
-                  cur[q*2+1] = 255;
-                  cur[q*2+0] = cur[q];
-               }
-            } else {
-               STBI_ASSERT(img_n == 3);
-               for (q=x-1; q >= 0; --q) {
-                  cur[q*4+3] = 255;
-                  cur[q*4+2] = cur[q*3+2];
-                  cur[q*4+1] = cur[q*3+1];
-                  cur[q*4+0] = cur[q*3+0];
-               }
-            }
-         }
-      }
-   } else if (depth == 16) {
-      // force the image data from big-endian to platform-native.
-      // this is done in a separate pass due to the decoding relying
-      // on the data being untouched, but could probably be done
-      // per-line during decode if care is taken.
-      stbi_uc *cur = a->out;
-      stbi__uint16 *cur16 = (stbi__uint16*)cur;
-
-      for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
-         *cur16 = (cur[0] << 8) | cur[1];
-      }
-   }
-
-   return 1;
-}
-
-static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
-{
-   int bytes = (depth == 16 ? 2 : 1);
-   int out_bytes = out_n * bytes;
-   stbi_uc *final;
-   int p;
-   if (!interlaced)
-      return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
-
-   // de-interlacing
-   final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
-   if (!final) return stbi__err("outofmem", "Out of memory");
-   for (p=0; p < 7; ++p) {
-      int xorig[] = { 0,4,0,2,0,1,0 };
-      int yorig[] = { 0,0,4,0,2,0,1 };
-      int xspc[]  = { 8,8,4,4,2,2,1 };
-      int yspc[]  = { 8,8,8,4,4,2,2 };
-      int i,j,x,y;
-      // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
-      x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
-      y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
-      if (x && y) {
-         stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
-         if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
-            STBI_FREE(final);
-            return 0;
-         }
-         for (j=0; j < y; ++j) {
-            for (i=0; i < x; ++i) {
-               int out_y = j*yspc[p]+yorig[p];
-               int out_x = i*xspc[p]+xorig[p];
-               memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
-                      a->out + (j*x+i)*out_bytes, out_bytes);
-            }
-         }
-         STBI_FREE(a->out);
-         image_data += img_len;
-         image_data_len -= img_len;
-      }
-   }
-   a->out = final;
-
-   return 1;
-}
-
-static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
-{
-   stbi__context *s = z->s;
-   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
-   stbi_uc *p = z->out;
-
-   // compute color-based transparency, assuming we've
-   // already got 255 as the alpha value in the output
-   STBI_ASSERT(out_n == 2 || out_n == 4);
-
-   if (out_n == 2) {
-      for (i=0; i < pixel_count; ++i) {
-         p[1] = (p[0] == tc[0] ? 0 : 255);
-         p += 2;
-      }
-   } else {
-      for (i=0; i < pixel_count; ++i) {
-         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
-            p[3] = 0;
-         p += 4;
-      }
-   }
-   return 1;
-}
-
-static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
-{
-   stbi__context *s = z->s;
-   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
-   stbi__uint16 *p = (stbi__uint16*) z->out;
-
-   // compute color-based transparency, assuming we've
-   // already got 65535 as the alpha value in the output
-   STBI_ASSERT(out_n == 2 || out_n == 4);
-
-   if (out_n == 2) {
-      for (i = 0; i < pixel_count; ++i) {
-         p[1] = (p[0] == tc[0] ? 0 : 65535);
-         p += 2;
-      }
-   } else {
-      for (i = 0; i < pixel_count; ++i) {
-         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
-            p[3] = 0;
-         p += 4;
-      }
-   }
-   return 1;
-}
-
-static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
-{
-   stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
-   stbi_uc *p, *temp_out, *orig = a->out;
-
-   p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
-   if (p == NULL) return stbi__err("outofmem", "Out of memory");
-
-   // between here and free(out) below, exitting would leak
-   temp_out = p;
-
-   if (pal_img_n == 3) {
-      for (i=0; i < pixel_count; ++i) {
-         int n = orig[i]*4;
-         p[0] = palette[n  ];
-         p[1] = palette[n+1];
-         p[2] = palette[n+2];
-         p += 3;
-      }
-   } else {
-      for (i=0; i < pixel_count; ++i) {
-         int n = orig[i]*4;
-         p[0] = palette[n  ];
-         p[1] = palette[n+1];
-         p[2] = palette[n+2];
-         p[3] = palette[n+3];
-         p += 4;
-      }
-   }
-   STBI_FREE(a->out);
-   a->out = temp_out;
-
-   STBI_NOTUSED(len);
-
-   return 1;
-}
-
-static int stbi__unpremultiply_on_load_global = 0;
-static int stbi__de_iphone_flag_global = 0;
-
-STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
-{
-   stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;
-}
-
-STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
-{
-   stbi__de_iphone_flag_global = flag_true_if_should_convert;
-}
-
-#ifndef STBI_THREAD_LOCAL
-#define stbi__unpremultiply_on_load  stbi__unpremultiply_on_load_global
-#define stbi__de_iphone_flag  stbi__de_iphone_flag_global
-#else
-static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;
-static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;
-
-STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
-{
-   stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
-   stbi__unpremultiply_on_load_set = 1;
-}
-
-STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)
-{
-   stbi__de_iphone_flag_local = flag_true_if_should_convert;
-   stbi__de_iphone_flag_set = 1;
-}
-
-#define stbi__unpremultiply_on_load  (stbi__unpremultiply_on_load_set           \
-                                       ? stbi__unpremultiply_on_load_local      \
-                                       : stbi__unpremultiply_on_load_global)
-#define stbi__de_iphone_flag  (stbi__de_iphone_flag_set                         \
-                                ? stbi__de_iphone_flag_local                    \
-                                : stbi__de_iphone_flag_global)
-#endif // STBI_THREAD_LOCAL
-
-static void stbi__de_iphone(stbi__png *z)
-{
-   stbi__context *s = z->s;
-   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
-   stbi_uc *p = z->out;
-
-   if (s->img_out_n == 3) {  // convert bgr to rgb
-      for (i=0; i < pixel_count; ++i) {
-         stbi_uc t = p[0];
-         p[0] = p[2];
-         p[2] = t;
-         p += 3;
-      }
-   } else {
-      STBI_ASSERT(s->img_out_n == 4);
-      if (stbi__unpremultiply_on_load) {
-         // convert bgr to rgb and unpremultiply
-         for (i=0; i < pixel_count; ++i) {
-            stbi_uc a = p[3];
-            stbi_uc t = p[0];
-            if (a) {
-               stbi_uc half = a / 2;
-               p[0] = (p[2] * 255 + half) / a;
-               p[1] = (p[1] * 255 + half) / a;
-               p[2] = ( t   * 255 + half) / a;
-            } else {
-               p[0] = p[2];
-               p[2] = t;
-            }
-            p += 4;
-         }
-      } else {
-         // convert bgr to rgb
-         for (i=0; i < pixel_count; ++i) {
-            stbi_uc t = p[0];
-            p[0] = p[2];
-            p[2] = t;
-            p += 4;
-         }
-      }
-   }
-}
-
-#define STBI__PNG_TYPE(a,b,c,d)  (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
-
-static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
-{
-   stbi_uc palette[1024], pal_img_n=0;
-   stbi_uc has_trans=0, tc[3]={0};
-   stbi__uint16 tc16[3];
-   stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
-   int first=1,k,interlace=0, color=0, is_iphone=0;
-   stbi__context *s = z->s;
-
-   z->expanded = NULL;
-   z->idata = NULL;
-   z->out = NULL;
-
-   if (!stbi__check_png_header(s)) return 0;
-
-   if (scan == STBI__SCAN_type) return 1;
-
-   for (;;) {
-      stbi__pngchunk c = stbi__get_chunk_header(s);
-      switch (c.type) {
-         case STBI__PNG_TYPE('C','g','B','I'):
-            is_iphone = 1;
-            stbi__skip(s, c.length);
-            break;
-         case STBI__PNG_TYPE('I','H','D','R'): {
-            int comp,filter;
-            if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
-            first = 0;
-            if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
-            s->img_x = stbi__get32be(s);
-            s->img_y = stbi__get32be(s);
-            if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
-            if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
-            z->depth = stbi__get8(s);  if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)  return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
-            color = stbi__get8(s);  if (color > 6)         return stbi__err("bad ctype","Corrupt PNG");
-            if (color == 3 && z->depth == 16)                  return stbi__err("bad ctype","Corrupt PNG");
-            if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
-            comp  = stbi__get8(s);  if (comp) return stbi__err("bad comp method","Corrupt PNG");
-            filter= stbi__get8(s);  if (filter) return stbi__err("bad filter method","Corrupt PNG");
-            interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
-            if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
-            if (!pal_img_n) {
-               s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
-               if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
-            } else {
-               // if paletted, then pal_n is our final components, and
-               // img_n is # components to decompress/filter.
-               s->img_n = 1;
-               if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
-            }
-            // even with SCAN_header, have to scan to see if we have a tRNS
-            break;
-         }
-
-         case STBI__PNG_TYPE('P','L','T','E'):  {
-            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
-            if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
-            pal_len = c.length / 3;
-            if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
-            for (i=0; i < pal_len; ++i) {
-               palette[i*4+0] = stbi__get8(s);
-               palette[i*4+1] = stbi__get8(s);
-               palette[i*4+2] = stbi__get8(s);
-               palette[i*4+3] = 255;
-            }
-            break;
-         }
-
-         case STBI__PNG_TYPE('t','R','N','S'): {
-            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
-            if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
-            if (pal_img_n) {
-               if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
-               if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
-               if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
-               pal_img_n = 4;
-               for (i=0; i < c.length; ++i)
-                  palette[i*4+3] = stbi__get8(s);
-            } else {
-               if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
-               if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
-               has_trans = 1;
-               // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.
-               if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }
-               if (z->depth == 16) {
-                  for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
-               } else {
-                  for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
-               }
-            }
-            break;
-         }
-
-         case STBI__PNG_TYPE('I','D','A','T'): {
-            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
-            if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
-            if (scan == STBI__SCAN_header) {
-               // header scan definitely stops at first IDAT
-               if (pal_img_n)
-                  s->img_n = pal_img_n;
-               return 1;
-            }
-            if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes");
-            if ((int)(ioff + c.length) < (int)ioff) return 0;
-            if (ioff + c.length > idata_limit) {
-               stbi__uint32 idata_limit_old = idata_limit;
-               stbi_uc *p;
-               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
-               while (ioff + c.length > idata_limit)
-                  idata_limit *= 2;
-               STBI_NOTUSED(idata_limit_old);
-               p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
-               z->idata = p;
-            }
-            if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
-            ioff += c.length;
-            break;
-         }
-
-         case STBI__PNG_TYPE('I','E','N','D'): {
-            stbi__uint32 raw_len, bpl;
-            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
-            if (scan != STBI__SCAN_load) return 1;
-            if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
-            // initial guess for decoded data size to avoid unnecessary reallocs
-            bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
-            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
-            z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
-            if (z->expanded == NULL) return 0; // zlib should set error
-            STBI_FREE(z->idata); z->idata = NULL;
-            if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
-               s->img_out_n = s->img_n+1;
-            else
-               s->img_out_n = s->img_n;
-            if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
-            if (has_trans) {
-               if (z->depth == 16) {
-                  if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
-               } else {
-                  if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
-               }
-            }
-            if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
-               stbi__de_iphone(z);
-            if (pal_img_n) {
-               // pal_img_n == 3 or 4
-               s->img_n = pal_img_n; // record the actual colors we had
-               s->img_out_n = pal_img_n;
-               if (req_comp >= 3) s->img_out_n = req_comp;
-               if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
-                  return 0;
-            } else if (has_trans) {
-               // non-paletted image with tRNS -> source image has (constant) alpha
-               ++s->img_n;
-            }
-            STBI_FREE(z->expanded); z->expanded = NULL;
-            // end of PNG chunk, read and skip CRC
-            stbi__get32be(s);
-            return 1;
-         }
-
-         default:
-            // if critical, fail
-            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
-            if ((c.type & (1 << 29)) == 0) {
-               #ifndef STBI_NO_FAILURE_STRINGS
-               // not threadsafe
-               static char invalid_chunk[] = "XXXX PNG chunk not known";
-               invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
-               invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
-               invalid_chunk[2] = STBI__BYTECAST(c.type >>  8);
-               invalid_chunk[3] = STBI__BYTECAST(c.type >>  0);
-               #endif
-               return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
-            }
-            stbi__skip(s, c.length);
-            break;
-      }
-      // end of PNG chunk, read and skip CRC
-      stbi__get32be(s);
-   }
-}
-
-static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
-{
-   void *result=NULL;
-   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
-   if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
-      if (p->depth <= 8)
-         ri->bits_per_channel = 8;
-      else if (p->depth == 16)
-         ri->bits_per_channel = 16;
-      else
-         return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth");
-      result = p->out;
-      p->out = NULL;
-      if (req_comp && req_comp != p->s->img_out_n) {
-         if (ri->bits_per_channel == 8)
-            result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
-         else
-            result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
-         p->s->img_out_n = req_comp;
-         if (result == NULL) return result;
-      }
-      *x = p->s->img_x;
-      *y = p->s->img_y;
-      if (n) *n = p->s->img_n;
-   }
-   STBI_FREE(p->out);      p->out      = NULL;
-   STBI_FREE(p->expanded); p->expanded = NULL;
-   STBI_FREE(p->idata);    p->idata    = NULL;
-
-   return result;
-}
-
-static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
-{
-   stbi__png p;
-   p.s = s;
-   return stbi__do_png(&p, x,y,comp,req_comp, ri);
-}
-
-static int stbi__png_test(stbi__context *s)
-{
-   int r;
-   r = stbi__check_png_header(s);
-   stbi__rewind(s);
-   return r;
-}
-
-static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
-{
-   if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
-      stbi__rewind( p->s );
-      return 0;
-   }
-   if (x) *x = p->s->img_x;
-   if (y) *y = p->s->img_y;
-   if (comp) *comp = p->s->img_n;
-   return 1;
-}
-
-static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   stbi__png p;
-   p.s = s;
-   return stbi__png_info_raw(&p, x, y, comp);
-}
-
-static int stbi__png_is16(stbi__context *s)
-{
-   stbi__png p;
-   p.s = s;
-   if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
-	   return 0;
-   if (p.depth != 16) {
-      stbi__rewind(p.s);
-      return 0;
-   }
-   return 1;
-}
-#endif
-
-// Microsoft/Windows BMP image
-
-#ifndef STBI_NO_BMP
-static int stbi__bmp_test_raw(stbi__context *s)
-{
-   int r;
-   int sz;
-   if (stbi__get8(s) != 'B') return 0;
-   if (stbi__get8(s) != 'M') return 0;
-   stbi__get32le(s); // discard filesize
-   stbi__get16le(s); // discard reserved
-   stbi__get16le(s); // discard reserved
-   stbi__get32le(s); // discard data offset
-   sz = stbi__get32le(s);
-   r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
-   return r;
-}
-
-static int stbi__bmp_test(stbi__context *s)
-{
-   int r = stbi__bmp_test_raw(s);
-   stbi__rewind(s);
-   return r;
-}
-
-
-// returns 0..31 for the highest set bit
-static int stbi__high_bit(unsigned int z)
-{
-   int n=0;
-   if (z == 0) return -1;
-   if (z >= 0x10000) { n += 16; z >>= 16; }
-   if (z >= 0x00100) { n +=  8; z >>=  8; }
-   if (z >= 0x00010) { n +=  4; z >>=  4; }
-   if (z >= 0x00004) { n +=  2; z >>=  2; }
-   if (z >= 0x00002) { n +=  1;/* >>=  1;*/ }
-   return n;
-}
-
-static int stbi__bitcount(unsigned int a)
-{
-   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
-   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
-   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
-   a = (a + (a >> 8)); // max 16 per 8 bits
-   a = (a + (a >> 16)); // max 32 per 8 bits
-   return a & 0xff;
-}
-
-// extract an arbitrarily-aligned N-bit value (N=bits)
-// from v, and then make it 8-bits long and fractionally
-// extend it to full full range.
-static int stbi__shiftsigned(unsigned int v, int shift, int bits)
-{
-   static unsigned int mul_table[9] = {
-      0,
-      0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
-      0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
-   };
-   static unsigned int shift_table[9] = {
-      0, 0,0,1,0,2,4,6,0,
-   };
-   if (shift < 0)
-      v <<= -shift;
-   else
-      v >>= shift;
-   STBI_ASSERT(v < 256);
-   v >>= (8-bits);
-   STBI_ASSERT(bits >= 0 && bits <= 8);
-   return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
-}
-
-typedef struct
-{
-   int bpp, offset, hsz;
-   unsigned int mr,mg,mb,ma, all_a;
-   int extra_read;
-} stbi__bmp_data;
-
-static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)
-{
-   // BI_BITFIELDS specifies masks explicitly, don't override
-   if (compress == 3)
-      return 1;
-
-   if (compress == 0) {
-      if (info->bpp == 16) {
-         info->mr = 31u << 10;
-         info->mg = 31u <<  5;
-         info->mb = 31u <<  0;
-      } else if (info->bpp == 32) {
-         info->mr = 0xffu << 16;
-         info->mg = 0xffu <<  8;
-         info->mb = 0xffu <<  0;
-         info->ma = 0xffu << 24;
-         info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
-      } else {
-         // otherwise, use defaults, which is all-0
-         info->mr = info->mg = info->mb = info->ma = 0;
-      }
-      return 1;
-   }
-   return 0; // error
-}
-
-static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
-{
-   int hsz;
-   if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
-   stbi__get32le(s); // discard filesize
-   stbi__get16le(s); // discard reserved
-   stbi__get16le(s); // discard reserved
-   info->offset = stbi__get32le(s);
-   info->hsz = hsz = stbi__get32le(s);
-   info->mr = info->mg = info->mb = info->ma = 0;
-   info->extra_read = 14;
-
-   if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP");
-
-   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
-   if (hsz == 12) {
-      s->img_x = stbi__get16le(s);
-      s->img_y = stbi__get16le(s);
-   } else {
-      s->img_x = stbi__get32le(s);
-      s->img_y = stbi__get32le(s);
-   }
-   if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
-   info->bpp = stbi__get16le(s);
-   if (hsz != 12) {
-      int compress = stbi__get32le(s);
-      if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
-      if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes
-      if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel
-      stbi__get32le(s); // discard sizeof
-      stbi__get32le(s); // discard hres
-      stbi__get32le(s); // discard vres
-      stbi__get32le(s); // discard colorsused
-      stbi__get32le(s); // discard max important
-      if (hsz == 40 || hsz == 56) {
-         if (hsz == 56) {
-            stbi__get32le(s);
-            stbi__get32le(s);
-            stbi__get32le(s);
-            stbi__get32le(s);
-         }
-         if (info->bpp == 16 || info->bpp == 32) {
-            if (compress == 0) {
-               stbi__bmp_set_mask_defaults(info, compress);
-            } else if (compress == 3) {
-               info->mr = stbi__get32le(s);
-               info->mg = stbi__get32le(s);
-               info->mb = stbi__get32le(s);
-               info->extra_read += 12;
-               // not documented, but generated by photoshop and handled by mspaint
-               if (info->mr == info->mg && info->mg == info->mb) {
-                  // ?!?!?
-                  return stbi__errpuc("bad BMP", "bad BMP");
-               }
-            } else
-               return stbi__errpuc("bad BMP", "bad BMP");
-         }
-      } else {
-         // V4/V5 header
-         int i;
-         if (hsz != 108 && hsz != 124)
-            return stbi__errpuc("bad BMP", "bad BMP");
-         info->mr = stbi__get32le(s);
-         info->mg = stbi__get32le(s);
-         info->mb = stbi__get32le(s);
-         info->ma = stbi__get32le(s);
-         if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs
-            stbi__bmp_set_mask_defaults(info, compress);
-         stbi__get32le(s); // discard color space
-         for (i=0; i < 12; ++i)
-            stbi__get32le(s); // discard color space parameters
-         if (hsz == 124) {
-            stbi__get32le(s); // discard rendering intent
-            stbi__get32le(s); // discard offset of profile data
-            stbi__get32le(s); // discard size of profile data
-            stbi__get32le(s); // discard reserved
-         }
-      }
-   }
-   return (void *) 1;
-}
-
-
-static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
-{
-   stbi_uc *out;
-   unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
-   stbi_uc pal[256][4];
-   int psize=0,i,j,width;
-   int flip_vertically, pad, target;
-   stbi__bmp_data info;
-   STBI_NOTUSED(ri);
-
-   info.all_a = 255;
-   if (stbi__bmp_parse_header(s, &info) == NULL)
-      return NULL; // error code already set
-
-   flip_vertically = ((int) s->img_y) > 0;
-   s->img_y = abs((int) s->img_y);
-
-   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
-   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
-
-   mr = info.mr;
-   mg = info.mg;
-   mb = info.mb;
-   ma = info.ma;
-   all_a = info.all_a;
-
-   if (info.hsz == 12) {
-      if (info.bpp < 24)
-         psize = (info.offset - info.extra_read - 24) / 3;
-   } else {
-      if (info.bpp < 16)
-         psize = (info.offset - info.extra_read - info.hsz) >> 2;
-   }
-   if (psize == 0) {
-      // accept some number of extra bytes after the header, but if the offset points either to before
-      // the header ends or implies a large amount of extra data, reject the file as malformed
-      int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);
-      int header_limit = 1024; // max we actually read is below 256 bytes currently.
-      int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.
-      if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {
-         return stbi__errpuc("bad header", "Corrupt BMP");
-      }
-      // we established that bytes_read_so_far is positive and sensible.
-      // the first half of this test rejects offsets that are either too small positives, or
-      // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn
-      // ensures the number computed in the second half of the test can't overflow.
-      if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {
-         return stbi__errpuc("bad offset", "Corrupt BMP");
-      } else {
-         stbi__skip(s, info.offset - bytes_read_so_far);
-      }
-   }
-
-   if (info.bpp == 24 && ma == 0xff000000)
-      s->img_n = 3;
-   else
-      s->img_n = ma ? 4 : 3;
-   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
-      target = req_comp;
-   else
-      target = s->img_n; // if they want monochrome, we'll post-convert
-
-   // sanity-check size
-   if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
-      return stbi__errpuc("too large", "Corrupt BMP");
-
-   out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
-   if (!out) return stbi__errpuc("outofmem", "Out of memory");
-   if (info.bpp < 16) {
-      int z=0;
-      if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
-      for (i=0; i < psize; ++i) {
-         pal[i][2] = stbi__get8(s);
-         pal[i][1] = stbi__get8(s);
-         pal[i][0] = stbi__get8(s);
-         if (info.hsz != 12) stbi__get8(s);
-         pal[i][3] = 255;
-      }
-      stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
-      if (info.bpp == 1) width = (s->img_x + 7) >> 3;
-      else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
-      else if (info.bpp == 8) width = s->img_x;
-      else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
-      pad = (-width)&3;
-      if (info.bpp == 1) {
-         for (j=0; j < (int) s->img_y; ++j) {
-            int bit_offset = 7, v = stbi__get8(s);
-            for (i=0; i < (int) s->img_x; ++i) {
-               int color = (v>>bit_offset)&0x1;
-               out[z++] = pal[color][0];
-               out[z++] = pal[color][1];
-               out[z++] = pal[color][2];
-               if (target == 4) out[z++] = 255;
-               if (i+1 == (int) s->img_x) break;
-               if((--bit_offset) < 0) {
-                  bit_offset = 7;
-                  v = stbi__get8(s);
-               }
-            }
-            stbi__skip(s, pad);
-         }
-      } else {
-         for (j=0; j < (int) s->img_y; ++j) {
-            for (i=0; i < (int) s->img_x; i += 2) {
-               int v=stbi__get8(s),v2=0;
-               if (info.bpp == 4) {
-                  v2 = v & 15;
-                  v >>= 4;
-               }
-               out[z++] = pal[v][0];
-               out[z++] = pal[v][1];
-               out[z++] = pal[v][2];
-               if (target == 4) out[z++] = 255;
-               if (i+1 == (int) s->img_x) break;
-               v = (info.bpp == 8) ? stbi__get8(s) : v2;
-               out[z++] = pal[v][0];
-               out[z++] = pal[v][1];
-               out[z++] = pal[v][2];
-               if (target == 4) out[z++] = 255;
-            }
-            stbi__skip(s, pad);
-         }
-      }
-   } else {
-      int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
-      int z = 0;
-      int easy=0;
-      stbi__skip(s, info.offset - info.extra_read - info.hsz);
-      if (info.bpp == 24) width = 3 * s->img_x;
-      else if (info.bpp == 16) width = 2*s->img_x;
-      else /* bpp = 32 and pad = 0 */ width=0;
-      pad = (-width) & 3;
-      if (info.bpp == 24) {
-         easy = 1;
-      } else if (info.bpp == 32) {
-         if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
-            easy = 2;
-      }
-      if (!easy) {
-         if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
-         // right shift amt to put high bit in position #7
-         rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
-         gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
-         bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
-         ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
-         if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
-      }
-      for (j=0; j < (int) s->img_y; ++j) {
-         if (easy) {
-            for (i=0; i < (int) s->img_x; ++i) {
-               unsigned char a;
-               out[z+2] = stbi__get8(s);
-               out[z+1] = stbi__get8(s);
-               out[z+0] = stbi__get8(s);
-               z += 3;
-               a = (easy == 2 ? stbi__get8(s) : 255);
-               all_a |= a;
-               if (target == 4) out[z++] = a;
-            }
-         } else {
-            int bpp = info.bpp;
-            for (i=0; i < (int) s->img_x; ++i) {
-               stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
-               unsigned int a;
-               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
-               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
-               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
-               a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
-               all_a |= a;
-               if (target == 4) out[z++] = STBI__BYTECAST(a);
-            }
-         }
-         stbi__skip(s, pad);
-      }
-   }
-
-   // if alpha channel is all 0s, replace with all 255s
-   if (target == 4 && all_a == 0)
-      for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
-         out[i] = 255;
-
-   if (flip_vertically) {
-      stbi_uc t;
-      for (j=0; j < (int) s->img_y>>1; ++j) {
-         stbi_uc *p1 = out +      j     *s->img_x*target;
-         stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
-         for (i=0; i < (int) s->img_x*target; ++i) {
-            t = p1[i]; p1[i] = p2[i]; p2[i] = t;
-         }
-      }
-   }
-
-   if (req_comp && req_comp != target) {
-      out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
-      if (out == NULL) return out; // stbi__convert_format frees input on failure
-   }
-
-   *x = s->img_x;
-   *y = s->img_y;
-   if (comp) *comp = s->img_n;
-   return out;
-}
-#endif
-
-// Targa Truevision - TGA
-// by Jonathan Dummer
-#ifndef STBI_NO_TGA
-// returns STBI_rgb or whatever, 0 on error
-static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
-{
-   // only RGB or RGBA (incl. 16bit) or grey allowed
-   if (is_rgb16) *is_rgb16 = 0;
-   switch(bits_per_pixel) {
-      case 8:  return STBI_grey;
-      case 16: if(is_grey) return STBI_grey_alpha;
-               // fallthrough
-      case 15: if(is_rgb16) *is_rgb16 = 1;
-               return STBI_rgb;
-      case 24: // fallthrough
-      case 32: return bits_per_pixel/8;
-      default: return 0;
-   }
-}
-
-static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
-{
-    int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
-    int sz, tga_colormap_type;
-    stbi__get8(s);                   // discard Offset
-    tga_colormap_type = stbi__get8(s); // colormap type
-    if( tga_colormap_type > 1 ) {
-        stbi__rewind(s);
-        return 0;      // only RGB or indexed allowed
-    }
-    tga_image_type = stbi__get8(s); // image type
-    if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
-        if (tga_image_type != 1 && tga_image_type != 9) {
-            stbi__rewind(s);
-            return 0;
-        }
-        stbi__skip(s,4);       // skip index of first colormap entry and number of entries
-        sz = stbi__get8(s);    //   check bits per palette color entry
-        if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
-            stbi__rewind(s);
-            return 0;
-        }
-        stbi__skip(s,4);       // skip image x and y origin
-        tga_colormap_bpp = sz;
-    } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
-        if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
-            stbi__rewind(s);
-            return 0; // only RGB or grey allowed, +/- RLE
-        }
-        stbi__skip(s,9); // skip colormap specification and image x/y origin
-        tga_colormap_bpp = 0;
-    }
-    tga_w = stbi__get16le(s);
-    if( tga_w < 1 ) {
-        stbi__rewind(s);
-        return 0;   // test width
-    }
-    tga_h = stbi__get16le(s);
-    if( tga_h < 1 ) {
-        stbi__rewind(s);
-        return 0;   // test height
-    }
-    tga_bits_per_pixel = stbi__get8(s); // bits per pixel
-    stbi__get8(s); // ignore alpha bits
-    if (tga_colormap_bpp != 0) {
-        if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
-            // when using a colormap, tga_bits_per_pixel is the size of the indexes
-            // I don't think anything but 8 or 16bit indexes makes sense
-            stbi__rewind(s);
-            return 0;
-        }
-        tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
-    } else {
-        tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
-    }
-    if(!tga_comp) {
-      stbi__rewind(s);
-      return 0;
-    }
-    if (x) *x = tga_w;
-    if (y) *y = tga_h;
-    if (comp) *comp = tga_comp;
-    return 1;                   // seems to have passed everything
-}
-
-static int stbi__tga_test(stbi__context *s)
-{
-   int res = 0;
-   int sz, tga_color_type;
-   stbi__get8(s);      //   discard Offset
-   tga_color_type = stbi__get8(s);   //   color type
-   if ( tga_color_type > 1 ) goto errorEnd;   //   only RGB or indexed allowed
-   sz = stbi__get8(s);   //   image type
-   if ( tga_color_type == 1 ) { // colormapped (paletted) image
-      if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
-      stbi__skip(s,4);       // skip index of first colormap entry and number of entries
-      sz = stbi__get8(s);    //   check bits per palette color entry
-      if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
-      stbi__skip(s,4);       // skip image x and y origin
-   } else { // "normal" image w/o colormap
-      if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
-      stbi__skip(s,9); // skip colormap specification and image x/y origin
-   }
-   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test width
-   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test height
-   sz = stbi__get8(s);   //   bits per pixel
-   if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
-   if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
-
-   res = 1; // if we got this far, everything's good and we can return 1 instead of 0
-
-errorEnd:
-   stbi__rewind(s);
-   return res;
-}
-
-// read 16bit value and convert to 24bit RGB
-static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
-{
-   stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
-   stbi__uint16 fiveBitMask = 31;
-   // we have 3 channels with 5bits each
-   int r = (px >> 10) & fiveBitMask;
-   int g = (px >> 5) & fiveBitMask;
-   int b = px & fiveBitMask;
-   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
-   out[0] = (stbi_uc)((r * 255)/31);
-   out[1] = (stbi_uc)((g * 255)/31);
-   out[2] = (stbi_uc)((b * 255)/31);
-
-   // some people claim that the most significant bit might be used for alpha
-   // (possibly if an alpha-bit is set in the "image descriptor byte")
-   // but that only made 16bit test images completely translucent..
-   // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
-}
-
-static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
-{
-   //   read in the TGA header stuff
-   int tga_offset = stbi__get8(s);
-   int tga_indexed = stbi__get8(s);
-   int tga_image_type = stbi__get8(s);
-   int tga_is_RLE = 0;
-   int tga_palette_start = stbi__get16le(s);
-   int tga_palette_len = stbi__get16le(s);
-   int tga_palette_bits = stbi__get8(s);
-   int tga_x_origin = stbi__get16le(s);
-   int tga_y_origin = stbi__get16le(s);
-   int tga_width = stbi__get16le(s);
-   int tga_height = stbi__get16le(s);
-   int tga_bits_per_pixel = stbi__get8(s);
-   int tga_comp, tga_rgb16=0;
-   int tga_inverted = stbi__get8(s);
-   // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
-   //   image data
-   unsigned char *tga_data;
-   unsigned char *tga_palette = NULL;
-   int i, j;
-   unsigned char raw_data[4] = {0};
-   int RLE_count = 0;
-   int RLE_repeating = 0;
-   int read_next_pixel = 1;
-   STBI_NOTUSED(ri);
-   STBI_NOTUSED(tga_x_origin); // @TODO
-   STBI_NOTUSED(tga_y_origin); // @TODO
-
-   if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
-   if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
-
-   //   do a tiny bit of precessing
-   if ( tga_image_type >= 8 )
-   {
-      tga_image_type -= 8;
-      tga_is_RLE = 1;
-   }
-   tga_inverted = 1 - ((tga_inverted >> 5) & 1);
-
-   //   If I'm paletted, then I'll use the number of bits from the palette
-   if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
-   else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
-
-   if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
-      return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
-
-   //   tga info
-   *x = tga_width;
-   *y = tga_height;
-   if (comp) *comp = tga_comp;
-
-   if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
-      return stbi__errpuc("too large", "Corrupt TGA");
-
-   tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
-   if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
-
-   // skip to the data's starting position (offset usually = 0)
-   stbi__skip(s, tga_offset );
-
-   if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
-      for (i=0; i < tga_height; ++i) {
-         int row = tga_inverted ? tga_height -i - 1 : i;
-         stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
-         stbi__getn(s, tga_row, tga_width * tga_comp);
-      }
-   } else  {
-      //   do I need to load a palette?
-      if ( tga_indexed)
-      {
-         if (tga_palette_len == 0) {  /* you have to have at least one entry! */
-            STBI_FREE(tga_data);
-            return stbi__errpuc("bad palette", "Corrupt TGA");
-         }
-
-         //   any data to skip? (offset usually = 0)
-         stbi__skip(s, tga_palette_start );
-         //   load the palette
-         tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
-         if (!tga_palette) {
-            STBI_FREE(tga_data);
-            return stbi__errpuc("outofmem", "Out of memory");
-         }
-         if (tga_rgb16) {
-            stbi_uc *pal_entry = tga_palette;
-            STBI_ASSERT(tga_comp == STBI_rgb);
-            for (i=0; i < tga_palette_len; ++i) {
-               stbi__tga_read_rgb16(s, pal_entry);
-               pal_entry += tga_comp;
-            }
-         } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
-               STBI_FREE(tga_data);
-               STBI_FREE(tga_palette);
-               return stbi__errpuc("bad palette", "Corrupt TGA");
-         }
-      }
-      //   load the data
-      for (i=0; i < tga_width * tga_height; ++i)
-      {
-         //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
-         if ( tga_is_RLE )
-         {
-            if ( RLE_count == 0 )
-            {
-               //   yep, get the next byte as a RLE command
-               int RLE_cmd = stbi__get8(s);
-               RLE_count = 1 + (RLE_cmd & 127);
-               RLE_repeating = RLE_cmd >> 7;
-               read_next_pixel = 1;
-            } else if ( !RLE_repeating )
-            {
-               read_next_pixel = 1;
-            }
-         } else
-         {
-            read_next_pixel = 1;
-         }
-         //   OK, if I need to read a pixel, do it now
-         if ( read_next_pixel )
-         {
-            //   load however much data we did have
-            if ( tga_indexed )
-            {
-               // read in index, then perform the lookup
-               int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
-               if ( pal_idx >= tga_palette_len ) {
-                  // invalid index
-                  pal_idx = 0;
-               }
-               pal_idx *= tga_comp;
-               for (j = 0; j < tga_comp; ++j) {
-                  raw_data[j] = tga_palette[pal_idx+j];
-               }
-            } else if(tga_rgb16) {
-               STBI_ASSERT(tga_comp == STBI_rgb);
-               stbi__tga_read_rgb16(s, raw_data);
-            } else {
-               //   read in the data raw
-               for (j = 0; j < tga_comp; ++j) {
-                  raw_data[j] = stbi__get8(s);
-               }
-            }
-            //   clear the reading flag for the next pixel
-            read_next_pixel = 0;
-         } // end of reading a pixel
-
-         // copy data
-         for (j = 0; j < tga_comp; ++j)
-           tga_data[i*tga_comp+j] = raw_data[j];
-
-         //   in case we're in RLE mode, keep counting down
-         --RLE_count;
-      }
-      //   do I need to invert the image?
-      if ( tga_inverted )
-      {
-         for (j = 0; j*2 < tga_height; ++j)
-         {
-            int index1 = j * tga_width * tga_comp;
-            int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
-            for (i = tga_width * tga_comp; i > 0; --i)
-            {
-               unsigned char temp = tga_data[index1];
-               tga_data[index1] = tga_data[index2];
-               tga_data[index2] = temp;
-               ++index1;
-               ++index2;
-            }
-         }
-      }
-      //   clear my palette, if I had one
-      if ( tga_palette != NULL )
-      {
-         STBI_FREE( tga_palette );
-      }
-   }
-
-   // swap RGB - if the source data was RGB16, it already is in the right order
-   if (tga_comp >= 3 && !tga_rgb16)
-   {
-      unsigned char* tga_pixel = tga_data;
-      for (i=0; i < tga_width * tga_height; ++i)
-      {
-         unsigned char temp = tga_pixel[0];
-         tga_pixel[0] = tga_pixel[2];
-         tga_pixel[2] = temp;
-         tga_pixel += tga_comp;
-      }
-   }
-
-   // convert to target component count
-   if (req_comp && req_comp != tga_comp)
-      tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
-
-   //   the things I do to get rid of an error message, and yet keep
-   //   Microsoft's C compilers happy... [8^(
-   tga_palette_start = tga_palette_len = tga_palette_bits =
-         tga_x_origin = tga_y_origin = 0;
-   STBI_NOTUSED(tga_palette_start);
-   //   OK, done
-   return tga_data;
-}
-#endif
-
-// *************************************************************************************************
-// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
-
-#ifndef STBI_NO_PSD
-static int stbi__psd_test(stbi__context *s)
-{
-   int r = (stbi__get32be(s) == 0x38425053);
-   stbi__rewind(s);
-   return r;
-}
-
-static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
-{
-   int count, nleft, len;
-
-   count = 0;
-   while ((nleft = pixelCount - count) > 0) {
-      len = stbi__get8(s);
-      if (len == 128) {
-         // No-op.
-      } else if (len < 128) {
-         // Copy next len+1 bytes literally.
-         len++;
-         if (len > nleft) return 0; // corrupt data
-         count += len;
-         while (len) {
-            *p = stbi__get8(s);
-            p += 4;
-            len--;
-         }
-      } else if (len > 128) {
-         stbi_uc   val;
-         // Next -len+1 bytes in the dest are replicated from next source byte.
-         // (Interpret len as a negative 8-bit int.)
-         len = 257 - len;
-         if (len > nleft) return 0; // corrupt data
-         val = stbi__get8(s);
-         count += len;
-         while (len) {
-            *p = val;
-            p += 4;
-            len--;
-         }
-      }
-   }
-
-   return 1;
-}
-
-static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
-{
-   int pixelCount;
-   int channelCount, compression;
-   int channel, i;
-   int bitdepth;
-   int w,h;
-   stbi_uc *out;
-   STBI_NOTUSED(ri);
-
-   // Check identifier
-   if (stbi__get32be(s) != 0x38425053)   // "8BPS"
-      return stbi__errpuc("not PSD", "Corrupt PSD image");
-
-   // Check file type version.
-   if (stbi__get16be(s) != 1)
-      return stbi__errpuc("wrong version", "Unsupported version of PSD image");
-
-   // Skip 6 reserved bytes.
-   stbi__skip(s, 6 );
-
-   // Read the number of channels (R, G, B, A, etc).
-   channelCount = stbi__get16be(s);
-   if (channelCount < 0 || channelCount > 16)
-      return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
-
-   // Read the rows and columns of the image.
-   h = stbi__get32be(s);
-   w = stbi__get32be(s);
-
-   if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
-   if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
-
-   // Make sure the depth is 8 bits.
-   bitdepth = stbi__get16be(s);
-   if (bitdepth != 8 && bitdepth != 16)
-      return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
-
-   // Make sure the color mode is RGB.
-   // Valid options are:
-   //   0: Bitmap
-   //   1: Grayscale
-   //   2: Indexed color
-   //   3: RGB color
-   //   4: CMYK color
-   //   7: Multichannel
-   //   8: Duotone
-   //   9: Lab color
-   if (stbi__get16be(s) != 3)
-      return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
-
-   // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)
-   stbi__skip(s,stbi__get32be(s) );
-
-   // Skip the image resources.  (resolution, pen tool paths, etc)
-   stbi__skip(s, stbi__get32be(s) );
-
-   // Skip the reserved data.
-   stbi__skip(s, stbi__get32be(s) );
-
-   // Find out if the data is compressed.
-   // Known values:
-   //   0: no compression
-   //   1: RLE compressed
-   compression = stbi__get16be(s);
-   if (compression > 1)
-      return stbi__errpuc("bad compression", "PSD has an unknown compression format");
-
-   // Check size
-   if (!stbi__mad3sizes_valid(4, w, h, 0))
-      return stbi__errpuc("too large", "Corrupt PSD");
-
-   // Create the destination image.
-
-   if (!compression && bitdepth == 16 && bpc == 16) {
-      out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
-      ri->bits_per_channel = 16;
-   } else
-      out = (stbi_uc *) stbi__malloc(4 * w*h);
-
-   if (!out) return stbi__errpuc("outofmem", "Out of memory");
-   pixelCount = w*h;
-
-   // Initialize the data to zero.
-   //memset( out, 0, pixelCount * 4 );
-
-   // Finally, the image data.
-   if (compression) {
-      // RLE as used by .PSD and .TIFF
-      // Loop until you get the number of unpacked bytes you are expecting:
-      //     Read the next source byte into n.
-      //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
-      //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
-      //     Else if n is 128, noop.
-      // Endloop
-
-      // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
-      // which we're going to just skip.
-      stbi__skip(s, h * channelCount * 2 );
-
-      // Read the RLE data by channel.
-      for (channel = 0; channel < 4; channel++) {
-         stbi_uc *p;
-
-         p = out+channel;
-         if (channel >= channelCount) {
-            // Fill this channel with default data.
-            for (i = 0; i < pixelCount; i++, p += 4)
-               *p = (channel == 3 ? 255 : 0);
-         } else {
-            // Read the RLE data.
-            if (!stbi__psd_decode_rle(s, p, pixelCount)) {
-               STBI_FREE(out);
-               return stbi__errpuc("corrupt", "bad RLE data");
-            }
-         }
-      }
-
-   } else {
-      // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
-      // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
-
-      // Read the data by channel.
-      for (channel = 0; channel < 4; channel++) {
-         if (channel >= channelCount) {
-            // Fill this channel with default data.
-            if (bitdepth == 16 && bpc == 16) {
-               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
-               stbi__uint16 val = channel == 3 ? 65535 : 0;
-               for (i = 0; i < pixelCount; i++, q += 4)
-                  *q = val;
-            } else {
-               stbi_uc *p = out+channel;
-               stbi_uc val = channel == 3 ? 255 : 0;
-               for (i = 0; i < pixelCount; i++, p += 4)
-                  *p = val;
-            }
-         } else {
-            if (ri->bits_per_channel == 16) {    // output bpc
-               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
-               for (i = 0; i < pixelCount; i++, q += 4)
-                  *q = (stbi__uint16) stbi__get16be(s);
-            } else {
-               stbi_uc *p = out+channel;
-               if (bitdepth == 16) {  // input bpc
-                  for (i = 0; i < pixelCount; i++, p += 4)
-                     *p = (stbi_uc) (stbi__get16be(s) >> 8);
-               } else {
-                  for (i = 0; i < pixelCount; i++, p += 4)
-                     *p = stbi__get8(s);
-               }
-            }
-         }
-      }
-   }
-
-   // remove weird white matte from PSD
-   if (channelCount >= 4) {
-      if (ri->bits_per_channel == 16) {
-         for (i=0; i < w*h; ++i) {
-            stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
-            if (pixel[3] != 0 && pixel[3] != 65535) {
-               float a = pixel[3] / 65535.0f;
-               float ra = 1.0f / a;
-               float inv_a = 65535.0f * (1 - ra);
-               pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
-               pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
-               pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
-            }
-         }
-      } else {
-         for (i=0; i < w*h; ++i) {
-            unsigned char *pixel = out + 4*i;
-            if (pixel[3] != 0 && pixel[3] != 255) {
-               float a = pixel[3] / 255.0f;
-               float ra = 1.0f / a;
-               float inv_a = 255.0f * (1 - ra);
-               pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);
-               pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);
-               pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);
-            }
-         }
-      }
-   }
-
-   // convert to desired output format
-   if (req_comp && req_comp != 4) {
-      if (ri->bits_per_channel == 16)
-         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
-      else
-         out = stbi__convert_format(out, 4, req_comp, w, h);
-      if (out == NULL) return out; // stbi__convert_format frees input on failure
-   }
-
-   if (comp) *comp = 4;
-   *y = h;
-   *x = w;
-
-   return out;
-}
-#endif
-
-// *************************************************************************************************
-// Softimage PIC loader
-// by Tom Seddon
-//
-// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
-// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
-
-#ifndef STBI_NO_PIC
-static int stbi__pic_is4(stbi__context *s,const char *str)
-{
-   int i;
-   for (i=0; i<4; ++i)
-      if (stbi__get8(s) != (stbi_uc)str[i])
-         return 0;
-
-   return 1;
-}
-
-static int stbi__pic_test_core(stbi__context *s)
-{
-   int i;
-
-   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
-      return 0;
-
-   for(i=0;i<84;++i)
-      stbi__get8(s);
-
-   if (!stbi__pic_is4(s,"PICT"))
-      return 0;
-
-   return 1;
-}
-
-typedef struct
-{
-   stbi_uc size,type,channel;
-} stbi__pic_packet;
-
-static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
-{
-   int mask=0x80, i;
-
-   for (i=0; i<4; ++i, mask>>=1) {
-      if (channel & mask) {
-         if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
-         dest[i]=stbi__get8(s);
-      }
-   }
-
-   return dest;
-}
-
-static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
-{
-   int mask=0x80,i;
-
-   for (i=0;i<4; ++i, mask>>=1)
-      if (channel&mask)
-         dest[i]=src[i];
-}
-
-static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
-{
-   int act_comp=0,num_packets=0,y,chained;
-   stbi__pic_packet packets[10];
-
-   // this will (should...) cater for even some bizarre stuff like having data
-    // for the same channel in multiple packets.
-   do {
-      stbi__pic_packet *packet;
-
-      if (num_packets==sizeof(packets)/sizeof(packets[0]))
-         return stbi__errpuc("bad format","too many packets");
-
-      packet = &packets[num_packets++];
-
-      chained = stbi__get8(s);
-      packet->size    = stbi__get8(s);
-      packet->type    = stbi__get8(s);
-      packet->channel = stbi__get8(s);
-
-      act_comp |= packet->channel;
-
-      if (stbi__at_eof(s))          return stbi__errpuc("bad file","file too short (reading packets)");
-      if (packet->size != 8)  return stbi__errpuc("bad format","packet isn't 8bpp");
-   } while (chained);
-
-   *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
-
-   for(y=0; y<height; ++y) {
-      int packet_idx;
-
-      for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
-         stbi__pic_packet *packet = &packets[packet_idx];
-         stbi_uc *dest = result+y*width*4;
-
-         switch (packet->type) {
-            default:
-               return stbi__errpuc("bad format","packet has bad compression type");
-
-            case 0: {//uncompressed
-               int x;
-
-               for(x=0;x<width;++x, dest+=4)
-                  if (!stbi__readval(s,packet->channel,dest))
-                     return 0;
-               break;
-            }
-
-            case 1://Pure RLE
-               {
-                  int left=width, i;
-
-                  while (left>0) {
-                     stbi_uc count,value[4];
-
-                     count=stbi__get8(s);
-                     if (stbi__at_eof(s))   return stbi__errpuc("bad file","file too short (pure read count)");
-
-                     if (count > left)
-                        count = (stbi_uc) left;
-
-                     if (!stbi__readval(s,packet->channel,value))  return 0;
-
-                     for(i=0; i<count; ++i,dest+=4)
-                        stbi__copyval(packet->channel,dest,value);
-                     left -= count;
-                  }
-               }
-               break;
-
-            case 2: {//Mixed RLE
-               int left=width;
-               while (left>0) {
-                  int count = stbi__get8(s), i;
-                  if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (mixed read count)");
-
-                  if (count >= 128) { // Repeated
-                     stbi_uc value[4];
-
-                     if (count==128)
-                        count = stbi__get16be(s);
-                     else
-                        count -= 127;
-                     if (count > left)
-                        return stbi__errpuc("bad file","scanline overrun");
-
-                     if (!stbi__readval(s,packet->channel,value))
-                        return 0;
-
-                     for(i=0;i<count;++i, dest += 4)
-                        stbi__copyval(packet->channel,dest,value);
-                  } else { // Raw
-                     ++count;
-                     if (count>left) return stbi__errpuc("bad file","scanline overrun");
-
-                     for(i=0;i<count;++i, dest+=4)
-                        if (!stbi__readval(s,packet->channel,dest))
-                           return 0;
-                  }
-                  left-=count;
-               }
-               break;
-            }
-         }
-      }
-   }
-
-   return result;
-}
-
-static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)
-{
-   stbi_uc *result;
-   int i, x,y, internal_comp;
-   STBI_NOTUSED(ri);
-
-   if (!comp) comp = &internal_comp;
-
-   for (i=0; i<92; ++i)
-      stbi__get8(s);
-
-   x = stbi__get16be(s);
-   y = stbi__get16be(s);
-
-   if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
-   if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
-
-   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
-   if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
-
-   stbi__get32be(s); //skip `ratio'
-   stbi__get16be(s); //skip `fields'
-   stbi__get16be(s); //skip `pad'
-
-   // intermediate buffer is RGBA
-   result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
-   if (!result) return stbi__errpuc("outofmem", "Out of memory");
-   memset(result, 0xff, x*y*4);
-
-   if (!stbi__pic_load_core(s,x,y,comp, result)) {
-      STBI_FREE(result);
-      result=0;
-   }
-   *px = x;
-   *py = y;
-   if (req_comp == 0) req_comp = *comp;
-   result=stbi__convert_format(result,4,req_comp,x,y);
-
-   return result;
-}
-
-static int stbi__pic_test(stbi__context *s)
-{
-   int r = stbi__pic_test_core(s);
-   stbi__rewind(s);
-   return r;
-}
-#endif
-
-// *************************************************************************************************
-// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
-
-#ifndef STBI_NO_GIF
-typedef struct
-{
-   stbi__int16 prefix;
-   stbi_uc first;
-   stbi_uc suffix;
-} stbi__gif_lzw;
-
-typedef struct
-{
-   int w,h;
-   stbi_uc *out;                 // output buffer (always 4 components)
-   stbi_uc *background;          // The current "background" as far as a gif is concerned
-   stbi_uc *history;
-   int flags, bgindex, ratio, transparent, eflags;
-   stbi_uc  pal[256][4];
-   stbi_uc lpal[256][4];
-   stbi__gif_lzw codes[8192];
-   stbi_uc *color_table;
-   int parse, step;
-   int lflags;
-   int start_x, start_y;
-   int max_x, max_y;
-   int cur_x, cur_y;
-   int line_size;
-   int delay;
-} stbi__gif;
-
-static int stbi__gif_test_raw(stbi__context *s)
-{
-   int sz;
-   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
-   sz = stbi__get8(s);
-   if (sz != '9' && sz != '7') return 0;
-   if (stbi__get8(s) != 'a') return 0;
-   return 1;
-}
-
-static int stbi__gif_test(stbi__context *s)
-{
-   int r = stbi__gif_test_raw(s);
-   stbi__rewind(s);
-   return r;
-}
-
-static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
-{
-   int i;
-   for (i=0; i < num_entries; ++i) {
-      pal[i][2] = stbi__get8(s);
-      pal[i][1] = stbi__get8(s);
-      pal[i][0] = stbi__get8(s);
-      pal[i][3] = transp == i ? 0 : 255;
-   }
-}
-
-static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
-{
-   stbi_uc version;
-   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
-      return stbi__err("not GIF", "Corrupt GIF");
-
-   version = stbi__get8(s);
-   if (version != '7' && version != '9')    return stbi__err("not GIF", "Corrupt GIF");
-   if (stbi__get8(s) != 'a')                return stbi__err("not GIF", "Corrupt GIF");
-
-   stbi__g_failure_reason = "";
-   g->w = stbi__get16le(s);
-   g->h = stbi__get16le(s);
-   g->flags = stbi__get8(s);
-   g->bgindex = stbi__get8(s);
-   g->ratio = stbi__get8(s);
-   g->transparent = -1;
-
-   if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
-   if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
-
-   if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
-
-   if (is_info) return 1;
-
-   if (g->flags & 0x80)
-      stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
-
-   return 1;
-}
-
-static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
-{
-   stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
-   if (!g) return stbi__err("outofmem", "Out of memory");
-   if (!stbi__gif_header(s, g, comp, 1)) {
-      STBI_FREE(g);
-      stbi__rewind( s );
-      return 0;
-   }
-   if (x) *x = g->w;
-   if (y) *y = g->h;
-   STBI_FREE(g);
-   return 1;
-}
-
-static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
-{
-   stbi_uc *p, *c;
-   int idx;
-
-   // recurse to decode the prefixes, since the linked-list is backwards,
-   // and working backwards through an interleaved image would be nasty
-   if (g->codes[code].prefix >= 0)
-      stbi__out_gif_code(g, g->codes[code].prefix);
-
-   if (g->cur_y >= g->max_y) return;
-
-   idx = g->cur_x + g->cur_y;
-   p = &g->out[idx];
-   g->history[idx / 4] = 1;
-
-   c = &g->color_table[g->codes[code].suffix * 4];
-   if (c[3] > 128) { // don't render transparent pixels;
-      p[0] = c[2];
-      p[1] = c[1];
-      p[2] = c[0];
-      p[3] = c[3];
-   }
-   g->cur_x += 4;
-
-   if (g->cur_x >= g->max_x) {
-      g->cur_x = g->start_x;
-      g->cur_y += g->step;
-
-      while (g->cur_y >= g->max_y && g->parse > 0) {
-         g->step = (1 << g->parse) * g->line_size;
-         g->cur_y = g->start_y + (g->step >> 1);
-         --g->parse;
-      }
-   }
-}
-
-static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
-{
-   stbi_uc lzw_cs;
-   stbi__int32 len, init_code;
-   stbi__uint32 first;
-   stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
-   stbi__gif_lzw *p;
-
-   lzw_cs = stbi__get8(s);
-   if (lzw_cs > 12) return NULL;
-   clear = 1 << lzw_cs;
-   first = 1;
-   codesize = lzw_cs + 1;
-   codemask = (1 << codesize) - 1;
-   bits = 0;
-   valid_bits = 0;
-   for (init_code = 0; init_code < clear; init_code++) {
-      g->codes[init_code].prefix = -1;
-      g->codes[init_code].first = (stbi_uc) init_code;
-      g->codes[init_code].suffix = (stbi_uc) init_code;
-   }
-
-   // support no starting clear code
-   avail = clear+2;
-   oldcode = -1;
-
-   len = 0;
-   for(;;) {
-      if (valid_bits < codesize) {
-         if (len == 0) {
-            len = stbi__get8(s); // start new block
-            if (len == 0)
-               return g->out;
-         }
-         --len;
-         bits |= (stbi__int32) stbi__get8(s) << valid_bits;
-         valid_bits += 8;
-      } else {
-         stbi__int32 code = bits & codemask;
-         bits >>= codesize;
-         valid_bits -= codesize;
-         // @OPTIMIZE: is there some way we can accelerate the non-clear path?
-         if (code == clear) {  // clear code
-            codesize = lzw_cs + 1;
-            codemask = (1 << codesize) - 1;
-            avail = clear + 2;
-            oldcode = -1;
-            first = 0;
-         } else if (code == clear + 1) { // end of stream code
-            stbi__skip(s, len);
-            while ((len = stbi__get8(s)) > 0)
-               stbi__skip(s,len);
-            return g->out;
-         } else if (code <= avail) {
-            if (first) {
-               return stbi__errpuc("no clear code", "Corrupt GIF");
-            }
-
-            if (oldcode >= 0) {
-               p = &g->codes[avail++];
-               if (avail > 8192) {
-                  return stbi__errpuc("too many codes", "Corrupt GIF");
-               }
-
-               p->prefix = (stbi__int16) oldcode;
-               p->first = g->codes[oldcode].first;
-               p->suffix = (code == avail) ? p->first : g->codes[code].first;
-            } else if (code == avail)
-               return stbi__errpuc("illegal code in raster", "Corrupt GIF");
-
-            stbi__out_gif_code(g, (stbi__uint16) code);
-
-            if ((avail & codemask) == 0 && avail <= 0x0FFF) {
-               codesize++;
-               codemask = (1 << codesize) - 1;
-            }
-
-            oldcode = code;
-         } else {
-            return stbi__errpuc("illegal code in raster", "Corrupt GIF");
-         }
-      }
-   }
-}
-
-// this function is designed to support animated gifs, although stb_image doesn't support it
-// two back is the image from two frames ago, used for a very specific disposal format
-static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
-{
-   int dispose;
-   int first_frame;
-   int pi;
-   int pcount;
-   STBI_NOTUSED(req_comp);
-
-   // on first frame, any non-written pixels get the background colour (non-transparent)
-   first_frame = 0;
-   if (g->out == 0) {
-      if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
-      if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
-         return stbi__errpuc("too large", "GIF image is too large");
-      pcount = g->w * g->h;
-      g->out = (stbi_uc *) stbi__malloc(4 * pcount);
-      g->background = (stbi_uc *) stbi__malloc(4 * pcount);
-      g->history = (stbi_uc *) stbi__malloc(pcount);
-      if (!g->out || !g->background || !g->history)
-         return stbi__errpuc("outofmem", "Out of memory");
-
-      // image is treated as "transparent" at the start - ie, nothing overwrites the current background;
-      // background colour is only used for pixels that are not rendered first frame, after that "background"
-      // color refers to the color that was there the previous frame.
-      memset(g->out, 0x00, 4 * pcount);
-      memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
-      memset(g->history, 0x00, pcount);        // pixels that were affected previous frame
-      first_frame = 1;
-   } else {
-      // second frame - how do we dispose of the previous one?
-      dispose = (g->eflags & 0x1C) >> 2;
-      pcount = g->w * g->h;
-
-      if ((dispose == 3) && (two_back == 0)) {
-         dispose = 2; // if I don't have an image to revert back to, default to the old background
-      }
-
-      if (dispose == 3) { // use previous graphic
-         for (pi = 0; pi < pcount; ++pi) {
-            if (g->history[pi]) {
-               memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
-            }
-         }
-      } else if (dispose == 2) {
-         // restore what was changed last frame to background before that frame;
-         for (pi = 0; pi < pcount; ++pi) {
-            if (g->history[pi]) {
-               memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
-            }
-         }
-      } else {
-         // This is a non-disposal case eithe way, so just
-         // leave the pixels as is, and they will become the new background
-         // 1: do not dispose
-         // 0:  not specified.
-      }
-
-      // background is what out is after the undoing of the previou frame;
-      memcpy( g->background, g->out, 4 * g->w * g->h );
-   }
-
-   // clear my history;
-   memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
-
-   for (;;) {
-      int tag = stbi__get8(s);
-      switch (tag) {
-         case 0x2C: /* Image Descriptor */
-         {
-            stbi__int32 x, y, w, h;
-            stbi_uc *o;
-
-            x = stbi__get16le(s);
-            y = stbi__get16le(s);
-            w = stbi__get16le(s);
-            h = stbi__get16le(s);
-            if (((x + w) > (g->w)) || ((y + h) > (g->h)))
-               return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
-
-            g->line_size = g->w * 4;
-            g->start_x = x * 4;
-            g->start_y = y * g->line_size;
-            g->max_x   = g->start_x + w * 4;
-            g->max_y   = g->start_y + h * g->line_size;
-            g->cur_x   = g->start_x;
-            g->cur_y   = g->start_y;
-
-            // if the width of the specified rectangle is 0, that means
-            // we may not see *any* pixels or the image is malformed;
-            // to make sure this is caught, move the current y down to
-            // max_y (which is what out_gif_code checks).
-            if (w == 0)
-               g->cur_y = g->max_y;
-
-            g->lflags = stbi__get8(s);
-
-            if (g->lflags & 0x40) {
-               g->step = 8 * g->line_size; // first interlaced spacing
-               g->parse = 3;
-            } else {
-               g->step = g->line_size;
-               g->parse = 0;
-            }
-
-            if (g->lflags & 0x80) {
-               stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
-               g->color_table = (stbi_uc *) g->lpal;
-            } else if (g->flags & 0x80) {
-               g->color_table = (stbi_uc *) g->pal;
-            } else
-               return stbi__errpuc("missing color table", "Corrupt GIF");
-
-            o = stbi__process_gif_raster(s, g);
-            if (!o) return NULL;
-
-            // if this was the first frame,
-            pcount = g->w * g->h;
-            if (first_frame && (g->bgindex > 0)) {
-               // if first frame, any pixel not drawn to gets the background color
-               for (pi = 0; pi < pcount; ++pi) {
-                  if (g->history[pi] == 0) {
-                     g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;
-                     memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
-                  }
-               }
-            }
-
-            return o;
-         }
-
-         case 0x21: // Comment Extension.
-         {
-            int len;
-            int ext = stbi__get8(s);
-            if (ext == 0xF9) { // Graphic Control Extension.
-               len = stbi__get8(s);
-               if (len == 4) {
-                  g->eflags = stbi__get8(s);
-                  g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
-
-                  // unset old transparent
-                  if (g->transparent >= 0) {
-                     g->pal[g->transparent][3] = 255;
-                  }
-                  if (g->eflags & 0x01) {
-                     g->transparent = stbi__get8(s);
-                     if (g->transparent >= 0) {
-                        g->pal[g->transparent][3] = 0;
-                     }
-                  } else {
-                     // don't need transparent
-                     stbi__skip(s, 1);
-                     g->transparent = -1;
-                  }
-               } else {
-                  stbi__skip(s, len);
-                  break;
-               }
-            }
-            while ((len = stbi__get8(s)) != 0) {
-               stbi__skip(s, len);
-            }
-            break;
-         }
-
-         case 0x3B: // gif stream termination code
-            return (stbi_uc *) s; // using '1' causes warning on some compilers
-
-         default:
-            return stbi__errpuc("unknown code", "Corrupt GIF");
-      }
-   }
-}
-
-static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)
-{
-   STBI_FREE(g->out);
-   STBI_FREE(g->history);
-   STBI_FREE(g->background);
-
-   if (out) STBI_FREE(out);
-   if (delays && *delays) STBI_FREE(*delays);
-   return stbi__errpuc("outofmem", "Out of memory");
-}
-
-static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
-{
-   if (stbi__gif_test(s)) {
-      int layers = 0;
-      stbi_uc *u = 0;
-      stbi_uc *out = 0;
-      stbi_uc *two_back = 0;
-      stbi__gif g;
-      int stride;
-      int out_size = 0;
-      int delays_size = 0;
-
-      STBI_NOTUSED(out_size);
-      STBI_NOTUSED(delays_size);
-
-      memset(&g, 0, sizeof(g));
-      if (delays) {
-         *delays = 0;
-      }
-
-      do {
-         u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
-         if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
-
-         if (u) {
-            *x = g.w;
-            *y = g.h;
-            ++layers;
-            stride = g.w * g.h * 4;
-
-            if (out) {
-               void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride );
-               if (!tmp)
-                  return stbi__load_gif_main_outofmem(&g, out, delays);
-               else {
-                   out = (stbi_uc*) tmp;
-                   out_size = layers * stride;
-               }
-
-               if (delays) {
-                  int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers );
-                  if (!new_delays)
-                     return stbi__load_gif_main_outofmem(&g, out, delays);
-                  *delays = new_delays;
-                  delays_size = layers * sizeof(int);
-               }
-            } else {
-               out = (stbi_uc*)stbi__malloc( layers * stride );
-               if (!out)
-                  return stbi__load_gif_main_outofmem(&g, out, delays);
-               out_size = layers * stride;
-               if (delays) {
-                  *delays = (int*) stbi__malloc( layers * sizeof(int) );
-                  if (!*delays)
-                     return stbi__load_gif_main_outofmem(&g, out, delays);
-                  delays_size = layers * sizeof(int);
-               }
-            }
-            memcpy( out + ((layers - 1) * stride), u, stride );
-            if (layers >= 2) {
-               two_back = out - 2 * stride;
-            }
-
-            if (delays) {
-               (*delays)[layers - 1U] = g.delay;
-            }
-         }
-      } while (u != 0);
-
-      // free temp buffer;
-      STBI_FREE(g.out);
-      STBI_FREE(g.history);
-      STBI_FREE(g.background);
-
-      // do the final conversion after loading everything;
-      if (req_comp && req_comp != 4)
-         out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
-
-      *z = layers;
-      return out;
-   } else {
-      return stbi__errpuc("not GIF", "Image was not as a gif type.");
-   }
-}
-
-static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
-{
-   stbi_uc *u = 0;
-   stbi__gif g;
-   memset(&g, 0, sizeof(g));
-   STBI_NOTUSED(ri);
-
-   u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
-   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
-   if (u) {
-      *x = g.w;
-      *y = g.h;
-
-      // moved conversion to after successful load so that the same
-      // can be done for multiple frames.
-      if (req_comp && req_comp != 4)
-         u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
-   } else if (g.out) {
-      // if there was an error and we allocated an image buffer, free it!
-      STBI_FREE(g.out);
-   }
-
-   // free buffers needed for multiple frame loading;
-   STBI_FREE(g.history);
-   STBI_FREE(g.background);
-
-   return u;
-}
-
-static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   return stbi__gif_info_raw(s,x,y,comp);
-}
-#endif
-
-// *************************************************************************************************
-// Radiance RGBE HDR loader
-// originally by Nicolas Schulz
-#ifndef STBI_NO_HDR
-static int stbi__hdr_test_core(stbi__context *s, const char *signature)
-{
-   int i;
-   for (i=0; signature[i]; ++i)
-      if (stbi__get8(s) != signature[i])
-          return 0;
-   stbi__rewind(s);
-   return 1;
-}
-
-static int stbi__hdr_test(stbi__context* s)
-{
-   int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
-   stbi__rewind(s);
-   if(!r) {
-       r = stbi__hdr_test_core(s, "#?RGBE\n");
-       stbi__rewind(s);
-   }
-   return r;
-}
-
-#define STBI__HDR_BUFLEN  1024
-static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
-{
-   int len=0;
-   char c = '\0';
-
-   c = (char) stbi__get8(z);
-
-   while (!stbi__at_eof(z) && c != '\n') {
-      buffer[len++] = c;
-      if (len == STBI__HDR_BUFLEN-1) {
-         // flush to end of line
-         while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
-            ;
-         break;
-      }
-      c = (char) stbi__get8(z);
-   }
-
-   buffer[len] = 0;
-   return buffer;
-}
-
-static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
-{
-   if ( input[3] != 0 ) {
-      float f1;
-      // Exponent
-      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
-      if (req_comp <= 2)
-         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
-      else {
-         output[0] = input[0] * f1;
-         output[1] = input[1] * f1;
-         output[2] = input[2] * f1;
-      }
-      if (req_comp == 2) output[1] = 1;
-      if (req_comp == 4) output[3] = 1;
-   } else {
-      switch (req_comp) {
-         case 4: output[3] = 1; /* fallthrough */
-         case 3: output[0] = output[1] = output[2] = 0;
-                 break;
-         case 2: output[1] = 1; /* fallthrough */
-         case 1: output[0] = 0;
-                 break;
-      }
-   }
-}
-
-static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
-{
-   char buffer[STBI__HDR_BUFLEN];
-   char *token;
-   int valid = 0;
-   int width, height;
-   stbi_uc *scanline;
-   float *hdr_data;
-   int len;
-   unsigned char count, value;
-   int i, j, k, c1,c2, z;
-   const char *headerToken;
-   STBI_NOTUSED(ri);
-
-   // Check identifier
-   headerToken = stbi__hdr_gettoken(s,buffer);
-   if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
-      return stbi__errpf("not HDR", "Corrupt HDR image");
-
-   // Parse header
-   for(;;) {
-      token = stbi__hdr_gettoken(s,buffer);
-      if (token[0] == 0) break;
-      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
-   }
-
-   if (!valid)    return stbi__errpf("unsupported format", "Unsupported HDR format");
-
-   // Parse width and height
-   // can't use sscanf() if we're not using stdio!
-   token = stbi__hdr_gettoken(s,buffer);
-   if (strncmp(token, "-Y ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   height = (int) strtol(token, &token, 10);
-   while (*token == ' ') ++token;
-   if (strncmp(token, "+X ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
-   token += 3;
-   width = (int) strtol(token, NULL, 10);
-
-   if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
-   if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
-
-   *x = width;
-   *y = height;
-
-   if (comp) *comp = 3;
-   if (req_comp == 0) req_comp = 3;
-
-   if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
-      return stbi__errpf("too large", "HDR image is too large");
-
-   // Read data
-   hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
-   if (!hdr_data)
-      return stbi__errpf("outofmem", "Out of memory");
-
-   // Load image data
-   // image data is stored as some number of sca
-   if ( width < 8 || width >= 32768) {
-      // Read flat data
-      for (j=0; j < height; ++j) {
-         for (i=0; i < width; ++i) {
-            stbi_uc rgbe[4];
-           main_decode_loop:
-            stbi__getn(s, rgbe, 4);
-            stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
-         }
-      }
-   } else {
-      // Read RLE-encoded data
-      scanline = NULL;
-
-      for (j = 0; j < height; ++j) {
-         c1 = stbi__get8(s);
-         c2 = stbi__get8(s);
-         len = stbi__get8(s);
-         if (c1 != 2 || c2 != 2 || (len & 0x80)) {
-            // not run-length encoded, so we have to actually use THIS data as a decoded
-            // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
-            stbi_uc rgbe[4];
-            rgbe[0] = (stbi_uc) c1;
-            rgbe[1] = (stbi_uc) c2;
-            rgbe[2] = (stbi_uc) len;
-            rgbe[3] = (stbi_uc) stbi__get8(s);
-            stbi__hdr_convert(hdr_data, rgbe, req_comp);
-            i = 1;
-            j = 0;
-            STBI_FREE(scanline);
-            goto main_decode_loop; // yes, this makes no sense
-         }
-         len <<= 8;
-         len |= stbi__get8(s);
-         if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
-         if (scanline == NULL) {
-            scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);
-            if (!scanline) {
-               STBI_FREE(hdr_data);
-               return stbi__errpf("outofmem", "Out of memory");
-            }
-         }
-
-         for (k = 0; k < 4; ++k) {
-            int nleft;
-            i = 0;
-            while ((nleft = width - i) > 0) {
-               count = stbi__get8(s);
-               if (count > 128) {
-                  // Run
-                  value = stbi__get8(s);
-                  count -= 128;
-                  if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
-                  for (z = 0; z < count; ++z)
-                     scanline[i++ * 4 + k] = value;
-               } else {
-                  // Dump
-                  if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
-                  for (z = 0; z < count; ++z)
-                     scanline[i++ * 4 + k] = stbi__get8(s);
-               }
-            }
-         }
-         for (i=0; i < width; ++i)
-            stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
-      }
-      if (scanline)
-         STBI_FREE(scanline);
-   }
-
-   return hdr_data;
-}
-
-static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   char buffer[STBI__HDR_BUFLEN];
-   char *token;
-   int valid = 0;
-   int dummy;
-
-   if (!x) x = &dummy;
-   if (!y) y = &dummy;
-   if (!comp) comp = &dummy;
-
-   if (stbi__hdr_test(s) == 0) {
-       stbi__rewind( s );
-       return 0;
-   }
-
-   for(;;) {
-      token = stbi__hdr_gettoken(s,buffer);
-      if (token[0] == 0) break;
-      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
-   }
-
-   if (!valid) {
-       stbi__rewind( s );
-       return 0;
-   }
-   token = stbi__hdr_gettoken(s,buffer);
-   if (strncmp(token, "-Y ", 3)) {
-       stbi__rewind( s );
-       return 0;
-   }
-   token += 3;
-   *y = (int) strtol(token, &token, 10);
-   while (*token == ' ') ++token;
-   if (strncmp(token, "+X ", 3)) {
-       stbi__rewind( s );
-       return 0;
-   }
-   token += 3;
-   *x = (int) strtol(token, NULL, 10);
-   *comp = 3;
-   return 1;
-}
-#endif // STBI_NO_HDR
-
-#ifndef STBI_NO_BMP
-static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   void *p;
-   stbi__bmp_data info;
-
-   info.all_a = 255;
-   p = stbi__bmp_parse_header(s, &info);
-   if (p == NULL) {
-      stbi__rewind( s );
-      return 0;
-   }
-   if (x) *x = s->img_x;
-   if (y) *y = s->img_y;
-   if (comp) {
-      if (info.bpp == 24 && info.ma == 0xff000000)
-         *comp = 3;
-      else
-         *comp = info.ma ? 4 : 3;
-   }
-   return 1;
-}
-#endif
-
-#ifndef STBI_NO_PSD
-static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   int channelCount, dummy, depth;
-   if (!x) x = &dummy;
-   if (!y) y = &dummy;
-   if (!comp) comp = &dummy;
-   if (stbi__get32be(s) != 0x38425053) {
-       stbi__rewind( s );
-       return 0;
-   }
-   if (stbi__get16be(s) != 1) {
-       stbi__rewind( s );
-       return 0;
-   }
-   stbi__skip(s, 6);
-   channelCount = stbi__get16be(s);
-   if (channelCount < 0 || channelCount > 16) {
-       stbi__rewind( s );
-       return 0;
-   }
-   *y = stbi__get32be(s);
-   *x = stbi__get32be(s);
-   depth = stbi__get16be(s);
-   if (depth != 8 && depth != 16) {
-       stbi__rewind( s );
-       return 0;
-   }
-   if (stbi__get16be(s) != 3) {
-       stbi__rewind( s );
-       return 0;
-   }
-   *comp = 4;
-   return 1;
-}
-
-static int stbi__psd_is16(stbi__context *s)
-{
-   int channelCount, depth;
-   if (stbi__get32be(s) != 0x38425053) {
-       stbi__rewind( s );
-       return 0;
-   }
-   if (stbi__get16be(s) != 1) {
-       stbi__rewind( s );
-       return 0;
-   }
-   stbi__skip(s, 6);
-   channelCount = stbi__get16be(s);
-   if (channelCount < 0 || channelCount > 16) {
-       stbi__rewind( s );
-       return 0;
-   }
-   STBI_NOTUSED(stbi__get32be(s));
-   STBI_NOTUSED(stbi__get32be(s));
-   depth = stbi__get16be(s);
-   if (depth != 16) {
-       stbi__rewind( s );
-       return 0;
-   }
-   return 1;
-}
-#endif
-
-#ifndef STBI_NO_PIC
-static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   int act_comp=0,num_packets=0,chained,dummy;
-   stbi__pic_packet packets[10];
-
-   if (!x) x = &dummy;
-   if (!y) y = &dummy;
-   if (!comp) comp = &dummy;
-
-   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
-      stbi__rewind(s);
-      return 0;
-   }
-
-   stbi__skip(s, 88);
-
-   *x = stbi__get16be(s);
-   *y = stbi__get16be(s);
-   if (stbi__at_eof(s)) {
-      stbi__rewind( s);
-      return 0;
-   }
-   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
-      stbi__rewind( s );
-      return 0;
-   }
-
-   stbi__skip(s, 8);
-
-   do {
-      stbi__pic_packet *packet;
-
-      if (num_packets==sizeof(packets)/sizeof(packets[0]))
-         return 0;
-
-      packet = &packets[num_packets++];
-      chained = stbi__get8(s);
-      packet->size    = stbi__get8(s);
-      packet->type    = stbi__get8(s);
-      packet->channel = stbi__get8(s);
-      act_comp |= packet->channel;
-
-      if (stbi__at_eof(s)) {
-          stbi__rewind( s );
-          return 0;
-      }
-      if (packet->size != 8) {
-          stbi__rewind( s );
-          return 0;
-      }
-   } while (chained);
-
-   *comp = (act_comp & 0x10 ? 4 : 3);
-
-   return 1;
-}
-#endif
-
-// *************************************************************************************************
-// Portable Gray Map and Portable Pixel Map loader
-// by Ken Miller
-//
-// PGM: http://netpbm.sourceforge.net/doc/pgm.html
-// PPM: http://netpbm.sourceforge.net/doc/ppm.html
-//
-// Known limitations:
-//    Does not support comments in the header section
-//    Does not support ASCII image data (formats P2 and P3)
-
-#ifndef STBI_NO_PNM
-
-static int      stbi__pnm_test(stbi__context *s)
-{
-   char p, t;
-   p = (char) stbi__get8(s);
-   t = (char) stbi__get8(s);
-   if (p != 'P' || (t != '5' && t != '6')) {
-       stbi__rewind( s );
-       return 0;
-   }
-   return 1;
-}
-
-static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
-{
-   stbi_uc *out;
-   STBI_NOTUSED(ri);
-
-   ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);
-   if (ri->bits_per_channel == 0)
-      return 0;
-
-   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
-   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
-
-   *x = s->img_x;
-   *y = s->img_y;
-   if (comp) *comp = s->img_n;
-
-   if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))
-      return stbi__errpuc("too large", "PNM too large");
-
-   out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);
-   if (!out) return stbi__errpuc("outofmem", "Out of memory");
-   if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {
-      STBI_FREE(out);
-      return stbi__errpuc("bad PNM", "PNM file truncated");
-   }
-
-   if (req_comp && req_comp != s->img_n) {
-      if (ri->bits_per_channel == 16) {
-         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y);
-      } else {
-         out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
-      }
-      if (out == NULL) return out; // stbi__convert_format frees input on failure
-   }
-   return out;
-}
-
-static int      stbi__pnm_isspace(char c)
-{
-   return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
-}
-
-static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)
-{
-   for (;;) {
-      while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
-         *c = (char) stbi__get8(s);
-
-      if (stbi__at_eof(s) || *c != '#')
-         break;
-
-      while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
-         *c = (char) stbi__get8(s);
-   }
-}
-
-static int      stbi__pnm_isdigit(char c)
-{
-   return c >= '0' && c <= '9';
-}
-
-static int      stbi__pnm_getinteger(stbi__context *s, char *c)
-{
-   int value = 0;
-
-   while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
-      value = value*10 + (*c - '0');
-      *c = (char) stbi__get8(s);
-      if((value > 214748364) || (value == 214748364 && *c > '7'))
-          return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int");
-   }
-
-   return value;
-}
-
-static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
-{
-   int maxv, dummy;
-   char c, p, t;
-
-   if (!x) x = &dummy;
-   if (!y) y = &dummy;
-   if (!comp) comp = &dummy;
-
-   stbi__rewind(s);
-
-   // Get identifier
-   p = (char) stbi__get8(s);
-   t = (char) stbi__get8(s);
-   if (p != 'P' || (t != '5' && t != '6')) {
-       stbi__rewind(s);
-       return 0;
-   }
-
-   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm
-
-   c = (char) stbi__get8(s);
-   stbi__pnm_skip_whitespace(s, &c);
-
-   *x = stbi__pnm_getinteger(s, &c); // read width
-   if(*x == 0)
-       return stbi__err("invalid width", "PPM image header had zero or overflowing width");
-   stbi__pnm_skip_whitespace(s, &c);
-
-   *y = stbi__pnm_getinteger(s, &c); // read height
-   if (*y == 0)
-       return stbi__err("invalid width", "PPM image header had zero or overflowing width");
-   stbi__pnm_skip_whitespace(s, &c);
-
-   maxv = stbi__pnm_getinteger(s, &c);  // read max value
-   if (maxv > 65535)
-      return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");
-   else if (maxv > 255)
-      return 16;
-   else
-      return 8;
-}
-
-static int stbi__pnm_is16(stbi__context *s)
-{
-   if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)
-	   return 1;
-   return 0;
-}
-#endif
-
-static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
-{
-   #ifndef STBI_NO_JPEG
-   if (stbi__jpeg_info(s, x, y, comp)) return 1;
-   #endif
-
-   #ifndef STBI_NO_PNG
-   if (stbi__png_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_GIF
-   if (stbi__gif_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_BMP
-   if (stbi__bmp_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_PSD
-   if (stbi__psd_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_PIC
-   if (stbi__pic_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_PNM
-   if (stbi__pnm_info(s, x, y, comp))  return 1;
-   #endif
-
-   #ifndef STBI_NO_HDR
-   if (stbi__hdr_info(s, x, y, comp))  return 1;
-   #endif
-
-   // test tga last because it's a crappy test!
-   #ifndef STBI_NO_TGA
-   if (stbi__tga_info(s, x, y, comp))
-       return 1;
-   #endif
-   return stbi__err("unknown image type", "Image not of any known type, or corrupt");
-}
-
-static int stbi__is_16_main(stbi__context *s)
-{
-   #ifndef STBI_NO_PNG
-   if (stbi__png_is16(s))  return 1;
-   #endif
-
-   #ifndef STBI_NO_PSD
-   if (stbi__psd_is16(s))  return 1;
-   #endif
-
-   #ifndef STBI_NO_PNM
-   if (stbi__pnm_is16(s))  return 1;
-   #endif
-   return 0;
-}
-
-#ifndef STBI_NO_STDIO
-STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
-{
-    FILE *f = stbi__fopen(filename, "rb");
-    int result;
-    if (!f) return stbi__err("can't fopen", "Unable to open file");
-    result = stbi_info_from_file(f, x, y, comp);
-    fclose(f);
-    return result;
-}
-
-STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
-{
-   int r;
-   stbi__context s;
-   long pos = ftell(f);
-   stbi__start_file(&s, f);
-   r = stbi__info_main(&s,x,y,comp);
-   fseek(f,pos,SEEK_SET);
-   return r;
-}
-
-STBIDEF int stbi_is_16_bit(char const *filename)
-{
-    FILE *f = stbi__fopen(filename, "rb");
-    int result;
-    if (!f) return stbi__err("can't fopen", "Unable to open file");
-    result = stbi_is_16_bit_from_file(f);
-    fclose(f);
-    return result;
-}
-
-STBIDEF int stbi_is_16_bit_from_file(FILE *f)
-{
-   int r;
-   stbi__context s;
-   long pos = ftell(f);
-   stbi__start_file(&s, f);
-   r = stbi__is_16_main(&s);
-   fseek(f,pos,SEEK_SET);
-   return r;
-}
-#endif // !STBI_NO_STDIO
-
-STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
-{
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-   return stbi__info_main(&s,x,y,comp);
-}
-
-STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
-{
-   stbi__context s;
-   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
-   return stbi__info_main(&s,x,y,comp);
-}
-
-STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
-{
-   stbi__context s;
-   stbi__start_mem(&s,buffer,len);
-   return stbi__is_16_main(&s);
-}
-
-STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)
-{
-   stbi__context s;
-   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
-   return stbi__is_16_main(&s);
-}
-
-#endif // STB_IMAGE_IMPLEMENTATION
-
-/*
-   revision history:
-      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
-      2.19  (2018-02-11) fix warning
-      2.18  (2018-01-30) fix warnings
-      2.17  (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
-                         1-bit BMP
-                         *_is_16_bit api
-                         avoid warnings
-      2.16  (2017-07-23) all functions have 16-bit variants;
-                         STBI_NO_STDIO works again;
-                         compilation fixes;
-                         fix rounding in unpremultiply;
-                         optimize vertical flip;
-                         disable raw_len validation;
-                         documentation fixes
-      2.15  (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
-                         warning fixes; disable run-time SSE detection on gcc;
-                         uniform handling of optional "return" values;
-                         thread-safe initialization of zlib tables
-      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
-      2.13  (2016-11-29) add 16-bit API, only supported for PNG right now
-      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
-      2.11  (2016-04-02) allocate large structures on the stack
-                         remove white matting for transparent PSD
-                         fix reported channel count for PNG & BMP
-                         re-enable SSE2 in non-gcc 64-bit
-                         support RGB-formatted JPEG
-                         read 16-bit PNGs (only as 8-bit)
-      2.10  (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
-      2.09  (2016-01-16) allow comments in PNM files
-                         16-bit-per-pixel TGA (not bit-per-component)
-                         info() for TGA could break due to .hdr handling
-                         info() for BMP to shares code instead of sloppy parse
-                         can use STBI_REALLOC_SIZED if allocator doesn't support realloc
-                         code cleanup
-      2.08  (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
-      2.07  (2015-09-13) fix compiler warnings
-                         partial animated GIF support
-                         limited 16-bpc PSD support
-                         #ifdef unused functions
-                         bug with < 92 byte PIC,PNM,HDR,TGA
-      2.06  (2015-04-19) fix bug where PSD returns wrong '*comp' value
-      2.05  (2015-04-19) fix bug in progressive JPEG handling, fix warning
-      2.04  (2015-04-15) try to re-enable SIMD on MinGW 64-bit
-      2.03  (2015-04-12) extra corruption checking (mmozeiko)
-                         stbi_set_flip_vertically_on_load (nguillemot)
-                         fix NEON support; fix mingw support
-      2.02  (2015-01-19) fix incorrect assert, fix warning
-      2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
-      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
-      2.00  (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
-                         progressive JPEG (stb)
-                         PGM/PPM support (Ken Miller)
-                         STBI_MALLOC,STBI_REALLOC,STBI_FREE
-                         GIF bugfix -- seemingly never worked
-                         STBI_NO_*, STBI_ONLY_*
-      1.48  (2014-12-14) fix incorrectly-named assert()
-      1.47  (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
-                         optimize PNG (ryg)
-                         fix bug in interlaced PNG with user-specified channel count (stb)
-      1.46  (2014-08-26)
-              fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
-      1.45  (2014-08-16)
-              fix MSVC-ARM internal compiler error by wrapping malloc
-      1.44  (2014-08-07)
-              various warning fixes from Ronny Chevalier
-      1.43  (2014-07-15)
-              fix MSVC-only compiler problem in code changed in 1.42
-      1.42  (2014-07-09)
-              don't define _CRT_SECURE_NO_WARNINGS (affects user code)
-              fixes to stbi__cleanup_jpeg path
-              added STBI_ASSERT to avoid requiring assert.h
-      1.41  (2014-06-25)
-              fix search&replace from 1.36 that messed up comments/error messages
-      1.40  (2014-06-22)
-              fix gcc struct-initialization warning
-      1.39  (2014-06-15)
-              fix to TGA optimization when req_comp != number of components in TGA;
-              fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
-              add support for BMP version 5 (more ignored fields)
-      1.38  (2014-06-06)
-              suppress MSVC warnings on integer casts truncating values
-              fix accidental rename of 'skip' field of I/O
-      1.37  (2014-06-04)
-              remove duplicate typedef
-      1.36  (2014-06-03)
-              convert to header file single-file library
-              if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
-      1.35  (2014-05-27)
-              various warnings
-              fix broken STBI_SIMD path
-              fix bug where stbi_load_from_file no longer left file pointer in correct place
-              fix broken non-easy path for 32-bit BMP (possibly never used)
-              TGA optimization by Arseny Kapoulkine
-      1.34  (unknown)
-              use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
-      1.33  (2011-07-14)
-              make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
-      1.32  (2011-07-13)
-              support for "info" function for all supported filetypes (SpartanJ)
-      1.31  (2011-06-20)
-              a few more leak fixes, bug in PNG handling (SpartanJ)
-      1.30  (2011-06-11)
-              added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
-              removed deprecated format-specific test/load functions
-              removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
-              error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
-              fix inefficiency in decoding 32-bit BMP (David Woo)
-      1.29  (2010-08-16)
-              various warning fixes from Aurelien Pocheville
-      1.28  (2010-08-01)
-              fix bug in GIF palette transparency (SpartanJ)
-      1.27  (2010-08-01)
-              cast-to-stbi_uc to fix warnings
-      1.26  (2010-07-24)
-              fix bug in file buffering for PNG reported by SpartanJ
-      1.25  (2010-07-17)
-              refix trans_data warning (Won Chun)
-      1.24  (2010-07-12)
-              perf improvements reading from files on platforms with lock-heavy fgetc()
-              minor perf improvements for jpeg
-              deprecated type-specific functions so we'll get feedback if they're needed
-              attempt to fix trans_data warning (Won Chun)
-      1.23    fixed bug in iPhone support
-      1.22  (2010-07-10)
-              removed image *writing* support
-              stbi_info support from Jetro Lauha
-              GIF support from Jean-Marc Lienher
-              iPhone PNG-extensions from James Brown
-              warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
-      1.21    fix use of 'stbi_uc' in header (reported by jon blow)
-      1.20    added support for Softimage PIC, by Tom Seddon
-      1.19    bug in interlaced PNG corruption check (found by ryg)
-      1.18  (2008-08-02)
-              fix a threading bug (local mutable static)
-      1.17    support interlaced PNG
-      1.16    major bugfix - stbi__convert_format converted one too many pixels
-      1.15    initialize some fields for thread safety
-      1.14    fix threadsafe conversion bug
-              header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
-      1.13    threadsafe
-      1.12    const qualifiers in the API
-      1.11    Support installable IDCT, colorspace conversion routines
-      1.10    Fixes for 64-bit (don't use "unsigned long")
-              optimized upsampling by Fabian "ryg" Giesen
-      1.09    Fix format-conversion for PSD code (bad global variables!)
-      1.08    Thatcher Ulrich's PSD code integrated by Nicolas Schulz
-      1.07    attempt to fix C++ warning/errors again
-      1.06    attempt to fix C++ warning/errors again
-      1.05    fix TGA loading to return correct *comp and use good luminance calc
-      1.04    default float alpha is 1, not 255; use 'void *' for stbi_image_free
-      1.03    bugfixes to STBI_NO_STDIO, STBI_NO_HDR
-      1.02    support for (subset of) HDR files, float interface for preferred access to them
-      1.01    fix bug: possible bug in handling right-side up bmps... not sure
-              fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
-      1.00    interface to zlib that skips zlib header
-      0.99    correct handling of alpha in palette
-      0.98    TGA loader by lonesock; dynamically add loaders (untested)
-      0.97    jpeg errors on too large a file; also catch another malloc failure
-      0.96    fix detection of invalid v value - particleman@mollyrocket forum
-      0.95    during header scan, seek to markers in case of padding
-      0.94    STBI_NO_STDIO to disable stdio usage; rename all #defines the same
-      0.93    handle jpegtran output; verbose errors
-      0.92    read 4,8,16,24,32-bit BMP files of several formats
-      0.91    output 24-bit Windows 3.0 BMP files
-      0.90    fix a few more warnings; bump version number to approach 1.0
-      0.61    bugfixes due to Marc LeBlanc, Christopher Lloyd
-      0.60    fix compiling as c++
-      0.59    fix warnings: merge Dave Moore's -Wall fixes
-      0.58    fix bug: zlib uncompressed mode len/nlen was wrong endian
-      0.57    fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
-      0.56    fix bug: zlib uncompressed mode len vs. nlen
-      0.55    fix bug: restart_interval not initialized to 0
-      0.54    allow NULL for 'int *comp'
-      0.53    fix bug in png 3->4; speedup png decoding
-      0.52    png handles req_comp=3,4 directly; minor cleanup; jpeg comments
-      0.51    obey req_comp requests, 1-component jpegs return as 1-component,
-              on 'test' only check type, not whether we support this variant
-      0.50  (2006-11-19)
-              first released version
-*/
-
-
-/*
-------------------------------------------------------------------------------
-This software is available under 2 licenses -- choose whichever you prefer.
-------------------------------------------------------------------------------
-ALTERNATIVE A - MIT License
-Copyright (c) 2017 Sean Barrett
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-------------------------------------------------------------------------------
-ALTERNATIVE B - Public Domain (www.unlicense.org)
-This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
-software, either in source code form or as a compiled binary, for any purpose,
-commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this
-software dedicate any and all copyright interest in the software to the public
-domain. We make this dedication for the benefit of the public at large and to
-the detriment of our heirs and successors. We intend this dedication to be an
-overt act of relinquishment in perpetuity of all present and future rights to
-this software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------
-*/
diff --git a/include/image/imagebuilder.hpp b/include/image/imagebuilder.hpp
new file mode 100644
index 00000000..18c2adfa
--- /dev/null
+++ b/include/image/imagebuilder.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "image/imagedata.hpp"
+#include "image/imagehandle.hpp"
+
+namespace Toolbox::UI {
+
+    class ImageBuilder {
+    public:
+        static ScopePtr<ImageData> ImageAdd(const ImageData &a, const ImageData &b,
+                                            float scale = 1.0f, float offset = 0.0f);
+        static ScopePtr<ImageData> ImageAddModulo(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageBlend(const ImageData &a, const ImageData &b,
+                                              float alpha);
+        static ScopePtr<ImageData> ImageComposite(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageDarker(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageDifference(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageDivide(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageLighter(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageMultiply(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageOffset(const ImageData &image, int x, int y);
+        static ScopePtr<ImageData> ImageOverlay(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageResize(const ImageData &image, int width, int height);
+        static ScopePtr<ImageData> ImageScreen(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageSubtract(const ImageData &a, const ImageData &b,
+                                                 float scale = 1.0f, float offset = 0.0f);
+        static ScopePtr<ImageData> ImageSubtractModulo(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageAND(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageOR(const ImageData &a, const ImageData &b);
+        static ScopePtr<ImageData> ImageXOR(const ImageData &a, const ImageData &b);
+    };
+
+}  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/image/imagedata.hpp b/include/image/imagedata.hpp
new file mode 100644
index 00000000..2e1f214d
--- /dev/null
+++ b/include/image/imagedata.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "core/core.hpp"
+#include "color.hpp"
+#include "fsystem.hpp"
+
+#include <span>
+
+namespace Toolbox {
+
+    class ImageData {
+    public:
+        friend class ImageBuilder;
+        friend class ImageHandle;
+
+        ImageData()                      = default;
+        ImageData(const ImageData &)     = default;
+        ImageData(ImageData &&) noexcept = default;
+
+        ~ImageData();
+
+        ImageData(const fs_path &res_path);
+
+        ImageData(std::span<u8> data);
+        ImageData(std::span<u8> data, int channels, int dx, int dy);
+
+        ImageData(const Buffer &data);
+
+        // Data should be a valid RED, RGB, or RGBA image as loaded by stbi
+        ImageData(Buffer &&data, int channels, int dx, int dy);
+
+        [[nodiscard]] bool save(const fs_path &filename) const;
+
+        [[nodiscard]] bool isValid() const noexcept {
+            return m_width > 0 && m_height > 0 && m_channels > 0;
+        }
+
+        [[nodiscard]] int getWidth() const noexcept { return m_width; }
+        [[nodiscard]] int getHeight() const noexcept { return m_height; }
+        [[nodiscard]] int getChannels() const noexcept { return m_channels; }
+
+        [[nodiscard]]
+        [[nodiscard]] const u8 *getData() const noexcept { return m_data.buf<u8>(); }
+        [[nodiscard]] size_t getSize() const noexcept { return m_data.size(); }
+
+        ImageData &operator=(const ImageData &)     = default;
+        ImageData &operator=(ImageData &&) noexcept = default;
+
+    private:
+        int m_width    = 0;
+        int m_height   = 0;
+        int m_channels = 0;
+        Buffer m_data;
+    };
+
+}  // namespace Toolbox
\ No newline at end of file
diff --git a/include/image/imagehandle.hpp b/include/image/imagehandle.hpp
index 46750d02..609e52bf 100644
--- a/include/image/imagehandle.hpp
+++ b/include/image/imagehandle.hpp
@@ -5,6 +5,8 @@
 #include <imgui/imgui.h>
 #include <span>
 
+#include "image/imagedata.hpp"
+
 namespace Toolbox {
 
     namespace UI {
@@ -13,6 +15,7 @@ namespace Toolbox {
 
     class ImageHandle {
         friend class UI::ImagePainter;
+        friend class ImageBuilder;
 
     public:
         ImageHandle() = default;
@@ -26,6 +29,7 @@ namespace Toolbox {
         ImageHandle(std::span<u8> data, int channels, int dx, int dy);
 
         ImageHandle(const Buffer &data);
+        ImageHandle(const ImageData &data);
 
         // Data should be a valid RED, RGB, or RGBA image as loaded by stbi
         ImageHandle(const Buffer &data, int channels, int dx, int dy);
diff --git a/include/resource/resource.hpp b/include/resource/resource.hpp
index 9ccf0037..ee89606f 100644
--- a/include/resource/resource.hpp
+++ b/include/resource/resource.hpp
@@ -73,6 +73,11 @@ namespace Toolbox {
                                        const UUID64 &resource_path_uuid = 0) const;
         [[nodiscard]] bool hasDataPath(fs_path &&path, const UUID64 &resource_path_uuid = 0) const;
 
+        [[nodiscard]] Result<RefPtr<const ImageData>, FSError>
+        getImageData(const fs_path &path, const UUID64 &resource_path_uuid = 0) const;
+        [[nodiscard]] Result<RefPtr<const ImageData>, FSError>
+        getImageData(fs_path &&path, const UUID64 &resource_path_uuid = 0) const;
+
         [[nodiscard]] Result<RefPtr<const ImageHandle>, FSError>
         getImageHandle(const fs_path &path, const UUID64 &resource_path_uuid = 0) const;
         [[nodiscard]] Result<RefPtr<const ImageHandle>, FSError>
diff --git a/lib/stb/stb_image.h b/lib/stb/stb_image.h
new file mode 100644
index 00000000..cb03941c
--- /dev/null
+++ b/lib/stb/stb_image.h
@@ -0,0 +1,8509 @@
+/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb
+                                  no warranty implied; use at your own risk
+
+   Do this:
+      #define STB_IMAGE_IMPLEMENTATION
+   before you include this file in *one* C or C++ file to create the implementation.
+
+   // i.e. it should look like this:
+   #include ...
+   #include ...
+   #include ...
+   #define STB_IMAGE_IMPLEMENTATION
+   #include "stb_image.h"
+
+   You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
+   And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
+
+
+   QUICK NOTES:
+      Primarily of interest to game developers and other people who can
+          avoid problematic images and only need the trivial interface
+
+      JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
+      PNG 1/2/4/8/16-bit-per-channel
+
+      TGA (not sure what subset, if a subset)
+      BMP non-1bpp, non-RLE
+      PSD (composited view only, no extra channels, 8/16 bit-per-channel)
+
+      GIF (*comp always reports as 4-channel)
+      HDR (radiance rgbE format)
+      PIC (Softimage PIC)
+      PNM (PPM and PGM binary only)
+
+      Animated GIF still needs a proper API, but here's one way to do it:
+          http://gist.github.com/urraka/685d9a6340b26b830d49
+
+      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+      - decode from arbitrary I/O callbacks
+      - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
+
+   Full documentation under "DOCUMENTATION" below.
+
+
+LICENSE
+
+  See end of file for license information.
+
+RECENT REVISION HISTORY:
+
+      2.30  (2024-05-31) avoid erroneous gcc warning
+      2.29  (2023-05-xx) optimizations
+      2.28  (2023-01-29) many error fixes, security errors, just tons of stuff
+      2.27  (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes
+      2.26  (2020-07-13) many minor fixes
+      2.25  (2020-02-02) fix warnings
+      2.24  (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically
+      2.23  (2019-08-11) fix clang static analysis warning
+      2.22  (2019-03-04) gif fixes, fix warnings
+      2.21  (2019-02-25) fix typo in comment
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
+      2.16  (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
+      2.15  (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
+                         RGB-format JPEG; remove white matting in PSD;
+                         allocate large structures on the stack;
+                         correct channel count for PNG & BMP
+      2.10  (2016-01-22) avoid warning introduced in 2.09
+      2.09  (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
+
+   See end of file for full revision history.
+
+
+ ============================    Contributors    =========================
+
+ Image formats                          Extensions, features
+    Sean Barrett (jpeg, png, bmp)          Jetro Lauha (stbi_info)
+    Nicolas Schulz (hdr, psd)              Martin "SpartanJ" Golini (stbi_info)
+    Jonathan Dummer (tga)                  James "moose2000" Brown (iPhone PNG)
+    Jean-Marc Lienher (gif)                Ben "Disch" Wenger (io callbacks)
+    Tom Seddon (pic)                       Omar Cornut (1/2/4-bit PNG)
+    Thatcher Ulrich (psd)                  Nicolas Guillemot (vertical flip)
+    Ken Miller (pgm, ppm)                  Richard Mitton (16-bit PSD)
+    github:urraka (animated gif)           Junggon Kim (PNM comments)
+    Christopher Forseth (animated gif)     Daniel Gibson (16-bit TGA)
+                                           socks-the-fox (16-bit PNG)
+                                           Jeremy Sawicki (handle all ImageNet JPGs)
+ Optimizations & bugfixes                  Mikhail Morozov (1-bit BMP)
+    Fabian "ryg" Giesen                    Anael Seghezzi (is-16-bit query)
+    Arseny Kapoulkine                      Simon Breuss (16-bit PNM)
+    John-Mark Allen
+    Carmelo J Fdez-Aguera
+
+ Bug & warning fixes
+    Marc LeBlanc            David Woo          Guillaume George     Martins Mozeiko
+    Christpher Lloyd        Jerry Jansson      Joseph Thomson       Blazej Dariusz Roszkowski
+    Phil Jordan                                Dave Moore           Roy Eltham
+    Hayaki Saito            Nathan Reed        Won Chun
+    Luke Graham             Johan Duparc       Nick Verigakis       the Horde3D community
+    Thomas Ruf              Ronny Chevalier                         github:rlyeh
+    Janez Zemva             John Bartholomew   Michal Cichon        github:romigrou
+    Jonathan Blow           Ken Hamada         Tero Hanninen        github:svdijk
+    Eugene Golushkov        Laurent Gomila     Cort Stratton        github:snagar
+    Aruelien Pocheville     Sergio Gonzalez    Thibault Reuille     github:Zelex
+    Cass Everitt            Ryamond Barbiero                        github:grim210
+    Paul Du Bois            Engin Manap        Aldo Culquicondor    github:sammyhw
+    Philipp Wiesemann       Dale Weiler        Oriol Ferrer Mesia   github:phprus
+    Josh Tobin              Neil Bickford      Matthew Gregan       github:poppolopoppo
+    Julian Raschke          Gregory Mullen     Christian Floisand   github:darealshinji
+    Baldur Karlsson         Kevin Schmidt      JR Smith             github:Michaelangel007
+                            Brad Weinberger    Matvey Cherevko      github:mosra
+    Luca Sas                Alexander Veselov  Zack Middleton       [reserved]
+    Ryan C. Gordon          [reserved]                              [reserved]
+                     DO NOT ADD YOUR NAME HERE
+
+                     Jacko Dirks
+
+  To add your name to the credits, pick a random blank space in the middle and fill it.
+  80% of merge conflicts on stb PRs are due to people adding their name at the end
+  of the credits.
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// DOCUMENTATION
+//
+// Limitations:
+//    - no 12-bit-per-channel JPEG
+//    - no JPEGs with arithmetic coding
+//    - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below for HDR usage):
+//    int x,y,n;
+//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+//    // ... process data if not NULL ...
+//    // ... x = width, y = height, n = # 8-bit components per pixel ...
+//    // ... replace '0' with '1'..'4' to force that many components per pixel
+//    // ... but 'n' will always be the number that it would have been if you said 0
+//    stbi_image_free(data);
+//
+// Standard parameters:
+//    int *x                 -- outputs image width in pixels
+//    int *y                 -- outputs image height in pixels
+//    int *channels_in_file  -- outputs # of image components in image file
+//    int desired_channels   -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data, or NULL on an allocation failure or if the image is
+// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'desired_channels' if desired_channels is non-zero, or
+// *channels_in_file otherwise. If desired_channels is non-zero,
+// *channels_in_file has the number of components that _would_ have been
+// output otherwise. E.g. if you set desired_channels to 4, you will always
+// get RGBA output, but you can check *channels_in_file to see if it's trivially
+// opaque because e.g. there were only 3 channels in the source image.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+//     N=#comp     components
+//       1           grey
+//       2           grey, alpha
+//       3           red, green, blue
+//       4           red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *channels_in_file will be unchanged. The function
+// stbi_failure_reason() can be queried for an extremely brief, end-user
+// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS
+// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+//
+// To query the width, height and component count of an image without having to
+// decode the full file, you can use the stbi_info family of functions:
+//
+//   int x,y,n,ok;
+//   ok = stbi_info(filename, &x, &y, &n);
+//   // returns ok=1 and sets x, y, n if image is a supported format,
+//   // 0 otherwise.
+//
+// Note that stb_image pervasively uses ints in its public API for sizes,
+// including sizes of memory buffers. This is now part of the API and thus
+// hard to change without causing breakage. As a result, the various image
+// loaders all have certain limits on image size; these differ somewhat
+// by format but generally boil down to either just under 2GB or just under
+// 1GB. When the decoded image would be larger than this, stb_image decoding
+// will fail.
+//
+// Additionally, stb_image will reject image files that have any of their
+// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS,
+// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit,
+// the only way to have an image with such dimensions load correctly
+// is for it to have a rather extreme aspect ratio. Either way, the
+// assumption here is that such larger images are likely to be malformed
+// or malicious. If you do need to load an image with individual dimensions
+// larger than that, and it still fits in the overall size limit, you can
+// #define STBI_MAX_DIMENSIONS on your own to be something larger.
+//
+// ===========================================================================
+//
+// UNICODE:
+//
+//   If compiling for Windows and you wish to use Unicode filenames, compile
+//   with
+//       #define STBI_WINDOWS_UTF8
+//   and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
+//   Windows wchar_t filenames to utf8.
+//
+// ===========================================================================
+//
+// Philosophy
+//
+// stb libraries are designed with the following priorities:
+//
+//    1. easy to use
+//    2. easy to maintain
+//    3. good performance
+//
+// Sometimes I let "good performance" creep up in priority over "easy to maintain",
+// and for best performance I may provide less-easy-to-use APIs that give higher
+// performance, in addition to the easy-to-use ones. Nevertheless, it's important
+// to keep in mind that from the standpoint of you, a client of this library,
+// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
+//
+// Some secondary priorities arise directly from the first two, some of which
+// provide more explicit reasons why performance can't be emphasized.
+//
+//    - Portable ("ease of use")
+//    - Small source code footprint ("easy to maintain")
+//    - No dependencies ("ease of use")
+//
+// ===========================================================================
+//
+// I/O callbacks
+//
+// I/O callbacks allow you to read from arbitrary sources, like packaged
+// files or some other source. Data read from callbacks are processed
+// through a small internal buffer (currently 128 bytes) to try to reduce
+// overhead.
+//
+// The three functions you must define are "read" (reads some bytes of data),
+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
+//
+// ===========================================================================
+//
+// SIMD support
+//
+// The JPEG decoder will try to automatically use SIMD kernels on x86 when
+// supported by the compiler. For ARM Neon support, you must explicitly
+// request it.
+//
+// (The old do-it-yourself SIMD API is no longer supported in the current
+// code.)
+//
+// On x86, SSE2 will automatically be used when available based on a run-time
+// test; if not, the generic C versions are used as a fall-back. On ARM targets,
+// the typical path is to have separate builds for NEON and non-NEON devices
+// (at least this is true for iOS and Android). Therefore, the NEON support is
+// toggled by a build flag: define STBI_NEON to get NEON loops.
+//
+// If for some reason you do not want to use any of SIMD code, or if
+// you have issues compiling it, you can disable it entirely by
+// defining STBI_NO_SIMD.
+//
+// ===========================================================================
+//
+// HDR image support   (disable by defining STBI_NO_HDR)
+//
+// stb_image supports loading HDR images in general, and currently the Radiance
+// .HDR file format specifically. You can still load any file through the existing
+// interface; if you attempt to load an HDR file, it will be automatically remapped
+// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+//     stbi_hdr_to_ldr_gamma(2.2f);
+//     stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
+//
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+//     stbi_ldr_to_hdr_scale(1.0f);
+//     stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+//     stbi_is_hdr(char *filename);
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// We optionally support converting iPhone-formatted PNGs (which store
+// premultiplied BGRA) back to RGB, even though they're internally encoded
+// differently. To enable this conversion, call
+// stbi_convert_iphone_png_to_rgb(1).
+//
+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
+// pixel to remove any premultiplied alpha *only* if the image file explicitly
+// says there's premultiplied data (currently only happens in iPhone images,
+// and only if iPhone convert-to-rgb processing is on).
+//
+// ===========================================================================
+//
+// ADDITIONAL CONFIGURATION
+//
+//  - You can suppress implementation of any of the decoders to reduce
+//    your code footprint by #defining one or more of the following
+//    symbols before creating the implementation.
+//
+//        STBI_NO_JPEG
+//        STBI_NO_PNG
+//        STBI_NO_BMP
+//        STBI_NO_PSD
+//        STBI_NO_TGA
+//        STBI_NO_GIF
+//        STBI_NO_HDR
+//        STBI_NO_PIC
+//        STBI_NO_PNM   (.ppm and .pgm)
+//
+//  - You can request *only* certain decoders and suppress all other ones
+//    (this will be more forward-compatible, as addition of new decoders
+//    doesn't require you to disable them explicitly):
+//
+//        STBI_ONLY_JPEG
+//        STBI_ONLY_PNG
+//        STBI_ONLY_BMP
+//        STBI_ONLY_PSD
+//        STBI_ONLY_TGA
+//        STBI_ONLY_GIF
+//        STBI_ONLY_HDR
+//        STBI_ONLY_PIC
+//        STBI_ONLY_PNM   (.ppm and .pgm)
+//
+//   - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
+//     want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
+//
+//  - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater
+//    than that size (in either width or height) without further processing.
+//    This is to let programs in the wild set an upper bound to prevent
+//    denial-of-service attacks on untrusted data, as one could generate a
+//    valid image of gigantic dimensions and force stb_image to allocate a
+//    huge block of memory and spend disproportionate time decoding it. By
+//    default this is set to (1 << 24), which is 16777216, but that's still
+//    very big.
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif  // STBI_NO_STDIO
+
+#define STBI_VERSION 1
+
+enum {
+    STBI_default = 0,  // only used for desired_channels
+
+    STBI_grey       = 1,
+    STBI_grey_alpha = 2,
+    STBI_rgb        = 3,
+    STBI_rgb_alpha  = 4
+};
+
+#include <stdlib.h>
+typedef unsigned char stbi_uc;
+typedef unsigned short stbi_us;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef STBIDEF
+#ifdef STB_IMAGE_STATIC
+#define STBIDEF static
+#else
+#define STBIDEF extern
+#endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PRIMARY API - works on images of any type
+//
+
+//
+// load image by filename, open file, or memory buffer
+//
+
+typedef struct {
+    int (*read)(void *user, char *data,
+                int size);  // fill 'data' with 'size' bytes.  return number of bytes actually read
+    void (*skip)(void *user,
+                 int n);     // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
+    int (*eof)(void *user);  // returns nonzero if we are at end of file/data
+} stbi_io_callbacks;
+
+////////////////////////////////////
+//
+// 8-bits-per-channel interface
+//
+
+STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y,
+                                       int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y,
+                                          int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *channels_in_file,
+                           int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *channels_in_file,
+                                     int desired_channels);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x,
+                                           int *y, int *z, int *comp, int req_comp);
+#endif
+
+#ifdef STBI_WINDOWS_UTF8
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t *input);
+#endif
+
+////////////////////////////////////
+//
+// 16-bits-per-channel interface
+//
+
+STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y,
+                                          int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x,
+                                             int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *channels_in_file,
+                              int desired_channels);
+STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file,
+                                        int desired_channels);
+#endif
+
+////////////////////////////////////
+//
+// float-per-channel interface
+//
+#ifndef STBI_NO_LINEAR
+STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y,
+                                      int *channels_in_file, int desired_channels);
+STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y,
+                                         int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *channels_in_file,
+                          int desired_channels);
+STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *channels_in_file,
+                                    int desired_channels);
+#endif
+#endif
+
+#ifndef STBI_NO_HDR
+STBIDEF void stbi_hdr_to_ldr_gamma(float gamma);
+STBIDEF void stbi_hdr_to_ldr_scale(float scale);
+#endif  // STBI_NO_HDR
+
+#ifndef STBI_NO_LINEAR
+STBIDEF void stbi_ldr_to_hdr_gamma(float gamma);
+STBIDEF void stbi_ldr_to_hdr_scale(float scale);
+#endif  // STBI_NO_LINEAR
+
+// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
+STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_is_hdr(char const *filename);
+STBIDEF int stbi_is_hdr_from_file(FILE *f);
+#endif  // STBI_NO_STDIO
+
+// get a VERY brief reason for failure
+// on most compilers (and ALL modern mainstream compilers) this is threadsafe
+STBIDEF const char *stbi_failure_reason(void);
+
+// free the loaded image -- this is just free()
+STBIDEF void stbi_image_free(void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y,
+                                     int *comp);
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp);
+STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp);
+STBIDEF int stbi_is_16_bit(char const *filename);
+STBIDEF int stbi_is_16_bit_from_file(FILE *f);
+#endif
+
+// for image formats that explicitly notate that they have premultiplied alpha,
+// we just return the colors as stored in the file. set this flag to force
+// unpremultiplication. results are undefined if the unpremultiply overflow.
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
+
+// indicate whether we should process iphone images back to canonical format,
+// or just pass them through "as-is"
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+// flip the image vertically, so the first pixel in the output array is the bottom left
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
+
+// as above, but only applies to images loaded on the thread that calls the function
+// this function is only available if your compiler supports thread-local variables;
+// calling it will fail to link if your compiler doesn't
+STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply);
+STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert);
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);
+
+// ZLIB client - used by PNG, available for other purposes
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size,
+                                                int *outlen);
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len,
+                                                           int initial_size, int *outlen,
+                                                           int parse_header);
+STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer,
+                                             int ilen);
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif  // STBI_INCLUDE_STB_IMAGE_H
+
+#ifdef STB_IMAGE_IMPLEMENTATION
+
+#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) ||                 \
+    defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) ||                  \
+    defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) ||                  \
+    defined(STBI_ONLY_ZLIB)
+#ifndef STBI_ONLY_JPEG
+#define STBI_NO_JPEG
+#endif
+#ifndef STBI_ONLY_PNG
+#define STBI_NO_PNG
+#endif
+#ifndef STBI_ONLY_BMP
+#define STBI_NO_BMP
+#endif
+#ifndef STBI_ONLY_PSD
+#define STBI_NO_PSD
+#endif
+#ifndef STBI_ONLY_TGA
+#define STBI_NO_TGA
+#endif
+#ifndef STBI_ONLY_GIF
+#define STBI_NO_GIF
+#endif
+#ifndef STBI_ONLY_HDR
+#define STBI_NO_HDR
+#endif
+#ifndef STBI_ONLY_PIC
+#define STBI_NO_PIC
+#endif
+#ifndef STBI_ONLY_PNM
+#define STBI_NO_PNM
+#endif
+#endif
+
+#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
+#define STBI_NO_ZLIB
+#endif
+
+#include <limits.h>
+#include <stdarg.h>
+#include <stddef.h>  // ptrdiff_t on osx
+#include <stdlib.h>
+#include <string.h>
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+#include <math.h>  // ldexp, pow
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifndef STBI_ASSERT
+#include <assert.h>
+#define STBI_ASSERT(x) assert(x)
+#endif
+
+#ifdef __cplusplus
+#define STBI_EXTERN extern "C"
+#else
+#define STBI_EXTERN extern
+#endif
+
+#ifndef _MSC_VER
+#ifdef __cplusplus
+#define stbi_inline inline
+#else
+#define stbi_inline
+#endif
+#else
+#define stbi_inline __forceinline
+#endif
+
+#ifndef STBI_NO_THREAD_LOCALS
+#if defined(__cplusplus) && __cplusplus >= 201103L
+#define STBI_THREAD_LOCAL thread_local
+#elif defined(__GNUC__) && __GNUC__ < 5
+#define STBI_THREAD_LOCAL __thread
+#elif defined(_MSC_VER)
+#define STBI_THREAD_LOCAL __declspec(thread)
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
+#define STBI_THREAD_LOCAL _Thread_local
+#endif
+
+#ifndef STBI_THREAD_LOCAL
+#if defined(__GNUC__)
+#define STBI_THREAD_LOCAL __thread
+#endif
+#endif
+#endif
+
+#if defined(_MSC_VER) || defined(__SYMBIAN32__)
+typedef unsigned short stbi__uint16;
+typedef signed short stbi__int16;
+typedef unsigned int stbi__uint32;
+typedef signed int stbi__int32;
+#else
+#include <stdint.h>
+typedef uint16_t stbi__uint16;
+typedef int16_t stbi__int16;
+typedef uint32_t stbi__uint32;
+typedef int32_t stbi__int32;
+#endif
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(stbi__uint32) == 4 ? 1 : -1];
+
+#ifdef _MSC_VER
+#define STBI_NOTUSED(v) (void)(v)
+#else
+#define STBI_NOTUSED(v) (void)sizeof(v)
+#endif
+
+#ifdef _MSC_VER
+#define STBI_HAS_LROTL
+#endif
+
+#ifdef STBI_HAS_LROTL
+#define stbi_lrot(x, y) _lrotl(x, y)
+#else
+#define stbi_lrot(x, y) (((x) << (y)) | ((x) >> (-(y) & 31)))
+#endif
+
+#if defined(STBI_MALLOC) && defined(STBI_FREE) &&                                                  \
+    (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
+// ok
+#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) &&                    \
+    !defined(STBI_REALLOC_SIZED)
+// ok
+#else
+#error                                                                                             \
+    "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
+#endif
+
+#ifndef STBI_MALLOC
+#define STBI_MALLOC(sz)        malloc(sz)
+#define STBI_REALLOC(p, newsz) realloc(p, newsz)
+#define STBI_FREE(p)           free(p)
+#endif
+
+#ifndef STBI_REALLOC_SIZED
+#define STBI_REALLOC_SIZED(p, oldsz, newsz) STBI_REALLOC(p, newsz)
+#endif
+
+// x86/x64 detection
+#if defined(__x86_64__) || defined(_M_X64)
+#define STBI__X64_TARGET
+#elif defined(__i386) || defined(_M_IX86)
+#define STBI__X86_TARGET
+#endif
+
+#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
+// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
+// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
+// but previous attempts to provide the SSE2 functions with runtime
+// detection caused numerous issues. The way architecture extensions are
+// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
+// New behavior: if compiled with -msse2, we use SSE2 without any
+// detection; if not, we don't use it at all.
+#define STBI_NO_SIMD
+#endif
+
+#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) &&       \
+    !defined(STBI_NO_SIMD)
+// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
+//
+// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
+// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
+// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
+// simultaneously enabling "-mstackrealign".
+//
+// See https://github.com/nothings/stb/issues/81 for more information.
+//
+// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
+// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
+#define STBI_NO_SIMD
+#endif
+
+#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
+#define STBI_SSE2
+#include <emmintrin.h>
+
+#ifdef _MSC_VER
+
+#if _MSC_VER >= 1400  // not VC6
+#include <intrin.h>   // __cpuid
+static int stbi__cpuid3(void) {
+    int info[4];
+    __cpuid(info, 1);
+    return info[3];
+}
+#else
+static int stbi__cpuid3(void) {
+    int res;
+    __asm {
+      mov  eax,1
+      cpuid
+      mov  res,edx
+    }
+    return res;
+}
+#endif
+
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void) {
+    int info3 = stbi__cpuid3();
+    return ((info3 >> 26) & 1) != 0;
+}
+#endif
+
+#else  // assume GCC-style if not VC++
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void) {
+    // If we're even attempting to compile this on GCC/Clang, that means
+    // -msse2 is on, which means the compiler is allowed to use SSE2
+    // instructions at will, and so are we.
+    return 1;
+}
+#endif
+
+#endif
+#endif
+
+// ARM NEON
+#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
+#undef STBI_NEON
+#endif
+
+#ifdef STBI_NEON
+#include <arm_neon.h>
+#ifdef _MSC_VER
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+#else
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+#endif
+#endif
+
+#ifndef STBI_SIMD_ALIGN
+#define STBI_SIMD_ALIGN(type, name) type name
+#endif
+
+#ifndef STBI_MAX_DIMENSIONS
+#define STBI_MAX_DIMENSIONS (1 << 24)
+#endif
+
+///////////////////////////////////////////////
+//
+//  stbi__context struct and start_xxx functions
+
+// stbi__context structure is our basic context used by all images, so it
+// contains all the IO context, plus some basic image information
+typedef struct {
+    stbi__uint32 img_x, img_y;
+    int img_n, img_out_n;
+
+    stbi_io_callbacks io;
+    void *io_user_data;
+
+    int read_from_callbacks;
+    int buflen;
+    stbi_uc buffer_start[128];
+    int callback_already_read;
+
+    stbi_uc *img_buffer, *img_buffer_end;
+    stbi_uc *img_buffer_original, *img_buffer_original_end;
+} stbi__context;
+
+static void stbi__refill_buffer(stbi__context *s);
+
+// initialize a memory-decode context
+static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) {
+    s->io.read               = NULL;
+    s->read_from_callbacks   = 0;
+    s->callback_already_read = 0;
+    s->img_buffer = s->img_buffer_original = (stbi_uc *)buffer;
+    s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *)buffer + len;
+}
+
+// initialize a callback-based context
+static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) {
+    s->io                    = *c;
+    s->io_user_data          = user;
+    s->buflen                = sizeof(s->buffer_start);
+    s->read_from_callbacks   = 1;
+    s->callback_already_read = 0;
+    s->img_buffer = s->img_buffer_original = s->buffer_start;
+    stbi__refill_buffer(s);
+    s->img_buffer_original_end = s->img_buffer_end;
+}
+
+#ifndef STBI_NO_STDIO
+
+static int stbi__stdio_read(void *user, char *data, int size) {
+    return (int)fread(data, 1, size, (FILE *)user);
+}
+
+static void stbi__stdio_skip(void *user, int n) {
+    int ch;
+    fseek((FILE *)user, n, SEEK_CUR);
+    ch = fgetc((FILE *)user); /* have to read a byte to reset feof()'s flag */
+    if (ch != EOF) {
+        ungetc(ch, (FILE *)user); /* push byte back onto stream if valid. */
+    }
+}
+
+static int stbi__stdio_eof(void *user) { return feof((FILE *)user) || ferror((FILE *)user); }
+
+static stbi_io_callbacks stbi__stdio_callbacks = {
+    stbi__stdio_read,
+    stbi__stdio_skip,
+    stbi__stdio_eof,
+};
+
+static void stbi__start_file(stbi__context *s, FILE *f) {
+    stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *)f);
+}
+
+// static void stop_file(stbi__context *s) { }
+
+#endif  // !STBI_NO_STDIO
+
+static void stbi__rewind(stbi__context *s) {
+    // conceptually rewind SHOULD rewind to the beginning of the stream,
+    // but we just rewind to the beginning of the initial buffer, because
+    // we only use it after doing 'test', which only ever looks at at most 92 bytes
+    s->img_buffer     = s->img_buffer_original;
+    s->img_buffer_end = s->img_buffer_original_end;
+}
+
+enum { STBI_ORDER_RGB, STBI_ORDER_BGR };
+
+typedef struct {
+    int bits_per_channel;
+    int num_channels;
+    int channel_order;
+} stbi__result_info;
+
+#ifndef STBI_NO_JPEG
+static int stbi__jpeg_test(stbi__context *s);
+static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                             stbi__result_info *ri);
+static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNG
+static int stbi__png_test(stbi__context *s);
+static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri);
+static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
+static int stbi__png_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_test(stbi__context *s);
+static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri);
+static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_TGA
+static int stbi__tga_test(stbi__context *s);
+static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri);
+static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_test(stbi__context *s);
+static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri, int bpc);
+static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
+static int stbi__psd_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_HDR
+static int stbi__hdr_test(stbi__context *s);
+static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                             stbi__result_info *ri);
+static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_test(stbi__context *s);
+static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri);
+static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_GIF
+static int stbi__gif_test(stbi__context *s);
+static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri);
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp,
+                                 int req_comp);
+static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNM
+static int stbi__pnm_test(stbi__context *s);
+static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri);
+static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
+static int stbi__pnm_is16(stbi__context *s);
+#endif
+
+static
+#ifdef STBI_THREAD_LOCAL
+    STBI_THREAD_LOCAL
+#endif
+    const char *stbi__g_failure_reason;
+
+STBIDEF const char *stbi_failure_reason(void) { return stbi__g_failure_reason; }
+
+#ifndef STBI_NO_FAILURE_STRINGS
+static int stbi__err(const char *str) {
+    stbi__g_failure_reason = str;
+    return 0;
+}
+#endif
+
+static void *stbi__malloc(size_t size) { return STBI_MALLOC(size); }
+
+// stb_image uses ints pervasively, including for offset calculations.
+// therefore the largest decoded image size we can support with the
+// current code, even on 64-bit targets, is INT_MAX. this is not a
+// significant limitation for the intended use case.
+//
+// we do, however, need to make sure our size calculations don't
+// overflow. hence a few helper functions for size calculations that
+// multiply integers together, making sure that they're non-negative
+// and no overflow occurs.
+
+// return 1 if the sum is valid, 0 on overflow.
+// negative terms are considered invalid.
+static int stbi__addsizes_valid(int a, int b) {
+    if (b < 0)
+        return 0;
+    // now 0 <= b <= INT_MAX, hence also
+    // 0 <= INT_MAX - b <= INTMAX.
+    // And "a + b <= INT_MAX" (which might overflow) is the
+    // same as a <= INT_MAX - b (no overflow)
+    return a <= INT_MAX - b;
+}
+
+// returns 1 if the product is valid, 0 on overflow.
+// negative factors are considered invalid.
+static int stbi__mul2sizes_valid(int a, int b) {
+    if (a < 0 || b < 0)
+        return 0;
+    if (b == 0)
+        return 1;  // mul-by-0 is always safe
+    // portable way to check for no overflows in a*b
+    return a <= INT_MAX / b;
+}
+
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) ||                    \
+    !defined(STBI_NO_HDR)
+// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad2sizes_valid(int a, int b, int add) {
+    return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a * b, add);
+}
+#endif
+
+// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad3sizes_valid(int a, int b, int c, int add) {
+    return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a * b, c) &&
+           stbi__addsizes_valid(a * b * c, add);
+}
+
+// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
+static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) {
+    return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a * b, c) &&
+           stbi__mul2sizes_valid(a * b * c, d) && stbi__addsizes_valid(a * b * c * d, add);
+}
+#endif
+
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) ||                    \
+    !defined(STBI_NO_HDR)
+// mallocs with size overflow checking
+static void *stbi__malloc_mad2(int a, int b, int add) {
+    if (!stbi__mad2sizes_valid(a, b, add))
+        return NULL;
+    return stbi__malloc(a * b + add);
+}
+#endif
+
+static void *stbi__malloc_mad3(int a, int b, int c, int add) {
+    if (!stbi__mad3sizes_valid(a, b, c, add))
+        return NULL;
+    return stbi__malloc(a * b * c + add);
+}
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
+static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) {
+    if (!stbi__mad4sizes_valid(a, b, c, d, add))
+        return NULL;
+    return stbi__malloc(a * b * c * d + add);
+}
+#endif
+
+// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on
+// overflow.
+static int stbi__addints_valid(int a, int b) {
+    if ((a >= 0) != (b >= 0))
+        return 1;  // a and b have different signs, so no overflow
+    if (a < 0 && b < 0)
+        return a >=
+               INT_MIN - b;  // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.
+    return a <= INT_MAX - b;
+}
+
+// returns 1 if the product of two ints fits in a signed short, 0 on overflow.
+static int stbi__mul2shorts_valid(int a, int b) {
+    if (b == 0 || b == -1)
+        return 1;  // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow
+    if ((a >= 0) == (b >= 0))
+        return a <= SHRT_MAX / b;  // product is positive, so similar to mul2sizes_valid
+    if (b < 0)
+        return a <= SHRT_MIN / b;  // same as a * b >= SHRT_MIN
+    return a >= SHRT_MIN / b;
+}
+
+// stbi__err - error
+// stbi__errpf - error returning pointer to float
+// stbi__errpuc - error returning pointer to unsigned char
+
+#ifdef STBI_NO_FAILURE_STRINGS
+#define stbi__err(x, y) 0
+#elif defined(STBI_FAILURE_USERMSG)
+#define stbi__err(x, y) stbi__err(y)
+#else
+#define stbi__err(x, y) stbi__err(x)
+#endif
+
+#define stbi__errpf(x, y)  ((float *)(size_t)(stbi__err(x, y) ? NULL : NULL))
+#define stbi__errpuc(x, y) ((unsigned char *)(size_t)(stbi__err(x, y) ? NULL : NULL))
+
+STBIDEF void stbi_image_free(void *retval_from_stbi_load) { STBI_FREE(retval_from_stbi_load); }
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
+#endif
+
+#ifndef STBI_NO_HDR
+static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);
+#endif
+
+static int stbi__vertically_flip_on_load_global = 0;
+
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) {
+    stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
+}
+
+#ifndef STBI_THREAD_LOCAL
+#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global
+#else
+static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
+
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) {
+    stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
+    stbi__vertically_flip_on_load_set   = 1;
+}
+
+#define stbi__vertically_flip_on_load                                                              \
+    (stbi__vertically_flip_on_load_set ? stbi__vertically_flip_on_load_local                       \
+                                       : stbi__vertically_flip_on_load_global)
+#endif  // STBI_THREAD_LOCAL
+
+static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                             stbi__result_info *ri, int bpc) {
+    memset(ri, 0, sizeof(*ri));          // make sure it's initialized if we add new fields
+    ri->bits_per_channel = 8;            // default is 8 so most paths don't have to be changed
+    ri->channel_order = STBI_ORDER_RGB;  // all current input & output are this, but this is here so
+                                         // we can add BGR order
+    ri->num_channels = 0;
+
+// test the formats with a very explicit header first (at least a FOURCC
+// or distinctive magic number first)
+#ifndef STBI_NO_PNG
+    if (stbi__png_test(s))
+        return stbi__png_load(s, x, y, comp, req_comp, ri);
+#endif
+#ifndef STBI_NO_BMP
+    if (stbi__bmp_test(s))
+        return stbi__bmp_load(s, x, y, comp, req_comp, ri);
+#endif
+#ifndef STBI_NO_GIF
+    if (stbi__gif_test(s))
+        return stbi__gif_load(s, x, y, comp, req_comp, ri);
+#endif
+#ifndef STBI_NO_PSD
+    if (stbi__psd_test(s))
+        return stbi__psd_load(s, x, y, comp, req_comp, ri, bpc);
+#else
+    STBI_NOTUSED(bpc);
+#endif
+#ifndef STBI_NO_PIC
+    if (stbi__pic_test(s))
+        return stbi__pic_load(s, x, y, comp, req_comp, ri);
+#endif
+
+// then the formats that can end up attempting to load with just 1 or 2
+// bytes matching expectations; these are prone to false positives, so
+// try them later
+#ifndef STBI_NO_JPEG
+    if (stbi__jpeg_test(s))
+        return stbi__jpeg_load(s, x, y, comp, req_comp, ri);
+#endif
+#ifndef STBI_NO_PNM
+    if (stbi__pnm_test(s))
+        return stbi__pnm_load(s, x, y, comp, req_comp, ri);
+#endif
+
+#ifndef STBI_NO_HDR
+    if (stbi__hdr_test(s)) {
+        float *hdr = stbi__hdr_load(s, x, y, comp, req_comp, ri);
+        return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+    }
+#endif
+
+#ifndef STBI_NO_TGA
+    // test tga last because it's a crappy test!
+    if (stbi__tga_test(s))
+        return stbi__tga_load(s, x, y, comp, req_comp, ri);
+#endif
+
+    return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) {
+    int i;
+    int img_len = w * h * channels;
+    stbi_uc *reduced;
+
+    reduced = (stbi_uc *)stbi__malloc(img_len);
+    if (reduced == NULL)
+        return stbi__errpuc("outofmem", "Out of memory");
+
+    for (i = 0; i < img_len; ++i)
+        reduced[i] =
+            (stbi_uc)((orig[i] >> 8) &
+                      0xFF);  // top half of each byte is sufficient approx of 16->8 bit scaling
+
+    STBI_FREE(orig);
+    return reduced;
+}
+
+static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) {
+    int i;
+    int img_len = w * h * channels;
+    stbi__uint16 *enlarged;
+
+    enlarged = (stbi__uint16 *)stbi__malloc(img_len * 2);
+    if (enlarged == NULL)
+        return (stbi__uint16 *)stbi__errpuc("outofmem", "Out of memory");
+
+    for (i = 0; i < img_len; ++i)
+        enlarged[i] =
+            (stbi__uint16)((orig[i] << 8) +
+                           orig[i]);  // replicate to high and low byte, maps 0->0, 255->0xffff
+
+    STBI_FREE(orig);
+    return enlarged;
+}
+
+static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) {
+    int row;
+    size_t bytes_per_row = (size_t)w * bytes_per_pixel;
+    stbi_uc temp[2048];
+    stbi_uc *bytes = (stbi_uc *)image;
+
+    for (row = 0; row < (h >> 1); row++) {
+        stbi_uc *row0 = bytes + row * bytes_per_row;
+        stbi_uc *row1 = bytes + (h - row - 1) * bytes_per_row;
+        // swap row0 with row1
+        size_t bytes_left = bytes_per_row;
+        while (bytes_left) {
+            size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
+            memcpy(temp, row0, bytes_copy);
+            memcpy(row0, row1, bytes_copy);
+            memcpy(row1, temp, bytes_copy);
+            row0 += bytes_copy;
+            row1 += bytes_copy;
+            bytes_left -= bytes_copy;
+        }
+    }
+}
+
+#ifndef STBI_NO_GIF
+static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) {
+    int slice;
+    int slice_size = w * h * bytes_per_pixel;
+
+    stbi_uc *bytes = (stbi_uc *)image;
+    for (slice = 0; slice < z; ++slice) {
+        stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
+        bytes += slice_size;
+    }
+}
+#endif
+
+static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp,
+                                                      int req_comp) {
+    stbi__result_info ri;
+    void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
+
+    if (result == NULL)
+        return NULL;
+
+    // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
+    STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
+
+    if (ri.bits_per_channel != 8) {
+        result =
+            stbi__convert_16_to_8((stbi__uint16 *)result, *x, *y, req_comp == 0 ? *comp : req_comp);
+        ri.bits_per_channel = 8;
+    }
+
+    // @TODO: move stbi__convert_format to here
+
+    if (stbi__vertically_flip_on_load) {
+        int channels = req_comp ? req_comp : *comp;
+        stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
+    }
+
+    return (unsigned char *)result;
+}
+
+static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp,
+                                                      int req_comp) {
+    stbi__result_info ri;
+    void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
+
+    if (result == NULL)
+        return NULL;
+
+    // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
+    STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
+
+    if (ri.bits_per_channel != 16) {
+        result = stbi__convert_8_to_16((stbi_uc *)result, *x, *y, req_comp == 0 ? *comp : req_comp);
+        ri.bits_per_channel = 16;
+    }
+
+    // @TODO: move stbi__convert_format16 to here
+    // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
+
+    if (stbi__vertically_flip_on_load) {
+        int channels = req_comp ? req_comp : *comp;
+        stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
+    }
+
+    return (stbi__uint16 *)result;
+}
+
+#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
+static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) {
+    if (stbi__vertically_flip_on_load && result != NULL) {
+        int channels = req_comp ? req_comp : *comp;
+        stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
+    }
+}
+#endif
+
+#ifndef STBI_NO_STDIO
+
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp,
+                                                                    unsigned long flags,
+                                                                    const char *str, int cbmb,
+                                                                    wchar_t *widestr, int cchwide);
+STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(
+    unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb,
+    const char *defchar, int *used_default);
+#endif
+
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t *input) {
+    return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int)bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbi__fopen(char const *filename, char const *mode) {
+    FILE *f;
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+    wchar_t wMode[64];
+    wchar_t wFilename[1024];
+    if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename,
+                                 sizeof(wFilename) / sizeof(*wFilename)))
+        return 0;
+
+    if (0 ==
+        MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode) / sizeof(*wMode)))
+        return 0;
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    if (0 != _wfopen_s(&f, wFilename, wMode))
+        f = 0;
+#else
+    f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+    if (0 != fopen_s(&f, filename, mode))
+        f = 0;
+#else
+    f = fopen(filename, mode);
+#endif
+    return f;
+}
+
+STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) {
+    FILE *f = stbi__fopen(filename, "rb");
+    unsigned char *result;
+    if (!f)
+        return stbi__errpuc("can't fopen", "Unable to open file");
+    result = stbi_load_from_file(f, x, y, comp, req_comp);
+    fclose(f);
+    return result;
+}
+
+STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) {
+    unsigned char *result;
+    stbi__context s;
+    stbi__start_file(&s, f);
+    result = stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp);
+    if (result) {
+        // need to 'unget' all the characters in the IO buffer
+        fseek(f, -(int)(s.img_buffer_end - s.img_buffer), SEEK_CUR);
+    }
+    return result;
+}
+
+STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) {
+    stbi__uint16 *result;
+    stbi__context s;
+    stbi__start_file(&s, f);
+    result = stbi__load_and_postprocess_16bit(&s, x, y, comp, req_comp);
+    if (result) {
+        // need to 'unget' all the characters in the IO buffer
+        fseek(f, -(int)(s.img_buffer_end - s.img_buffer), SEEK_CUR);
+    }
+    return result;
+}
+
+STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) {
+    FILE *f = stbi__fopen(filename, "rb");
+    stbi__uint16 *result;
+    if (!f)
+        return (stbi_us *)stbi__errpuc("can't fopen", "Unable to open file");
+    result = stbi_load_from_file_16(f, x, y, comp, req_comp);
+    fclose(f);
+    return result;
+}
+
+#endif  //! STBI_NO_STDIO
+
+STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y,
+                                          int *channels_in_file, int desired_channels) {
+    stbi__context s;
+    stbi__start_mem(&s, buffer, len);
+    return stbi__load_and_postprocess_16bit(&s, x, y, channels_in_file, desired_channels);
+}
+
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x,
+                                             int *y, int *channels_in_file, int desired_channels) {
+    stbi__context s;
+    stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+    return stbi__load_and_postprocess_16bit(&s, x, y, channels_in_file, desired_channels);
+}
+
+STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp,
+                                       int req_comp) {
+    stbi__context s;
+    stbi__start_mem(&s, buffer, len);
+    return stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp);
+}
+
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y,
+                                          int *comp, int req_comp) {
+    stbi__context s;
+    stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+    return stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp);
+}
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x,
+                                           int *y, int *z, int *comp, int req_comp) {
+    unsigned char *result;
+    stbi__context s;
+    stbi__start_mem(&s, buffer, len);
+
+    result = (unsigned char *)stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
+    if (stbi__vertically_flip_on_load) {
+        stbi__vertical_flip_slices(result, *x, *y, *z, *comp);
+    }
+
+    return result;
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) {
+    unsigned char *data;
+#ifndef STBI_NO_HDR
+    if (stbi__hdr_test(s)) {
+        stbi__result_info ri;
+        float *hdr_data = stbi__hdr_load(s, x, y, comp, req_comp, &ri);
+        if (hdr_data)
+            stbi__float_postprocess(hdr_data, x, y, comp, req_comp);
+        return hdr_data;
+    }
+#endif
+    data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
+    if (data)
+        return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+    return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
+}
+
+STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp,
+                                      int req_comp) {
+    stbi__context s;
+    stbi__start_mem(&s, buffer, len);
+    return stbi__loadf_main(&s, x, y, comp, req_comp);
+}
+
+STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y,
+                                         int *comp, int req_comp) {
+    stbi__context s;
+    stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+    return stbi__loadf_main(&s, x, y, comp, req_comp);
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) {
+    float *result;
+    FILE *f = stbi__fopen(filename, "rb");
+    if (!f)
+        return stbi__errpf("can't fopen", "Unable to open file");
+    result = stbi_loadf_from_file(f, x, y, comp, req_comp);
+    fclose(f);
+    return result;
+}
+
+STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) {
+    stbi__context s;
+    stbi__start_file(&s, f);
+    return stbi__loadf_main(&s, x, y, comp, req_comp);
+}
+#endif  // !STBI_NO_STDIO
+
+#endif  // !STBI_NO_LINEAR
+
+// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
+// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
+// reports false!
+
+STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) {
+#ifndef STBI_NO_HDR
+    stbi__context s;
+    stbi__start_mem(&s, buffer, len);
+    return stbi__hdr_test(&s);
+#else
+    STBI_NOTUSED(buffer);
+    STBI_NOTUSED(len);
+    return 0;
+#endif
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_is_hdr(char const *filename) {
+    FILE *f    = stbi__fopen(filename, "rb");
+    int result = 0;
+    if (f) {
+        result = stbi_is_hdr_from_file(f);
+        fclose(f);
+    }
+    return result;
+}
+
+STBIDEF int stbi_is_hdr_from_file(FILE *f) {
+#ifndef STBI_NO_HDR
+    long pos = ftell(f);
+    int res;
+    stbi__context s;
+    stbi__start_file(&s, f);
+    res = stbi__hdr_test(&s);
+    fseek(f, pos, SEEK_SET);
+    return res;
+#else
+    STBI_NOTUSED(f);
+    return 0;
+#endif
+}
+#endif  // !STBI_NO_STDIO
+
+STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) {
+#ifndef STBI_NO_HDR
+    stbi__context s;
+    stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+    return stbi__hdr_test(&s);
+#else
+    STBI_NOTUSED(clbk);
+    STBI_NOTUSED(user);
+    return 0;
+#endif
+}
+
+#ifndef STBI_NO_LINEAR
+static float stbi__l2h_gamma = 2.2f, stbi__l2h_scale = 1.0f;
+
+STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
+STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
+#endif
+
+static float stbi__h2l_gamma_i = 1.0f / 2.2f, stbi__h2l_scale_i = 1.0f;
+
+STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1 / gamma; }
+STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1 / scale; }
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Common code used by all image loaders
+//
+
+enum { STBI__SCAN_load = 0, STBI__SCAN_type, STBI__SCAN_header };
+
+static void stbi__refill_buffer(stbi__context *s) {
+    int n = (s->io.read)(s->io_user_data, (char *)s->buffer_start, s->buflen);
+    s->callback_already_read += (int)(s->img_buffer - s->img_buffer_original);
+    if (n == 0) {
+        // at end of file, treat same as if from memory, but need to handle case
+        // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
+        s->read_from_callbacks = 0;
+        s->img_buffer          = s->buffer_start;
+        s->img_buffer_end      = s->buffer_start + 1;
+        *s->img_buffer         = 0;
+    } else {
+        s->img_buffer     = s->buffer_start;
+        s->img_buffer_end = s->buffer_start + n;
+    }
+}
+
+stbi_inline static stbi_uc stbi__get8(stbi__context *s) {
+    if (s->img_buffer < s->img_buffer_end)
+        return *s->img_buffer++;
+    if (s->read_from_callbacks) {
+        stbi__refill_buffer(s);
+        return *s->img_buffer++;
+    }
+    return 0;
+}
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+stbi_inline static int stbi__at_eof(stbi__context *s) {
+    if (s->io.read) {
+        if (!(s->io.eof)(s->io_user_data))
+            return 0;
+        // if feof() is true, check if buffer = end
+        // special case: we've only got the special 0 character at the end
+        if (s->read_from_callbacks == 0)
+            return 1;
+    }
+
+    return s->img_buffer >= s->img_buffer_end;
+}
+#endif
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) &&                       \
+    defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
+// nothing
+#else
+static void stbi__skip(stbi__context *s, int n) {
+    if (n == 0)
+        return;  // already there!
+    if (n < 0) {
+        s->img_buffer = s->img_buffer_end;
+        return;
+    }
+    if (s->io.read) {
+        int blen = (int)(s->img_buffer_end - s->img_buffer);
+        if (blen < n) {
+            s->img_buffer = s->img_buffer_end;
+            (s->io.skip)(s->io_user_data, n - blen);
+            return;
+        }
+    }
+    s->img_buffer += n;
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
+// nothing
+#else
+static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) {
+    if (s->io.read) {
+        int blen = (int)(s->img_buffer_end - s->img_buffer);
+        if (blen < n) {
+            int res, count;
+
+            memcpy(buffer, s->img_buffer, blen);
+
+            count         = (s->io.read)(s->io_user_data, (char *)buffer + blen, n - blen);
+            res           = (count == (n - blen));
+            s->img_buffer = s->img_buffer_end;
+            return res;
+        }
+    }
+
+    if (s->img_buffer + n <= s->img_buffer_end) {
+        memcpy(buffer, s->img_buffer, n);
+        s->img_buffer += n;
+        return 1;
+    } else
+        return 0;
+}
+#endif
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
+static int stbi__get16be(stbi__context *s) {
+    int z = stbi__get8(s);
+    return (z << 8) + stbi__get8(s);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
+static stbi__uint32 stbi__get32be(stbi__context *s) {
+    stbi__uint32 z = stbi__get16be(s);
+    return (z << 16) + stbi__get16be(s);
+}
+#endif
+
+#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
+// nothing
+#else
+static int stbi__get16le(stbi__context *s) {
+    int z = stbi__get8(s);
+    return z + (stbi__get8(s) << 8);
+}
+#endif
+
+#ifndef STBI_NO_BMP
+static stbi__uint32 stbi__get32le(stbi__context *s) {
+    stbi__uint32 z = stbi__get16le(s);
+    z += (stbi__uint32)stbi__get16le(s) << 16;
+    return z;
+}
+#endif
+
+#define STBI__BYTECAST(x) ((stbi_uc)((x) & 255))  // truncate int to byte without warnings
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) &&                       \
+    defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) &&                        \
+    defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+//////////////////////////////////////////////////////////////////////////////
+//
+//  generic converter from built-in img_n to req_comp
+//    individual types do this automatically as much as possible (e.g. jpeg
+//    does all cases internally since it needs to colorspace convert anyway,
+//    and it never has alpha, so very few cases ). png can automatically
+//    interleave an alpha=255 channel, but falls back to this for other cases
+//
+//  assume data buffer is malloced, so malloc a new one and free that one
+//  only failure mode is malloc failing
+
+static stbi_uc stbi__compute_y(int r, int g, int b) {
+    return (stbi_uc)(((r * 77) + (g * 150) + (29 * b)) >> 8);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) &&                        \
+    defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp,
+                                           unsigned int x, unsigned int y) {
+    int i, j;
+    unsigned char *good;
+
+    if (req_comp == img_n)
+        return data;
+    STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+    good = (unsigned char *)stbi__malloc_mad3(req_comp, x, y, 0);
+    if (good == NULL) {
+        STBI_FREE(data);
+        return stbi__errpuc("outofmem", "Out of memory");
+    }
+
+    for (j = 0; j < (int)y; ++j) {
+        unsigned char *src  = data + j * x * img_n;
+        unsigned char *dest = good + j * x * req_comp;
+
+#define STBI__COMBO(a, b) ((a) * 8 + (b))
+#define STBI__CASE(a, b)                                                                           \
+    case STBI__COMBO(a, b):                                                                        \
+        for (i = x - 1; i >= 0; --i, src += a, dest += b)
+        // convert source image with img_n components to one with req_comp components;
+        // avoid switch per pixel, so use switch per scanline and massive macros
+        switch (STBI__COMBO(img_n, req_comp)) {
+            STBI__CASE(1, 2) {
+                dest[0] = src[0];
+                dest[1] = 255;
+            }
+            break;
+            STBI__CASE(1, 3) { dest[0] = dest[1] = dest[2] = src[0]; }
+            break;
+            STBI__CASE(1, 4) {
+                dest[0] = dest[1] = dest[2] = src[0];
+                dest[3]                     = 255;
+            }
+            break;
+            STBI__CASE(2, 1) { dest[0] = src[0]; }
+            break;
+            STBI__CASE(2, 3) { dest[0] = dest[1] = dest[2] = src[0]; }
+            break;
+            STBI__CASE(2, 4) {
+                dest[0] = dest[1] = dest[2] = src[0];
+                dest[3]                     = src[1];
+            }
+            break;
+            STBI__CASE(3, 4) {
+                dest[0] = src[0];
+                dest[1] = src[1];
+                dest[2] = src[2];
+                dest[3] = 255;
+            }
+            break;
+            STBI__CASE(3, 1) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); }
+            break;
+            STBI__CASE(3, 2) {
+                dest[0] = stbi__compute_y(src[0], src[1], src[2]);
+                dest[1] = 255;
+            }
+            break;
+            STBI__CASE(4, 1) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); }
+            break;
+            STBI__CASE(4, 2) {
+                dest[0] = stbi__compute_y(src[0], src[1], src[2]);
+                dest[1] = src[3];
+            }
+            break;
+            STBI__CASE(4, 3) {
+                dest[0] = src[0];
+                dest[1] = src[1];
+                dest[2] = src[2];
+            }
+            break;
+        default:
+            STBI_ASSERT(0);
+            STBI_FREE(data);
+            STBI_FREE(good);
+            return stbi__errpuc("unsupported", "Unsupported format conversion");
+        }
+#undef STBI__CASE
+    }
+
+    STBI_FREE(data);
+    return good;
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
+static stbi__uint16 stbi__compute_y_16(int r, int g, int b) {
+    return (stbi__uint16)(((r * 77) + (g * 150) + (29 * b)) >> 8);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
+static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp,
+                                            unsigned int x, unsigned int y) {
+    int i, j;
+    stbi__uint16 *good;
+
+    if (req_comp == img_n)
+        return data;
+    STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+    good = (stbi__uint16 *)stbi__malloc(req_comp * x * y * 2);
+    if (good == NULL) {
+        STBI_FREE(data);
+        return (stbi__uint16 *)stbi__errpuc("outofmem", "Out of memory");
+    }
+
+    for (j = 0; j < (int)y; ++j) {
+        stbi__uint16 *src  = data + j * x * img_n;
+        stbi__uint16 *dest = good + j * x * req_comp;
+
+#define STBI__COMBO(a, b) ((a) * 8 + (b))
+#define STBI__CASE(a, b)                                                                           \
+    case STBI__COMBO(a, b):                                                                        \
+        for (i = x - 1; i >= 0; --i, src += a, dest += b)
+        // convert source image with img_n components to one with req_comp components;
+        // avoid switch per pixel, so use switch per scanline and massive macros
+        switch (STBI__COMBO(img_n, req_comp)) {
+            STBI__CASE(1, 2) {
+                dest[0] = src[0];
+                dest[1] = 0xffff;
+            }
+            break;
+            STBI__CASE(1, 3) { dest[0] = dest[1] = dest[2] = src[0]; }
+            break;
+            STBI__CASE(1, 4) {
+                dest[0] = dest[1] = dest[2] = src[0];
+                dest[3]                     = 0xffff;
+            }
+            break;
+            STBI__CASE(2, 1) { dest[0] = src[0]; }
+            break;
+            STBI__CASE(2, 3) { dest[0] = dest[1] = dest[2] = src[0]; }
+            break;
+            STBI__CASE(2, 4) {
+                dest[0] = dest[1] = dest[2] = src[0];
+                dest[3]                     = src[1];
+            }
+            break;
+            STBI__CASE(3, 4) {
+                dest[0] = src[0];
+                dest[1] = src[1];
+                dest[2] = src[2];
+                dest[3] = 0xffff;
+            }
+            break;
+            STBI__CASE(3, 1) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); }
+            break;
+            STBI__CASE(3, 2) {
+                dest[0] = stbi__compute_y_16(src[0], src[1], src[2]);
+                dest[1] = 0xffff;
+            }
+            break;
+            STBI__CASE(4, 1) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); }
+            break;
+            STBI__CASE(4, 2) {
+                dest[0] = stbi__compute_y_16(src[0], src[1], src[2]);
+                dest[1] = src[3];
+            }
+            break;
+            STBI__CASE(4, 3) {
+                dest[0] = src[0];
+                dest[1] = src[1];
+                dest[2] = src[2];
+            }
+            break;
+        default:
+            STBI_ASSERT(0);
+            STBI_FREE(data);
+            STBI_FREE(good);
+            return (stbi__uint16 *)stbi__errpuc("unsupported", "Unsupported format conversion");
+        }
+#undef STBI__CASE
+    }
+
+    STBI_FREE(data);
+    return good;
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) {
+    int i, k, n;
+    float *output;
+    if (!data)
+        return NULL;
+    output = (float *)stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
+    if (output == NULL) {
+        STBI_FREE(data);
+        return stbi__errpf("outofmem", "Out of memory");
+    }
+    // compute number of non-alpha components
+    if (comp & 1)
+        n = comp;
+    else
+        n = comp - 1;
+    for (i = 0; i < x * y; ++i) {
+        for (k = 0; k < n; ++k) {
+            output[i * comp + k] =
+                (float)(pow(data[i * comp + k] / 255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
+        }
+    }
+    if (n < comp) {
+        for (i = 0; i < x * y; ++i) {
+            output[i * comp + n] = data[i * comp + n] / 255.0f;
+        }
+    }
+    STBI_FREE(data);
+    return output;
+}
+#endif
+
+#ifndef STBI_NO_HDR
+#define stbi__float2int(x) ((int)(x))
+static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) {
+    int i, k, n;
+    stbi_uc *output;
+    if (!data)
+        return NULL;
+    output = (stbi_uc *)stbi__malloc_mad3(x, y, comp, 0);
+    if (output == NULL) {
+        STBI_FREE(data);
+        return stbi__errpuc("outofmem", "Out of memory");
+    }
+    // compute number of non-alpha components
+    if (comp & 1)
+        n = comp;
+    else
+        n = comp - 1;
+    for (i = 0; i < x * y; ++i) {
+        for (k = 0; k < n; ++k) {
+            float z =
+                (float)pow(data[i * comp + k] * stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
+            if (z < 0)
+                z = 0;
+            if (z > 255)
+                z = 255;
+            output[i * comp + k] = (stbi_uc)stbi__float2int(z);
+        }
+        if (k < comp) {
+            float z = data[i * comp + k] * 255 + 0.5f;
+            if (z < 0)
+                z = 0;
+            if (z > 255)
+                z = 255;
+            output[i * comp + k] = (stbi_uc)stbi__float2int(z);
+        }
+    }
+    STBI_FREE(data);
+    return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  "baseline" JPEG/JFIF decoder
+//
+//    simple implementation
+//      - doesn't support delayed output of y-dimension
+//      - simple interface (only one output format: 8-bit interleaved RGB)
+//      - doesn't try to recover corrupt jpegs
+//      - doesn't allow partial loading, loading multiple at once
+//      - still fast on x86 (copying globals into locals doesn't help x86)
+//      - allocates lots of intermediate memory (full size of all components)
+//        - non-interleaved case requires this anyway
+//        - allows good upsampling (see next)
+//    high-quality
+//      - upsampled channels are bilinearly interpolated, even across blocks
+//      - quality integer IDCT derived from IJG's 'slow'
+//    performance
+//      - fast huffman; reasonable integer IDCT
+//      - some SIMD kernels for common paths on targets with SSE2/NEON
+//      - uses a lot of intermediate memory, could cache poorly
+
+#ifndef STBI_NO_JPEG
+
+// huffman decoding acceleration
+#define FAST_BITS 9  // larger handles more cases; smaller stomps less cache
+
+typedef struct {
+    stbi_uc fast[1 << FAST_BITS];
+    // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+    stbi__uint16 code[256];
+    stbi_uc values[256];
+    stbi_uc size[257];
+    unsigned int maxcode[18];
+    int delta[17];  // old 'firstsymbol' - old 'firstcode'
+} stbi__huffman;
+
+typedef struct {
+    stbi__context *s;
+    stbi__huffman huff_dc[4];
+    stbi__huffman huff_ac[4];
+    stbi__uint16 dequant[4][64];
+    stbi__int16 fast_ac[4][1 << FAST_BITS];
+
+    // sizes for components, interleaved MCUs
+    int img_h_max, img_v_max;
+    int img_mcu_x, img_mcu_y;
+    int img_mcu_w, img_mcu_h;
+
+    // definition of jpeg image component
+    struct {
+        int id;
+        int h, v;
+        int tq;
+        int hd, ha;
+        int dc_pred;
+
+        int x, y, w2, h2;
+        stbi_uc *data;
+        void *raw_data, *raw_coeff;
+        stbi_uc *linebuf;
+        short *coeff;          // progressive only
+        int coeff_w, coeff_h;  // number of 8x8 coefficient blocks
+    } img_comp[4];
+
+    stbi__uint32 code_buffer;  // jpeg entropy-coded buffer
+    int code_bits;             // number of valid bits
+    unsigned char marker;      // marker seen while filling entropy buffer
+    int nomore;                // flag if we saw a marker so must stop
+
+    int progressive;
+    int spec_start;
+    int spec_end;
+    int succ_high;
+    int succ_low;
+    int eob_run;
+    int jfif;
+    int app14_color_transform;  // Adobe APP14 tag
+    int rgb;
+
+    int scan_n, order[4];
+    int restart_interval, todo;
+
+    // kernels
+    void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
+    void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb,
+                                const stbi_uc *pcr, int count, int step);
+    stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w,
+                                         int hs);
+} stbi__jpeg;
+
+static int stbi__build_huffman(stbi__huffman *h, int *count) {
+    int i, j, k = 0;
+    unsigned int code;
+    // build size list for each symbol (from JPEG spec)
+    for (i = 0; i < 16; ++i) {
+        for (j = 0; j < count[i]; ++j) {
+            h->size[k++] = (stbi_uc)(i + 1);
+            if (k >= 257)
+                return stbi__err("bad size list", "Corrupt JPEG");
+        }
+    }
+    h->size[k] = 0;
+
+    // compute actual symbols (from jpeg spec)
+    code = 0;
+    k    = 0;
+    for (j = 1; j <= 16; ++j) {
+        // compute delta to add to code to compute symbol id
+        h->delta[j] = k - code;
+        if (h->size[k] == j) {
+            while (h->size[k] == j)
+                h->code[k++] = (stbi__uint16)(code++);
+            if (code - 1 >= (1u << j))
+                return stbi__err("bad code lengths", "Corrupt JPEG");
+        }
+        // compute largest code + 1 for this size, preshifted as needed later
+        h->maxcode[j] = code << (16 - j);
+        code <<= 1;
+    }
+    h->maxcode[j] = 0xffffffff;
+
+    // build non-spec acceleration table; 255 is flag for not-accelerated
+    memset(h->fast, 255, 1 << FAST_BITS);
+    for (i = 0; i < k; ++i) {
+        int s = h->size[i];
+        if (s <= FAST_BITS) {
+            int c = h->code[i] << (FAST_BITS - s);
+            int m = 1 << (FAST_BITS - s);
+            for (j = 0; j < m; ++j) {
+                h->fast[c + j] = (stbi_uc)i;
+            }
+        }
+    }
+    return 1;
+}
+
+// build a table that decodes both magnitude and value of small ACs in
+// one go.
+static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) {
+    int i;
+    for (i = 0; i < (1 << FAST_BITS); ++i) {
+        stbi_uc fast = h->fast[i];
+        fast_ac[i]   = 0;
+        if (fast < 255) {
+            int rs      = h->values[fast];
+            int run     = (rs >> 4) & 15;
+            int magbits = rs & 15;
+            int len     = h->size[fast];
+
+            if (magbits && len + magbits <= FAST_BITS) {
+                // magnitude code followed by receive_extend code
+                int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
+                int m = 1 << (magbits - 1);
+                if (k < m)
+                    k += (~0U << magbits) + 1;
+                // if the result is small enough, we can fit it in fast_ac table
+                if (k >= -128 && k <= 127)
+                    fast_ac[i] = (stbi__int16)((k * 256) + (run * 16) + (len + magbits));
+            }
+        }
+    }
+}
+
+static void stbi__grow_buffer_unsafe(stbi__jpeg *j) {
+    do {
+        unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
+        if (b == 0xff) {
+            int c = stbi__get8(j->s);
+            while (c == 0xff)
+                c = stbi__get8(j->s);  // consume fill bytes
+            if (c != 0) {
+                j->marker = (unsigned char)c;
+                j->nomore = 1;
+                return;
+            }
+        }
+        j->code_buffer |= b << (24 - j->code_bits);
+        j->code_bits += 8;
+    } while (j->code_bits <= 24);
+}
+
+// (1 << n) - 1
+static const stbi__uint32 stbi__bmask[17] = {0,   1,    3,    7,    15,   31,    63,    127,  255,
+                                             511, 1023, 2047, 4095, 8191, 16383, 32767, 65535};
+
+// decode a jpeg huffman value from the bitstream
+stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) {
+    unsigned int temp;
+    int c, k;
+
+    if (j->code_bits < 16)
+        stbi__grow_buffer_unsafe(j);
+
+    // look at the top FAST_BITS and determine what symbol ID it is,
+    // if the code is <= FAST_BITS
+    c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS) - 1);
+    k = h->fast[c];
+    if (k < 255) {
+        int s = h->size[k];
+        if (s > j->code_bits)
+            return -1;
+        j->code_buffer <<= s;
+        j->code_bits -= s;
+        return h->values[k];
+    }
+
+    // naive test is to shift the code_buffer down so k bits are
+    // valid, then test against maxcode. To speed this up, we've
+    // preshifted maxcode left so that it has (16-k) 0s at the
+    // end; in other words, regardless of the number of bits, it
+    // wants to be compared against something shifted to have 16;
+    // that way we don't need to shift inside the loop.
+    temp = j->code_buffer >> 16;
+    for (k = FAST_BITS + 1;; ++k)
+        if (temp < h->maxcode[k])
+            break;
+    if (k == 17) {
+        // error! code not found
+        j->code_bits -= 16;
+        return -1;
+    }
+
+    if (k > j->code_bits)
+        return -1;
+
+    // convert the huffman code to the symbol id
+    c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
+    if (c < 0 || c >= 256)  // symbol id out of bounds!
+        return -1;
+    STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
+
+    // convert the id to a symbol
+    j->code_bits -= k;
+    j->code_buffer <<= k;
+    return h->values[c];
+}
+
+// bias[n] = (-1<<n) + 1
+static const int stbi__jbias[16] = {0,    -1,   -3,    -7,    -15,   -31,   -63,    -127,
+                                    -255, -511, -1023, -2047, -4095, -8191, -16383, -32767};
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n) {
+    unsigned int k;
+    int sgn;
+    if (j->code_bits < n)
+        stbi__grow_buffer_unsafe(j);
+    if (j->code_bits < n)
+        return 0;  // ran out of bits from stream, return 0s intead of continuing
+
+    sgn = j->code_buffer >>
+          31;  // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)
+    k              = stbi_lrot(j->code_buffer, n);
+    j->code_buffer = k & ~stbi__bmask[n];
+    k &= stbi__bmask[n];
+    j->code_bits -= n;
+    return k + (stbi__jbias[n] & (sgn - 1));
+}
+
+// get some unsigned bits
+stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) {
+    unsigned int k;
+    if (j->code_bits < n)
+        stbi__grow_buffer_unsafe(j);
+    if (j->code_bits < n)
+        return 0;  // ran out of bits from stream, return 0s intead of continuing
+    k              = stbi_lrot(j->code_buffer, n);
+    j->code_buffer = k & ~stbi__bmask[n];
+    k &= stbi__bmask[n];
+    j->code_bits -= n;
+    return k;
+}
+
+stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) {
+    unsigned int k;
+    if (j->code_bits < 1)
+        stbi__grow_buffer_unsafe(j);
+    if (j->code_bits < 1)
+        return 0;  // ran out of bits from stream, return 0s intead of continuing
+    k = j->code_buffer;
+    j->code_buffer <<= 1;
+    --j->code_bits;
+    return k & 0x80000000;
+}
+
+// given a value that's at position X in the zigzag stream,
+// where does it appear in the 8x8 matrix coded as row-major?
+static const stbi_uc stbi__jpeg_dezigzag[64 + 15] = {
+    0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20,
+    13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59,
+    52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
+    // let corrupt input sample past end
+    63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63};
+
+// decode one 64-entry block--
+static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc,
+                                   stbi__huffman *hac, stbi__int16 *fac, int b,
+                                   stbi__uint16 *dequant) {
+    int diff, dc, k;
+    int t;
+
+    if (j->code_bits < 16)
+        stbi__grow_buffer_unsafe(j);
+    t = stbi__jpeg_huff_decode(j, hdc);
+    if (t < 0 || t > 15)
+        return stbi__err("bad huffman code", "Corrupt JPEG");
+
+    // 0 all the ac values now so we can do it 32-bits at a time
+    memset(data, 0, 64 * sizeof(data[0]));
+
+    diff = t ? stbi__extend_receive(j, t) : 0;
+    if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff))
+        return stbi__err("bad delta", "Corrupt JPEG");
+    dc                     = j->img_comp[b].dc_pred + diff;
+    j->img_comp[b].dc_pred = dc;
+    if (!stbi__mul2shorts_valid(dc, dequant[0]))
+        return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+    data[0] = (short)(dc * dequant[0]);
+
+    // decode AC components, see JPEG spec
+    k = 1;
+    do {
+        unsigned int zig;
+        int c, r, s;
+        if (j->code_bits < 16)
+            stbi__grow_buffer_unsafe(j);
+        c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS) - 1);
+        r = fac[c];
+        if (r) {                 // fast-AC path
+            k += (r >> 4) & 15;  // run
+            s = r & 15;          // combined length
+            if (s > j->code_bits)
+                return stbi__err("bad huffman code",
+                                 "Combined length longer than code bits available");
+            j->code_buffer <<= s;
+            j->code_bits -= s;
+            // decode into unzigzag'd location
+            zig       = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short)((r >> 8) * dequant[zig]);
+        } else {
+            int rs = stbi__jpeg_huff_decode(j, hac);
+            if (rs < 0)
+                return stbi__err("bad huffman code", "Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+                if (rs != 0xf0)
+                    break;  // end block
+                k += 16;
+            } else {
+                k += r;
+                // decode into unzigzag'd location
+                zig       = stbi__jpeg_dezigzag[k++];
+                data[zig] = (short)(stbi__extend_receive(j, s) * dequant[zig]);
+            }
+        }
+    } while (k < 64);
+    return 1;
+}
+
+static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc,
+                                           int b) {
+    int diff, dc;
+    int t;
+    if (j->spec_end != 0)
+        return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+    if (j->code_bits < 16)
+        stbi__grow_buffer_unsafe(j);
+
+    if (j->succ_high == 0) {
+        // first scan for DC coefficient, must be first
+        memset(data, 0, 64 * sizeof(data[0]));  // 0 all the ac values now
+        t = stbi__jpeg_huff_decode(j, hdc);
+        if (t < 0 || t > 15)
+            return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+        diff = t ? stbi__extend_receive(j, t) : 0;
+
+        if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff))
+            return stbi__err("bad delta", "Corrupt JPEG");
+        dc                     = j->img_comp[b].dc_pred + diff;
+        j->img_comp[b].dc_pred = dc;
+        if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low))
+            return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+        data[0] = (short)(dc * (1 << j->succ_low));
+    } else {
+        // refinement scan for DC coefficient
+        if (stbi__jpeg_get_bit(j))
+            data[0] += (short)(1 << j->succ_low);
+    }
+    return 1;
+}
+
+// @OPTIMIZE: store non-zigzagged during the decode passes,
+// and only de-zigzag when dequantizing
+static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac,
+                                           stbi__int16 *fac) {
+    int k;
+    if (j->spec_start == 0)
+        return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+    if (j->succ_high == 0) {
+        int shift = j->succ_low;
+
+        if (j->eob_run) {
+            --j->eob_run;
+            return 1;
+        }
+
+        k = j->spec_start;
+        do {
+            unsigned int zig;
+            int c, r, s;
+            if (j->code_bits < 16)
+                stbi__grow_buffer_unsafe(j);
+            c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS) - 1);
+            r = fac[c];
+            if (r) {                 // fast-AC path
+                k += (r >> 4) & 15;  // run
+                s = r & 15;          // combined length
+                if (s > j->code_bits)
+                    return stbi__err("bad huffman code",
+                                     "Combined length longer than code bits available");
+                j->code_buffer <<= s;
+                j->code_bits -= s;
+                zig       = stbi__jpeg_dezigzag[k++];
+                data[zig] = (short)((r >> 8) * (1 << shift));
+            } else {
+                int rs = stbi__jpeg_huff_decode(j, hac);
+                if (rs < 0)
+                    return stbi__err("bad huffman code", "Corrupt JPEG");
+                s = rs & 15;
+                r = rs >> 4;
+                if (s == 0) {
+                    if (r < 15) {
+                        j->eob_run = (1 << r);
+                        if (r)
+                            j->eob_run += stbi__jpeg_get_bits(j, r);
+                        --j->eob_run;
+                        break;
+                    }
+                    k += 16;
+                } else {
+                    k += r;
+                    zig       = stbi__jpeg_dezigzag[k++];
+                    data[zig] = (short)(stbi__extend_receive(j, s) * (1 << shift));
+                }
+            }
+        } while (k <= j->spec_end);
+    } else {
+        // refinement scan for these AC coefficients
+
+        short bit = (short)(1 << j->succ_low);
+
+        if (j->eob_run) {
+            --j->eob_run;
+            for (k = j->spec_start; k <= j->spec_end; ++k) {
+                short *p = &data[stbi__jpeg_dezigzag[k]];
+                if (*p != 0)
+                    if (stbi__jpeg_get_bit(j))
+                        if ((*p & bit) == 0) {
+                            if (*p > 0)
+                                *p += bit;
+                            else
+                                *p -= bit;
+                        }
+            }
+        } else {
+            k = j->spec_start;
+            do {
+                int r, s;
+                int rs = stbi__jpeg_huff_decode(j, hac);  // @OPTIMIZE see if we can use the fast
+                                                          // path here, advance-by-r is so slow, eh
+                if (rs < 0)
+                    return stbi__err("bad huffman code", "Corrupt JPEG");
+                s = rs & 15;
+                r = rs >> 4;
+                if (s == 0) {
+                    if (r < 15) {
+                        j->eob_run = (1 << r) - 1;
+                        if (r)
+                            j->eob_run += stbi__jpeg_get_bits(j, r);
+                        r = 64;  // force end of block
+                    } else {
+                        // r=15 s=0 should write 16 0s, so we just do
+                        // a run of 15 0s and then write s (which is 0),
+                        // so we don't have to do anything special here
+                    }
+                } else {
+                    if (s != 1)
+                        return stbi__err("bad huffman code", "Corrupt JPEG");
+                    // sign bit
+                    if (stbi__jpeg_get_bit(j))
+                        s = bit;
+                    else
+                        s = -bit;
+                }
+
+                // advance by r
+                while (k <= j->spec_end) {
+                    short *p = &data[stbi__jpeg_dezigzag[k++]];
+                    if (*p != 0) {
+                        if (stbi__jpeg_get_bit(j))
+                            if ((*p & bit) == 0) {
+                                if (*p > 0)
+                                    *p += bit;
+                                else
+                                    *p -= bit;
+                            }
+                    } else {
+                        if (r == 0) {
+                            *p = (short)s;
+                            break;
+                        }
+                        --r;
+                    }
+                }
+            } while (k <= j->spec_end);
+        }
+    }
+    return 1;
+}
+
+// take a -128..127 value and stbi__clamp it and convert to 0..255
+stbi_inline static stbi_uc stbi__clamp(int x) {
+    // trick to use a single test to catch both cases
+    if ((unsigned int)x > 255) {
+        if (x < 0)
+            return 0;
+        if (x > 255)
+            return 255;
+    }
+    return (stbi_uc)x;
+}
+
+#define stbi__f2f(x) ((int)(((x) * 4096 + 0.5)))
+#define stbi__fsh(x) ((x) * 4096)
+
+// derived from jidctint -- DCT_ISLOW
+#define STBI__IDCT_1D(s0, s1, s2, s3, s4, s5, s6, s7)                                              \
+    int t0, t1, t2, t3, p1, p2, p3, p4, p5, x0, x1, x2, x3;                                        \
+    p2 = s2;                                                                                       \
+    p3 = s6;                                                                                       \
+    p1 = (p2 + p3) * stbi__f2f(0.5411961f);                                                        \
+    t2 = p1 + p3 * stbi__f2f(-1.847759065f);                                                       \
+    t3 = p1 + p2 * stbi__f2f(0.765366865f);                                                        \
+    p2 = s0;                                                                                       \
+    p3 = s4;                                                                                       \
+    t0 = stbi__fsh(p2 + p3);                                                                       \
+    t1 = stbi__fsh(p2 - p3);                                                                       \
+    x0 = t0 + t3;                                                                                  \
+    x3 = t0 - t3;                                                                                  \
+    x1 = t1 + t2;                                                                                  \
+    x2 = t1 - t2;                                                                                  \
+    t0 = s7;                                                                                       \
+    t1 = s5;                                                                                       \
+    t2 = s3;                                                                                       \
+    t3 = s1;                                                                                       \
+    p3 = t0 + t2;                                                                                  \
+    p4 = t1 + t3;                                                                                  \
+    p1 = t0 + t3;                                                                                  \
+    p2 = t1 + t2;                                                                                  \
+    p5 = (p3 + p4) * stbi__f2f(1.175875602f);                                                      \
+    t0 = t0 * stbi__f2f(0.298631336f);                                                             \
+    t1 = t1 * stbi__f2f(2.053119869f);                                                             \
+    t2 = t2 * stbi__f2f(3.072711026f);                                                             \
+    t3 = t3 * stbi__f2f(1.501321110f);                                                             \
+    p1 = p5 + p1 * stbi__f2f(-0.899976223f);                                                       \
+    p2 = p5 + p2 * stbi__f2f(-2.562915447f);                                                       \
+    p3 = p3 * stbi__f2f(-1.961570560f);                                                            \
+    p4 = p4 * stbi__f2f(-0.390180644f);                                                            \
+    t3 += p1 + p4;                                                                                 \
+    t2 += p2 + p3;                                                                                 \
+    t1 += p2 + p4;                                                                                 \
+    t0 += p1 + p3;
+
+static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) {
+    int i, val[64], *v = val;
+    stbi_uc *o;
+    short *d = data;
+
+    // columns
+    for (i = 0; i < 8; ++i, ++d, ++v) {
+        // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
+        if (d[8] == 0 && d[16] == 0 && d[24] == 0 && d[32] == 0 && d[40] == 0 && d[48] == 0 &&
+            d[56] == 0) {
+            //    no shortcut                 0     seconds
+            //    (1|2|3|4|5|6|7)==0          0     seconds
+            //    all separate               -0.047 seconds
+            //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds
+            int dcterm = d[0] * 4;
+            v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+        } else {
+            STBI__IDCT_1D(d[0], d[8], d[16], d[24], d[32], d[40], d[48], d[56])
+            // constants scaled things up by 1<<12; let's bring them back
+            // down, but keep 2 extra bits of precision
+            x0 += 512;
+            x1 += 512;
+            x2 += 512;
+            x3 += 512;
+            v[0]  = (x0 + t3) >> 10;
+            v[56] = (x0 - t3) >> 10;
+            v[8]  = (x1 + t2) >> 10;
+            v[48] = (x1 - t2) >> 10;
+            v[16] = (x2 + t1) >> 10;
+            v[40] = (x2 - t1) >> 10;
+            v[24] = (x3 + t0) >> 10;
+            v[32] = (x3 - t0) >> 10;
+        }
+    }
+
+    for (i = 0, v = val, o = out; i < 8; ++i, v += 8, o += out_stride) {
+        // no fast case since the first 1D IDCT spread components out
+        STBI__IDCT_1D(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7])
+        // constants scaled things up by 1<<12, plus we had 1<<2 from first
+        // loop, plus horizontal and vertical each scale by sqrt(8) so together
+        // we've got an extra 1<<3, so 1<<17 total we need to remove.
+        // so we want to round that, which means adding 0.5 * 1<<17,
+        // aka 65536. Also, we'll end up with -128 to 127 that we want
+        // to encode as 0..255 by adding 128, so we'll add that before the shift
+        x0 += 65536 + (128 << 17);
+        x1 += 65536 + (128 << 17);
+        x2 += 65536 + (128 << 17);
+        x3 += 65536 + (128 << 17);
+        // tried computing the shifts into temps, or'ing the temps to see
+        // if any were out of range, but that was slower
+        o[0] = stbi__clamp((x0 + t3) >> 17);
+        o[7] = stbi__clamp((x0 - t3) >> 17);
+        o[1] = stbi__clamp((x1 + t2) >> 17);
+        o[6] = stbi__clamp((x1 - t2) >> 17);
+        o[2] = stbi__clamp((x2 + t1) >> 17);
+        o[5] = stbi__clamp((x2 - t1) >> 17);
+        o[3] = stbi__clamp((x3 + t0) >> 17);
+        o[4] = stbi__clamp((x3 - t0) >> 17);
+    }
+}
+
+#ifdef STBI_SSE2
+// sse2 integer IDCT. not the fastest possible implementation but it
+// produces bit-identical results to the generic C version so it's
+// fully "transparent".
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) {
+    // This is constructed to match our regular (generic) integer IDCT exactly.
+    __m128i row0, row1, row2, row3, row4, row5, row6, row7;
+    __m128i tmp;
+
+// dot product constant: even elems=x, odd elems=y
+#define dct_const(x, y) _mm_setr_epi16((x), (y), (x), (y), (x), (y), (x), (y))
+
+// out(0) = c0[even]*x + c0[odd]*y   (c0, x, y 16-bit, out 32-bit)
+// out(1) = c1[even]*x + c1[odd]*y
+#define dct_rot(out0, out1, x, y, c0, c1)                                                          \
+    __m128i c0##lo   = _mm_unpacklo_epi16((x), (y));                                               \
+    __m128i c0##hi   = _mm_unpackhi_epi16((x), (y));                                               \
+    __m128i out0##_l = _mm_madd_epi16(c0##lo, c0);                                                 \
+    __m128i out0##_h = _mm_madd_epi16(c0##hi, c0);                                                 \
+    __m128i out1##_l = _mm_madd_epi16(c0##lo, c1);                                                 \
+    __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
+
+// out = in << 12  (in 16-bit, out 32-bit)
+#define dct_widen(out, in)                                                                         \
+    __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4);            \
+    __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
+
+// wide add
+#define dct_wadd(out, a, b)                                                                        \
+    __m128i out##_l = _mm_add_epi32(a##_l, b##_l);                                                 \
+    __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
+
+// wide sub
+#define dct_wsub(out, a, b)                                                                        \
+    __m128i out##_l = _mm_sub_epi32(a##_l, b##_l);                                                 \
+    __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
+
+// butterfly a/b, add bias, then shift by "s" and pack
+#define dct_bfly32o(out0, out1, a, b, bias, s)                                                     \
+    {                                                                                              \
+        __m128i abiased_l = _mm_add_epi32(a##_l, bias);                                            \
+        __m128i abiased_h = _mm_add_epi32(a##_h, bias);                                            \
+        dct_wadd(sum, abiased, b);                                                                 \
+        dct_wsub(dif, abiased, b);                                                                 \
+        out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s));                \
+        out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s));                \
+    }
+
+// 8-bit interleave step (for transposes)
+#define dct_interleave8(a, b)                                                                      \
+    tmp = a;                                                                                       \
+    a   = _mm_unpacklo_epi8(a, b);                                                                 \
+    b   = _mm_unpackhi_epi8(tmp, b)
+
+// 16-bit interleave step (for transposes)
+#define dct_interleave16(a, b)                                                                     \
+    tmp = a;                                                                                       \
+    a   = _mm_unpacklo_epi16(a, b);                                                                \
+    b   = _mm_unpackhi_epi16(tmp, b)
+
+#define dct_pass(bias, shift)                                                                      \
+    {                                                                                              \
+        /* even part */                                                                            \
+        dct_rot(t2e, t3e, row2, row6, rot0_0, rot0_1);                                             \
+        __m128i sum04 = _mm_add_epi16(row0, row4);                                                 \
+        __m128i dif04 = _mm_sub_epi16(row0, row4);                                                 \
+        dct_widen(t0e, sum04);                                                                     \
+        dct_widen(t1e, dif04);                                                                     \
+        dct_wadd(x0, t0e, t3e);                                                                    \
+        dct_wsub(x3, t0e, t3e);                                                                    \
+        dct_wadd(x1, t1e, t2e);                                                                    \
+        dct_wsub(x2, t1e, t2e);                                                                    \
+        /* odd part */                                                                             \
+        dct_rot(y0o, y2o, row7, row3, rot2_0, rot2_1);                                             \
+        dct_rot(y1o, y3o, row5, row1, rot3_0, rot3_1);                                             \
+        __m128i sum17 = _mm_add_epi16(row1, row7);                                                 \
+        __m128i sum35 = _mm_add_epi16(row3, row5);                                                 \
+        dct_rot(y4o, y5o, sum17, sum35, rot1_0, rot1_1);                                           \
+        dct_wadd(x4, y0o, y4o);                                                                    \
+        dct_wadd(x5, y1o, y5o);                                                                    \
+        dct_wadd(x6, y2o, y5o);                                                                    \
+        dct_wadd(x7, y3o, y4o);                                                                    \
+        dct_bfly32o(row0, row7, x0, x7, bias, shift);                                              \
+        dct_bfly32o(row1, row6, x1, x6, bias, shift);                                              \
+        dct_bfly32o(row2, row5, x2, x5, bias, shift);                                              \
+        dct_bfly32o(row3, row4, x3, x4, bias, shift);                                              \
+    }
+
+    __m128i rot0_0 =
+        dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
+    __m128i rot0_1 =
+        dct_const(stbi__f2f(0.5411961f) + stbi__f2f(0.765366865f), stbi__f2f(0.5411961f));
+    __m128i rot1_0 =
+        dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
+    __m128i rot1_1 =
+        dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
+    __m128i rot2_0 =
+        dct_const(stbi__f2f(-1.961570560f) + stbi__f2f(0.298631336f), stbi__f2f(-1.961570560f));
+    __m128i rot2_1 =
+        dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f(3.072711026f));
+    __m128i rot3_0 =
+        dct_const(stbi__f2f(-0.390180644f) + stbi__f2f(2.053119869f), stbi__f2f(-0.390180644f));
+    __m128i rot3_1 =
+        dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f(1.501321110f));
+
+    // rounding biases in column/row passes, see stbi__idct_block for explanation.
+    __m128i bias_0 = _mm_set1_epi32(512);
+    __m128i bias_1 = _mm_set1_epi32(65536 + (128 << 17));
+
+    // load
+    row0 = _mm_load_si128((const __m128i *)(data + 0 * 8));
+    row1 = _mm_load_si128((const __m128i *)(data + 1 * 8));
+    row2 = _mm_load_si128((const __m128i *)(data + 2 * 8));
+    row3 = _mm_load_si128((const __m128i *)(data + 3 * 8));
+    row4 = _mm_load_si128((const __m128i *)(data + 4 * 8));
+    row5 = _mm_load_si128((const __m128i *)(data + 5 * 8));
+    row6 = _mm_load_si128((const __m128i *)(data + 6 * 8));
+    row7 = _mm_load_si128((const __m128i *)(data + 7 * 8));
+
+    // column pass
+    dct_pass(bias_0, 10);
+
+    {
+        // 16bit 8x8 transpose pass 1
+        dct_interleave16(row0, row4);
+        dct_interleave16(row1, row5);
+        dct_interleave16(row2, row6);
+        dct_interleave16(row3, row7);
+
+        // transpose pass 2
+        dct_interleave16(row0, row2);
+        dct_interleave16(row1, row3);
+        dct_interleave16(row4, row6);
+        dct_interleave16(row5, row7);
+
+        // transpose pass 3
+        dct_interleave16(row0, row1);
+        dct_interleave16(row2, row3);
+        dct_interleave16(row4, row5);
+        dct_interleave16(row6, row7);
+    }
+
+    // row pass
+    dct_pass(bias_1, 17);
+
+    {
+        // pack
+        __m128i p0 = _mm_packus_epi16(row0, row1);  // a0a1a2a3...a7b0b1b2b3...b7
+        __m128i p1 = _mm_packus_epi16(row2, row3);
+        __m128i p2 = _mm_packus_epi16(row4, row5);
+        __m128i p3 = _mm_packus_epi16(row6, row7);
+
+        // 8bit 8x8 transpose pass 1
+        dct_interleave8(p0, p2);  // a0e0a1e1...
+        dct_interleave8(p1, p3);  // c0g0c1g1...
+
+        // transpose pass 2
+        dct_interleave8(p0, p1);  // a0c0e0g0...
+        dct_interleave8(p2, p3);  // b0d0f0h0...
+
+        // transpose pass 3
+        dct_interleave8(p0, p2);  // a0b0c0d0...
+        dct_interleave8(p1, p3);  // a4b4c4d4...
+
+        // store
+        _mm_storel_epi64((__m128i *)out, p0);
+        out += out_stride;
+        _mm_storel_epi64((__m128i *)out, _mm_shuffle_epi32(p0, 0x4e));
+        out += out_stride;
+        _mm_storel_epi64((__m128i *)out, p2);
+        out += out_stride;
+        _mm_storel_epi64((__m128i *)out, _mm_shuffle_epi32(p2, 0x4e));
+        out += out_stride;
+        _mm_storel_epi64((__m128i *)out, p1);
+        out += out_stride;
+        _mm_storel_epi64((__m128i *)out, _mm_shuffle_epi32(p1, 0x4e));
+        out += out_stride;
+        _mm_storel_epi64((__m128i *)out, p3);
+        out += out_stride;
+        _mm_storel_epi64((__m128i *)out, _mm_shuffle_epi32(p3, 0x4e));
+    }
+
+#undef dct_const
+#undef dct_rot
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_interleave8
+#undef dct_interleave16
+#undef dct_pass
+}
+
+#endif  // STBI_SSE2
+
+#ifdef STBI_NEON
+
+// NEON integer IDCT. should produce bit-identical
+// results to the generic C version.
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) {
+    int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
+
+    int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
+    int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
+    int16x4_t rot0_2 = vdup_n_s16(stbi__f2f(0.765366865f));
+    int16x4_t rot1_0 = vdup_n_s16(stbi__f2f(1.175875602f));
+    int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
+    int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
+    int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
+    int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
+    int16x4_t rot3_0 = vdup_n_s16(stbi__f2f(0.298631336f));
+    int16x4_t rot3_1 = vdup_n_s16(stbi__f2f(2.053119869f));
+    int16x4_t rot3_2 = vdup_n_s16(stbi__f2f(3.072711026f));
+    int16x4_t rot3_3 = vdup_n_s16(stbi__f2f(1.501321110f));
+
+#define dct_long_mul(out, inq, coeff)                                                              \
+    int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff);                                       \
+    int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
+
+#define dct_long_mac(out, acc, inq, coeff)                                                         \
+    int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff);                              \
+    int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
+
+#define dct_widen(out, inq)                                                                        \
+    int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12);                                        \
+    int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
+
+// wide add
+#define dct_wadd(out, a, b)                                                                        \
+    int32x4_t out##_l = vaddq_s32(a##_l, b##_l);                                                   \
+    int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
+
+// wide sub
+#define dct_wsub(out, a, b)                                                                        \
+    int32x4_t out##_l = vsubq_s32(a##_l, b##_l);                                                   \
+    int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
+
+// butterfly a/b, then shift using "shiftop" by "s" and pack
+#define dct_bfly32o(out0, out1, a, b, shiftop, s)                                                  \
+    {                                                                                              \
+        dct_wadd(sum, a, b);                                                                       \
+        dct_wsub(dif, a, b);                                                                       \
+        out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s));                                 \
+        out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s));                                 \
+    }
+
+#define dct_pass(shiftop, shift)                                                                   \
+    {                                                                                              \
+        /* even part */                                                                            \
+        int16x8_t sum26 = vaddq_s16(row2, row6);                                                   \
+        dct_long_mul(p1e, sum26, rot0_0);                                                          \
+        dct_long_mac(t2e, p1e, row6, rot0_1);                                                      \
+        dct_long_mac(t3e, p1e, row2, rot0_2);                                                      \
+        int16x8_t sum04 = vaddq_s16(row0, row4);                                                   \
+        int16x8_t dif04 = vsubq_s16(row0, row4);                                                   \
+        dct_widen(t0e, sum04);                                                                     \
+        dct_widen(t1e, dif04);                                                                     \
+        dct_wadd(x0, t0e, t3e);                                                                    \
+        dct_wsub(x3, t0e, t3e);                                                                    \
+        dct_wadd(x1, t1e, t2e);                                                                    \
+        dct_wsub(x2, t1e, t2e);                                                                    \
+        /* odd part */                                                                             \
+        int16x8_t sum15  = vaddq_s16(row1, row5);                                                  \
+        int16x8_t sum17  = vaddq_s16(row1, row7);                                                  \
+        int16x8_t sum35  = vaddq_s16(row3, row5);                                                  \
+        int16x8_t sum37  = vaddq_s16(row3, row7);                                                  \
+        int16x8_t sumodd = vaddq_s16(sum17, sum35);                                                \
+        dct_long_mul(p5o, sumodd, rot1_0);                                                         \
+        dct_long_mac(p1o, p5o, sum17, rot1_1);                                                     \
+        dct_long_mac(p2o, p5o, sum35, rot1_2);                                                     \
+        dct_long_mul(p3o, sum37, rot2_0);                                                          \
+        dct_long_mul(p4o, sum15, rot2_1);                                                          \
+        dct_wadd(sump13o, p1o, p3o);                                                               \
+        dct_wadd(sump24o, p2o, p4o);                                                               \
+        dct_wadd(sump23o, p2o, p3o);                                                               \
+        dct_wadd(sump14o, p1o, p4o);                                                               \
+        dct_long_mac(x4, sump13o, row7, rot3_0);                                                   \
+        dct_long_mac(x5, sump24o, row5, rot3_1);                                                   \
+        dct_long_mac(x6, sump23o, row3, rot3_2);                                                   \
+        dct_long_mac(x7, sump14o, row1, rot3_3);                                                   \
+        dct_bfly32o(row0, row7, x0, x7, shiftop, shift);                                           \
+        dct_bfly32o(row1, row6, x1, x6, shiftop, shift);                                           \
+        dct_bfly32o(row2, row5, x2, x5, shiftop, shift);                                           \
+        dct_bfly32o(row3, row4, x3, x4, shiftop, shift);                                           \
+    }
+
+    // load
+    row0 = vld1q_s16(data + 0 * 8);
+    row1 = vld1q_s16(data + 1 * 8);
+    row2 = vld1q_s16(data + 2 * 8);
+    row3 = vld1q_s16(data + 3 * 8);
+    row4 = vld1q_s16(data + 4 * 8);
+    row5 = vld1q_s16(data + 5 * 8);
+    row6 = vld1q_s16(data + 6 * 8);
+    row7 = vld1q_s16(data + 7 * 8);
+
+    // add DC bias
+    row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
+
+    // column pass
+    dct_pass(vrshrn_n_s32, 10);
+
+    // 16bit 8x8 transpose
+    {
+// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
+// whether compilers actually get this is another story, sadly.
+#define dct_trn16(x, y)                                                                            \
+    {                                                                                              \
+        int16x8x2_t t = vtrnq_s16(x, y);                                                           \
+        x             = t.val[0];                                                                  \
+        y             = t.val[1];                                                                  \
+    }
+#define dct_trn32(x, y)                                                                            \
+    {                                                                                              \
+        int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y));             \
+        x             = vreinterpretq_s16_s32(t.val[0]);                                           \
+        y             = vreinterpretq_s16_s32(t.val[1]);                                           \
+    }
+#define dct_trn64(x, y)                                                                            \
+    {                                                                                              \
+        int16x8_t x0 = x;                                                                          \
+        int16x8_t y0 = y;                                                                          \
+        x            = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0));                           \
+        y            = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0));                         \
+    }
+
+        // pass 1
+        dct_trn16(row0, row1);  // a0b0a2b2a4b4a6b6
+        dct_trn16(row2, row3);
+        dct_trn16(row4, row5);
+        dct_trn16(row6, row7);
+
+        // pass 2
+        dct_trn32(row0, row2);  // a0b0c0d0a4b4c4d4
+        dct_trn32(row1, row3);
+        dct_trn32(row4, row6);
+        dct_trn32(row5, row7);
+
+        // pass 3
+        dct_trn64(row0, row4);  // a0b0c0d0e0f0g0h0
+        dct_trn64(row1, row5);
+        dct_trn64(row2, row6);
+        dct_trn64(row3, row7);
+
+#undef dct_trn16
+#undef dct_trn32
+#undef dct_trn64
+    }
+
+    // row pass
+    // vrshrn_n_s32 only supports shifts up to 16, we need
+    // 17. so do a non-rounding shift of 16 first then follow
+    // up with a rounding shift by 1.
+    dct_pass(vshrn_n_s32, 16);
+
+    {
+        // pack and round
+        uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
+        uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
+        uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
+        uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
+        uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
+        uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
+        uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
+        uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
+
+        // again, these can translate into one instruction, but often don't.
+#define dct_trn8_8(x, y)                                                                           \
+    {                                                                                              \
+        uint8x8x2_t t = vtrn_u8(x, y);                                                             \
+        x             = t.val[0];                                                                  \
+        y             = t.val[1];                                                                  \
+    }
+#define dct_trn8_16(x, y)                                                                          \
+    {                                                                                              \
+        uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y));                 \
+        x              = vreinterpret_u8_u16(t.val[0]);                                            \
+        y              = vreinterpret_u8_u16(t.val[1]);                                            \
+    }
+#define dct_trn8_32(x, y)                                                                          \
+    {                                                                                              \
+        uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y));                 \
+        x              = vreinterpret_u8_u32(t.val[0]);                                            \
+        y              = vreinterpret_u8_u32(t.val[1]);                                            \
+    }
+
+        // sadly can't use interleaved stores here since we only write
+        // 8 bytes to each scan line!
+
+        // 8x8 8-bit transpose pass 1
+        dct_trn8_8(p0, p1);
+        dct_trn8_8(p2, p3);
+        dct_trn8_8(p4, p5);
+        dct_trn8_8(p6, p7);
+
+        // pass 2
+        dct_trn8_16(p0, p2);
+        dct_trn8_16(p1, p3);
+        dct_trn8_16(p4, p6);
+        dct_trn8_16(p5, p7);
+
+        // pass 3
+        dct_trn8_32(p0, p4);
+        dct_trn8_32(p1, p5);
+        dct_trn8_32(p2, p6);
+        dct_trn8_32(p3, p7);
+
+        // store
+        vst1_u8(out, p0);
+        out += out_stride;
+        vst1_u8(out, p1);
+        out += out_stride;
+        vst1_u8(out, p2);
+        out += out_stride;
+        vst1_u8(out, p3);
+        out += out_stride;
+        vst1_u8(out, p4);
+        out += out_stride;
+        vst1_u8(out, p5);
+        out += out_stride;
+        vst1_u8(out, p6);
+        out += out_stride;
+        vst1_u8(out, p7);
+
+#undef dct_trn8_8
+#undef dct_trn8_16
+#undef dct_trn8_32
+    }
+
+#undef dct_long_mul
+#undef dct_long_mac
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_pass
+}
+
+#endif  // STBI_NEON
+
+#define STBI__MARKER_none 0xff
+// if there's a pending marker from the entropy stream, return that
+// otherwise, fetch from the stream and get a marker. if there's no
+// marker, return 0xff, which is never a valid marker value
+static stbi_uc stbi__get_marker(stbi__jpeg *j) {
+    stbi_uc x;
+    if (j->marker != STBI__MARKER_none) {
+        x         = j->marker;
+        j->marker = STBI__MARKER_none;
+        return x;
+    }
+    x = stbi__get8(j->s);
+    if (x != 0xff)
+        return STBI__MARKER_none;
+    while (x == 0xff)
+        x = stbi__get8(j->s);  // consume repeated 0xff fill bytes
+    return x;
+}
+
+// in each scan, we'll have scan_n components, and the order
+// of the components is specified by order[]
+#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
+
+// after a restart interval, stbi__jpeg_reset the entropy decoder and
+// the dc prediction
+static void stbi__jpeg_reset(stbi__jpeg *j) {
+    j->code_bits           = 0;
+    j->code_buffer         = 0;
+    j->nomore              = 0;
+    j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred =
+        j->img_comp[3].dc_pred                      = 0;
+    j->marker                                       = STBI__MARKER_none;
+    j->todo    = j->restart_interval ? j->restart_interval : 0x7fffffff;
+    j->eob_run = 0;
+    // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
+    // since we don't even allow 1<<30 pixels
+}
+
+static int stbi__parse_entropy_coded_data(stbi__jpeg *z) {
+    stbi__jpeg_reset(z);
+    if (!z->progressive) {
+        if (z->scan_n == 1) {
+            int i, j;
+            STBI_SIMD_ALIGN(short, data[64]);
+            int n = z->order[0];
+            // non-interleaved data, we just need to process one block at a time,
+            // in trivial scanline order
+            // number of blocks to do just depends on how many actual "pixels" this
+            // component has, independent of interleaved MCU blocking and such
+            int w = (z->img_comp[n].x + 7) >> 3;
+            int h = (z->img_comp[n].y + 7) >> 3;
+            for (j = 0; j < h; ++j) {
+                for (i = 0; i < w; ++i) {
+                    int ha = z->img_comp[n].ha;
+                    if (!stbi__jpeg_decode_block(z, data, z->huff_dc + z->img_comp[n].hd,
+                                                 z->huff_ac + ha, z->fast_ac[ha], n,
+                                                 z->dequant[z->img_comp[n].tq]))
+                        return 0;
+                    z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + i * 8,
+                                         z->img_comp[n].w2, data);
+                    // every data block is an MCU, so countdown the restart interval
+                    if (--z->todo <= 0) {
+                        if (z->code_bits < 24)
+                            stbi__grow_buffer_unsafe(z);
+                        // if it's NOT a restart, then just bail, so we get corrupt data
+                        // rather than no data
+                        if (!STBI__RESTART(z->marker))
+                            return 1;
+                        stbi__jpeg_reset(z);
+                    }
+                }
+            }
+            return 1;
+        } else {  // interleaved
+            int i, j, k, x, y;
+            STBI_SIMD_ALIGN(short, data[64]);
+            for (j = 0; j < z->img_mcu_y; ++j) {
+                for (i = 0; i < z->img_mcu_x; ++i) {
+                    // scan an interleaved mcu... process scan_n components in order
+                    for (k = 0; k < z->scan_n; ++k) {
+                        int n = z->order[k];
+                        // scan out an mcu's worth of this component; that's just determined
+                        // by the basic H and V specified for the component
+                        for (y = 0; y < z->img_comp[n].v; ++y) {
+                            for (x = 0; x < z->img_comp[n].h; ++x) {
+                                int x2 = (i * z->img_comp[n].h + x) * 8;
+                                int y2 = (j * z->img_comp[n].v + y) * 8;
+                                int ha = z->img_comp[n].ha;
+                                if (!stbi__jpeg_decode_block(
+                                        z, data, z->huff_dc + z->img_comp[n].hd, z->huff_ac + ha,
+                                        z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq]))
+                                    return 0;
+                                z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * y2 +
+                                                         x2,
+                                                     z->img_comp[n].w2, data);
+                            }
+                        }
+                    }
+                    // after all interleaved components, that's an interleaved MCU,
+                    // so now count down the restart interval
+                    if (--z->todo <= 0) {
+                        if (z->code_bits < 24)
+                            stbi__grow_buffer_unsafe(z);
+                        if (!STBI__RESTART(z->marker))
+                            return 1;
+                        stbi__jpeg_reset(z);
+                    }
+                }
+            }
+            return 1;
+        }
+    } else {
+        if (z->scan_n == 1) {
+            int i, j;
+            int n = z->order[0];
+            // non-interleaved data, we just need to process one block at a time,
+            // in trivial scanline order
+            // number of blocks to do just depends on how many actual "pixels" this
+            // component has, independent of interleaved MCU blocking and such
+            int w = (z->img_comp[n].x + 7) >> 3;
+            int h = (z->img_comp[n].y + 7) >> 3;
+            for (j = 0; j < h; ++j) {
+                for (i = 0; i < w; ++i) {
+                    short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+                    if (z->spec_start == 0) {
+                        if (!stbi__jpeg_decode_block_prog_dc(z, data,
+                                                             &z->huff_dc[z->img_comp[n].hd], n))
+                            return 0;
+                    } else {
+                        int ha = z->img_comp[n].ha;
+                        if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha],
+                                                             z->fast_ac[ha]))
+                            return 0;
+                    }
+                    // every data block is an MCU, so countdown the restart interval
+                    if (--z->todo <= 0) {
+                        if (z->code_bits < 24)
+                            stbi__grow_buffer_unsafe(z);
+                        if (!STBI__RESTART(z->marker))
+                            return 1;
+                        stbi__jpeg_reset(z);
+                    }
+                }
+            }
+            return 1;
+        } else {  // interleaved
+            int i, j, k, x, y;
+            for (j = 0; j < z->img_mcu_y; ++j) {
+                for (i = 0; i < z->img_mcu_x; ++i) {
+                    // scan an interleaved mcu... process scan_n components in order
+                    for (k = 0; k < z->scan_n; ++k) {
+                        int n = z->order[k];
+                        // scan out an mcu's worth of this component; that's just determined
+                        // by the basic H and V specified for the component
+                        for (y = 0; y < z->img_comp[n].v; ++y) {
+                            for (x = 0; x < z->img_comp[n].h; ++x) {
+                                int x2 = (i * z->img_comp[n].h + x);
+                                int y2 = (j * z->img_comp[n].v + y);
+                                short *data =
+                                    z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
+                                if (!stbi__jpeg_decode_block_prog_dc(
+                                        z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                                    return 0;
+                            }
+                        }
+                    }
+                    // after all interleaved components, that's an interleaved MCU,
+                    // so now count down the restart interval
+                    if (--z->todo <= 0) {
+                        if (z->code_bits < 24)
+                            stbi__grow_buffer_unsafe(z);
+                        if (!STBI__RESTART(z->marker))
+                            return 1;
+                        stbi__jpeg_reset(z);
+                    }
+                }
+            }
+            return 1;
+        }
+    }
+}
+
+static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) {
+    int i;
+    for (i = 0; i < 64; ++i)
+        data[i] *= dequant[i];
+}
+
+static void stbi__jpeg_finish(stbi__jpeg *z) {
+    if (z->progressive) {
+        // dequantize and idct the data
+        int i, j, n;
+        for (n = 0; n < z->s->img_n; ++n) {
+            int w = (z->img_comp[n].x + 7) >> 3;
+            int h = (z->img_comp[n].y + 7) >> 3;
+            for (j = 0; j < h; ++j) {
+                for (i = 0; i < w; ++i) {
+                    short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+                    stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
+                    z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + i * 8,
+                                         z->img_comp[n].w2, data);
+                }
+            }
+        }
+    }
+}
+
+static int stbi__process_marker(stbi__jpeg *z, int m) {
+    int L;
+    switch (m) {
+    case STBI__MARKER_none:  // no marker found
+        return stbi__err("expected marker", "Corrupt JPEG");
+
+    case 0xDD:  // DRI - specify restart interval
+        if (stbi__get16be(z->s) != 4)
+            return stbi__err("bad DRI len", "Corrupt JPEG");
+        z->restart_interval = stbi__get16be(z->s);
+        return 1;
+
+    case 0xDB:  // DQT - define quantization table
+        L = stbi__get16be(z->s) - 2;
+        while (L > 0) {
+            int q = stbi__get8(z->s);
+            int p = q >> 4, sixteen = (p != 0);
+            int t = q & 15, i;
+            if (p != 0 && p != 1)
+                return stbi__err("bad DQT type", "Corrupt JPEG");
+            if (t > 3)
+                return stbi__err("bad DQT table", "Corrupt JPEG");
+
+            for (i = 0; i < 64; ++i)
+                z->dequant[t][stbi__jpeg_dezigzag[i]] =
+                    (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
+            L -= (sixteen ? 129 : 65);
+        }
+        return L == 0;
+
+    case 0xC4:  // DHT - define huffman table
+        L = stbi__get16be(z->s) - 2;
+        while (L > 0) {
+            stbi_uc *v;
+            int sizes[16], i, n = 0;
+            int q  = stbi__get8(z->s);
+            int tc = q >> 4;
+            int th = q & 15;
+            if (tc > 1 || th > 3)
+                return stbi__err("bad DHT header", "Corrupt JPEG");
+            for (i = 0; i < 16; ++i) {
+                sizes[i] = stbi__get8(z->s);
+                n += sizes[i];
+            }
+            if (n > 256)
+                return stbi__err(
+                    "bad DHT header",
+                    "Corrupt JPEG");  // Loop over i < n would write past end of values!
+            L -= 17;
+            if (tc == 0) {
+                if (!stbi__build_huffman(z->huff_dc + th, sizes))
+                    return 0;
+                v = z->huff_dc[th].values;
+            } else {
+                if (!stbi__build_huffman(z->huff_ac + th, sizes))
+                    return 0;
+                v = z->huff_ac[th].values;
+            }
+            for (i = 0; i < n; ++i)
+                v[i] = stbi__get8(z->s);
+            if (tc != 0)
+                stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
+            L -= n;
+        }
+        return L == 0;
+    }
+
+    // check for comment block or APP blocks
+    if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+        L = stbi__get16be(z->s);
+        if (L < 2) {
+            if (m == 0xFE)
+                return stbi__err("bad COM len", "Corrupt JPEG");
+            else
+                return stbi__err("bad APP len", "Corrupt JPEG");
+        }
+        L -= 2;
+
+        if (m == 0xE0 && L >= 5) {  // JFIF APP0 segment
+            static const unsigned char tag[5] = {'J', 'F', 'I', 'F', '\0'};
+            int ok                            = 1;
+            int i;
+            for (i = 0; i < 5; ++i)
+                if (stbi__get8(z->s) != tag[i])
+                    ok = 0;
+            L -= 5;
+            if (ok)
+                z->jfif = 1;
+        } else if (m == 0xEE && L >= 12) {  // Adobe APP14 segment
+            static const unsigned char tag[6] = {'A', 'd', 'o', 'b', 'e', '\0'};
+            int ok                            = 1;
+            int i;
+            for (i = 0; i < 6; ++i)
+                if (stbi__get8(z->s) != tag[i])
+                    ok = 0;
+            L -= 6;
+            if (ok) {
+                stbi__get8(z->s);                             // version
+                stbi__get16be(z->s);                          // flags0
+                stbi__get16be(z->s);                          // flags1
+                z->app14_color_transform = stbi__get8(z->s);  // color transform
+                L -= 6;
+            }
+        }
+
+        stbi__skip(z->s, L);
+        return 1;
+    }
+
+    return stbi__err("unknown marker", "Corrupt JPEG");
+}
+
+// after we see SOS
+static int stbi__process_scan_header(stbi__jpeg *z) {
+    int i;
+    int Ls    = stbi__get16be(z->s);
+    z->scan_n = stbi__get8(z->s);
+    if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int)z->s->img_n)
+        return stbi__err("bad SOS component count", "Corrupt JPEG");
+    if (Ls != 6 + 2 * z->scan_n)
+        return stbi__err("bad SOS len", "Corrupt JPEG");
+    for (i = 0; i < z->scan_n; ++i) {
+        int id = stbi__get8(z->s), which;
+        int q  = stbi__get8(z->s);
+        for (which = 0; which < z->s->img_n; ++which)
+            if (z->img_comp[which].id == id)
+                break;
+        if (which == z->s->img_n)
+            return 0;  // no match
+        z->img_comp[which].hd = q >> 4;
+        if (z->img_comp[which].hd > 3)
+            return stbi__err("bad DC huff", "Corrupt JPEG");
+        z->img_comp[which].ha = q & 15;
+        if (z->img_comp[which].ha > 3)
+            return stbi__err("bad AC huff", "Corrupt JPEG");
+        z->order[i] = which;
+    }
+
+    {
+        int aa;
+        z->spec_start = stbi__get8(z->s);
+        z->spec_end   = stbi__get8(z->s);  // should be 63, but might be 0
+        aa            = stbi__get8(z->s);
+        z->succ_high  = (aa >> 4);
+        z->succ_low   = (aa & 15);
+        if (z->progressive) {
+            if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end ||
+                z->succ_high > 13 || z->succ_low > 13)
+                return stbi__err("bad SOS", "Corrupt JPEG");
+        } else {
+            if (z->spec_start != 0)
+                return stbi__err("bad SOS", "Corrupt JPEG");
+            if (z->succ_high != 0 || z->succ_low != 0)
+                return stbi__err("bad SOS", "Corrupt JPEG");
+            z->spec_end = 63;
+        }
+    }
+
+    return 1;
+}
+
+static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) {
+    int i;
+    for (i = 0; i < ncomp; ++i) {
+        if (z->img_comp[i].raw_data) {
+            STBI_FREE(z->img_comp[i].raw_data);
+            z->img_comp[i].raw_data = NULL;
+            z->img_comp[i].data     = NULL;
+        }
+        if (z->img_comp[i].raw_coeff) {
+            STBI_FREE(z->img_comp[i].raw_coeff);
+            z->img_comp[i].raw_coeff = 0;
+            z->img_comp[i].coeff     = 0;
+        }
+        if (z->img_comp[i].linebuf) {
+            STBI_FREE(z->img_comp[i].linebuf);
+            z->img_comp[i].linebuf = NULL;
+        }
+    }
+    return why;
+}
+
+static int stbi__process_frame_header(stbi__jpeg *z, int scan) {
+    stbi__context *s = z->s;
+    int Lf, p, i, q, h_max = 1, v_max = 1, c;
+    Lf = stbi__get16be(s);
+    if (Lf < 11)
+        return stbi__err("bad SOF len", "Corrupt JPEG");  // JPEG
+    p = stbi__get8(s);
+    if (p != 8)
+        return stbi__err("only 8-bit", "JPEG format not supported: 8-bit only");  // JPEG baseline
+    s->img_y = stbi__get16be(s);
+    if (s->img_y == 0)
+        return stbi__err(
+            "no header height",
+            "JPEG format not supported: delayed height");  // Legal, but we don't handle it--but
+                                                           // neither does IJG
+    s->img_x = stbi__get16be(s);
+    if (s->img_x == 0)
+        return stbi__err("0 width", "Corrupt JPEG");  // JPEG requires
+    if (s->img_y > STBI_MAX_DIMENSIONS)
+        return stbi__err("too large", "Very large image (corrupt?)");
+    if (s->img_x > STBI_MAX_DIMENSIONS)
+        return stbi__err("too large", "Very large image (corrupt?)");
+    c = stbi__get8(s);
+    if (c != 3 && c != 1 && c != 4)
+        return stbi__err("bad component count", "Corrupt JPEG");
+    s->img_n = c;
+    for (i = 0; i < c; ++i) {
+        z->img_comp[i].data    = NULL;
+        z->img_comp[i].linebuf = NULL;
+    }
+
+    if (Lf != 8 + 3 * s->img_n)
+        return stbi__err("bad SOF len", "Corrupt JPEG");
+
+    z->rgb = 0;
+    for (i = 0; i < s->img_n; ++i) {
+        static const unsigned char rgb[3] = {'R', 'G', 'B'};
+        z->img_comp[i].id                 = stbi__get8(s);
+        if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
+            ++z->rgb;
+        q                = stbi__get8(s);
+        z->img_comp[i].h = (q >> 4);
+        if (!z->img_comp[i].h || z->img_comp[i].h > 4)
+            return stbi__err("bad H", "Corrupt JPEG");
+        z->img_comp[i].v = q & 15;
+        if (!z->img_comp[i].v || z->img_comp[i].v > 4)
+            return stbi__err("bad V", "Corrupt JPEG");
+        z->img_comp[i].tq = stbi__get8(s);
+        if (z->img_comp[i].tq > 3)
+            return stbi__err("bad TQ", "Corrupt JPEG");
+    }
+
+    if (scan != STBI__SCAN_load)
+        return 1;
+
+    if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0))
+        return stbi__err("too large", "Image too large to decode");
+
+    for (i = 0; i < s->img_n; ++i) {
+        if (z->img_comp[i].h > h_max)
+            h_max = z->img_comp[i].h;
+        if (z->img_comp[i].v > v_max)
+            v_max = z->img_comp[i].v;
+    }
+
+    // check that plane subsampling factors are integer ratios; our resamplers can't deal with
+    // fractional ratios and I've never seen a non-corrupted JPEG file actually use them
+    for (i = 0; i < s->img_n; ++i) {
+        if (h_max % z->img_comp[i].h != 0)
+            return stbi__err("bad H", "Corrupt JPEG");
+        if (v_max % z->img_comp[i].v != 0)
+            return stbi__err("bad V", "Corrupt JPEG");
+    }
+
+    // compute interleaved mcu info
+    z->img_h_max = h_max;
+    z->img_v_max = v_max;
+    z->img_mcu_w = h_max * 8;
+    z->img_mcu_h = v_max * 8;
+    // these sizes can't be more than 17 bits
+    z->img_mcu_x = (s->img_x + z->img_mcu_w - 1) / z->img_mcu_w;
+    z->img_mcu_y = (s->img_y + z->img_mcu_h - 1) / z->img_mcu_h;
+
+    for (i = 0; i < s->img_n; ++i) {
+        // number of effective pixels (e.g. for non-interleaved MCU)
+        z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max - 1) / h_max;
+        z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max - 1) / v_max;
+        // to simplify generation, we'll allocate enough memory to decode
+        // the bogus oversized data from using interleaved MCUs and their
+        // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
+        // discard the extra data until colorspace conversion
+        //
+        // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
+        // so these muls can't overflow with 32-bit ints (which we require)
+        z->img_comp[i].w2        = z->img_mcu_x * z->img_comp[i].h * 8;
+        z->img_comp[i].h2        = z->img_mcu_y * z->img_comp[i].v * 8;
+        z->img_comp[i].coeff     = 0;
+        z->img_comp[i].raw_coeff = 0;
+        z->img_comp[i].linebuf   = NULL;
+        z->img_comp[i].raw_data  = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
+        if (z->img_comp[i].raw_data == NULL)
+            return stbi__free_jpeg_components(z, i + 1, stbi__err("outofmem", "Out of memory"));
+        // align blocks for idct using mmx/sse
+        z->img_comp[i].data = (stbi_uc *)(((size_t)z->img_comp[i].raw_data + 15) & ~15);
+        if (z->progressive) {
+            // w2, h2 are multiples of 8 (see above)
+            z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
+            z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
+            z->img_comp[i].raw_coeff =
+                stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
+            if (z->img_comp[i].raw_coeff == NULL)
+                return stbi__free_jpeg_components(z, i + 1, stbi__err("outofmem", "Out of memory"));
+            z->img_comp[i].coeff = (short *)(((size_t)z->img_comp[i].raw_coeff + 15) & ~15);
+        }
+    }
+
+    return 1;
+}
+
+// use comparisons since in some cases we handle more than one case (e.g. SOF)
+#define stbi__DNL(x) ((x) == 0xdc)
+#define stbi__SOI(x) ((x) == 0xd8)
+#define stbi__EOI(x) ((x) == 0xd9)
+#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
+#define stbi__SOS(x) ((x) == 0xda)
+
+#define stbi__SOF_progressive(x) ((x) == 0xc2)
+
+static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) {
+    int m;
+    z->jfif                  = 0;
+    z->app14_color_transform = -1;                 // valid values are 0,1,2
+    z->marker                = STBI__MARKER_none;  // initialize cached marker to empty
+    m                        = stbi__get_marker(z);
+    if (!stbi__SOI(m))
+        return stbi__err("no SOI", "Corrupt JPEG");
+    if (scan == STBI__SCAN_type)
+        return 1;
+    m = stbi__get_marker(z);
+    while (!stbi__SOF(m)) {
+        if (!stbi__process_marker(z, m))
+            return 0;
+        m = stbi__get_marker(z);
+        while (m == STBI__MARKER_none) {
+            // some files have extra padding after their blocks, so ok, we'll scan
+            if (stbi__at_eof(z->s))
+                return stbi__err("no SOF", "Corrupt JPEG");
+            m = stbi__get_marker(z);
+        }
+    }
+    z->progressive = stbi__SOF_progressive(m);
+    if (!stbi__process_frame_header(z, scan))
+        return 0;
+    return 1;
+}
+
+static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) {
+    // some JPEGs have junk at end, skip over it but if we find what looks
+    // like a valid marker, resume there
+    while (!stbi__at_eof(j->s)) {
+        stbi_uc x = stbi__get8(j->s);
+        while (x == 0xff) {  // might be a marker
+            if (stbi__at_eof(j->s))
+                return STBI__MARKER_none;
+            x = stbi__get8(j->s);
+            if (x != 0x00 && x != 0xff) {
+                // not a stuffed zero or lead-in to another marker, looks
+                // like an actual marker, return it
+                return x;
+            }
+            // stuffed zero has x=0 now which ends the loop, meaning we go
+            // back to regular scan loop.
+            // repeated 0xff keeps trying to read the next byte of the marker.
+        }
+    }
+    return STBI__MARKER_none;
+}
+
+// decode image to YCbCr format
+static int stbi__decode_jpeg_image(stbi__jpeg *j) {
+    int m;
+    for (m = 0; m < 4; m++) {
+        j->img_comp[m].raw_data  = NULL;
+        j->img_comp[m].raw_coeff = NULL;
+    }
+    j->restart_interval = 0;
+    if (!stbi__decode_jpeg_header(j, STBI__SCAN_load))
+        return 0;
+    m = stbi__get_marker(j);
+    while (!stbi__EOI(m)) {
+        if (stbi__SOS(m)) {
+            if (!stbi__process_scan_header(j))
+                return 0;
+            if (!stbi__parse_entropy_coded_data(j))
+                return 0;
+            if (j->marker == STBI__MARKER_none) {
+                j->marker = stbi__skip_jpeg_junk_at_end(j);
+                // if we reach eof without hitting a marker, stbi__get_marker() below will fail and
+                // we'll eventually return 0
+            }
+            m = stbi__get_marker(j);
+            if (STBI__RESTART(m))
+                m = stbi__get_marker(j);
+        } else if (stbi__DNL(m)) {
+            int Ld          = stbi__get16be(j->s);
+            stbi__uint32 NL = stbi__get16be(j->s);
+            if (Ld != 4)
+                return stbi__err("bad DNL len", "Corrupt JPEG");
+            if (NL != j->s->img_y)
+                return stbi__err("bad DNL height", "Corrupt JPEG");
+            m = stbi__get_marker(j);
+        } else {
+            if (!stbi__process_marker(j, m))
+                return 1;
+            m = stbi__get_marker(j);
+        }
+    }
+    if (j->progressive)
+        stbi__jpeg_finish(j);
+    return 1;
+}
+
+// static jfif-centered resampling (across block boundaries)
+
+typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, int w, int hs);
+
+#define stbi__div4(x) ((stbi_uc)((x) >> 2))
+
+static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) {
+    STBI_NOTUSED(out);
+    STBI_NOTUSED(in_far);
+    STBI_NOTUSED(w);
+    STBI_NOTUSED(hs);
+    return in_near;
+}
+
+static stbi_uc *stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w,
+                                       int hs) {
+    // need to generate two samples vertically for every one in input
+    int i;
+    STBI_NOTUSED(hs);
+    for (i = 0; i < w; ++i)
+        out[i] = stbi__div4(3 * in_near[i] + in_far[i] + 2);
+    return out;
+}
+
+static stbi_uc *stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w,
+                                       int hs) {
+    // need to generate two samples horizontally for every one in input
+    int i;
+    stbi_uc *input = in_near;
+
+    if (w == 1) {
+        // if only one sample, can't do any interpolation
+        out[0] = out[1] = input[0];
+        return out;
+    }
+
+    out[0] = input[0];
+    out[1] = stbi__div4(input[0] * 3 + input[1] + 2);
+    for (i = 1; i < w - 1; ++i) {
+        int n          = 3 * input[i] + 2;
+        out[i * 2 + 0] = stbi__div4(n + input[i - 1]);
+        out[i * 2 + 1] = stbi__div4(n + input[i + 1]);
+    }
+    out[i * 2 + 0] = stbi__div4(input[w - 2] * 3 + input[w - 1] + 2);
+    out[i * 2 + 1] = input[w - 1];
+
+    STBI_NOTUSED(in_far);
+    STBI_NOTUSED(hs);
+
+    return out;
+}
+
+#define stbi__div16(x) ((stbi_uc)((x) >> 4))
+
+static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w,
+                                        int hs) {
+    // need to generate 2x2 samples for every one in input
+    int i, t0, t1;
+    if (w == 1) {
+        out[0] = out[1] = stbi__div4(3 * in_near[0] + in_far[0] + 2);
+        return out;
+    }
+
+    t1     = 3 * in_near[0] + in_far[0];
+    out[0] = stbi__div4(t1 + 2);
+    for (i = 1; i < w; ++i) {
+        t0             = t1;
+        t1             = 3 * in_near[i] + in_far[i];
+        out[i * 2 - 1] = stbi__div16(3 * t0 + t1 + 8);
+        out[i * 2]     = stbi__div16(3 * t1 + t0 + 8);
+    }
+    out[w * 2 - 1] = stbi__div4(t1 + 2);
+
+    STBI_NOTUSED(hs);
+
+    return out;
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w,
+                                             int hs) {
+    // need to generate 2x2 samples for every one in input
+    int i = 0, t0, t1;
+
+    if (w == 1) {
+        out[0] = out[1] = stbi__div4(3 * in_near[0] + in_far[0] + 2);
+        return out;
+    }
+
+    t1 = 3 * in_near[0] + in_far[0];
+    // process groups of 8 pixels for as long as we can.
+    // note we can't handle the last pixel in a row in this loop
+    // because we need to handle the filter boundary conditions.
+    for (; i < ((w - 1) & ~7); i += 8) {
+#if defined(STBI_SSE2)
+        // load and perform the vertical filtering pass
+        // this uses 3*x + y = 4*x + (y - x)
+        __m128i zero  = _mm_setzero_si128();
+        __m128i farb  = _mm_loadl_epi64((__m128i *)(in_far + i));
+        __m128i nearb = _mm_loadl_epi64((__m128i *)(in_near + i));
+        __m128i farw  = _mm_unpacklo_epi8(farb, zero);
+        __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
+        __m128i diff  = _mm_sub_epi16(farw, nearw);
+        __m128i nears = _mm_slli_epi16(nearw, 2);
+        __m128i curr  = _mm_add_epi16(nears, diff);  // current row
+
+        // horizontal filter works the same based on shifted vers of current
+        // row. "prev" is current row shifted right by 1 pixel; we need to
+        // insert the previous pixel value (from t1).
+        // "next" is current row shifted left by 1 pixel, with first pixel
+        // of next block of 8 pixels added in.
+        __m128i prv0 = _mm_slli_si128(curr, 2);
+        __m128i nxt0 = _mm_srli_si128(curr, 2);
+        __m128i prev = _mm_insert_epi16(prv0, t1, 0);
+        __m128i next = _mm_insert_epi16(nxt0, 3 * in_near[i + 8] + in_far[i + 8], 7);
+
+        // horizontal filter, polyphase implementation since it's convenient:
+        // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+        // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+        // note the shared term.
+        __m128i bias = _mm_set1_epi16(8);
+        __m128i curs = _mm_slli_epi16(curr, 2);
+        __m128i prvd = _mm_sub_epi16(prev, curr);
+        __m128i nxtd = _mm_sub_epi16(next, curr);
+        __m128i curb = _mm_add_epi16(curs, bias);
+        __m128i even = _mm_add_epi16(prvd, curb);
+        __m128i odd  = _mm_add_epi16(nxtd, curb);
+
+        // interleave even and odd pixels, then undo scaling.
+        __m128i int0 = _mm_unpacklo_epi16(even, odd);
+        __m128i int1 = _mm_unpackhi_epi16(even, odd);
+        __m128i de0  = _mm_srli_epi16(int0, 4);
+        __m128i de1  = _mm_srli_epi16(int1, 4);
+
+        // pack and write output
+        __m128i outv = _mm_packus_epi16(de0, de1);
+        _mm_storeu_si128((__m128i *)(out + i * 2), outv);
+#elif defined(STBI_NEON)
+        // load and perform the vertical filtering pass
+        // this uses 3*x + y = 4*x + (y - x)
+        uint8x8_t farb  = vld1_u8(in_far + i);
+        uint8x8_t nearb = vld1_u8(in_near + i);
+        int16x8_t diff  = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
+        int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
+        int16x8_t curr  = vaddq_s16(nears, diff);  // current row
+
+        // horizontal filter works the same based on shifted vers of current
+        // row. "prev" is current row shifted right by 1 pixel; we need to
+        // insert the previous pixel value (from t1).
+        // "next" is current row shifted left by 1 pixel, with first pixel
+        // of next block of 8 pixels added in.
+        int16x8_t prv0 = vextq_s16(curr, curr, 7);
+        int16x8_t nxt0 = vextq_s16(curr, curr, 1);
+        int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
+        int16x8_t next = vsetq_lane_s16(3 * in_near[i + 8] + in_far[i + 8], nxt0, 7);
+
+        // horizontal filter, polyphase implementation since it's convenient:
+        // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+        // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+        // note the shared term.
+        int16x8_t curs = vshlq_n_s16(curr, 2);
+        int16x8_t prvd = vsubq_s16(prev, curr);
+        int16x8_t nxtd = vsubq_s16(next, curr);
+        int16x8_t even = vaddq_s16(curs, prvd);
+        int16x8_t odd  = vaddq_s16(curs, nxtd);
+
+        // undo scaling and round, then store with even/odd phases interleaved
+        uint8x8x2_t o;
+        o.val[0] = vqrshrun_n_s16(even, 4);
+        o.val[1] = vqrshrun_n_s16(odd, 4);
+        vst2_u8(out + i * 2, o);
+#endif
+
+        // "previous" value for next iter
+        t1 = 3 * in_near[i + 7] + in_far[i + 7];
+    }
+
+    t0         = t1;
+    t1         = 3 * in_near[i] + in_far[i];
+    out[i * 2] = stbi__div16(3 * t1 + t0 + 8);
+
+    for (++i; i < w; ++i) {
+        t0             = t1;
+        t1             = 3 * in_near[i] + in_far[i];
+        out[i * 2 - 1] = stbi__div16(3 * t0 + t1 + 8);
+        out[i * 2]     = stbi__div16(3 * t1 + t0 + 8);
+    }
+    out[w * 2 - 1] = stbi__div4(t1 + 2);
+
+    STBI_NOTUSED(hs);
+
+    return out;
+}
+#endif
+
+static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w,
+                                           int hs) {
+    // resample with nearest-neighbor
+    int i, j;
+    STBI_NOTUSED(in_far);
+    for (i = 0; i < w; ++i)
+        for (j = 0; j < hs; ++j)
+            out[i * hs + j] = in_near[i];
+    return out;
+}
+
+// this is a reduced-precision calculation of YCbCr-to-RGB introduced
+// to make sure the code produces the same results in both SIMD and scalar
+#define stbi__float2fixed(x) (((int)((x) * 4096.0f + 0.5f)) << 8)
+static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb,
+                                   const stbi_uc *pcr, int count, int step) {
+    int i;
+    for (i = 0; i < count; ++i) {
+        int y_fixed = (y[i] << 20) + (1 << 19);  // rounding
+        int r, g, b;
+        int cr = pcr[i] - 128;
+        int cb = pcb[i] - 128;
+        r      = y_fixed + cr * stbi__float2fixed(1.40200f);
+        g      = y_fixed + (cr * -stbi__float2fixed(0.71414f)) +
+            ((cb * -stbi__float2fixed(0.34414f)) & 0xffff0000);
+        b = y_fixed + cb * stbi__float2fixed(1.77200f);
+        r >>= 20;
+        g >>= 20;
+        b >>= 20;
+        if ((unsigned)r > 255) {
+            if (r < 0)
+                r = 0;
+            else
+                r = 255;
+        }
+        if ((unsigned)g > 255) {
+            if (g < 0)
+                g = 0;
+            else
+                g = 255;
+        }
+        if ((unsigned)b > 255) {
+            if (b < 0)
+                b = 0;
+            else
+                b = 255;
+        }
+        out[0] = (stbi_uc)r;
+        out[1] = (stbi_uc)g;
+        out[2] = (stbi_uc)b;
+        out[3] = 255;
+        out += step;
+    }
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb,
+                                    stbi_uc const *pcr, int count, int step) {
+    int i = 0;
+
+#ifdef STBI_SSE2
+    // step == 3 is pretty ugly on the final interleave, and i'm not convinced
+    // it's useful in practice (you wouldn't use it for textures, for example).
+    // so just accelerate step == 4 case.
+    if (step == 4) {
+        // this is a fairly straightforward implementation and not super-optimized.
+        __m128i signflip  = _mm_set1_epi8(-0x80);
+        __m128i cr_const0 = _mm_set1_epi16((short)(1.40200f * 4096.0f + 0.5f));
+        __m128i cr_const1 = _mm_set1_epi16(-(short)(0.71414f * 4096.0f + 0.5f));
+        __m128i cb_const0 = _mm_set1_epi16(-(short)(0.34414f * 4096.0f + 0.5f));
+        __m128i cb_const1 = _mm_set1_epi16((short)(1.77200f * 4096.0f + 0.5f));
+        __m128i y_bias    = _mm_set1_epi8((char)(unsigned char)128);
+        __m128i xw        = _mm_set1_epi16(255);  // alpha channel
+
+        for (; i + 7 < count; i += 8) {
+            // load
+            __m128i y_bytes   = _mm_loadl_epi64((__m128i *)(y + i));
+            __m128i cr_bytes  = _mm_loadl_epi64((__m128i *)(pcr + i));
+            __m128i cb_bytes  = _mm_loadl_epi64((__m128i *)(pcb + i));
+            __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip);  // -128
+            __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip);  // -128
+
+            // unpack to short (and left-shift cr, cb by 8)
+            __m128i yw  = _mm_unpacklo_epi8(y_bias, y_bytes);
+            __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
+            __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
+
+            // color transform
+            __m128i yws = _mm_srli_epi16(yw, 4);
+            __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
+            __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
+            __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
+            __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
+            __m128i rws = _mm_add_epi16(cr0, yws);
+            __m128i gwt = _mm_add_epi16(cb0, yws);
+            __m128i bws = _mm_add_epi16(yws, cb1);
+            __m128i gws = _mm_add_epi16(gwt, cr1);
+
+            // descale
+            __m128i rw = _mm_srai_epi16(rws, 4);
+            __m128i bw = _mm_srai_epi16(bws, 4);
+            __m128i gw = _mm_srai_epi16(gws, 4);
+
+            // back to byte, set up for transpose
+            __m128i brb = _mm_packus_epi16(rw, bw);
+            __m128i gxb = _mm_packus_epi16(gw, xw);
+
+            // transpose to interleave channels
+            __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
+            __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
+            __m128i o0 = _mm_unpacklo_epi16(t0, t1);
+            __m128i o1 = _mm_unpackhi_epi16(t0, t1);
+
+            // store
+            _mm_storeu_si128((__m128i *)(out + 0), o0);
+            _mm_storeu_si128((__m128i *)(out + 16), o1);
+            out += 32;
+        }
+    }
+#endif
+
+#ifdef STBI_NEON
+    // in this version, step=3 support would be easy to add. but is there demand?
+    if (step == 4) {
+        // this is a fairly straightforward implementation and not super-optimized.
+        uint8x8_t signflip  = vdup_n_u8(0x80);
+        int16x8_t cr_const0 = vdupq_n_s16((short)(1.40200f * 4096.0f + 0.5f));
+        int16x8_t cr_const1 = vdupq_n_s16(-(short)(0.71414f * 4096.0f + 0.5f));
+        int16x8_t cb_const0 = vdupq_n_s16(-(short)(0.34414f * 4096.0f + 0.5f));
+        int16x8_t cb_const1 = vdupq_n_s16((short)(1.77200f * 4096.0f + 0.5f));
+
+        for (; i + 7 < count; i += 8) {
+            // load
+            uint8x8_t y_bytes  = vld1_u8(y + i);
+            uint8x8_t cr_bytes = vld1_u8(pcr + i);
+            uint8x8_t cb_bytes = vld1_u8(pcb + i);
+            int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
+            int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
+
+            // expand to s16
+            int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
+            int16x8_t crw = vshll_n_s8(cr_biased, 7);
+            int16x8_t cbw = vshll_n_s8(cb_biased, 7);
+
+            // color transform
+            int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
+            int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
+            int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
+            int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
+            int16x8_t rws = vaddq_s16(yws, cr0);
+            int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
+            int16x8_t bws = vaddq_s16(yws, cb1);
+
+            // undo scaling, round, convert to byte
+            uint8x8x4_t o;
+            o.val[0] = vqrshrun_n_s16(rws, 4);
+            o.val[1] = vqrshrun_n_s16(gws, 4);
+            o.val[2] = vqrshrun_n_s16(bws, 4);
+            o.val[3] = vdup_n_u8(255);
+
+            // store, interleaving r/g/b/a
+            vst4_u8(out, o);
+            out += 8 * 4;
+        }
+    }
+#endif
+
+    for (; i < count; ++i) {
+        int y_fixed = (y[i] << 20) + (1 << 19);  // rounding
+        int r, g, b;
+        int cr = pcr[i] - 128;
+        int cb = pcb[i] - 128;
+        r      = y_fixed + cr * stbi__float2fixed(1.40200f);
+        g      = y_fixed + cr * -stbi__float2fixed(0.71414f) +
+            ((cb * -stbi__float2fixed(0.34414f)) & 0xffff0000);
+        b = y_fixed + cb * stbi__float2fixed(1.77200f);
+        r >>= 20;
+        g >>= 20;
+        b >>= 20;
+        if ((unsigned)r > 255) {
+            if (r < 0)
+                r = 0;
+            else
+                r = 255;
+        }
+        if ((unsigned)g > 255) {
+            if (g < 0)
+                g = 0;
+            else
+                g = 255;
+        }
+        if ((unsigned)b > 255) {
+            if (b < 0)
+                b = 0;
+            else
+                b = 255;
+        }
+        out[0] = (stbi_uc)r;
+        out[1] = (stbi_uc)g;
+        out[2] = (stbi_uc)b;
+        out[3] = 255;
+        out += step;
+    }
+}
+#endif
+
+// set up the kernels
+static void stbi__setup_jpeg(stbi__jpeg *j) {
+    j->idct_block_kernel        = stbi__idct_block;
+    j->YCbCr_to_RGB_kernel      = stbi__YCbCr_to_RGB_row;
+    j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
+
+#ifdef STBI_SSE2
+    if (stbi__sse2_available()) {
+        j->idct_block_kernel        = stbi__idct_simd;
+        j->YCbCr_to_RGB_kernel      = stbi__YCbCr_to_RGB_simd;
+        j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+    }
+#endif
+
+#ifdef STBI_NEON
+    j->idct_block_kernel        = stbi__idct_simd;
+    j->YCbCr_to_RGB_kernel      = stbi__YCbCr_to_RGB_simd;
+    j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+#endif
+}
+
+// clean up the temporary component buffers
+static void stbi__cleanup_jpeg(stbi__jpeg *j) { stbi__free_jpeg_components(j, j->s->img_n, 0); }
+
+typedef struct {
+    resample_row_func resample;
+    stbi_uc *line0, *line1;
+    int hs, vs;   // expansion factor in each axis
+    int w_lores;  // horizontal pixels pre-expansion
+    int ystep;    // how far through vertical expansion we are
+    int ypos;     // which pre-expansion row we're on
+} stbi__resample;
+
+// fast 0..255 * 0..255 => 0..255 rounded multiplication
+static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) {
+    unsigned int t = x * y + 128;
+    return (stbi_uc)((t + (t >> 8)) >> 8);
+}
+
+static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) {
+    int n, decode_n, is_rgb;
+    z->s->img_n = 0;  // make stbi__cleanup_jpeg safe
+
+    // validate req_comp
+    if (req_comp < 0 || req_comp > 4)
+        return stbi__errpuc("bad req_comp", "Internal error");
+
+    // load a jpeg image from whichever source, but leave in YCbCr format
+    if (!stbi__decode_jpeg_image(z)) {
+        stbi__cleanup_jpeg(z);
+        return NULL;
+    }
+
+    // determine actual number of components to generate
+    n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
+
+    is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
+
+    if (z->s->img_n == 3 && n < 3 && !is_rgb)
+        decode_n = 1;
+    else
+        decode_n = z->s->img_n;
+
+    // nothing to do if no components requested; check this now to avoid
+    // accessing uninitialized coutput[0] later
+    if (decode_n <= 0) {
+        stbi__cleanup_jpeg(z);
+        return NULL;
+    }
+
+    // resample and color-convert
+    {
+        int k;
+        unsigned int i, j;
+        stbi_uc *output;
+        stbi_uc *coutput[4] = {NULL, NULL, NULL, NULL};
+
+        stbi__resample res_comp[4];
+
+        for (k = 0; k < decode_n; ++k) {
+            stbi__resample *r = &res_comp[k];
+
+            // allocate line buffer big enough for upsampling off the edges
+            // with upsample factor of 4
+            z->img_comp[k].linebuf = (stbi_uc *)stbi__malloc(z->s->img_x + 3);
+            if (!z->img_comp[k].linebuf) {
+                stbi__cleanup_jpeg(z);
+                return stbi__errpuc("outofmem", "Out of memory");
+            }
+
+            r->hs      = z->img_h_max / z->img_comp[k].h;
+            r->vs      = z->img_v_max / z->img_comp[k].v;
+            r->ystep   = r->vs >> 1;
+            r->w_lores = (z->s->img_x + r->hs - 1) / r->hs;
+            r->ypos    = 0;
+            r->line0 = r->line1 = z->img_comp[k].data;
+
+            if (r->hs == 1 && r->vs == 1)
+                r->resample = resample_row_1;
+            else if (r->hs == 1 && r->vs == 2)
+                r->resample = stbi__resample_row_v_2;
+            else if (r->hs == 2 && r->vs == 1)
+                r->resample = stbi__resample_row_h_2;
+            else if (r->hs == 2 && r->vs == 2)
+                r->resample = z->resample_row_hv_2_kernel;
+            else
+                r->resample = stbi__resample_row_generic;
+        }
+
+        // can't error after this so, this is safe
+        output = (stbi_uc *)stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
+        if (!output) {
+            stbi__cleanup_jpeg(z);
+            return stbi__errpuc("outofmem", "Out of memory");
+        }
+
+        // now go ahead and resample
+        for (j = 0; j < z->s->img_y; ++j) {
+            stbi_uc *out = output + n * z->s->img_x * j;
+            for (k = 0; k < decode_n; ++k) {
+                stbi__resample *r = &res_comp[k];
+                int y_bot         = r->ystep >= (r->vs >> 1);
+                coutput[k]        = r->resample(z->img_comp[k].linebuf, y_bot ? r->line1 : r->line0,
+                                         y_bot ? r->line0 : r->line1, r->w_lores, r->hs);
+                if (++r->ystep >= r->vs) {
+                    r->ystep = 0;
+                    r->line0 = r->line1;
+                    if (++r->ypos < z->img_comp[k].y)
+                        r->line1 += z->img_comp[k].w2;
+                }
+            }
+            if (n >= 3) {
+                stbi_uc *y = coutput[0];
+                if (z->s->img_n == 3) {
+                    if (is_rgb) {
+                        for (i = 0; i < z->s->img_x; ++i) {
+                            out[0] = y[i];
+                            out[1] = coutput[1][i];
+                            out[2] = coutput[2][i];
+                            out[3] = 255;
+                            out += n;
+                        }
+                    } else {
+                        z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+                    }
+                } else if (z->s->img_n == 4) {
+                    if (z->app14_color_transform == 0) {  // CMYK
+                        for (i = 0; i < z->s->img_x; ++i) {
+                            stbi_uc m = coutput[3][i];
+                            out[0]    = stbi__blinn_8x8(coutput[0][i], m);
+                            out[1]    = stbi__blinn_8x8(coutput[1][i], m);
+                            out[2]    = stbi__blinn_8x8(coutput[2][i], m);
+                            out[3]    = 255;
+                            out += n;
+                        }
+                    } else if (z->app14_color_transform == 2) {  // YCCK
+                        z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+                        for (i = 0; i < z->s->img_x; ++i) {
+                            stbi_uc m = coutput[3][i];
+                            out[0]    = stbi__blinn_8x8(255 - out[0], m);
+                            out[1]    = stbi__blinn_8x8(255 - out[1], m);
+                            out[2]    = stbi__blinn_8x8(255 - out[2], m);
+                            out += n;
+                        }
+                    } else {  // YCbCr + alpha?  Ignore the fourth channel for now
+                        z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+                    }
+                } else
+                    for (i = 0; i < z->s->img_x; ++i) {
+                        out[0] = out[1] = out[2] = y[i];
+                        out[3]                   = 255;  // not used if n==3
+                        out += n;
+                    }
+            } else {
+                if (is_rgb) {
+                    if (n == 1)
+                        for (i = 0; i < z->s->img_x; ++i)
+                            *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+                    else {
+                        for (i = 0; i < z->s->img_x; ++i, out += 2) {
+                            out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+                            out[1] = 255;
+                        }
+                    }
+                } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
+                    for (i = 0; i < z->s->img_x; ++i) {
+                        stbi_uc m = coutput[3][i];
+                        stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
+                        stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
+                        stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
+                        out[0]    = stbi__compute_y(r, g, b);
+                        out[1]    = 255;
+                        out += n;
+                    }
+                } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
+                    for (i = 0; i < z->s->img_x; ++i) {
+                        out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
+                        out[1] = 255;
+                        out += n;
+                    }
+                } else {
+                    stbi_uc *y = coutput[0];
+                    if (n == 1)
+                        for (i = 0; i < z->s->img_x; ++i)
+                            out[i] = y[i];
+                    else
+                        for (i = 0; i < z->s->img_x; ++i) {
+                            *out++ = y[i];
+                            *out++ = 255;
+                        }
+                }
+            }
+        }
+        stbi__cleanup_jpeg(z);
+        *out_x = z->s->img_x;
+        *out_y = z->s->img_y;
+        if (comp)
+            *comp = z->s->img_n >= 3 ? 3 : 1;  // report original components, not output
+        return output;
+    }
+}
+
+static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                             stbi__result_info *ri) {
+    unsigned char *result;
+    stbi__jpeg *j = (stbi__jpeg *)stbi__malloc(sizeof(stbi__jpeg));
+    if (!j)
+        return stbi__errpuc("outofmem", "Out of memory");
+    memset(j, 0, sizeof(stbi__jpeg));
+    STBI_NOTUSED(ri);
+    j->s = s;
+    stbi__setup_jpeg(j);
+    result = load_jpeg_image(j, x, y, comp, req_comp);
+    STBI_FREE(j);
+    return result;
+}
+
+static int stbi__jpeg_test(stbi__context *s) {
+    int r;
+    stbi__jpeg *j = (stbi__jpeg *)stbi__malloc(sizeof(stbi__jpeg));
+    if (!j)
+        return stbi__err("outofmem", "Out of memory");
+    memset(j, 0, sizeof(stbi__jpeg));
+    j->s = s;
+    stbi__setup_jpeg(j);
+    r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
+    stbi__rewind(s);
+    STBI_FREE(j);
+    return r;
+}
+
+static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) {
+    if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
+        stbi__rewind(j->s);
+        return 0;
+    }
+    if (x)
+        *x = j->s->img_x;
+    if (y)
+        *y = j->s->img_y;
+    if (comp)
+        *comp = j->s->img_n >= 3 ? 3 : 1;
+    return 1;
+}
+
+static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) {
+    int result;
+    stbi__jpeg *j = (stbi__jpeg *)(stbi__malloc(sizeof(stbi__jpeg)));
+    if (!j)
+        return stbi__err("outofmem", "Out of memory");
+    memset(j, 0, sizeof(stbi__jpeg));
+    j->s   = s;
+    result = stbi__jpeg_info_raw(j, x, y, comp);
+    STBI_FREE(j);
+    return result;
+}
+#endif
+
+// public domain zlib decode    v0.2  Sean Barrett 2006-11-18
+//    simple implementation
+//      - all input must be provided in an upfront buffer
+//      - all output is written to a single output buffer (can malloc/realloc)
+//    performance
+//      - fast huffman
+
+#ifndef STBI_NO_ZLIB
+
+// fast-way is faster to check than jpeg huffman, but slow way is slower
+#define STBI__ZFAST_BITS 9  // accelerate all cases in default tables
+#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
+#define STBI__ZNSYMS     288  // number of symbols in literal/length alphabet
+
+// zlib-style huffman encoding
+// (jpegs packs from left, zlib from right, so can't share code)
+typedef struct {
+    stbi__uint16 fast[1 << STBI__ZFAST_BITS];
+    stbi__uint16 firstcode[16];
+    int maxcode[17];
+    stbi__uint16 firstsymbol[16];
+    stbi_uc size[STBI__ZNSYMS];
+    stbi__uint16 value[STBI__ZNSYMS];
+} stbi__zhuffman;
+
+stbi_inline static int stbi__bitreverse16(int n) {
+    n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
+    n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
+    n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
+    n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
+    return n;
+}
+
+stbi_inline static int stbi__bit_reverse(int v, int bits) {
+    STBI_ASSERT(bits <= 16);
+    // to bit reverse n bits, reverse 16 and shift
+    // e.g. 11 bits, bit reverse and shift away 5
+    return stbi__bitreverse16(v) >> (16 - bits);
+}
+
+static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) {
+    int i, k = 0;
+    int code, next_code[16], sizes[17];
+
+    // DEFLATE spec for generating codes
+    memset(sizes, 0, sizeof(sizes));
+    memset(z->fast, 0, sizeof(z->fast));
+    for (i = 0; i < num; ++i)
+        ++sizes[sizelist[i]];
+    sizes[0] = 0;
+    for (i = 1; i < 16; ++i)
+        if (sizes[i] > (1 << i))
+            return stbi__err("bad sizes", "Corrupt PNG");
+    code = 0;
+    for (i = 1; i < 16; ++i) {
+        next_code[i]      = code;
+        z->firstcode[i]   = (stbi__uint16)code;
+        z->firstsymbol[i] = (stbi__uint16)k;
+        code              = (code + sizes[i]);
+        if (sizes[i])
+            if (code - 1 >= (1 << i))
+                return stbi__err("bad codelengths", "Corrupt PNG");
+        z->maxcode[i] = code << (16 - i);  // preshift for inner loop
+        code <<= 1;
+        k += sizes[i];
+    }
+    z->maxcode[16] = 0x10000;  // sentinel
+    for (i = 0; i < num; ++i) {
+        int s = sizelist[i];
+        if (s) {
+            int c              = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
+            stbi__uint16 fastv = (stbi__uint16)((s << 9) | i);
+            z->size[c]         = (stbi_uc)s;
+            z->value[c]        = (stbi__uint16)i;
+            if (s <= STBI__ZFAST_BITS) {
+                int j = stbi__bit_reverse(next_code[s], s);
+                while (j < (1 << STBI__ZFAST_BITS)) {
+                    z->fast[j] = fastv;
+                    j += (1 << s);
+                }
+            }
+            ++next_code[s];
+        }
+    }
+    return 1;
+}
+
+// zlib-from-memory implementation for PNG reading
+//    because PNG allows splitting the zlib stream arbitrarily,
+//    and it's annoying structurally to have PNG call ZLIB call PNG,
+//    we require PNG read all the IDATs and combine them into a single
+//    memory buffer
+
+typedef struct {
+    stbi_uc *zbuffer, *zbuffer_end;
+    int num_bits;
+    int hit_zeof_once;
+    stbi__uint32 code_buffer;
+
+    char *zout;
+    char *zout_start;
+    char *zout_end;
+    int z_expandable;
+
+    stbi__zhuffman z_length, z_distance;
+} stbi__zbuf;
+
+stbi_inline static int stbi__zeof(stbi__zbuf *z) { return (z->zbuffer >= z->zbuffer_end); }
+
+stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) { return stbi__zeof(z) ? 0 : *z->zbuffer++; }
+
+static void stbi__fill_bits(stbi__zbuf *z) {
+    do {
+        if (z->code_buffer >= (1U << z->num_bits)) {
+            z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */
+            return;
+        }
+        z->code_buffer |= (unsigned int)stbi__zget8(z) << z->num_bits;
+        z->num_bits += 8;
+    } while (z->num_bits <= 24);
+}
+
+stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) {
+    unsigned int k;
+    if (z->num_bits < n)
+        stbi__fill_bits(z);
+    k = z->code_buffer & ((1 << n) - 1);
+    z->code_buffer >>= n;
+    z->num_bits -= n;
+    return k;
+}
+
+static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) {
+    int b, s, k;
+    // not resolved by fast table, so compute it the slow way
+    // use jpeg approach, which requires MSbits at top
+    k = stbi__bit_reverse(a->code_buffer, 16);
+    for (s = STBI__ZFAST_BITS + 1;; ++s)
+        if (k < z->maxcode[s])
+            break;
+    if (s >= 16)
+        return -1;  // invalid code!
+    // code size is s, so:
+    b = (k >> (16 - s)) - z->firstcode[s] + z->firstsymbol[s];
+    if (b >= STBI__ZNSYMS)
+        return -1;  // some data was corrupt somewhere!
+    if (z->size[b] != s)
+        return -1;  // was originally an assert, but report failure instead.
+    a->code_buffer >>= s;
+    a->num_bits -= s;
+    return z->value[b];
+}
+
+stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) {
+    int b, s;
+    if (a->num_bits < 16) {
+        if (stbi__zeof(a)) {
+            if (!a->hit_zeof_once) {
+                // This is the first time we hit eof, insert 16 extra padding btis
+                // to allow us to keep going; if we actually consume any of them
+                // though, that is invalid data. This is caught later.
+                a->hit_zeof_once = 1;
+                a->num_bits += 16;  // add 16 implicit zero bits
+            } else {
+                // We already inserted our extra 16 padding bits and are again
+                // out, this stream is actually prematurely terminated.
+                return -1;
+            }
+        } else {
+            stbi__fill_bits(a);
+        }
+    }
+    b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
+    if (b) {
+        s = b >> 9;
+        a->code_buffer >>= s;
+        a->num_bits -= s;
+        return b & 511;
+    }
+    return stbi__zhuffman_decode_slowpath(a, z);
+}
+
+static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
+{
+    char *q;
+    unsigned int cur, limit, old_limit;
+    z->zout = zout;
+    if (!z->z_expandable)
+        return stbi__err("output buffer limit", "Corrupt PNG");
+    cur   = (unsigned int)(z->zout - z->zout_start);
+    limit = old_limit = (unsigned)(z->zout_end - z->zout_start);
+    if (UINT_MAX - cur < (unsigned)n)
+        return stbi__err("outofmem", "Out of memory");
+    while (cur + n > limit) {
+        if (limit > UINT_MAX / 2)
+            return stbi__err("outofmem", "Out of memory");
+        limit *= 2;
+    }
+    q = (char *)STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
+    STBI_NOTUSED(old_limit);
+    if (q == NULL)
+        return stbi__err("outofmem", "Out of memory");
+    z->zout_start = q;
+    z->zout       = q + cur;
+    z->zout_end   = q + limit;
+    return 1;
+}
+
+static const int stbi__zlength_base[31] = {3,  4,   5,   6,   7,   8,   9,   10, 11, 13, 15,
+                                           17, 19,  23,  27,  31,  35,  43,  51, 59, 67, 83,
+                                           99, 115, 131, 163, 195, 227, 258, 0,  0};
+
+static const int stbi__zlength_extra[31] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+                                            3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0};
+
+static const int stbi__zdist_base[32] = {
+    1,   2,   3,   4,   5,    7,    9,    13,   17,   25,   33,   49,    65,    97,    129, 193,
+    257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0,   0};
+
+static const int stbi__zdist_extra[32] = {0, 0, 0, 0, 1, 1, 2, 2,  3,  3,  4,  4,  5,  5,  6,
+                                          6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
+
+static int stbi__parse_huffman_block(stbi__zbuf *a) {
+    char *zout = a->zout;
+    for (;;) {
+        int z = stbi__zhuffman_decode(a, &a->z_length);
+        if (z < 256) {
+            if (z < 0)
+                return stbi__err("bad huffman code", "Corrupt PNG");  // error in huffman codes
+            if (zout >= a->zout_end) {
+                if (!stbi__zexpand(a, zout, 1))
+                    return 0;
+                zout = a->zout;
+            }
+            *zout++ = (char)z;
+        } else {
+            stbi_uc *p;
+            int len, dist;
+            if (z == 256) {
+                a->zout = zout;
+                if (a->hit_zeof_once && a->num_bits < 16) {
+                    // The first time we hit zeof, we inserted 16 extra zero bits into our bit
+                    // buffer so the decoder can just do its speculative decoding. But if we
+                    // actually consumed any of those bits (which is the case when num_bits < 16),
+                    // the stream actually read past the end so it is malformed.
+                    return stbi__err("unexpected end", "Corrupt PNG");
+                }
+                return 1;
+            }
+            if (z >= 286)
+                return stbi__err("bad huffman code",
+                                 "Corrupt PNG");  // per DEFLATE, length codes 286 and 287 must not
+                                                  // appear in compressed data
+            z -= 257;
+            len = stbi__zlength_base[z];
+            if (stbi__zlength_extra[z])
+                len += stbi__zreceive(a, stbi__zlength_extra[z]);
+            z = stbi__zhuffman_decode(a, &a->z_distance);
+            if (z < 0 || z >= 30)
+                return stbi__err("bad huffman code",
+                                 "Corrupt PNG");  // per DEFLATE, distance codes 30 and 31 must not
+                                                  // appear in compressed data
+            dist = stbi__zdist_base[z];
+            if (stbi__zdist_extra[z])
+                dist += stbi__zreceive(a, stbi__zdist_extra[z]);
+            if (zout - a->zout_start < dist)
+                return stbi__err("bad dist", "Corrupt PNG");
+            if (len > a->zout_end - zout) {
+                if (!stbi__zexpand(a, zout, len))
+                    return 0;
+                zout = a->zout;
+            }
+            p = (stbi_uc *)(zout - dist);
+            if (dist == 1) {  // run of one byte; common in images.
+                stbi_uc v = *p;
+                if (len) {
+                    do
+                        *zout++ = v;
+                    while (--len);
+                }
+            } else {
+                if (len) {
+                    do
+                        *zout++ = *p++;
+                    while (--len);
+                }
+            }
+        }
+    }
+}
+
+static int stbi__compute_huffman_codes(stbi__zbuf *a) {
+    static const stbi_uc length_dezigzag[19] = {16, 17, 18, 0, 8,  7, 9,  6, 10, 5,
+                                                11, 4,  12, 3, 13, 2, 14, 1, 15};
+    stbi__zhuffman z_codelength;
+    stbi_uc lencodes[286 + 32 + 137];  // padding for maximum single op
+    stbi_uc codelength_sizes[19];
+    int i, n;
+
+    int hlit  = stbi__zreceive(a, 5) + 257;
+    int hdist = stbi__zreceive(a, 5) + 1;
+    int hclen = stbi__zreceive(a, 4) + 4;
+    int ntot  = hlit + hdist;
+
+    memset(codelength_sizes, 0, sizeof(codelength_sizes));
+    for (i = 0; i < hclen; ++i) {
+        int s                                = stbi__zreceive(a, 3);
+        codelength_sizes[length_dezigzag[i]] = (stbi_uc)s;
+    }
+    if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19))
+        return 0;
+
+    n = 0;
+    while (n < ntot) {
+        int c = stbi__zhuffman_decode(a, &z_codelength);
+        if (c < 0 || c >= 19)
+            return stbi__err("bad codelengths", "Corrupt PNG");
+        if (c < 16)
+            lencodes[n++] = (stbi_uc)c;
+        else {
+            stbi_uc fill = 0;
+            if (c == 16) {
+                c = stbi__zreceive(a, 2) + 3;
+                if (n == 0)
+                    return stbi__err("bad codelengths", "Corrupt PNG");
+                fill = lencodes[n - 1];
+            } else if (c == 17) {
+                c = stbi__zreceive(a, 3) + 3;
+            } else if (c == 18) {
+                c = stbi__zreceive(a, 7) + 11;
+            } else {
+                return stbi__err("bad codelengths", "Corrupt PNG");
+            }
+            if (ntot - n < c)
+                return stbi__err("bad codelengths", "Corrupt PNG");
+            memset(lencodes + n, fill, c);
+            n += c;
+        }
+    }
+    if (n != ntot)
+        return stbi__err("bad codelengths", "Corrupt PNG");
+    if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit))
+        return 0;
+    if (!stbi__zbuild_huffman(&a->z_distance, lencodes + hlit, hdist))
+        return 0;
+    return 1;
+}
+
+static int stbi__parse_uncompressed_block(stbi__zbuf *a) {
+    stbi_uc header[4];
+    int len, nlen, k;
+    if (a->num_bits & 7)
+        stbi__zreceive(a, a->num_bits & 7);  // discard
+    // drain the bit-packed data into header
+    k = 0;
+    while (a->num_bits > 0) {
+        header[k++] = (stbi_uc)(a->code_buffer & 255);  // suppress MSVC run-time check
+        a->code_buffer >>= 8;
+        a->num_bits -= 8;
+    }
+    if (a->num_bits < 0)
+        return stbi__err("zlib corrupt", "Corrupt PNG");
+    // now fill header the normal way
+    while (k < 4)
+        header[k++] = stbi__zget8(a);
+    len  = header[1] * 256 + header[0];
+    nlen = header[3] * 256 + header[2];
+    if (nlen != (len ^ 0xffff))
+        return stbi__err("zlib corrupt", "Corrupt PNG");
+    if (a->zbuffer + len > a->zbuffer_end)
+        return stbi__err("read past buffer", "Corrupt PNG");
+    if (a->zout + len > a->zout_end)
+        if (!stbi__zexpand(a, a->zout, len))
+            return 0;
+    memcpy(a->zout, a->zbuffer, len);
+    a->zbuffer += len;
+    a->zout += len;
+    return 1;
+}
+
+static int stbi__parse_zlib_header(stbi__zbuf *a) {
+    int cmf = stbi__zget8(a);
+    int cm  = cmf & 15;
+    /* int cinfo = cmf >> 4; */
+    int flg = stbi__zget8(a);
+    if (stbi__zeof(a))
+        return stbi__err("bad zlib header", "Corrupt PNG");  // zlib spec
+    if ((cmf * 256 + flg) % 31 != 0)
+        return stbi__err("bad zlib header", "Corrupt PNG");  // zlib spec
+    if (flg & 32)
+        return stbi__err("no preset dict", "Corrupt PNG");  // preset dictionary not allowed in png
+    if (cm != 8)
+        return stbi__err("bad compression", "Corrupt PNG");  // DEFLATE required for png
+    // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+    return 1;
+}
+
+static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = {
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+    9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+    9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+    9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8};
+static const stbi_uc stbi__zdefault_distance[32] = {5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+                                                    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5};
+/*
+Init algorithm:
+{
+   int i;   // use <= to match clearly with spec
+   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
+   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
+   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
+   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;
+
+   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
+}
+*/
+
+static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) {
+    int final, type;
+    if (parse_header)
+        if (!stbi__parse_zlib_header(a))
+            return 0;
+    a->num_bits      = 0;
+    a->code_buffer   = 0;
+    a->hit_zeof_once = 0;
+    do {
+        final = stbi__zreceive(a, 1);
+        type  = stbi__zreceive(a, 2);
+        if (type == 0) {
+            if (!stbi__parse_uncompressed_block(a))
+                return 0;
+        } else if (type == 3) {
+            return 0;
+        } else {
+            if (type == 1) {
+                // use fixed code lengths
+                if (!stbi__zbuild_huffman(&a->z_length, stbi__zdefault_length, STBI__ZNSYMS))
+                    return 0;
+                if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32))
+                    return 0;
+            } else {
+                if (!stbi__compute_huffman_codes(a))
+                    return 0;
+            }
+            if (!stbi__parse_huffman_block(a))
+                return 0;
+        }
+    } while (!final);
+    return 1;
+}
+
+static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) {
+    a->zout_start   = obuf;
+    a->zout         = obuf;
+    a->zout_end     = obuf + olen;
+    a->z_expandable = exp;
+
+    return stbi__parse_zlib(a, parse_header);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size,
+                                                int *outlen) {
+    stbi__zbuf a;
+    char *p = (char *)stbi__malloc(initial_size);
+    if (p == NULL)
+        return NULL;
+    a.zbuffer     = (stbi_uc *)buffer;
+    a.zbuffer_end = (stbi_uc *)buffer + len;
+    if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
+        if (outlen)
+            *outlen = (int)(a.zout - a.zout_start);
+        return a.zout_start;
+    } else {
+        STBI_FREE(a.zout_start);
+        return NULL;
+    }
+}
+
+STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) {
+    return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len,
+                                                           int initial_size, int *outlen,
+                                                           int parse_header) {
+    stbi__zbuf a;
+    char *p = (char *)stbi__malloc(initial_size);
+    if (p == NULL)
+        return NULL;
+    a.zbuffer     = (stbi_uc *)buffer;
+    a.zbuffer_end = (stbi_uc *)buffer + len;
+    if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
+        if (outlen)
+            *outlen = (int)(a.zout - a.zout_start);
+        return a.zout_start;
+    } else {
+        STBI_FREE(a.zout_start);
+        return NULL;
+    }
+}
+
+STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) {
+    stbi__zbuf a;
+    a.zbuffer     = (stbi_uc *)ibuffer;
+    a.zbuffer_end = (stbi_uc *)ibuffer + ilen;
+    if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
+        return (int)(a.zout - a.zout_start);
+    else
+        return -1;
+}
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) {
+    stbi__zbuf a;
+    char *p = (char *)stbi__malloc(16384);
+    if (p == NULL)
+        return NULL;
+    a.zbuffer     = (stbi_uc *)buffer;
+    a.zbuffer_end = (stbi_uc *)buffer + len;
+    if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
+        if (outlen)
+            *outlen = (int)(a.zout - a.zout_start);
+        return a.zout_start;
+    } else {
+        STBI_FREE(a.zout_start);
+        return NULL;
+    }
+}
+
+STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer,
+                                             int ilen) {
+    stbi__zbuf a;
+    a.zbuffer     = (stbi_uc *)ibuffer;
+    a.zbuffer_end = (stbi_uc *)ibuffer + ilen;
+    if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
+        return (int)(a.zout - a.zout_start);
+    else
+        return -1;
+}
+#endif
+
+// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18
+//    simple implementation
+//      - only 8-bit samples
+//      - no CRC checking
+//      - allocates lots of intermediate memory
+//        - avoids problem of streaming data between subsystems
+//        - avoids explicit window management
+//    performance
+//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding
+
+#ifndef STBI_NO_PNG
+typedef struct {
+    stbi__uint32 length;
+    stbi__uint32 type;
+} stbi__pngchunk;
+
+static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) {
+    stbi__pngchunk c;
+    c.length = stbi__get32be(s);
+    c.type   = stbi__get32be(s);
+    return c;
+}
+
+static int stbi__check_png_header(stbi__context *s) {
+    static const stbi_uc png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+    int i;
+    for (i = 0; i < 8; ++i)
+        if (stbi__get8(s) != png_sig[i])
+            return stbi__err("bad png sig", "Not a PNG");
+    return 1;
+}
+
+typedef struct {
+    stbi__context *s;
+    stbi_uc *idata, *expanded, *out;
+    int depth;
+} stbi__png;
+
+enum {
+    STBI__F_none  = 0,
+    STBI__F_sub   = 1,
+    STBI__F_up    = 2,
+    STBI__F_avg   = 3,
+    STBI__F_paeth = 4,
+    // synthetic filter used for first scanline to avoid needing a dummy row of 0s
+    STBI__F_avg_first
+};
+
+static stbi_uc first_row_filter[5] = {
+    STBI__F_none, STBI__F_sub, STBI__F_none, STBI__F_avg_first,
+    STBI__F_sub  // Paeth with b=c=0 turns out to be equivalent to sub
+};
+
+static int stbi__paeth(int a, int b, int c) {
+    // This formulation looks very different from the reference in the PNG spec, but is
+    // actually equivalent and has favorable data dependencies and admits straightforward
+    // generation of branch-free code, which helps performance significantly.
+    int thresh = c * 3 - (a + b);
+    int lo     = a < b ? a : b;
+    int hi     = a < b ? b : a;
+    int t0     = (hi <= thresh) ? lo : c;
+    int t1     = (thresh <= lo) ? hi : t0;
+    return t1;
+}
+
+static const stbi_uc stbi__depth_scale_table[9] = {0, 0xff, 0x55, 0, 0x11, 0, 0, 0, 0x01};
+
+// adds an extra all-255 alpha channel
+// dest == src is legal
+// img_n must be 1 or 3
+static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) {
+    int i;
+    // must process data backwards since we allow dest==src
+    if (img_n == 1) {
+        for (i = x - 1; i >= 0; --i) {
+            dest[i * 2 + 1] = 255;
+            dest[i * 2 + 0] = src[i];
+        }
+    } else {
+        STBI_ASSERT(img_n == 3);
+        for (i = x - 1; i >= 0; --i) {
+            dest[i * 4 + 3] = 255;
+            dest[i * 4 + 2] = src[i * 3 + 2];
+            dest[i * 4 + 1] = src[i * 3 + 1];
+            dest[i * 4 + 0] = src[i * 3 + 0];
+        }
+    }
+}
+
+// create the png data from post-deflated data
+static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n,
+                                      stbi__uint32 x, stbi__uint32 y, int depth, int color) {
+    int bytes        = (depth == 16 ? 2 : 1);
+    stbi__context *s = a->s;
+    stbi__uint32 i, j, stride = x * out_n * bytes;
+    stbi__uint32 img_len, img_width_bytes;
+    stbi_uc *filter_buf;
+    int all_ok = 1;
+    int k;
+    int img_n = s->img_n;  // copy it into a local for later
+
+    int output_bytes = out_n * bytes;
+    int filter_bytes = img_n * bytes;
+    int width        = x;
+
+    STBI_ASSERT(out_n == s->img_n || out_n == s->img_n + 1);
+    a->out = (stbi_uc *)stbi__malloc_mad3(x, y, output_bytes,
+                                          0);  // extra bytes to write off the end into
+    if (!a->out)
+        return stbi__err("outofmem", "Out of memory");
+
+    // note: error exits here don't need to clean up a->out individually,
+    // stbi__do_png always does on error.
+    if (!stbi__mad3sizes_valid(img_n, x, depth, 7))
+        return stbi__err("too large", "Corrupt PNG");
+    img_width_bytes = (((img_n * x * depth) + 7) >> 3);
+    if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes))
+        return stbi__err("too large", "Corrupt PNG");
+    img_len = (img_width_bytes + 1) * y;
+
+    // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
+    // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
+    // so just check for raw_len < img_len always.
+    if (raw_len < img_len)
+        return stbi__err("not enough pixels", "Corrupt PNG");
+
+    // Allocate two scan lines worth of filter workspace buffer.
+    filter_buf = (stbi_uc *)stbi__malloc_mad2(img_width_bytes, 2, 0);
+    if (!filter_buf)
+        return stbi__err("outofmem", "Out of memory");
+
+    // Filtering for low-bit-depth images
+    if (depth < 8) {
+        filter_bytes = 1;
+        width        = img_width_bytes;
+    }
+
+    for (j = 0; j < y; ++j) {
+        // cur/prior filter buffers alternate
+        stbi_uc *cur   = filter_buf + (j & 1) * img_width_bytes;
+        stbi_uc *prior = filter_buf + (~j & 1) * img_width_bytes;
+        stbi_uc *dest  = a->out + stride * j;
+        int nk         = width * filter_bytes;
+        int filter     = *raw++;
+
+        // check filter type
+        if (filter > 4) {
+            all_ok = stbi__err("invalid filter", "Corrupt PNG");
+            break;
+        }
+
+        // if first row, use special filter that doesn't sample previous row
+        if (j == 0)
+            filter = first_row_filter[filter];
+
+        // perform actual filtering
+        switch (filter) {
+        case STBI__F_none:
+            memcpy(cur, raw, nk);
+            break;
+        case STBI__F_sub:
+            memcpy(cur, raw, filter_bytes);
+            for (k = filter_bytes; k < nk; ++k)
+                cur[k] = STBI__BYTECAST(raw[k] + cur[k - filter_bytes]);
+            break;
+        case STBI__F_up:
+            for (k = 0; k < nk; ++k)
+                cur[k] = STBI__BYTECAST(raw[k] + prior[k]);
+            break;
+        case STBI__F_avg:
+            for (k = 0; k < filter_bytes; ++k)
+                cur[k] = STBI__BYTECAST(raw[k] + (prior[k] >> 1));
+            for (k = filter_bytes; k < nk; ++k)
+                cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k - filter_bytes]) >> 1));
+            break;
+        case STBI__F_paeth:
+            for (k = 0; k < filter_bytes; ++k)
+                cur[k] =
+                    STBI__BYTECAST(raw[k] + prior[k]);  // prior[k] == stbi__paeth(0,prior[k],0)
+            for (k = filter_bytes; k < nk; ++k)
+                cur[k] = STBI__BYTECAST(
+                    raw[k] + stbi__paeth(cur[k - filter_bytes], prior[k], prior[k - filter_bytes]));
+            break;
+        case STBI__F_avg_first:
+            memcpy(cur, raw, filter_bytes);
+            for (k = filter_bytes; k < nk; ++k)
+                cur[k] = STBI__BYTECAST(raw[k] + (cur[k - filter_bytes] >> 1));
+            break;
+        }
+
+        raw += nk;
+
+        // expand decoded bits in cur to dest, also adding an extra alpha channel if desired
+        if (depth < 8) {
+            stbi_uc scale     = (color == 0) ? stbi__depth_scale_table[depth]
+                                             : 1;  // scale grayscale values to 0..255 range
+            stbi_uc *in       = cur;
+            stbi_uc *out      = dest;
+            stbi_uc inb       = 0;
+            stbi__uint32 nsmp = x * img_n;
+
+            // expand bits to bytes first
+            if (depth == 4) {
+                for (i = 0; i < nsmp; ++i) {
+                    if ((i & 1) == 0)
+                        inb = *in++;
+                    *out++ = scale * (inb >> 4);
+                    inb <<= 4;
+                }
+            } else if (depth == 2) {
+                for (i = 0; i < nsmp; ++i) {
+                    if ((i & 3) == 0)
+                        inb = *in++;
+                    *out++ = scale * (inb >> 6);
+                    inb <<= 2;
+                }
+            } else {
+                STBI_ASSERT(depth == 1);
+                for (i = 0; i < nsmp; ++i) {
+                    if ((i & 7) == 0)
+                        inb = *in++;
+                    *out++ = scale * (inb >> 7);
+                    inb <<= 1;
+                }
+            }
+
+            // insert alpha=255 values if desired
+            if (img_n != out_n)
+                stbi__create_png_alpha_expand8(dest, dest, x, img_n);
+        } else if (depth == 8) {
+            if (img_n == out_n)
+                memcpy(dest, cur, x * img_n);
+            else
+                stbi__create_png_alpha_expand8(dest, cur, x, img_n);
+        } else if (depth == 16) {
+            // convert the image data from big-endian to platform-native
+            stbi__uint16 *dest16 = (stbi__uint16 *)dest;
+            stbi__uint32 nsmp    = x * img_n;
+
+            if (img_n == out_n) {
+                for (i = 0; i < nsmp; ++i, ++dest16, cur += 2)
+                    *dest16 = (cur[0] << 8) | cur[1];
+            } else {
+                STBI_ASSERT(img_n + 1 == out_n);
+                if (img_n == 1) {
+                    for (i = 0; i < x; ++i, dest16 += 2, cur += 2) {
+                        dest16[0] = (cur[0] << 8) | cur[1];
+                        dest16[1] = 0xffff;
+                    }
+                } else {
+                    STBI_ASSERT(img_n == 3);
+                    for (i = 0; i < x; ++i, dest16 += 4, cur += 6) {
+                        dest16[0] = (cur[0] << 8) | cur[1];
+                        dest16[1] = (cur[2] << 8) | cur[3];
+                        dest16[2] = (cur[4] << 8) | cur[5];
+                        dest16[3] = 0xffff;
+                    }
+                }
+            }
+        }
+    }
+
+    STBI_FREE(filter_buf);
+    if (!all_ok)
+        return 0;
+
+    return 1;
+}
+
+static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len,
+                                  int out_n, int depth, int color, int interlaced) {
+    int bytes     = (depth == 16 ? 2 : 1);
+    int out_bytes = out_n * bytes;
+    stbi_uc *final;
+    int p;
+    if (!interlaced)
+        return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x,
+                                          a->s->img_y, depth, color);
+
+    // de-interlacing
+    final = (stbi_uc *)stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
+    if (!final)
+        return stbi__err("outofmem", "Out of memory");
+    for (p = 0; p < 7; ++p) {
+        int xorig[] = {0, 4, 0, 2, 0, 1, 0};
+        int yorig[] = {0, 0, 4, 0, 2, 0, 1};
+        int xspc[]  = {8, 8, 4, 4, 2, 2, 1};
+        int yspc[]  = {8, 8, 8, 4, 4, 2, 2};
+        int i, j, x, y;
+        // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
+        x = (a->s->img_x - xorig[p] + xspc[p] - 1) / xspc[p];
+        y = (a->s->img_y - yorig[p] + yspc[p] - 1) / yspc[p];
+        if (x && y) {
+            stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
+            if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth,
+                                            color)) {
+                STBI_FREE(final);
+                return 0;
+            }
+            for (j = 0; j < y; ++j) {
+                for (i = 0; i < x; ++i) {
+                    int out_y = j * yspc[p] + yorig[p];
+                    int out_x = i * xspc[p] + xorig[p];
+                    memcpy(final + out_y * a->s->img_x * out_bytes + out_x * out_bytes,
+                           a->out + (j * x + i) * out_bytes, out_bytes);
+                }
+            }
+            STBI_FREE(a->out);
+            image_data += img_len;
+            image_data_len -= img_len;
+        }
+    }
+    a->out = final;
+
+    return 1;
+}
+
+static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) {
+    stbi__context *s = z->s;
+    stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+    stbi_uc *p = z->out;
+
+    // compute color-based transparency, assuming we've
+    // already got 255 as the alpha value in the output
+    STBI_ASSERT(out_n == 2 || out_n == 4);
+
+    if (out_n == 2) {
+        for (i = 0; i < pixel_count; ++i) {
+            p[1] = (p[0] == tc[0] ? 0 : 255);
+            p += 2;
+        }
+    } else {
+        for (i = 0; i < pixel_count; ++i) {
+            if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+                p[3] = 0;
+            p += 4;
+        }
+    }
+    return 1;
+}
+
+static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) {
+    stbi__context *s = z->s;
+    stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+    stbi__uint16 *p = (stbi__uint16 *)z->out;
+
+    // compute color-based transparency, assuming we've
+    // already got 65535 as the alpha value in the output
+    STBI_ASSERT(out_n == 2 || out_n == 4);
+
+    if (out_n == 2) {
+        for (i = 0; i < pixel_count; ++i) {
+            p[1] = (p[0] == tc[0] ? 0 : 65535);
+            p += 2;
+        }
+    } else {
+        for (i = 0; i < pixel_count; ++i) {
+            if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+                p[3] = 0;
+            p += 4;
+        }
+    }
+    return 1;
+}
+
+static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) {
+    stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+    stbi_uc *p, *temp_out, *orig = a->out;
+
+    p = (stbi_uc *)stbi__malloc_mad2(pixel_count, pal_img_n, 0);
+    if (p == NULL)
+        return stbi__err("outofmem", "Out of memory");
+
+    // between here and free(out) below, exitting would leak
+    temp_out = p;
+
+    if (pal_img_n == 3) {
+        for (i = 0; i < pixel_count; ++i) {
+            int n = orig[i] * 4;
+            p[0]  = palette[n];
+            p[1]  = palette[n + 1];
+            p[2]  = palette[n + 2];
+            p += 3;
+        }
+    } else {
+        for (i = 0; i < pixel_count; ++i) {
+            int n = orig[i] * 4;
+            p[0]  = palette[n];
+            p[1]  = palette[n + 1];
+            p[2]  = palette[n + 2];
+            p[3]  = palette[n + 3];
+            p += 4;
+        }
+    }
+    STBI_FREE(a->out);
+    a->out = temp_out;
+
+    STBI_NOTUSED(len);
+
+    return 1;
+}
+
+static int stbi__unpremultiply_on_load_global = 0;
+static int stbi__de_iphone_flag_global        = 0;
+
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) {
+    stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) {
+    stbi__de_iphone_flag_global = flag_true_if_should_convert;
+}
+
+#ifndef STBI_THREAD_LOCAL
+#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global
+#define stbi__de_iphone_flag        stbi__de_iphone_flag_global
+#else
+static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;
+static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;
+
+STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) {
+    stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
+    stbi__unpremultiply_on_load_set   = 1;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) {
+    stbi__de_iphone_flag_local = flag_true_if_should_convert;
+    stbi__de_iphone_flag_set   = 1;
+}
+
+#define stbi__unpremultiply_on_load                                                                \
+    (stbi__unpremultiply_on_load_set ? stbi__unpremultiply_on_load_local                           \
+                                     : stbi__unpremultiply_on_load_global)
+#define stbi__de_iphone_flag                                                                       \
+    (stbi__de_iphone_flag_set ? stbi__de_iphone_flag_local : stbi__de_iphone_flag_global)
+#endif  // STBI_THREAD_LOCAL
+
+static void stbi__de_iphone(stbi__png *z) {
+    stbi__context *s = z->s;
+    stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+    stbi_uc *p = z->out;
+
+    if (s->img_out_n == 3) {  // convert bgr to rgb
+        for (i = 0; i < pixel_count; ++i) {
+            stbi_uc t = p[0];
+            p[0]      = p[2];
+            p[2]      = t;
+            p += 3;
+        }
+    } else {
+        STBI_ASSERT(s->img_out_n == 4);
+        if (stbi__unpremultiply_on_load) {
+            // convert bgr to rgb and unpremultiply
+            for (i = 0; i < pixel_count; ++i) {
+                stbi_uc a = p[3];
+                stbi_uc t = p[0];
+                if (a) {
+                    stbi_uc half = a / 2;
+                    p[0]         = (p[2] * 255 + half) / a;
+                    p[1]         = (p[1] * 255 + half) / a;
+                    p[2]         = (t * 255 + half) / a;
+                } else {
+                    p[0] = p[2];
+                    p[2] = t;
+                }
+                p += 4;
+            }
+        } else {
+            // convert bgr to rgb
+            for (i = 0; i < pixel_count; ++i) {
+                stbi_uc t = p[0];
+                p[0]      = p[2];
+                p[2]      = t;
+                p += 4;
+            }
+        }
+    }
+}
+
+#define STBI__PNG_TYPE(a, b, c, d)                                                                 \
+    (((unsigned)(a) << 24) + ((unsigned)(b) << 16) + ((unsigned)(c) << 8) + (unsigned)(d))
+
+static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) {
+    stbi_uc palette[1024], pal_img_n = 0;
+    stbi_uc has_trans = 0, tc[3] = {0};
+    stbi__uint16 tc16[3];
+    stbi__uint32 ioff = 0, idata_limit = 0, i, pal_len = 0;
+    int first = 1, k, interlace = 0, color = 0, is_iphone = 0;
+    stbi__context *s = z->s;
+
+    z->expanded = NULL;
+    z->idata    = NULL;
+    z->out      = NULL;
+
+    if (!stbi__check_png_header(s))
+        return 0;
+
+    if (scan == STBI__SCAN_type)
+        return 1;
+
+    for (;;) {
+        stbi__pngchunk c = stbi__get_chunk_header(s);
+        switch (c.type) {
+        case STBI__PNG_TYPE('C', 'g', 'B', 'I'):
+            is_iphone = 1;
+            stbi__skip(s, c.length);
+            break;
+        case STBI__PNG_TYPE('I', 'H', 'D', 'R'): {
+            int comp, filter;
+            if (!first)
+                return stbi__err("multiple IHDR", "Corrupt PNG");
+            first = 0;
+            if (c.length != 13)
+                return stbi__err("bad IHDR len", "Corrupt PNG");
+            s->img_x = stbi__get32be(s);
+            s->img_y = stbi__get32be(s);
+            if (s->img_y > STBI_MAX_DIMENSIONS)
+                return stbi__err("too large", "Very large image (corrupt?)");
+            if (s->img_x > STBI_MAX_DIMENSIONS)
+                return stbi__err("too large", "Very large image (corrupt?)");
+            z->depth = stbi__get8(s);
+            if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)
+                return stbi__err("1/2/4/8/16-bit only", "PNG not supported: 1/2/4/8/16-bit only");
+            color = stbi__get8(s);
+            if (color > 6)
+                return stbi__err("bad ctype", "Corrupt PNG");
+            if (color == 3 && z->depth == 16)
+                return stbi__err("bad ctype", "Corrupt PNG");
+            if (color == 3)
+                pal_img_n = 3;
+            else if (color & 1)
+                return stbi__err("bad ctype", "Corrupt PNG");
+            comp = stbi__get8(s);
+            if (comp)
+                return stbi__err("bad comp method", "Corrupt PNG");
+            filter = stbi__get8(s);
+            if (filter)
+                return stbi__err("bad filter method", "Corrupt PNG");
+            interlace = stbi__get8(s);
+            if (interlace > 1)
+                return stbi__err("bad interlace method", "Corrupt PNG");
+            if (!s->img_x || !s->img_y)
+                return stbi__err("0-pixel image", "Corrupt PNG");
+            if (!pal_img_n) {
+                s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
+                if ((1 << 30) / s->img_x / s->img_n < s->img_y)
+                    return stbi__err("too large", "Image too large to decode");
+            } else {
+                // if paletted, then pal_n is our final components, and
+                // img_n is # components to decompress/filter.
+                s->img_n = 1;
+                if ((1 << 30) / s->img_x / 4 < s->img_y)
+                    return stbi__err("too large", "Corrupt PNG");
+            }
+            // even with SCAN_header, have to scan to see if we have a tRNS
+            break;
+        }
+
+        case STBI__PNG_TYPE('P', 'L', 'T', 'E'): {
+            if (first)
+                return stbi__err("first not IHDR", "Corrupt PNG");
+            if (c.length > 256 * 3)
+                return stbi__err("invalid PLTE", "Corrupt PNG");
+            pal_len = c.length / 3;
+            if (pal_len * 3 != c.length)
+                return stbi__err("invalid PLTE", "Corrupt PNG");
+            for (i = 0; i < pal_len; ++i) {
+                palette[i * 4 + 0] = stbi__get8(s);
+                palette[i * 4 + 1] = stbi__get8(s);
+                palette[i * 4 + 2] = stbi__get8(s);
+                palette[i * 4 + 3] = 255;
+            }
+            break;
+        }
+
+        case STBI__PNG_TYPE('t', 'R', 'N', 'S'): {
+            if (first)
+                return stbi__err("first not IHDR", "Corrupt PNG");
+            if (z->idata)
+                return stbi__err("tRNS after IDAT", "Corrupt PNG");
+            if (pal_img_n) {
+                if (scan == STBI__SCAN_header) {
+                    s->img_n = 4;
+                    return 1;
+                }
+                if (pal_len == 0)
+                    return stbi__err("tRNS before PLTE", "Corrupt PNG");
+                if (c.length > pal_len)
+                    return stbi__err("bad tRNS len", "Corrupt PNG");
+                pal_img_n = 4;
+                for (i = 0; i < c.length; ++i)
+                    palette[i * 4 + 3] = stbi__get8(s);
+            } else {
+                if (!(s->img_n & 1))
+                    return stbi__err("tRNS with alpha", "Corrupt PNG");
+                if (c.length != (stbi__uint32)s->img_n * 2)
+                    return stbi__err("bad tRNS len", "Corrupt PNG");
+                has_trans = 1;
+                // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.
+                if (scan == STBI__SCAN_header) {
+                    ++s->img_n;
+                    return 1;
+                }
+                if (z->depth == 16) {
+                    for (k = 0; k < s->img_n && k < 3;
+                         ++k)  // extra loop test to suppress false GCC warning
+                        tc16[k] = (stbi__uint16)stbi__get16be(s);  // copy the values as-is
+                } else {
+                    for (k = 0; k < s->img_n && k < 3; ++k)
+                        tc[k] =
+                            (stbi_uc)(stbi__get16be(s) & 255) *
+                            stbi__depth_scale_table[z->depth];  // non 8-bit images will be larger
+                }
+            }
+            break;
+        }
+
+        case STBI__PNG_TYPE('I', 'D', 'A', 'T'): {
+            if (first)
+                return stbi__err("first not IHDR", "Corrupt PNG");
+            if (pal_img_n && !pal_len)
+                return stbi__err("no PLTE", "Corrupt PNG");
+            if (scan == STBI__SCAN_header) {
+                // header scan definitely stops at first IDAT
+                if (pal_img_n)
+                    s->img_n = pal_img_n;
+                return 1;
+            }
+            if (c.length > (1u << 30))
+                return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes");
+            if ((int)(ioff + c.length) < (int)ioff)
+                return 0;
+            if (ioff + c.length > idata_limit) {
+                stbi__uint32 idata_limit_old = idata_limit;
+                stbi_uc *p;
+                if (idata_limit == 0)
+                    idata_limit = c.length > 4096 ? c.length : 4096;
+                while (ioff + c.length > idata_limit)
+                    idata_limit *= 2;
+                STBI_NOTUSED(idata_limit_old);
+                p = (stbi_uc *)STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit);
+                if (p == NULL)
+                    return stbi__err("outofmem", "Out of memory");
+                z->idata = p;
+            }
+            if (!stbi__getn(s, z->idata + ioff, c.length))
+                return stbi__err("outofdata", "Corrupt PNG");
+            ioff += c.length;
+            break;
+        }
+
+        case STBI__PNG_TYPE('I', 'E', 'N', 'D'): {
+            stbi__uint32 raw_len, bpl;
+            if (first)
+                return stbi__err("first not IHDR", "Corrupt PNG");
+            if (scan != STBI__SCAN_load)
+                return 1;
+            if (z->idata == NULL)
+                return stbi__err("no IDAT", "Corrupt PNG");
+            // initial guess for decoded data size to avoid unnecessary reallocs
+            bpl     = (s->img_x * z->depth + 7) / 8;  // bytes per line, per component
+            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
+            z->expanded = (stbi_uc *)stbi_zlib_decode_malloc_guesssize_headerflag(
+                (char *)z->idata, ioff, raw_len, (int *)&raw_len, !is_iphone);
+            if (z->expanded == NULL)
+                return 0;  // zlib should set error
+            STBI_FREE(z->idata);
+            z->idata = NULL;
+            if ((req_comp == s->img_n + 1 && req_comp != 3 && !pal_img_n) || has_trans)
+                s->img_out_n = s->img_n + 1;
+            else
+                s->img_out_n = s->img_n;
+            if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color,
+                                        interlace))
+                return 0;
+            if (has_trans) {
+                if (z->depth == 16) {
+                    if (!stbi__compute_transparency16(z, tc16, s->img_out_n))
+                        return 0;
+                } else {
+                    if (!stbi__compute_transparency(z, tc, s->img_out_n))
+                        return 0;
+                }
+            }
+            if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
+                stbi__de_iphone(z);
+            if (pal_img_n) {
+                // pal_img_n == 3 or 4
+                s->img_n     = pal_img_n;  // record the actual colors we had
+                s->img_out_n = pal_img_n;
+                if (req_comp >= 3)
+                    s->img_out_n = req_comp;
+                if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
+                    return 0;
+            } else if (has_trans) {
+                // non-paletted image with tRNS -> source image has (constant) alpha
+                ++s->img_n;
+            }
+            STBI_FREE(z->expanded);
+            z->expanded = NULL;
+            // end of PNG chunk, read and skip CRC
+            stbi__get32be(s);
+            return 1;
+        }
+
+        default:
+            // if critical, fail
+            if (first)
+                return stbi__err("first not IHDR", "Corrupt PNG");
+            if ((c.type & (1 << 29)) == 0) {
+#ifndef STBI_NO_FAILURE_STRINGS
+                // not threadsafe
+                static char invalid_chunk[] = "XXXX PNG chunk not known";
+                invalid_chunk[0]            = STBI__BYTECAST(c.type >> 24);
+                invalid_chunk[1]            = STBI__BYTECAST(c.type >> 16);
+                invalid_chunk[2]            = STBI__BYTECAST(c.type >> 8);
+                invalid_chunk[3]            = STBI__BYTECAST(c.type >> 0);
+#endif
+                return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
+            }
+            stbi__skip(s, c.length);
+            break;
+        }
+        // end of PNG chunk, read and skip CRC
+        stbi__get32be(s);
+    }
+}
+
+static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp,
+                          stbi__result_info *ri) {
+    void *result = NULL;
+    if (req_comp < 0 || req_comp > 4)
+        return stbi__errpuc("bad req_comp", "Internal error");
+    if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
+        if (p->depth <= 8)
+            ri->bits_per_channel = 8;
+        else if (p->depth == 16)
+            ri->bits_per_channel = 16;
+        else
+            return stbi__errpuc("bad bits_per_channel",
+                                "PNG not supported: unsupported color depth");
+        result = p->out;
+        p->out = NULL;
+        if (req_comp && req_comp != p->s->img_out_n) {
+            if (ri->bits_per_channel == 8)
+                result = stbi__convert_format((unsigned char *)result, p->s->img_out_n, req_comp,
+                                              p->s->img_x, p->s->img_y);
+            else
+                result = stbi__convert_format16((stbi__uint16 *)result, p->s->img_out_n, req_comp,
+                                                p->s->img_x, p->s->img_y);
+            p->s->img_out_n = req_comp;
+            if (result == NULL)
+                return result;
+        }
+        *x = p->s->img_x;
+        *y = p->s->img_y;
+        if (n)
+            *n = p->s->img_n;
+    }
+    STBI_FREE(p->out);
+    p->out = NULL;
+    STBI_FREE(p->expanded);
+    p->expanded = NULL;
+    STBI_FREE(p->idata);
+    p->idata = NULL;
+
+    return result;
+}
+
+static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri) {
+    stbi__png p;
+    p.s = s;
+    return stbi__do_png(&p, x, y, comp, req_comp, ri);
+}
+
+static int stbi__png_test(stbi__context *s) {
+    int r;
+    r = stbi__check_png_header(s);
+    stbi__rewind(s);
+    return r;
+}
+
+static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) {
+    if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
+        stbi__rewind(p->s);
+        return 0;
+    }
+    if (x)
+        *x = p->s->img_x;
+    if (y)
+        *y = p->s->img_y;
+    if (comp)
+        *comp = p->s->img_n;
+    return 1;
+}
+
+static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) {
+    stbi__png p;
+    p.s = s;
+    return stbi__png_info_raw(&p, x, y, comp);
+}
+
+static int stbi__png_is16(stbi__context *s) {
+    stbi__png p;
+    p.s = s;
+    if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
+        return 0;
+    if (p.depth != 16) {
+        stbi__rewind(p.s);
+        return 0;
+    }
+    return 1;
+}
+#endif
+
+// Microsoft/Windows BMP image
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_test_raw(stbi__context *s) {
+    int r;
+    int sz;
+    if (stbi__get8(s) != 'B')
+        return 0;
+    if (stbi__get8(s) != 'M')
+        return 0;
+    stbi__get32le(s);  // discard filesize
+    stbi__get16le(s);  // discard reserved
+    stbi__get16le(s);  // discard reserved
+    stbi__get32le(s);  // discard data offset
+    sz = stbi__get32le(s);
+    r  = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
+    return r;
+}
+
+static int stbi__bmp_test(stbi__context *s) {
+    int r = stbi__bmp_test_raw(s);
+    stbi__rewind(s);
+    return r;
+}
+
+// returns 0..31 for the highest set bit
+static int stbi__high_bit(unsigned int z) {
+    int n = 0;
+    if (z == 0)
+        return -1;
+    if (z >= 0x10000) {
+        n += 16;
+        z >>= 16;
+    }
+    if (z >= 0x00100) {
+        n += 8;
+        z >>= 8;
+    }
+    if (z >= 0x00010) {
+        n += 4;
+        z >>= 4;
+    }
+    if (z >= 0x00004) {
+        n += 2;
+        z >>= 2;
+    }
+    if (z >= 0x00002) {
+        n += 1; /* >>=  1;*/
+    }
+    return n;
+}
+
+static int stbi__bitcount(unsigned int a) {
+    a = (a & 0x55555555) + ((a >> 1) & 0x55555555);  // max 2
+    a = (a & 0x33333333) + ((a >> 2) & 0x33333333);  // max 4
+    a = (a + (a >> 4)) & 0x0f0f0f0f;                 // max 8 per 4, now 8 bits
+    a = (a + (a >> 8));                              // max 16 per 8 bits
+    a = (a + (a >> 16));                             // max 32 per 8 bits
+    return a & 0xff;
+}
+
+// extract an arbitrarily-aligned N-bit value (N=bits)
+// from v, and then make it 8-bits long and fractionally
+// extend it to full full range.
+static int stbi__shiftsigned(unsigned int v, int shift, int bits) {
+    static unsigned int mul_table[9] = {
+        0,
+        0xff /*0b11111111*/,
+        0x55 /*0b01010101*/,
+        0x49 /*0b01001001*/,
+        0x11 /*0b00010001*/,
+        0x21 /*0b00100001*/,
+        0x41 /*0b01000001*/,
+        0x81 /*0b10000001*/,
+        0x01 /*0b00000001*/,
+    };
+    static unsigned int shift_table[9] = {
+        0, 0, 0, 1, 0, 2, 4, 6, 0,
+    };
+    if (shift < 0)
+        v <<= -shift;
+    else
+        v >>= shift;
+    STBI_ASSERT(v < 256);
+    v >>= (8 - bits);
+    STBI_ASSERT(bits >= 0 && bits <= 8);
+    return (int)((unsigned)v * mul_table[bits]) >> shift_table[bits];
+}
+
+typedef struct {
+    int bpp, offset, hsz;
+    unsigned int mr, mg, mb, ma, all_a;
+    int extra_read;
+} stbi__bmp_data;
+
+static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) {
+    // BI_BITFIELDS specifies masks explicitly, don't override
+    if (compress == 3)
+        return 1;
+
+    if (compress == 0) {
+        if (info->bpp == 16) {
+            info->mr = 31u << 10;
+            info->mg = 31u << 5;
+            info->mb = 31u << 0;
+        } else if (info->bpp == 32) {
+            info->mr    = 0xffu << 16;
+            info->mg    = 0xffu << 8;
+            info->mb    = 0xffu << 0;
+            info->ma    = 0xffu << 24;
+            info->all_a = 0;  // if all_a is 0 at end, then we loaded alpha channel but it was all 0
+        } else {
+            // otherwise, use defaults, which is all-0
+            info->mr = info->mg = info->mb = info->ma = 0;
+        }
+        return 1;
+    }
+    return 0;  // error
+}
+
+static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) {
+    int hsz;
+    if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M')
+        return stbi__errpuc("not BMP", "Corrupt BMP");
+    stbi__get32le(s);  // discard filesize
+    stbi__get16le(s);  // discard reserved
+    stbi__get16le(s);  // discard reserved
+    info->offset = stbi__get32le(s);
+    info->hsz = hsz = stbi__get32le(s);
+    info->mr = info->mg = info->mb = info->ma = 0;
+    info->extra_read                          = 14;
+
+    if (info->offset < 0)
+        return stbi__errpuc("bad BMP", "bad BMP");
+
+    if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124)
+        return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
+    if (hsz == 12) {
+        s->img_x = stbi__get16le(s);
+        s->img_y = stbi__get16le(s);
+    } else {
+        s->img_x = stbi__get32le(s);
+        s->img_y = stbi__get32le(s);
+    }
+    if (stbi__get16le(s) != 1)
+        return stbi__errpuc("bad BMP", "bad BMP");
+    info->bpp = stbi__get16le(s);
+    if (hsz != 12) {
+        int compress = stbi__get32le(s);
+        if (compress == 1 || compress == 2)
+            return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
+        if (compress >= 4)
+            return stbi__errpuc(
+                "BMP JPEG/PNG",
+                "BMP type not supported: unsupported compression");  // this includes PNG/JPEG modes
+        if (compress == 3 && info->bpp != 16 && info->bpp != 32)
+            return stbi__errpuc("bad BMP", "bad BMP");  // bitfields requires 16 or 32 bits/pixel
+        stbi__get32le(s);                               // discard sizeof
+        stbi__get32le(s);                               // discard hres
+        stbi__get32le(s);                               // discard vres
+        stbi__get32le(s);                               // discard colorsused
+        stbi__get32le(s);                               // discard max important
+        if (hsz == 40 || hsz == 56) {
+            if (hsz == 56) {
+                stbi__get32le(s);
+                stbi__get32le(s);
+                stbi__get32le(s);
+                stbi__get32le(s);
+            }
+            if (info->bpp == 16 || info->bpp == 32) {
+                if (compress == 0) {
+                    stbi__bmp_set_mask_defaults(info, compress);
+                } else if (compress == 3) {
+                    info->mr = stbi__get32le(s);
+                    info->mg = stbi__get32le(s);
+                    info->mb = stbi__get32le(s);
+                    info->extra_read += 12;
+                    // not documented, but generated by photoshop and handled by mspaint
+                    if (info->mr == info->mg && info->mg == info->mb) {
+                        // ?!?!?
+                        return stbi__errpuc("bad BMP", "bad BMP");
+                    }
+                } else
+                    return stbi__errpuc("bad BMP", "bad BMP");
+            }
+        } else {
+            // V4/V5 header
+            int i;
+            if (hsz != 108 && hsz != 124)
+                return stbi__errpuc("bad BMP", "bad BMP");
+            info->mr = stbi__get32le(s);
+            info->mg = stbi__get32le(s);
+            info->mb = stbi__get32le(s);
+            info->ma = stbi__get32le(s);
+            if (compress != 3)  // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs
+                stbi__bmp_set_mask_defaults(info, compress);
+            stbi__get32le(s);  // discard color space
+            for (i = 0; i < 12; ++i)
+                stbi__get32le(s);  // discard color space parameters
+            if (hsz == 124) {
+                stbi__get32le(s);  // discard rendering intent
+                stbi__get32le(s);  // discard offset of profile data
+                stbi__get32le(s);  // discard size of profile data
+                stbi__get32le(s);  // discard reserved
+            }
+        }
+    }
+    return (void *)1;
+}
+
+static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri) {
+    stbi_uc *out;
+    unsigned int mr = 0, mg = 0, mb = 0, ma = 0, all_a;
+    stbi_uc pal[256][4];
+    int psize = 0, i, j, width;
+    int flip_vertically, pad, target;
+    stbi__bmp_data info;
+    STBI_NOTUSED(ri);
+
+    info.all_a = 255;
+    if (stbi__bmp_parse_header(s, &info) == NULL)
+        return NULL;  // error code already set
+
+    flip_vertically = ((int)s->img_y) > 0;
+    s->img_y        = abs((int)s->img_y);
+
+    if (s->img_y > STBI_MAX_DIMENSIONS)
+        return stbi__errpuc("too large", "Very large image (corrupt?)");
+    if (s->img_x > STBI_MAX_DIMENSIONS)
+        return stbi__errpuc("too large", "Very large image (corrupt?)");
+
+    mr    = info.mr;
+    mg    = info.mg;
+    mb    = info.mb;
+    ma    = info.ma;
+    all_a = info.all_a;
+
+    if (info.hsz == 12) {
+        if (info.bpp < 24)
+            psize = (info.offset - info.extra_read - 24) / 3;
+    } else {
+        if (info.bpp < 16)
+            psize = (info.offset - info.extra_read - info.hsz) >> 2;
+    }
+    if (psize == 0) {
+        // accept some number of extra bytes after the header, but if the offset points either to
+        // before the header ends or implies a large amount of extra data, reject the file as
+        // malformed
+        int bytes_read_so_far =
+            s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);
+        int header_limit = 1024;  // max we actually read is below 256 bytes currently.
+        int extra_data_limit =
+            256 *
+            4;  // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.
+        if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {
+            return stbi__errpuc("bad header", "Corrupt BMP");
+        }
+        // we established that bytes_read_so_far is positive and sensible.
+        // the first half of this test rejects offsets that are either too small positives, or
+        // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn
+        // ensures the number computed in the second half of the test can't overflow.
+        if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {
+            return stbi__errpuc("bad offset", "Corrupt BMP");
+        } else {
+            stbi__skip(s, info.offset - bytes_read_so_far);
+        }
+    }
+
+    if (info.bpp == 24 && ma == 0xff000000)
+        s->img_n = 3;
+    else
+        s->img_n = ma ? 4 : 3;
+    if (req_comp && req_comp >= 3)  // we can directly decode 3 or 4
+        target = req_comp;
+    else
+        target = s->img_n;  // if they want monochrome, we'll post-convert
+
+    // sanity-check size
+    if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
+        return stbi__errpuc("too large", "Corrupt BMP");
+
+    out = (stbi_uc *)stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
+    if (!out)
+        return stbi__errpuc("outofmem", "Out of memory");
+    if (info.bpp < 16) {
+        int z = 0;
+        if (psize == 0 || psize > 256) {
+            STBI_FREE(out);
+            return stbi__errpuc("invalid", "Corrupt BMP");
+        }
+        for (i = 0; i < psize; ++i) {
+            pal[i][2] = stbi__get8(s);
+            pal[i][1] = stbi__get8(s);
+            pal[i][0] = stbi__get8(s);
+            if (info.hsz != 12)
+                stbi__get8(s);
+            pal[i][3] = 255;
+        }
+        stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
+        if (info.bpp == 1)
+            width = (s->img_x + 7) >> 3;
+        else if (info.bpp == 4)
+            width = (s->img_x + 1) >> 1;
+        else if (info.bpp == 8)
+            width = s->img_x;
+        else {
+            STBI_FREE(out);
+            return stbi__errpuc("bad bpp", "Corrupt BMP");
+        }
+        pad = (-width) & 3;
+        if (info.bpp == 1) {
+            for (j = 0; j < (int)s->img_y; ++j) {
+                int bit_offset = 7, v = stbi__get8(s);
+                for (i = 0; i < (int)s->img_x; ++i) {
+                    int color = (v >> bit_offset) & 0x1;
+                    out[z++]  = pal[color][0];
+                    out[z++]  = pal[color][1];
+                    out[z++]  = pal[color][2];
+                    if (target == 4)
+                        out[z++] = 255;
+                    if (i + 1 == (int)s->img_x)
+                        break;
+                    if ((--bit_offset) < 0) {
+                        bit_offset = 7;
+                        v          = stbi__get8(s);
+                    }
+                }
+                stbi__skip(s, pad);
+            }
+        } else {
+            for (j = 0; j < (int)s->img_y; ++j) {
+                for (i = 0; i < (int)s->img_x; i += 2) {
+                    int v = stbi__get8(s), v2 = 0;
+                    if (info.bpp == 4) {
+                        v2 = v & 15;
+                        v >>= 4;
+                    }
+                    out[z++] = pal[v][0];
+                    out[z++] = pal[v][1];
+                    out[z++] = pal[v][2];
+                    if (target == 4)
+                        out[z++] = 255;
+                    if (i + 1 == (int)s->img_x)
+                        break;
+                    v        = (info.bpp == 8) ? stbi__get8(s) : v2;
+                    out[z++] = pal[v][0];
+                    out[z++] = pal[v][1];
+                    out[z++] = pal[v][2];
+                    if (target == 4)
+                        out[z++] = 255;
+                }
+                stbi__skip(s, pad);
+            }
+        }
+    } else {
+        int rshift = 0, gshift = 0, bshift = 0, ashift = 0, rcount = 0, gcount = 0, bcount = 0,
+            acount = 0;
+        int z      = 0;
+        int easy   = 0;
+        stbi__skip(s, info.offset - info.extra_read - info.hsz);
+        if (info.bpp == 24)
+            width = 3 * s->img_x;
+        else if (info.bpp == 16)
+            width = 2 * s->img_x;
+        else /* bpp = 32 and pad = 0 */
+            width = 0;
+        pad = (-width) & 3;
+        if (info.bpp == 24) {
+            easy = 1;
+        } else if (info.bpp == 32) {
+            if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+                easy = 2;
+        }
+        if (!easy) {
+            if (!mr || !mg || !mb) {
+                STBI_FREE(out);
+                return stbi__errpuc("bad masks", "Corrupt BMP");
+            }
+            // right shift amt to put high bit in position #7
+            rshift = stbi__high_bit(mr) - 7;
+            rcount = stbi__bitcount(mr);
+            gshift = stbi__high_bit(mg) - 7;
+            gcount = stbi__bitcount(mg);
+            bshift = stbi__high_bit(mb) - 7;
+            bcount = stbi__bitcount(mb);
+            ashift = stbi__high_bit(ma) - 7;
+            acount = stbi__bitcount(ma);
+            if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) {
+                STBI_FREE(out);
+                return stbi__errpuc("bad masks", "Corrupt BMP");
+            }
+        }
+        for (j = 0; j < (int)s->img_y; ++j) {
+            if (easy) {
+                for (i = 0; i < (int)s->img_x; ++i) {
+                    unsigned char a;
+                    out[z + 2] = stbi__get8(s);
+                    out[z + 1] = stbi__get8(s);
+                    out[z + 0] = stbi__get8(s);
+                    z += 3;
+                    a = (easy == 2 ? stbi__get8(s) : 255);
+                    all_a |= a;
+                    if (target == 4)
+                        out[z++] = a;
+                }
+            } else {
+                int bpp = info.bpp;
+                for (i = 0; i < (int)s->img_x; ++i) {
+                    stbi__uint32 v =
+                        (bpp == 16 ? (stbi__uint32)stbi__get16le(s) : stbi__get32le(s));
+                    unsigned int a;
+                    out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
+                    out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
+                    out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
+                    a        = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
+                    all_a |= a;
+                    if (target == 4)
+                        out[z++] = STBI__BYTECAST(a);
+                }
+            }
+            stbi__skip(s, pad);
+        }
+    }
+
+    // if alpha channel is all 0s, replace with all 255s
+    if (target == 4 && all_a == 0)
+        for (i = 4 * s->img_x * s->img_y - 1; i >= 0; i -= 4)
+            out[i] = 255;
+
+    if (flip_vertically) {
+        stbi_uc t;
+        for (j = 0; j < (int)s->img_y >> 1; ++j) {
+            stbi_uc *p1 = out + j * s->img_x * target;
+            stbi_uc *p2 = out + (s->img_y - 1 - j) * s->img_x * target;
+            for (i = 0; i < (int)s->img_x * target; ++i) {
+                t     = p1[i];
+                p1[i] = p2[i];
+                p2[i] = t;
+            }
+        }
+    }
+
+    if (req_comp && req_comp != target) {
+        out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
+        if (out == NULL)
+            return out;  // stbi__convert_format frees input on failure
+    }
+
+    *x = s->img_x;
+    *y = s->img_y;
+    if (comp)
+        *comp = s->img_n;
+    return out;
+}
+#endif
+
+// Targa Truevision - TGA
+// by Jonathan Dummer
+#ifndef STBI_NO_TGA
+// returns STBI_rgb or whatever, 0 on error
+static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int *is_rgb16) {
+    // only RGB or RGBA (incl. 16bit) or grey allowed
+    if (is_rgb16)
+        *is_rgb16 = 0;
+    switch (bits_per_pixel) {
+    case 8:
+        return STBI_grey;
+    case 16:
+        if (is_grey)
+            return STBI_grey_alpha;
+        // fallthrough
+    case 15:
+        if (is_rgb16)
+            *is_rgb16 = 1;
+        return STBI_rgb;
+    case 24:  // fallthrough
+    case 32:
+        return bits_per_pixel / 8;
+    default:
+        return 0;
+    }
+}
+
+static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) {
+    int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
+    int sz, tga_colormap_type;
+    stbi__get8(s);                      // discard Offset
+    tga_colormap_type = stbi__get8(s);  // colormap type
+    if (tga_colormap_type > 1) {
+        stbi__rewind(s);
+        return 0;  // only RGB or indexed allowed
+    }
+    tga_image_type = stbi__get8(s);  // image type
+    if (tga_colormap_type == 1) {    // colormapped (paletted) image
+        if (tga_image_type != 1 && tga_image_type != 9) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s, 4);    // skip index of first colormap entry and number of entries
+        sz = stbi__get8(s);  //   check bits per palette color entry
+        if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32)) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s, 4);  // skip image x and y origin
+        tga_colormap_bpp = sz;
+    } else {  // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
+        if ((tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) &&
+            (tga_image_type != 11)) {
+            stbi__rewind(s);
+            return 0;  // only RGB or grey allowed, +/- RLE
+        }
+        stbi__skip(s, 9);  // skip colormap specification and image x/y origin
+        tga_colormap_bpp = 0;
+    }
+    tga_w = stbi__get16le(s);
+    if (tga_w < 1) {
+        stbi__rewind(s);
+        return 0;  // test width
+    }
+    tga_h = stbi__get16le(s);
+    if (tga_h < 1) {
+        stbi__rewind(s);
+        return 0;  // test height
+    }
+    tga_bits_per_pixel = stbi__get8(s);  // bits per pixel
+    stbi__get8(s);                       // ignore alpha bits
+    if (tga_colormap_bpp != 0) {
+        if ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
+            // when using a colormap, tga_bits_per_pixel is the size of the indexes
+            // I don't think anything but 8 or 16bit indexes makes sense
+            stbi__rewind(s);
+            return 0;
+        }
+        tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
+    } else {
+        tga_comp = stbi__tga_get_comp(tga_bits_per_pixel,
+                                      (tga_image_type == 3) || (tga_image_type == 11), NULL);
+    }
+    if (!tga_comp) {
+        stbi__rewind(s);
+        return 0;
+    }
+    if (x)
+        *x = tga_w;
+    if (y)
+        *y = tga_h;
+    if (comp)
+        *comp = tga_comp;
+    return 1;  // seems to have passed everything
+}
+
+static int stbi__tga_test(stbi__context *s) {
+    int res = 0;
+    int sz, tga_color_type;
+    stbi__get8(s);                   //   discard Offset
+    tga_color_type = stbi__get8(s);  //   color type
+    if (tga_color_type > 1)
+        goto errorEnd;          //   only RGB or indexed allowed
+    sz = stbi__get8(s);         //   image type
+    if (tga_color_type == 1) {  // colormapped (paletted) image
+        if (sz != 1 && sz != 9)
+            goto errorEnd;   // colortype 1 demands image type 1 or 9
+        stbi__skip(s, 4);    // skip index of first colormap entry and number of entries
+        sz = stbi__get8(s);  //   check bits per palette color entry
+        if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32))
+            goto errorEnd;
+        stbi__skip(s, 4);  // skip image x and y origin
+    } else {               // "normal" image w/o colormap
+        if ((sz != 2) && (sz != 3) && (sz != 10) && (sz != 11))
+            goto errorEnd;  // only RGB or grey allowed, +/- RLE
+        stbi__skip(s, 9);   // skip colormap specification and image x/y origin
+    }
+    if (stbi__get16le(s) < 1)
+        goto errorEnd;  //   test width
+    if (stbi__get16le(s) < 1)
+        goto errorEnd;   //   test height
+    sz = stbi__get8(s);  //   bits per pixel
+    if ((tga_color_type == 1) && (sz != 8) && (sz != 16))
+        goto errorEnd;  // for colormapped images, bpp is size of an index
+    if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32))
+        goto errorEnd;
+
+    res = 1;  // if we got this far, everything's good and we can return 1 instead of 0
+
+errorEnd:
+    stbi__rewind(s);
+    return res;
+}
+
+// read 16bit value and convert to 24bit RGB
+static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc *out) {
+    stbi__uint16 px          = (stbi__uint16)stbi__get16le(s);
+    stbi__uint16 fiveBitMask = 31;
+    // we have 3 channels with 5bits each
+    int r = (px >> 10) & fiveBitMask;
+    int g = (px >> 5) & fiveBitMask;
+    int b = px & fiveBitMask;
+    // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
+    out[0] = (stbi_uc)((r * 255) / 31);
+    out[1] = (stbi_uc)((g * 255) / 31);
+    out[2] = (stbi_uc)((b * 255) / 31);
+
+    // some people claim that the most significant bit might be used for alpha
+    // (possibly if an alpha-bit is set in the "image descriptor byte")
+    // but that only made 16bit test images completely translucent..
+    // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
+}
+
+static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri) {
+    //   read in the TGA header stuff
+    int tga_offset         = stbi__get8(s);
+    int tga_indexed        = stbi__get8(s);
+    int tga_image_type     = stbi__get8(s);
+    int tga_is_RLE         = 0;
+    int tga_palette_start  = stbi__get16le(s);
+    int tga_palette_len    = stbi__get16le(s);
+    int tga_palette_bits   = stbi__get8(s);
+    int tga_x_origin       = stbi__get16le(s);
+    int tga_y_origin       = stbi__get16le(s);
+    int tga_width          = stbi__get16le(s);
+    int tga_height         = stbi__get16le(s);
+    int tga_bits_per_pixel = stbi__get8(s);
+    int tga_comp, tga_rgb16 = 0;
+    int tga_inverted = stbi__get8(s);
+    // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
+    //   image data
+    unsigned char *tga_data;
+    unsigned char *tga_palette = NULL;
+    int i, j;
+    unsigned char raw_data[4] = {0};
+    int RLE_count             = 0;
+    int RLE_repeating         = 0;
+    int read_next_pixel       = 1;
+    STBI_NOTUSED(ri);
+    STBI_NOTUSED(tga_x_origin);  // @TODO
+    STBI_NOTUSED(tga_y_origin);  // @TODO
+
+    if (tga_height > STBI_MAX_DIMENSIONS)
+        return stbi__errpuc("too large", "Very large image (corrupt?)");
+    if (tga_width > STBI_MAX_DIMENSIONS)
+        return stbi__errpuc("too large", "Very large image (corrupt?)");
+
+    //   do a tiny bit of precessing
+    if (tga_image_type >= 8) {
+        tga_image_type -= 8;
+        tga_is_RLE = 1;
+    }
+    tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+    //   If I'm paletted, then I'll use the number of bits from the palette
+    if (tga_indexed)
+        tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
+    else
+        tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
+
+    if (!tga_comp)  // shouldn't really happen, stbi__tga_test() should have ensured basic
+                    // consistency
+        return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
+
+    //   tga info
+    *x = tga_width;
+    *y = tga_height;
+    if (comp)
+        *comp = tga_comp;
+
+    if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
+        return stbi__errpuc("too large", "Corrupt TGA");
+
+    tga_data = (unsigned char *)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
+    if (!tga_data)
+        return stbi__errpuc("outofmem", "Out of memory");
+
+    // skip to the data's starting position (offset usually = 0)
+    stbi__skip(s, tga_offset);
+
+    if (!tga_indexed && !tga_is_RLE && !tga_rgb16) {
+        for (i = 0; i < tga_height; ++i) {
+            int row          = tga_inverted ? tga_height - i - 1 : i;
+            stbi_uc *tga_row = tga_data + row * tga_width * tga_comp;
+            stbi__getn(s, tga_row, tga_width * tga_comp);
+        }
+    } else {
+        //   do I need to load a palette?
+        if (tga_indexed) {
+            if (tga_palette_len == 0) { /* you have to have at least one entry! */
+                STBI_FREE(tga_data);
+                return stbi__errpuc("bad palette", "Corrupt TGA");
+            }
+
+            //   any data to skip? (offset usually = 0)
+            stbi__skip(s, tga_palette_start);
+            //   load the palette
+            tga_palette = (unsigned char *)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
+            if (!tga_palette) {
+                STBI_FREE(tga_data);
+                return stbi__errpuc("outofmem", "Out of memory");
+            }
+            if (tga_rgb16) {
+                stbi_uc *pal_entry = tga_palette;
+                STBI_ASSERT(tga_comp == STBI_rgb);
+                for (i = 0; i < tga_palette_len; ++i) {
+                    stbi__tga_read_rgb16(s, pal_entry);
+                    pal_entry += tga_comp;
+                }
+            } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
+                STBI_FREE(tga_data);
+                STBI_FREE(tga_palette);
+                return stbi__errpuc("bad palette", "Corrupt TGA");
+            }
+        }
+        //   load the data
+        for (i = 0; i < tga_width * tga_height; ++i) {
+            //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
+            if (tga_is_RLE) {
+                if (RLE_count == 0) {
+                    //   yep, get the next byte as a RLE command
+                    int RLE_cmd     = stbi__get8(s);
+                    RLE_count       = 1 + (RLE_cmd & 127);
+                    RLE_repeating   = RLE_cmd >> 7;
+                    read_next_pixel = 1;
+                } else if (!RLE_repeating) {
+                    read_next_pixel = 1;
+                }
+            } else {
+                read_next_pixel = 1;
+            }
+            //   OK, if I need to read a pixel, do it now
+            if (read_next_pixel) {
+                //   load however much data we did have
+                if (tga_indexed) {
+                    // read in index, then perform the lookup
+                    int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
+                    if (pal_idx >= tga_palette_len) {
+                        // invalid index
+                        pal_idx = 0;
+                    }
+                    pal_idx *= tga_comp;
+                    for (j = 0; j < tga_comp; ++j) {
+                        raw_data[j] = tga_palette[pal_idx + j];
+                    }
+                } else if (tga_rgb16) {
+                    STBI_ASSERT(tga_comp == STBI_rgb);
+                    stbi__tga_read_rgb16(s, raw_data);
+                } else {
+                    //   read in the data raw
+                    for (j = 0; j < tga_comp; ++j) {
+                        raw_data[j] = stbi__get8(s);
+                    }
+                }
+                //   clear the reading flag for the next pixel
+                read_next_pixel = 0;
+            }  // end of reading a pixel
+
+            // copy data
+            for (j = 0; j < tga_comp; ++j)
+                tga_data[i * tga_comp + j] = raw_data[j];
+
+            //   in case we're in RLE mode, keep counting down
+            --RLE_count;
+        }
+        //   do I need to invert the image?
+        if (tga_inverted) {
+            for (j = 0; j * 2 < tga_height; ++j) {
+                int index1 = j * tga_width * tga_comp;
+                int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
+                for (i = tga_width * tga_comp; i > 0; --i) {
+                    unsigned char temp = tga_data[index1];
+                    tga_data[index1]   = tga_data[index2];
+                    tga_data[index2]   = temp;
+                    ++index1;
+                    ++index2;
+                }
+            }
+        }
+        //   clear my palette, if I had one
+        if (tga_palette != NULL) {
+            STBI_FREE(tga_palette);
+        }
+    }
+
+    // swap RGB - if the source data was RGB16, it already is in the right order
+    if (tga_comp >= 3 && !tga_rgb16) {
+        unsigned char *tga_pixel = tga_data;
+        for (i = 0; i < tga_width * tga_height; ++i) {
+            unsigned char temp = tga_pixel[0];
+            tga_pixel[0]       = tga_pixel[2];
+            tga_pixel[2]       = temp;
+            tga_pixel += tga_comp;
+        }
+    }
+
+    // convert to target component count
+    if (req_comp && req_comp != tga_comp)
+        tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
+
+    //   the things I do to get rid of an error message, and yet keep
+    //   Microsoft's C compilers happy... [8^(
+    tga_palette_start = tga_palette_len = tga_palette_bits = tga_x_origin = tga_y_origin = 0;
+    STBI_NOTUSED(tga_palette_start);
+    //   OK, done
+    return tga_data;
+}
+#endif
+
+// *************************************************************************************************
+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_test(stbi__context *s) {
+    int r = (stbi__get32be(s) == 0x38425053);
+    stbi__rewind(s);
+    return r;
+}
+
+static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) {
+    int count, nleft, len;
+
+    count = 0;
+    while ((nleft = pixelCount - count) > 0) {
+        len = stbi__get8(s);
+        if (len == 128) {
+            // No-op.
+        } else if (len < 128) {
+            // Copy next len+1 bytes literally.
+            len++;
+            if (len > nleft)
+                return 0;  // corrupt data
+            count += len;
+            while (len) {
+                *p = stbi__get8(s);
+                p += 4;
+                len--;
+            }
+        } else if (len > 128) {
+            stbi_uc val;
+            // Next -len+1 bytes in the dest are replicated from next source byte.
+            // (Interpret len as a negative 8-bit int.)
+            len = 257 - len;
+            if (len > nleft)
+                return 0;  // corrupt data
+            val = stbi__get8(s);
+            count += len;
+            while (len) {
+                *p = val;
+                p += 4;
+                len--;
+            }
+        }
+    }
+
+    return 1;
+}
+
+static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri, int bpc) {
+    int pixelCount;
+    int channelCount, compression;
+    int channel, i;
+    int bitdepth;
+    int w, h;
+    stbi_uc *out;
+    STBI_NOTUSED(ri);
+
+    // Check identifier
+    if (stbi__get32be(s) != 0x38425053)  // "8BPS"
+        return stbi__errpuc("not PSD", "Corrupt PSD image");
+
+    // Check file type version.
+    if (stbi__get16be(s) != 1)
+        return stbi__errpuc("wrong version", "Unsupported version of PSD image");
+
+    // Skip 6 reserved bytes.
+    stbi__skip(s, 6);
+
+    // Read the number of channels (R, G, B, A, etc).
+    channelCount = stbi__get16be(s);
+    if (channelCount < 0 || channelCount > 16)
+        return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
+
+    // Read the rows and columns of the image.
+    h = stbi__get32be(s);
+    w = stbi__get32be(s);
+
+    if (h > STBI_MAX_DIMENSIONS)
+        return stbi__errpuc("too large", "Very large image (corrupt?)");
+    if (w > STBI_MAX_DIMENSIONS)
+        return stbi__errpuc("too large", "Very large image (corrupt?)");
+
+    // Make sure the depth is 8 bits.
+    bitdepth = stbi__get16be(s);
+    if (bitdepth != 8 && bitdepth != 16)
+        return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
+
+    // Make sure the color mode is RGB.
+    // Valid options are:
+    //   0: Bitmap
+    //   1: Grayscale
+    //   2: Indexed color
+    //   3: RGB color
+    //   4: CMYK color
+    //   7: Multichannel
+    //   8: Duotone
+    //   9: Lab color
+    if (stbi__get16be(s) != 3)
+        return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
+
+    // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)
+    stbi__skip(s, stbi__get32be(s));
+
+    // Skip the image resources.  (resolution, pen tool paths, etc)
+    stbi__skip(s, stbi__get32be(s));
+
+    // Skip the reserved data.
+    stbi__skip(s, stbi__get32be(s));
+
+    // Find out if the data is compressed.
+    // Known values:
+    //   0: no compression
+    //   1: RLE compressed
+    compression = stbi__get16be(s);
+    if (compression > 1)
+        return stbi__errpuc("bad compression", "PSD has an unknown compression format");
+
+    // Check size
+    if (!stbi__mad3sizes_valid(4, w, h, 0))
+        return stbi__errpuc("too large", "Corrupt PSD");
+
+    // Create the destination image.
+
+    if (!compression && bitdepth == 16 && bpc == 16) {
+        out                  = (stbi_uc *)stbi__malloc_mad3(8, w, h, 0);
+        ri->bits_per_channel = 16;
+    } else
+        out = (stbi_uc *)stbi__malloc(4 * w * h);
+
+    if (!out)
+        return stbi__errpuc("outofmem", "Out of memory");
+    pixelCount = w * h;
+
+    // Initialize the data to zero.
+    // memset( out, 0, pixelCount * 4 );
+
+    // Finally, the image data.
+    if (compression) {
+        // RLE as used by .PSD and .TIFF
+        // Loop until you get the number of unpacked bytes you are expecting:
+        //     Read the next source byte into n.
+        //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
+        //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
+        //     Else if n is 128, noop.
+        // Endloop
+
+        // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
+        // which we're going to just skip.
+        stbi__skip(s, h * channelCount * 2);
+
+        // Read the RLE data by channel.
+        for (channel = 0; channel < 4; channel++) {
+            stbi_uc *p;
+
+            p = out + channel;
+            if (channel >= channelCount) {
+                // Fill this channel with default data.
+                for (i = 0; i < pixelCount; i++, p += 4)
+                    *p = (channel == 3 ? 255 : 0);
+            } else {
+                // Read the RLE data.
+                if (!stbi__psd_decode_rle(s, p, pixelCount)) {
+                    STBI_FREE(out);
+                    return stbi__errpuc("corrupt", "bad RLE data");
+                }
+            }
+        }
+
+    } else {
+        // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
+        // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
+
+        // Read the data by channel.
+        for (channel = 0; channel < 4; channel++) {
+            if (channel >= channelCount) {
+                // Fill this channel with default data.
+                if (bitdepth == 16 && bpc == 16) {
+                    stbi__uint16 *q  = ((stbi__uint16 *)out) + channel;
+                    stbi__uint16 val = channel == 3 ? 65535 : 0;
+                    for (i = 0; i < pixelCount; i++, q += 4)
+                        *q = val;
+                } else {
+                    stbi_uc *p  = out + channel;
+                    stbi_uc val = channel == 3 ? 255 : 0;
+                    for (i = 0; i < pixelCount; i++, p += 4)
+                        *p = val;
+                }
+            } else {
+                if (ri->bits_per_channel == 16) {  // output bpc
+                    stbi__uint16 *q = ((stbi__uint16 *)out) + channel;
+                    for (i = 0; i < pixelCount; i++, q += 4)
+                        *q = (stbi__uint16)stbi__get16be(s);
+                } else {
+                    stbi_uc *p = out + channel;
+                    if (bitdepth == 16) {  // input bpc
+                        for (i = 0; i < pixelCount; i++, p += 4)
+                            *p = (stbi_uc)(stbi__get16be(s) >> 8);
+                    } else {
+                        for (i = 0; i < pixelCount; i++, p += 4)
+                            *p = stbi__get8(s);
+                    }
+                }
+            }
+        }
+    }
+
+    // remove weird white matte from PSD
+    if (channelCount >= 4) {
+        if (ri->bits_per_channel == 16) {
+            for (i = 0; i < w * h; ++i) {
+                stbi__uint16 *pixel = (stbi__uint16 *)out + 4 * i;
+                if (pixel[3] != 0 && pixel[3] != 65535) {
+                    float a     = pixel[3] / 65535.0f;
+                    float ra    = 1.0f / a;
+                    float inv_a = 65535.0f * (1 - ra);
+                    pixel[0]    = (stbi__uint16)(pixel[0] * ra + inv_a);
+                    pixel[1]    = (stbi__uint16)(pixel[1] * ra + inv_a);
+                    pixel[2]    = (stbi__uint16)(pixel[2] * ra + inv_a);
+                }
+            }
+        } else {
+            for (i = 0; i < w * h; ++i) {
+                unsigned char *pixel = out + 4 * i;
+                if (pixel[3] != 0 && pixel[3] != 255) {
+                    float a     = pixel[3] / 255.0f;
+                    float ra    = 1.0f / a;
+                    float inv_a = 255.0f * (1 - ra);
+                    pixel[0]    = (unsigned char)(pixel[0] * ra + inv_a);
+                    pixel[1]    = (unsigned char)(pixel[1] * ra + inv_a);
+                    pixel[2]    = (unsigned char)(pixel[2] * ra + inv_a);
+                }
+            }
+        }
+    }
+
+    // convert to desired output format
+    if (req_comp && req_comp != 4) {
+        if (ri->bits_per_channel == 16)
+            out = (stbi_uc *)stbi__convert_format16((stbi__uint16 *)out, 4, req_comp, w, h);
+        else
+            out = stbi__convert_format(out, 4, req_comp, w, h);
+        if (out == NULL)
+            return out;  // stbi__convert_format frees input on failure
+    }
+
+    if (comp)
+        *comp = 4;
+    *y = h;
+    *x = w;
+
+    return out;
+}
+#endif
+
+// *************************************************************************************************
+// Softimage PIC loader
+// by Tom Seddon
+//
+// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
+// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_is4(stbi__context *s, const char *str) {
+    int i;
+    for (i = 0; i < 4; ++i)
+        if (stbi__get8(s) != (stbi_uc)str[i])
+            return 0;
+
+    return 1;
+}
+
+static int stbi__pic_test_core(stbi__context *s) {
+    int i;
+
+    if (!stbi__pic_is4(s, "\x53\x80\xF6\x34"))
+        return 0;
+
+    for (i = 0; i < 84; ++i)
+        stbi__get8(s);
+
+    if (!stbi__pic_is4(s, "PICT"))
+        return 0;
+
+    return 1;
+}
+
+typedef struct {
+    stbi_uc size, type, channel;
+} stbi__pic_packet;
+
+static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) {
+    int mask = 0x80, i;
+
+    for (i = 0; i < 4; ++i, mask >>= 1) {
+        if (channel & mask) {
+            if (stbi__at_eof(s))
+                return stbi__errpuc("bad file", "PIC file too short");
+            dest[i] = stbi__get8(s);
+        }
+    }
+
+    return dest;
+}
+
+static void stbi__copyval(int channel, stbi_uc *dest, const stbi_uc *src) {
+    int mask = 0x80, i;
+
+    for (i = 0; i < 4; ++i, mask >>= 1)
+        if (channel & mask)
+            dest[i] = src[i];
+}
+
+static stbi_uc *stbi__pic_load_core(stbi__context *s, int width, int height, int *comp,
+                                    stbi_uc *result) {
+    int act_comp = 0, num_packets = 0, y, chained;
+    stbi__pic_packet packets[10];
+
+    // this will (should...) cater for even some bizarre stuff like having data
+    // for the same channel in multiple packets.
+    do {
+        stbi__pic_packet *packet;
+
+        if (num_packets == sizeof(packets) / sizeof(packets[0]))
+            return stbi__errpuc("bad format", "too many packets");
+
+        packet = &packets[num_packets++];
+
+        chained         = stbi__get8(s);
+        packet->size    = stbi__get8(s);
+        packet->type    = stbi__get8(s);
+        packet->channel = stbi__get8(s);
+
+        act_comp |= packet->channel;
+
+        if (stbi__at_eof(s))
+            return stbi__errpuc("bad file", "file too short (reading packets)");
+        if (packet->size != 8)
+            return stbi__errpuc("bad format", "packet isn't 8bpp");
+    } while (chained);
+
+    *comp = (act_comp & 0x10 ? 4 : 3);  // has alpha channel?
+
+    for (y = 0; y < height; ++y) {
+        int packet_idx;
+
+        for (packet_idx = 0; packet_idx < num_packets; ++packet_idx) {
+            stbi__pic_packet *packet = &packets[packet_idx];
+            stbi_uc *dest            = result + y * width * 4;
+
+            switch (packet->type) {
+            default:
+                return stbi__errpuc("bad format", "packet has bad compression type");
+
+            case 0: {  // uncompressed
+                int x;
+
+                for (x = 0; x < width; ++x, dest += 4)
+                    if (!stbi__readval(s, packet->channel, dest))
+                        return 0;
+                break;
+            }
+
+            case 1:  // Pure RLE
+            {
+                int left = width, i;
+
+                while (left > 0) {
+                    stbi_uc count, value[4];
+
+                    count = stbi__get8(s);
+                    if (stbi__at_eof(s))
+                        return stbi__errpuc("bad file", "file too short (pure read count)");
+
+                    if (count > left)
+                        count = (stbi_uc)left;
+
+                    if (!stbi__readval(s, packet->channel, value))
+                        return 0;
+
+                    for (i = 0; i < count; ++i, dest += 4)
+                        stbi__copyval(packet->channel, dest, value);
+                    left -= count;
+                }
+            } break;
+
+            case 2: {  // Mixed RLE
+                int left = width;
+                while (left > 0) {
+                    int count = stbi__get8(s), i;
+                    if (stbi__at_eof(s))
+                        return stbi__errpuc("bad file", "file too short (mixed read count)");
+
+                    if (count >= 128) {  // Repeated
+                        stbi_uc value[4];
+
+                        if (count == 128)
+                            count = stbi__get16be(s);
+                        else
+                            count -= 127;
+                        if (count > left)
+                            return stbi__errpuc("bad file", "scanline overrun");
+
+                        if (!stbi__readval(s, packet->channel, value))
+                            return 0;
+
+                        for (i = 0; i < count; ++i, dest += 4)
+                            stbi__copyval(packet->channel, dest, value);
+                    } else {  // Raw
+                        ++count;
+                        if (count > left)
+                            return stbi__errpuc("bad file", "scanline overrun");
+
+                        for (i = 0; i < count; ++i, dest += 4)
+                            if (!stbi__readval(s, packet->channel, dest))
+                                return 0;
+                    }
+                    left -= count;
+                }
+                break;
+            }
+            }
+        }
+    }
+
+    return result;
+}
+
+static void *stbi__pic_load(stbi__context *s, int *px, int *py, int *comp, int req_comp,
+                            stbi__result_info *ri) {
+    stbi_uc *result;
+    int i, x, y, internal_comp;
+    STBI_NOTUSED(ri);
+
+    if (!comp)
+        comp = &internal_comp;
+
+    for (i = 0; i < 92; ++i)
+        stbi__get8(s);
+
+    x = stbi__get16be(s);
+    y = stbi__get16be(s);
+
+    if (y > STBI_MAX_DIMENSIONS)
+        return stbi__errpuc("too large", "Very large image (corrupt?)");
+    if (x > STBI_MAX_DIMENSIONS)
+        return stbi__errpuc("too large", "Very large image (corrupt?)");
+
+    if (stbi__at_eof(s))
+        return stbi__errpuc("bad file", "file too short (pic header)");
+    if (!stbi__mad3sizes_valid(x, y, 4, 0))
+        return stbi__errpuc("too large", "PIC image too large to decode");
+
+    stbi__get32be(s);  // skip `ratio'
+    stbi__get16be(s);  // skip `fields'
+    stbi__get16be(s);  // skip `pad'
+
+    // intermediate buffer is RGBA
+    result = (stbi_uc *)stbi__malloc_mad3(x, y, 4, 0);
+    if (!result)
+        return stbi__errpuc("outofmem", "Out of memory");
+    memset(result, 0xff, x * y * 4);
+
+    if (!stbi__pic_load_core(s, x, y, comp, result)) {
+        STBI_FREE(result);
+        result = 0;
+    }
+    *px = x;
+    *py = y;
+    if (req_comp == 0)
+        req_comp = *comp;
+    result = stbi__convert_format(result, 4, req_comp, x, y);
+
+    return result;
+}
+
+static int stbi__pic_test(stbi__context *s) {
+    int r = stbi__pic_test_core(s);
+    stbi__rewind(s);
+    return r;
+}
+#endif
+
+// *************************************************************************************************
+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
+
+#ifndef STBI_NO_GIF
+typedef struct {
+    stbi__int16 prefix;
+    stbi_uc first;
+    stbi_uc suffix;
+} stbi__gif_lzw;
+
+typedef struct {
+    int w, h;
+    stbi_uc *out;         // output buffer (always 4 components)
+    stbi_uc *background;  // The current "background" as far as a gif is concerned
+    stbi_uc *history;
+    int flags, bgindex, ratio, transparent, eflags;
+    stbi_uc pal[256][4];
+    stbi_uc lpal[256][4];
+    stbi__gif_lzw codes[8192];
+    stbi_uc *color_table;
+    int parse, step;
+    int lflags;
+    int start_x, start_y;
+    int max_x, max_y;
+    int cur_x, cur_y;
+    int line_size;
+    int delay;
+} stbi__gif;
+
+static int stbi__gif_test_raw(stbi__context *s) {
+    int sz;
+    if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' ||
+        stbi__get8(s) != '8')
+        return 0;
+    sz = stbi__get8(s);
+    if (sz != '9' && sz != '7')
+        return 0;
+    if (stbi__get8(s) != 'a')
+        return 0;
+    return 1;
+}
+
+static int stbi__gif_test(stbi__context *s) {
+    int r = stbi__gif_test_raw(s);
+    stbi__rewind(s);
+    return r;
+}
+
+static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries,
+                                       int transp) {
+    int i;
+    for (i = 0; i < num_entries; ++i) {
+        pal[i][2] = stbi__get8(s);
+        pal[i][1] = stbi__get8(s);
+        pal[i][0] = stbi__get8(s);
+        pal[i][3] = transp == i ? 0 : 255;
+    }
+}
+
+static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) {
+    stbi_uc version;
+    if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' ||
+        stbi__get8(s) != '8')
+        return stbi__err("not GIF", "Corrupt GIF");
+
+    version = stbi__get8(s);
+    if (version != '7' && version != '9')
+        return stbi__err("not GIF", "Corrupt GIF");
+    if (stbi__get8(s) != 'a')
+        return stbi__err("not GIF", "Corrupt GIF");
+
+    stbi__g_failure_reason = "";
+    g->w                   = stbi__get16le(s);
+    g->h                   = stbi__get16le(s);
+    g->flags               = stbi__get8(s);
+    g->bgindex             = stbi__get8(s);
+    g->ratio               = stbi__get8(s);
+    g->transparent         = -1;
+
+    if (g->w > STBI_MAX_DIMENSIONS)
+        return stbi__err("too large", "Very large image (corrupt?)");
+    if (g->h > STBI_MAX_DIMENSIONS)
+        return stbi__err("too large", "Very large image (corrupt?)");
+
+    if (comp != 0)
+        *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
+
+    if (is_info)
+        return 1;
+
+    if (g->flags & 0x80)
+        stbi__gif_parse_colortable(s, g->pal, 2 << (g->flags & 7), -1);
+
+    return 1;
+}
+
+static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) {
+    stbi__gif *g = (stbi__gif *)stbi__malloc(sizeof(stbi__gif));
+    if (!g)
+        return stbi__err("outofmem", "Out of memory");
+    if (!stbi__gif_header(s, g, comp, 1)) {
+        STBI_FREE(g);
+        stbi__rewind(s);
+        return 0;
+    }
+    if (x)
+        *x = g->w;
+    if (y)
+        *y = g->h;
+    STBI_FREE(g);
+    return 1;
+}
+
+static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) {
+    stbi_uc *p, *c;
+    int idx;
+
+    // recurse to decode the prefixes, since the linked-list is backwards,
+    // and working backwards through an interleaved image would be nasty
+    if (g->codes[code].prefix >= 0)
+        stbi__out_gif_code(g, g->codes[code].prefix);
+
+    if (g->cur_y >= g->max_y)
+        return;
+
+    idx                 = g->cur_x + g->cur_y;
+    p                   = &g->out[idx];
+    g->history[idx / 4] = 1;
+
+    c = &g->color_table[g->codes[code].suffix * 4];
+    if (c[3] > 128) {  // don't render transparent pixels;
+        p[0] = c[2];
+        p[1] = c[1];
+        p[2] = c[0];
+        p[3] = c[3];
+    }
+    g->cur_x += 4;
+
+    if (g->cur_x >= g->max_x) {
+        g->cur_x = g->start_x;
+        g->cur_y += g->step;
+
+        while (g->cur_y >= g->max_y && g->parse > 0) {
+            g->step  = (1 << g->parse) * g->line_size;
+            g->cur_y = g->start_y + (g->step >> 1);
+            --g->parse;
+        }
+    }
+}
+
+static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) {
+    stbi_uc lzw_cs;
+    stbi__int32 len, init_code;
+    stbi__uint32 first;
+    stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+    stbi__gif_lzw *p;
+
+    lzw_cs = stbi__get8(s);
+    if (lzw_cs > 12)
+        return NULL;
+    clear      = 1 << lzw_cs;
+    first      = 1;
+    codesize   = lzw_cs + 1;
+    codemask   = (1 << codesize) - 1;
+    bits       = 0;
+    valid_bits = 0;
+    for (init_code = 0; init_code < clear; init_code++) {
+        g->codes[init_code].prefix = -1;
+        g->codes[init_code].first  = (stbi_uc)init_code;
+        g->codes[init_code].suffix = (stbi_uc)init_code;
+    }
+
+    // support no starting clear code
+    avail   = clear + 2;
+    oldcode = -1;
+
+    len = 0;
+    for (;;) {
+        if (valid_bits < codesize) {
+            if (len == 0) {
+                len = stbi__get8(s);  // start new block
+                if (len == 0)
+                    return g->out;
+            }
+            --len;
+            bits |= (stbi__int32)stbi__get8(s) << valid_bits;
+            valid_bits += 8;
+        } else {
+            stbi__int32 code = bits & codemask;
+            bits >>= codesize;
+            valid_bits -= codesize;
+            // @OPTIMIZE: is there some way we can accelerate the non-clear path?
+            if (code == clear) {  // clear code
+                codesize = lzw_cs + 1;
+                codemask = (1 << codesize) - 1;
+                avail    = clear + 2;
+                oldcode  = -1;
+                first    = 0;
+            } else if (code == clear + 1) {  // end of stream code
+                stbi__skip(s, len);
+                while ((len = stbi__get8(s)) > 0)
+                    stbi__skip(s, len);
+                return g->out;
+            } else if (code <= avail) {
+                if (first) {
+                    return stbi__errpuc("no clear code", "Corrupt GIF");
+                }
+
+                if (oldcode >= 0) {
+                    p = &g->codes[avail++];
+                    if (avail > 8192) {
+                        return stbi__errpuc("too many codes", "Corrupt GIF");
+                    }
+
+                    p->prefix = (stbi__int16)oldcode;
+                    p->first  = g->codes[oldcode].first;
+                    p->suffix = (code == avail) ? p->first : g->codes[code].first;
+                } else if (code == avail)
+                    return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+
+                stbi__out_gif_code(g, (stbi__uint16)code);
+
+                if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+                    codesize++;
+                    codemask = (1 << codesize) - 1;
+                }
+
+                oldcode = code;
+            } else {
+                return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+            }
+        }
+    }
+}
+
+// this function is designed to support animated gifs, although stb_image doesn't support it
+// two back is the image from two frames ago, used for a very specific disposal format
+static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp,
+                                    stbi_uc *two_back) {
+    int dispose;
+    int first_frame;
+    int pi;
+    int pcount;
+    STBI_NOTUSED(req_comp);
+
+    // on first frame, any non-written pixels get the background colour (non-transparent)
+    first_frame = 0;
+    if (g->out == 0) {
+        if (!stbi__gif_header(s, g, comp, 0))
+            return 0;  // stbi__g_failure_reason set by stbi__gif_header
+        if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
+            return stbi__errpuc("too large", "GIF image is too large");
+        pcount        = g->w * g->h;
+        g->out        = (stbi_uc *)stbi__malloc(4 * pcount);
+        g->background = (stbi_uc *)stbi__malloc(4 * pcount);
+        g->history    = (stbi_uc *)stbi__malloc(pcount);
+        if (!g->out || !g->background || !g->history)
+            return stbi__errpuc("outofmem", "Out of memory");
+
+        // image is treated as "transparent" at the start - ie, nothing overwrites the current
+        // background; background colour is only used for pixels that are not rendered first frame,
+        // after that "background" color refers to the color that was there the previous frame.
+        memset(g->out, 0x00, 4 * pcount);
+        memset(g->background, 0x00, 4 * pcount);  // state of the background (starts transparent)
+        memset(g->history, 0x00, pcount);         // pixels that were affected previous frame
+        first_frame = 1;
+    } else {
+        // second frame - how do we dispose of the previous one?
+        dispose = (g->eflags & 0x1C) >> 2;
+        pcount  = g->w * g->h;
+
+        if ((dispose == 3) && (two_back == 0)) {
+            dispose =
+                2;  // if I don't have an image to revert back to, default to the old background
+        }
+
+        if (dispose == 3) {  // use previous graphic
+            for (pi = 0; pi < pcount; ++pi) {
+                if (g->history[pi]) {
+                    memcpy(&g->out[pi * 4], &two_back[pi * 4], 4);
+                }
+            }
+        } else if (dispose == 2) {
+            // restore what was changed last frame to background before that frame;
+            for (pi = 0; pi < pcount; ++pi) {
+                if (g->history[pi]) {
+                    memcpy(&g->out[pi * 4], &g->background[pi * 4], 4);
+                }
+            }
+        } else {
+            // This is a non-disposal case eithe way, so just
+            // leave the pixels as is, and they will become the new background
+            // 1: do not dispose
+            // 0:  not specified.
+        }
+
+        // background is what out is after the undoing of the previou frame;
+        memcpy(g->background, g->out, 4 * g->w * g->h);
+    }
+
+    // clear my history;
+    memset(g->history, 0x00, g->w * g->h);  // pixels that were affected previous frame
+
+    for (;;) {
+        int tag = stbi__get8(s);
+        switch (tag) {
+        case 0x2C: /* Image Descriptor */
+        {
+            stbi__int32 x, y, w, h;
+            stbi_uc *o;
+
+            x = stbi__get16le(s);
+            y = stbi__get16le(s);
+            w = stbi__get16le(s);
+            h = stbi__get16le(s);
+            if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+                return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
+
+            g->line_size = g->w * 4;
+            g->start_x   = x * 4;
+            g->start_y   = y * g->line_size;
+            g->max_x     = g->start_x + w * 4;
+            g->max_y     = g->start_y + h * g->line_size;
+            g->cur_x     = g->start_x;
+            g->cur_y     = g->start_y;
+
+            // if the width of the specified rectangle is 0, that means
+            // we may not see *any* pixels or the image is malformed;
+            // to make sure this is caught, move the current y down to
+            // max_y (which is what out_gif_code checks).
+            if (w == 0)
+                g->cur_y = g->max_y;
+
+            g->lflags = stbi__get8(s);
+
+            if (g->lflags & 0x40) {
+                g->step  = 8 * g->line_size;  // first interlaced spacing
+                g->parse = 3;
+            } else {
+                g->step  = g->line_size;
+                g->parse = 0;
+            }
+
+            if (g->lflags & 0x80) {
+                stbi__gif_parse_colortable(s, g->lpal, 2 << (g->lflags & 7),
+                                           g->eflags & 0x01 ? g->transparent : -1);
+                g->color_table = (stbi_uc *)g->lpal;
+            } else if (g->flags & 0x80) {
+                g->color_table = (stbi_uc *)g->pal;
+            } else
+                return stbi__errpuc("missing color table", "Corrupt GIF");
+
+            o = stbi__process_gif_raster(s, g);
+            if (!o)
+                return NULL;
+
+            // if this was the first frame,
+            pcount = g->w * g->h;
+            if (first_frame && (g->bgindex > 0)) {
+                // if first frame, any pixel not drawn to gets the background color
+                for (pi = 0; pi < pcount; ++pi) {
+                    if (g->history[pi] == 0) {
+                        g->pal[g->bgindex][3] =
+                            255;  // just in case it was made transparent, undo that; It will be
+                                  // reset next frame if need be;
+                        memcpy(&g->out[pi * 4], &g->pal[g->bgindex], 4);
+                    }
+                }
+            }
+
+            return o;
+        }
+
+        case 0x21:  // Comment Extension.
+        {
+            int len;
+            int ext = stbi__get8(s);
+            if (ext == 0xF9) {  // Graphic Control Extension.
+                len = stbi__get8(s);
+                if (len == 4) {
+                    g->eflags = stbi__get8(s);
+                    g->delay =
+                        10 * stbi__get16le(s);  // delay - 1/100th of a second, saving as 1/1000ths.
+
+                    // unset old transparent
+                    if (g->transparent >= 0) {
+                        g->pal[g->transparent][3] = 255;
+                    }
+                    if (g->eflags & 0x01) {
+                        g->transparent = stbi__get8(s);
+                        if (g->transparent >= 0) {
+                            g->pal[g->transparent][3] = 0;
+                        }
+                    } else {
+                        // don't need transparent
+                        stbi__skip(s, 1);
+                        g->transparent = -1;
+                    }
+                } else {
+                    stbi__skip(s, len);
+                    break;
+                }
+            }
+            while ((len = stbi__get8(s)) != 0) {
+                stbi__skip(s, len);
+            }
+            break;
+        }
+
+        case 0x3B:                // gif stream termination code
+            return (stbi_uc *)s;  // using '1' causes warning on some compilers
+
+        default:
+            return stbi__errpuc("unknown code", "Corrupt GIF");
+        }
+    }
+}
+
+static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) {
+    STBI_FREE(g->out);
+    STBI_FREE(g->history);
+    STBI_FREE(g->background);
+
+    if (out)
+        STBI_FREE(out);
+    if (delays && *delays)
+        STBI_FREE(*delays);
+    return stbi__errpuc("outofmem", "Out of memory");
+}
+
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp,
+                                 int req_comp) {
+    if (stbi__gif_test(s)) {
+        int layers        = 0;
+        stbi_uc *u        = 0;
+        stbi_uc *out      = 0;
+        stbi_uc *two_back = 0;
+        stbi__gif g;
+        int stride;
+        int out_size    = 0;
+        int delays_size = 0;
+
+        STBI_NOTUSED(out_size);
+        STBI_NOTUSED(delays_size);
+
+        memset(&g, 0, sizeof(g));
+        if (delays) {
+            *delays = 0;
+        }
+
+        do {
+            u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
+            if (u == (stbi_uc *)s)
+                u = 0;  // end of animated gif marker
+
+            if (u) {
+                *x = g.w;
+                *y = g.h;
+                ++layers;
+                stride = g.w * g.h * 4;
+
+                if (out) {
+                    void *tmp = (stbi_uc *)STBI_REALLOC_SIZED(out, out_size, layers * stride);
+                    if (!tmp)
+                        return stbi__load_gif_main_outofmem(&g, out, delays);
+                    else {
+                        out      = (stbi_uc *)tmp;
+                        out_size = layers * stride;
+                    }
+
+                    if (delays) {
+                        int *new_delays =
+                            (int *)STBI_REALLOC_SIZED(*delays, delays_size, sizeof(int) * layers);
+                        if (!new_delays)
+                            return stbi__load_gif_main_outofmem(&g, out, delays);
+                        *delays     = new_delays;
+                        delays_size = layers * sizeof(int);
+                    }
+                } else {
+                    out = (stbi_uc *)stbi__malloc(layers * stride);
+                    if (!out)
+                        return stbi__load_gif_main_outofmem(&g, out, delays);
+                    out_size = layers * stride;
+                    if (delays) {
+                        *delays = (int *)stbi__malloc(layers * sizeof(int));
+                        if (!*delays)
+                            return stbi__load_gif_main_outofmem(&g, out, delays);
+                        delays_size = layers * sizeof(int);
+                    }
+                }
+                memcpy(out + ((layers - 1) * stride), u, stride);
+                if (layers >= 2) {
+                    two_back = out - 2 * stride;
+                }
+
+                if (delays) {
+                    (*delays)[layers - 1U] = g.delay;
+                }
+            }
+        } while (u != 0);
+
+        // free temp buffer;
+        STBI_FREE(g.out);
+        STBI_FREE(g.history);
+        STBI_FREE(g.background);
+
+        // do the final conversion after loading everything;
+        if (req_comp && req_comp != 4)
+            out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
+
+        *z = layers;
+        return out;
+    } else {
+        return stbi__errpuc("not GIF", "Image was not as a gif type.");
+    }
+}
+
+static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri) {
+    stbi_uc *u = 0;
+    stbi__gif g;
+    memset(&g, 0, sizeof(g));
+    STBI_NOTUSED(ri);
+
+    u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
+    if (u == (stbi_uc *)s)
+        u = 0;  // end of animated gif marker
+    if (u) {
+        *x = g.w;
+        *y = g.h;
+
+        // moved conversion to after successful load so that the same
+        // can be done for multiple frames.
+        if (req_comp && req_comp != 4)
+            u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
+    } else if (g.out) {
+        // if there was an error and we allocated an image buffer, free it!
+        STBI_FREE(g.out);
+    }
+
+    // free buffers needed for multiple frame loading;
+    STBI_FREE(g.history);
+    STBI_FREE(g.background);
+
+    return u;
+}
+
+static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) {
+    return stbi__gif_info_raw(s, x, y, comp);
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR loader
+// originally by Nicolas Schulz
+#ifndef STBI_NO_HDR
+static int stbi__hdr_test_core(stbi__context *s, const char *signature) {
+    int i;
+    for (i = 0; signature[i]; ++i)
+        if (stbi__get8(s) != signature[i])
+            return 0;
+    stbi__rewind(s);
+    return 1;
+}
+
+static int stbi__hdr_test(stbi__context *s) {
+    int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
+    stbi__rewind(s);
+    if (!r) {
+        r = stbi__hdr_test_core(s, "#?RGBE\n");
+        stbi__rewind(s);
+    }
+    return r;
+}
+
+#define STBI__HDR_BUFLEN 1024
+static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) {
+    int len = 0;
+    char c  = '\0';
+
+    c = (char)stbi__get8(z);
+
+    while (!stbi__at_eof(z) && c != '\n') {
+        buffer[len++] = c;
+        if (len == STBI__HDR_BUFLEN - 1) {
+            // flush to end of line
+            while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
+                ;
+            break;
+        }
+        c = (char)stbi__get8(z);
+    }
+
+    buffer[len] = 0;
+    return buffer;
+}
+
+static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) {
+    if (input[3] != 0) {
+        float f1;
+        // Exponent
+        f1 = (float)ldexp(1.0f, input[3] - (int)(128 + 8));
+        if (req_comp <= 2)
+            output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
+        else {
+            output[0] = input[0] * f1;
+            output[1] = input[1] * f1;
+            output[2] = input[2] * f1;
+        }
+        if (req_comp == 2)
+            output[1] = 1;
+        if (req_comp == 4)
+            output[3] = 1;
+    } else {
+        switch (req_comp) {
+        case 4:
+            output[3] = 1; /* fallthrough */
+        case 3:
+            output[0] = output[1] = output[2] = 0;
+            break;
+        case 2:
+            output[1] = 1; /* fallthrough */
+        case 1:
+            output[0] = 0;
+            break;
+        }
+    }
+}
+
+static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                             stbi__result_info *ri) {
+    char buffer[STBI__HDR_BUFLEN];
+    char *token;
+    int valid = 0;
+    int width, height;
+    stbi_uc *scanline;
+    float *hdr_data;
+    int len;
+    unsigned char count, value;
+    int i, j, k, c1, c2, z;
+    const char *headerToken;
+    STBI_NOTUSED(ri);
+
+    // Check identifier
+    headerToken = stbi__hdr_gettoken(s, buffer);
+    if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
+        return stbi__errpf("not HDR", "Corrupt HDR image");
+
+    // Parse header
+    for (;;) {
+        token = stbi__hdr_gettoken(s, buffer);
+        if (token[0] == 0)
+            break;
+        if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0)
+            valid = 1;
+    }
+
+    if (!valid)
+        return stbi__errpf("unsupported format", "Unsupported HDR format");
+
+    // Parse width and height
+    // can't use sscanf() if we're not using stdio!
+    token = stbi__hdr_gettoken(s, buffer);
+    if (strncmp(token, "-Y ", 3))
+        return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+    token += 3;
+    height = (int)strtol(token, &token, 10);
+    while (*token == ' ')
+        ++token;
+    if (strncmp(token, "+X ", 3))
+        return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+    token += 3;
+    width = (int)strtol(token, NULL, 10);
+
+    if (height > STBI_MAX_DIMENSIONS)
+        return stbi__errpf("too large", "Very large image (corrupt?)");
+    if (width > STBI_MAX_DIMENSIONS)
+        return stbi__errpf("too large", "Very large image (corrupt?)");
+
+    *x = width;
+    *y = height;
+
+    if (comp)
+        *comp = 3;
+    if (req_comp == 0)
+        req_comp = 3;
+
+    if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
+        return stbi__errpf("too large", "HDR image is too large");
+
+    // Read data
+    hdr_data = (float *)stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
+    if (!hdr_data)
+        return stbi__errpf("outofmem", "Out of memory");
+
+    // Load image data
+    // image data is stored as some number of sca
+    if (width < 8 || width >= 32768) {
+        // Read flat data
+        for (j = 0; j < height; ++j) {
+            for (i = 0; i < width; ++i) {
+                stbi_uc rgbe[4];
+            main_decode_loop:
+                stbi__getn(s, rgbe, 4);
+                stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+            }
+        }
+    } else {
+        // Read RLE-encoded data
+        scanline = NULL;
+
+        for (j = 0; j < height; ++j) {
+            c1  = stbi__get8(s);
+            c2  = stbi__get8(s);
+            len = stbi__get8(s);
+            if (c1 != 2 || c2 != 2 || (len & 0x80)) {
+                // not run-length encoded, so we have to actually use THIS data as a decoded
+                // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
+                stbi_uc rgbe[4];
+                rgbe[0] = (stbi_uc)c1;
+                rgbe[1] = (stbi_uc)c2;
+                rgbe[2] = (stbi_uc)len;
+                rgbe[3] = (stbi_uc)stbi__get8(s);
+                stbi__hdr_convert(hdr_data, rgbe, req_comp);
+                i = 1;
+                j = 0;
+                STBI_FREE(scanline);
+                goto main_decode_loop;  // yes, this makes no sense
+            }
+            len <<= 8;
+            len |= stbi__get8(s);
+            if (len != width) {
+                STBI_FREE(hdr_data);
+                STBI_FREE(scanline);
+                return stbi__errpf("invalid decoded scanline length", "corrupt HDR");
+            }
+            if (scanline == NULL) {
+                scanline = (stbi_uc *)stbi__malloc_mad2(width, 4, 0);
+                if (!scanline) {
+                    STBI_FREE(hdr_data);
+                    return stbi__errpf("outofmem", "Out of memory");
+                }
+            }
+
+            for (k = 0; k < 4; ++k) {
+                int nleft;
+                i = 0;
+                while ((nleft = width - i) > 0) {
+                    count = stbi__get8(s);
+                    if (count > 128) {
+                        // Run
+                        value = stbi__get8(s);
+                        count -= 128;
+                        if ((count == 0) || (count > nleft)) {
+                            STBI_FREE(hdr_data);
+                            STBI_FREE(scanline);
+                            return stbi__errpf("corrupt", "bad RLE data in HDR");
+                        }
+                        for (z = 0; z < count; ++z)
+                            scanline[i++ * 4 + k] = value;
+                    } else {
+                        // Dump
+                        if ((count == 0) || (count > nleft)) {
+                            STBI_FREE(hdr_data);
+                            STBI_FREE(scanline);
+                            return stbi__errpf("corrupt", "bad RLE data in HDR");
+                        }
+                        for (z = 0; z < count; ++z)
+                            scanline[i++ * 4 + k] = stbi__get8(s);
+                    }
+                }
+            }
+            for (i = 0; i < width; ++i)
+                stbi__hdr_convert(hdr_data + (j * width + i) * req_comp, scanline + i * 4,
+                                  req_comp);
+        }
+        if (scanline)
+            STBI_FREE(scanline);
+    }
+
+    return hdr_data;
+}
+
+static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) {
+    char buffer[STBI__HDR_BUFLEN];
+    char *token;
+    int valid = 0;
+    int dummy;
+
+    if (!x)
+        x = &dummy;
+    if (!y)
+        y = &dummy;
+    if (!comp)
+        comp = &dummy;
+
+    if (stbi__hdr_test(s) == 0) {
+        stbi__rewind(s);
+        return 0;
+    }
+
+    for (;;) {
+        token = stbi__hdr_gettoken(s, buffer);
+        if (token[0] == 0)
+            break;
+        if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0)
+            valid = 1;
+    }
+
+    if (!valid) {
+        stbi__rewind(s);
+        return 0;
+    }
+    token = stbi__hdr_gettoken(s, buffer);
+    if (strncmp(token, "-Y ", 3)) {
+        stbi__rewind(s);
+        return 0;
+    }
+    token += 3;
+    *y = (int)strtol(token, &token, 10);
+    while (*token == ' ')
+        ++token;
+    if (strncmp(token, "+X ", 3)) {
+        stbi__rewind(s);
+        return 0;
+    }
+    token += 3;
+    *x    = (int)strtol(token, NULL, 10);
+    *comp = 3;
+    return 1;
+}
+#endif  // STBI_NO_HDR
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) {
+    void *p;
+    stbi__bmp_data info;
+
+    info.all_a = 255;
+    p          = stbi__bmp_parse_header(s, &info);
+    if (p == NULL) {
+        stbi__rewind(s);
+        return 0;
+    }
+    if (x)
+        *x = s->img_x;
+    if (y)
+        *y = s->img_y;
+    if (comp) {
+        if (info.bpp == 24 && info.ma == 0xff000000)
+            *comp = 3;
+        else
+            *comp = info.ma ? 4 : 3;
+    }
+    return 1;
+}
+#endif
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) {
+    int channelCount, dummy, depth;
+    if (!x)
+        x = &dummy;
+    if (!y)
+        y = &dummy;
+    if (!comp)
+        comp = &dummy;
+    if (stbi__get32be(s) != 0x38425053) {
+        stbi__rewind(s);
+        return 0;
+    }
+    if (stbi__get16be(s) != 1) {
+        stbi__rewind(s);
+        return 0;
+    }
+    stbi__skip(s, 6);
+    channelCount = stbi__get16be(s);
+    if (channelCount < 0 || channelCount > 16) {
+        stbi__rewind(s);
+        return 0;
+    }
+    *y    = stbi__get32be(s);
+    *x    = stbi__get32be(s);
+    depth = stbi__get16be(s);
+    if (depth != 8 && depth != 16) {
+        stbi__rewind(s);
+        return 0;
+    }
+    if (stbi__get16be(s) != 3) {
+        stbi__rewind(s);
+        return 0;
+    }
+    *comp = 4;
+    return 1;
+}
+
+static int stbi__psd_is16(stbi__context *s) {
+    int channelCount, depth;
+    if (stbi__get32be(s) != 0x38425053) {
+        stbi__rewind(s);
+        return 0;
+    }
+    if (stbi__get16be(s) != 1) {
+        stbi__rewind(s);
+        return 0;
+    }
+    stbi__skip(s, 6);
+    channelCount = stbi__get16be(s);
+    if (channelCount < 0 || channelCount > 16) {
+        stbi__rewind(s);
+        return 0;
+    }
+    STBI_NOTUSED(stbi__get32be(s));
+    STBI_NOTUSED(stbi__get32be(s));
+    depth = stbi__get16be(s);
+    if (depth != 16) {
+        stbi__rewind(s);
+        return 0;
+    }
+    return 1;
+}
+#endif
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) {
+    int act_comp = 0, num_packets = 0, chained, dummy;
+    stbi__pic_packet packets[10];
+
+    if (!x)
+        x = &dummy;
+    if (!y)
+        y = &dummy;
+    if (!comp)
+        comp = &dummy;
+
+    if (!stbi__pic_is4(s, "\x53\x80\xF6\x34")) {
+        stbi__rewind(s);
+        return 0;
+    }
+
+    stbi__skip(s, 88);
+
+    *x = stbi__get16be(s);
+    *y = stbi__get16be(s);
+    if (stbi__at_eof(s)) {
+        stbi__rewind(s);
+        return 0;
+    }
+    if ((*x) != 0 && (1 << 28) / (*x) < (*y)) {
+        stbi__rewind(s);
+        return 0;
+    }
+
+    stbi__skip(s, 8);
+
+    do {
+        stbi__pic_packet *packet;
+
+        if (num_packets == sizeof(packets) / sizeof(packets[0]))
+            return 0;
+
+        packet          = &packets[num_packets++];
+        chained         = stbi__get8(s);
+        packet->size    = stbi__get8(s);
+        packet->type    = stbi__get8(s);
+        packet->channel = stbi__get8(s);
+        act_comp |= packet->channel;
+
+        if (stbi__at_eof(s)) {
+            stbi__rewind(s);
+            return 0;
+        }
+        if (packet->size != 8) {
+            stbi__rewind(s);
+            return 0;
+        }
+    } while (chained);
+
+    *comp = (act_comp & 0x10 ? 4 : 3);
+
+    return 1;
+}
+#endif
+
+// *************************************************************************************************
+// Portable Gray Map and Portable Pixel Map loader
+// by Ken Miller
+//
+// PGM: http://netpbm.sourceforge.net/doc/pgm.html
+// PPM: http://netpbm.sourceforge.net/doc/ppm.html
+//
+// Known limitations:
+//    Does not support comments in the header section
+//    Does not support ASCII image data (formats P2 and P3)
+
+#ifndef STBI_NO_PNM
+
+static int stbi__pnm_test(stbi__context *s) {
+    char p, t;
+    p = (char)stbi__get8(s);
+    t = (char)stbi__get8(s);
+    if (p != 'P' || (t != '5' && t != '6')) {
+        stbi__rewind(s);
+        return 0;
+    }
+    return 1;
+}
+
+static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp,
+                            stbi__result_info *ri) {
+    stbi_uc *out;
+    STBI_NOTUSED(ri);
+
+    ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);
+    if (ri->bits_per_channel == 0)
+        return 0;
+
+    if (s->img_y > STBI_MAX_DIMENSIONS)
+        return stbi__errpuc("too large", "Very large image (corrupt?)");
+    if (s->img_x > STBI_MAX_DIMENSIONS)
+        return stbi__errpuc("too large", "Very large image (corrupt?)");
+
+    *x = s->img_x;
+    *y = s->img_y;
+    if (comp)
+        *comp = s->img_n;
+
+    if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))
+        return stbi__errpuc("too large", "PNM too large");
+
+    out = (stbi_uc *)stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);
+    if (!out)
+        return stbi__errpuc("outofmem", "Out of memory");
+    if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {
+        STBI_FREE(out);
+        return stbi__errpuc("bad PNM", "PNM file truncated");
+    }
+
+    if (req_comp && req_comp != s->img_n) {
+        if (ri->bits_per_channel == 16) {
+            out = (stbi_uc *)stbi__convert_format16((stbi__uint16 *)out, s->img_n, req_comp,
+                                                    s->img_x, s->img_y);
+        } else {
+            out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
+        }
+        if (out == NULL)
+            return out;  // stbi__convert_format frees input on failure
+    }
+    return out;
+}
+
+static int stbi__pnm_isspace(char c) {
+    return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+}
+
+static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) {
+    for (;;) {
+        while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
+            *c = (char)stbi__get8(s);
+
+        if (stbi__at_eof(s) || *c != '#')
+            break;
+
+        while (!stbi__at_eof(s) && *c != '\n' && *c != '\r')
+            *c = (char)stbi__get8(s);
+    }
+}
+
+static int stbi__pnm_isdigit(char c) { return c >= '0' && c <= '9'; }
+
+static int stbi__pnm_getinteger(stbi__context *s, char *c) {
+    int value = 0;
+
+    while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
+        value = value * 10 + (*c - '0');
+        *c    = (char)stbi__get8(s);
+        if ((value > 214748364) || (value == 214748364 && *c > '7'))
+            return stbi__err("integer parse overflow",
+                             "Parsing an integer in the PPM header overflowed a 32-bit int");
+    }
+
+    return value;
+}
+
+static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) {
+    int maxv, dummy;
+    char c, p, t;
+
+    if (!x)
+        x = &dummy;
+    if (!y)
+        y = &dummy;
+    if (!comp)
+        comp = &dummy;
+
+    stbi__rewind(s);
+
+    // Get identifier
+    p = (char)stbi__get8(s);
+    t = (char)stbi__get8(s);
+    if (p != 'P' || (t != '5' && t != '6')) {
+        stbi__rewind(s);
+        return 0;
+    }
+
+    *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm
+
+    c = (char)stbi__get8(s);
+    stbi__pnm_skip_whitespace(s, &c);
+
+    *x = stbi__pnm_getinteger(s, &c);  // read width
+    if (*x == 0)
+        return stbi__err("invalid width", "PPM image header had zero or overflowing width");
+    stbi__pnm_skip_whitespace(s, &c);
+
+    *y = stbi__pnm_getinteger(s, &c);  // read height
+    if (*y == 0)
+        return stbi__err("invalid width", "PPM image header had zero or overflowing width");
+    stbi__pnm_skip_whitespace(s, &c);
+
+    maxv = stbi__pnm_getinteger(s, &c);  // read max value
+    if (maxv > 65535)
+        return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");
+    else if (maxv > 255)
+        return 16;
+    else
+        return 8;
+}
+
+static int stbi__pnm_is16(stbi__context *s) {
+    if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)
+        return 1;
+    return 0;
+}
+#endif
+
+static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) {
+#ifndef STBI_NO_JPEG
+    if (stbi__jpeg_info(s, x, y, comp))
+        return 1;
+#endif
+
+#ifndef STBI_NO_PNG
+    if (stbi__png_info(s, x, y, comp))
+        return 1;
+#endif
+
+#ifndef STBI_NO_GIF
+    if (stbi__gif_info(s, x, y, comp))
+        return 1;
+#endif
+
+#ifndef STBI_NO_BMP
+    if (stbi__bmp_info(s, x, y, comp))
+        return 1;
+#endif
+
+#ifndef STBI_NO_PSD
+    if (stbi__psd_info(s, x, y, comp))
+        return 1;
+#endif
+
+#ifndef STBI_NO_PIC
+    if (stbi__pic_info(s, x, y, comp))
+        return 1;
+#endif
+
+#ifndef STBI_NO_PNM
+    if (stbi__pnm_info(s, x, y, comp))
+        return 1;
+#endif
+
+#ifndef STBI_NO_HDR
+    if (stbi__hdr_info(s, x, y, comp))
+        return 1;
+#endif
+
+// test tga last because it's a crappy test!
+#ifndef STBI_NO_TGA
+    if (stbi__tga_info(s, x, y, comp))
+        return 1;
+#endif
+    return stbi__err("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static int stbi__is_16_main(stbi__context *s) {
+#ifndef STBI_NO_PNG
+    if (stbi__png_is16(s))
+        return 1;
+#endif
+
+#ifndef STBI_NO_PSD
+    if (stbi__psd_is16(s))
+        return 1;
+#endif
+
+#ifndef STBI_NO_PNM
+    if (stbi__pnm_is16(s))
+        return 1;
+#endif
+    return 0;
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) {
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f)
+        return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_info_from_file(f, x, y, comp);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) {
+    int r;
+    stbi__context s;
+    long pos = ftell(f);
+    stbi__start_file(&s, f);
+    r = stbi__info_main(&s, x, y, comp);
+    fseek(f, pos, SEEK_SET);
+    return r;
+}
+
+STBIDEF int stbi_is_16_bit(char const *filename) {
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f)
+        return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_is_16_bit_from_file(f);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_is_16_bit_from_file(FILE *f) {
+    int r;
+    stbi__context s;
+    long pos = ftell(f);
+    stbi__start_file(&s, f);
+    r = stbi__is_16_main(&s);
+    fseek(f, pos, SEEK_SET);
+    return r;
+}
+#endif  // !STBI_NO_STDIO
+
+STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) {
+    stbi__context s;
+    stbi__start_mem(&s, buffer, len);
+    return stbi__info_main(&s, x, y, comp);
+}
+
+STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y,
+                                     int *comp) {
+    stbi__context s;
+    stbi__start_callbacks(&s, (stbi_io_callbacks *)c, user);
+    return stbi__info_main(&s, x, y, comp);
+}
+
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) {
+    stbi__context s;
+    stbi__start_mem(&s, buffer, len);
+    return stbi__is_16_main(&s);
+}
+
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) {
+    stbi__context s;
+    stbi__start_callbacks(&s, (stbi_io_callbacks *)c, user);
+    return stbi__is_16_main(&s);
+}
+
+#endif  // STB_IMAGE_IMPLEMENTATION
+
+/*
+   revision history:
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
+                         1-bit BMP
+                         *_is_16_bit api
+                         avoid warnings
+      2.16  (2017-07-23) all functions have 16-bit variants;
+                         STBI_NO_STDIO works again;
+                         compilation fixes;
+                         fix rounding in unpremultiply;
+                         optimize vertical flip;
+                         disable raw_len validation;
+                         documentation fixes
+      2.15  (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
+                         warning fixes; disable run-time SSE detection on gcc;
+                         uniform handling of optional "return" values;
+                         thread-safe initialization of zlib tables
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-11-29) add 16-bit API, only supported for PNG right now
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) allocate large structures on the stack
+                         remove white matting for transparent PSD
+                         fix reported channel count for PNG & BMP
+                         re-enable SSE2 in non-gcc 64-bit
+                         support RGB-formatted JPEG
+                         read 16-bit PNGs (only as 8-bit)
+      2.10  (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
+      2.09  (2016-01-16) allow comments in PNM files
+                         16-bit-per-pixel TGA (not bit-per-component)
+                         info() for TGA could break due to .hdr handling
+                         info() for BMP to shares code instead of sloppy parse
+                         can use STBI_REALLOC_SIZED if allocator doesn't support realloc
+                         code cleanup
+      2.08  (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
+      2.07  (2015-09-13) fix compiler warnings
+                         partial animated GIF support
+                         limited 16-bpc PSD support
+                         #ifdef unused functions
+                         bug with < 92 byte PIC,PNM,HDR,TGA
+      2.06  (2015-04-19) fix bug where PSD returns wrong '*comp' value
+      2.05  (2015-04-19) fix bug in progressive JPEG handling, fix warning
+      2.04  (2015-04-15) try to re-enable SIMD on MinGW 64-bit
+      2.03  (2015-04-12) extra corruption checking (mmozeiko)
+                         stbi_set_flip_vertically_on_load (nguillemot)
+                         fix NEON support; fix mingw support
+      2.02  (2015-01-19) fix incorrect assert, fix warning
+      2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
+      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
+      2.00  (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
+                         progressive JPEG (stb)
+                         PGM/PPM support (Ken Miller)
+                         STBI_MALLOC,STBI_REALLOC,STBI_FREE
+                         GIF bugfix -- seemingly never worked
+                         STBI_NO_*, STBI_ONLY_*
+      1.48  (2014-12-14) fix incorrectly-named assert()
+      1.47  (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
+                         optimize PNG (ryg)
+                         fix bug in interlaced PNG with user-specified channel count (stb)
+      1.46  (2014-08-26)
+              fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
+      1.45  (2014-08-16)
+              fix MSVC-ARM internal compiler error by wrapping malloc
+      1.44  (2014-08-07)
+              various warning fixes from Ronny Chevalier
+      1.43  (2014-07-15)
+              fix MSVC-only compiler problem in code changed in 1.42
+      1.42  (2014-07-09)
+              don't define _CRT_SECURE_NO_WARNINGS (affects user code)
+              fixes to stbi__cleanup_jpeg path
+              added STBI_ASSERT to avoid requiring assert.h
+      1.41  (2014-06-25)
+              fix search&replace from 1.36 that messed up comments/error messages
+      1.40  (2014-06-22)
+              fix gcc struct-initialization warning
+      1.39  (2014-06-15)
+              fix to TGA optimization when req_comp != number of components in TGA;
+              fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
+              add support for BMP version 5 (more ignored fields)
+      1.38  (2014-06-06)
+              suppress MSVC warnings on integer casts truncating values
+              fix accidental rename of 'skip' field of I/O
+      1.37  (2014-06-04)
+              remove duplicate typedef
+      1.36  (2014-06-03)
+              convert to header file single-file library
+              if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
+      1.35  (2014-05-27)
+              various warnings
+              fix broken STBI_SIMD path
+              fix bug where stbi_load_from_file no longer left file pointer in correct place
+              fix broken non-easy path for 32-bit BMP (possibly never used)
+              TGA optimization by Arseny Kapoulkine
+      1.34  (unknown)
+              use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure
+   case 1.33  (2011-07-14) make stbi_is_hdr work in STBI_NO_HDR (as specified), minor
+   compiler-friendly improvements 1.32  (2011-07-13) support for "info" function for all supported
+   filetypes (SpartanJ) 1.31  (2011-06-20) a few more leak fixes, bug in PNG handling (SpartanJ)
+      1.30  (2011-06-11)
+              added ability to load files via callbacks to accomidate custom input streams (Ben
+   Wenger) removed deprecated format-specific test/load functions removed support for installable
+   file formats (stbi_loader) -- would have been broken for IO callbacks anyway error cases in bmp
+   and tga give messages and don't leak (Raymond Barbiero, grisha) fix inefficiency in decoding
+   32-bit BMP (David Woo) 1.29  (2010-08-16) various warning fixes from Aurelien Pocheville 1.28
+   (2010-08-01) fix bug in GIF palette transparency (SpartanJ) 1.27  (2010-08-01) cast-to-stbi_uc to
+   fix warnings 1.26  (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ 1.25
+   (2010-07-17) refix trans_data warning (Won Chun) 1.24  (2010-07-12) perf improvements reading
+   from files on platforms with lock-heavy fgetc() minor perf improvements for jpeg deprecated
+   type-specific functions so we'll get feedback if they're needed attempt to fix trans_data warning
+   (Won Chun) 1.23    fixed bug in iPhone support 1.22  (2010-07-10) removed image *writing* support
+              stbi_info support from Jetro Lauha
+              GIF support from Jean-Marc Lienher
+              iPhone PNG-extensions from James Brown
+              warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
+      1.21    fix use of 'stbi_uc' in header (reported by jon blow)
+      1.20    added support for Softimage PIC, by Tom Seddon
+      1.19    bug in interlaced PNG corruption check (found by ryg)
+      1.18  (2008-08-02)
+              fix a threading bug (local mutable static)
+      1.17    support interlaced PNG
+      1.16    major bugfix - stbi__convert_format converted one too many pixels
+      1.15    initialize some fields for thread safety
+      1.14    fix threadsafe conversion bug
+              header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
+      1.13    threadsafe
+      1.12    const qualifiers in the API
+      1.11    Support installable IDCT, colorspace conversion routines
+      1.10    Fixes for 64-bit (don't use "unsigned long")
+              optimized upsampling by Fabian "ryg" Giesen
+      1.09    Fix format-conversion for PSD code (bad global variables!)
+      1.08    Thatcher Ulrich's PSD code integrated by Nicolas Schulz
+      1.07    attempt to fix C++ warning/errors again
+      1.06    attempt to fix C++ warning/errors again
+      1.05    fix TGA loading to return correct *comp and use good luminance calc
+      1.04    default float alpha is 1, not 255; use 'void *' for stbi_image_free
+      1.03    bugfixes to STBI_NO_STDIO, STBI_NO_HDR
+      1.02    support for (subset of) HDR files, float interface for preferred access to them
+      1.01    fix bug: possible bug in handling right-side up bmps... not sure
+              fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
+      1.00    interface to zlib that skips zlib header
+      0.99    correct handling of alpha in palette
+      0.98    TGA loader by lonesock; dynamically add loaders (untested)
+      0.97    jpeg errors on too large a file; also catch another malloc failure
+      0.96    fix detection of invalid v value - particleman@mollyrocket forum
+      0.95    during header scan, seek to markers in case of padding
+      0.94    STBI_NO_STDIO to disable stdio usage; rename all #defines the same
+      0.93    handle jpegtran output; verbose errors
+      0.92    read 4,8,16,24,32-bit BMP files of several formats
+      0.91    output 24-bit Windows 3.0 BMP files
+      0.90    fix a few more warnings; bump version number to approach 1.0
+      0.61    bugfixes due to Marc LeBlanc, Christopher Lloyd
+      0.60    fix compiling as c++
+      0.59    fix warnings: merge Dave Moore's -Wall fixes
+      0.58    fix bug: zlib uncompressed mode len/nlen was wrong endian
+      0.57    fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
+      0.56    fix bug: zlib uncompressed mode len vs. nlen
+      0.55    fix bug: restart_interval not initialized to 0
+      0.54    allow NULL for 'int *comp'
+      0.53    fix bug in png 3->4; speedup png decoding
+      0.52    png handles req_comp=3,4 directly; minor cleanup; jpeg comments
+      0.51    obey req_comp requests, 1-component jpegs return as 1-component,
+              on 'test' only check type, not whether we support this variant
+      0.50  (2006-11-19)
+              first released version
+*/
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
\ No newline at end of file
diff --git a/lib/stb/stb_image_resize2.h b/lib/stb/stb_image_resize2.h
new file mode 100644
index 00000000..96cbc511
--- /dev/null
+++ b/lib/stb/stb_image_resize2.h
@@ -0,0 +1,11576 @@
+/* stb_image_resize2 - v2.11 - public domain image resizing
+
+   by Jeff Roberts (v2) and Jorge L Rodriguez
+   http://github.com/nothings/stb
+
+   Can be threaded with the extended API. SSE2, AVX, Neon and WASM SIMD support. Only
+   scaling and translation is supported, no rotations or shears.
+
+   COMPILING & LINKING
+      In one C/C++ file that #includes this file, do this:
+         #define STB_IMAGE_RESIZE_IMPLEMENTATION
+      before the #include. That will create the implementation in that file.
+
+   EASY API CALLS:
+     Easy API downsamples w/Mitchell filter, upsamples w/cubic interpolation, clamps to edge.
+
+     stbir_resize_uint8_srgb( input_pixels,  input_w,  input_h,  input_stride_in_bytes,
+                              output_pixels, output_w, output_h, output_stride_in_bytes,
+                              pixel_layout_enum )
+
+     stbir_resize_uint8_linear( input_pixels,  input_w,  input_h,  input_stride_in_bytes,
+                                output_pixels, output_w, output_h, output_stride_in_bytes,
+                                pixel_layout_enum )
+
+     stbir_resize_float_linear( input_pixels,  input_w,  input_h,  input_stride_in_bytes,
+                                output_pixels, output_w, output_h, output_stride_in_bytes,
+                                pixel_layout_enum )
+
+     If you pass NULL or zero for the output_pixels, we will allocate the output buffer
+     for you and return it from the function (free with free() or STBIR_FREE).
+     As a special case, XX_stride_in_bytes of 0 means packed continuously in memory.
+
+   API LEVELS
+      There are three levels of API - easy-to-use, medium-complexity and extended-complexity.
+
+      See the "header file" section of the source for API documentation.
+
+   ADDITIONAL DOCUMENTATION
+
+      MEMORY ALLOCATION
+         By default, we use malloc and free for memory allocation.  To override the
+         memory allocation, before the implementation #include, add a:
+
+            #define STBIR_MALLOC(size,user_data) ...
+            #define STBIR_FREE(ptr,user_data)   ...
+
+         Each resize makes exactly one call to malloc/free (unless you use the
+         extended API where you can do one allocation for many resizes). Under
+         address sanitizer, we do separate allocations to find overread/writes.
+
+      PERFORMANCE
+         This library was written with an emphasis on performance. When testing
+         stb_image_resize with RGBA, the fastest mode is STBIR_4CHANNEL with
+         STBIR_TYPE_UINT8 pixels and CLAMPed edges (which is what many other resize
+         libs do by default). Also, make sure SIMD is turned on of course (default
+         for 64-bit targets). Avoid WRAP edge mode if you want the fastest speed.
+
+         This library also comes with profiling built-in. If you define STBIR_PROFILE,
+         you can use the advanced API and get low-level profiling information by
+         calling stbir_resize_extended_profile_info() or stbir_resize_split_profile_info()
+         after a resize.
+
+      SIMD
+         Most of the routines have optimized SSE2, AVX, NEON and WASM versions.
+
+         On Microsoft compilers, we automatically turn on SIMD for 64-bit x64 and
+         ARM; for 32-bit x86 and ARM, you select SIMD mode by defining STBIR_SSE2 or
+         STBIR_NEON. For AVX and AVX2, we auto-select it by detecting the /arch:AVX
+         or /arch:AVX2 switches. You can also always manually turn SSE2, AVX or AVX2
+         support on by defining STBIR_SSE2, STBIR_AVX or STBIR_AVX2.
+
+         On Linux, SSE2 and Neon is on by default for 64-bit x64 or ARM64. For 32-bit,
+         we select x86 SIMD mode by whether you have -msse2, -mavx or -mavx2 enabled
+         on the command line. For 32-bit ARM, you must pass -mfpu=neon-vfpv4 for both
+         clang and GCC, but GCC also requires an additional -mfp16-format=ieee to
+         automatically enable NEON.
+
+         On x86 platforms, you can also define STBIR_FP16C to turn on FP16C instructions
+         for converting back and forth to half-floats. This is autoselected when we
+         are using AVX2. Clang and GCC also require the -mf16c switch. ARM always uses
+         the built-in half float hardware NEON instructions.
+
+         You can also tell us to use multiply-add instructions with STBIR_USE_FMA.
+         Because x86 doesn't always have fma, we turn it off by default to maintain
+         determinism across all platforms. If you don't care about non-FMA determinism
+         and are willing to restrict yourself to more recent x86 CPUs (around the AVX
+         timeframe), then fma will give you around a 15% speedup.
+
+         You can force off SIMD in all cases by defining STBIR_NO_SIMD. You can turn
+         off AVX or AVX2 specifically with STBIR_NO_AVX or STBIR_NO_AVX2. AVX is 10%
+         to 40% faster, and AVX2 is generally another 12%.
+
+      ALPHA CHANNEL
+         Most of the resizing functions provide the ability to control how the alpha
+         channel of an image is processed.
+
+         When alpha represents transparency, it is important that when combining
+         colors with filtering, the pixels should not be treated equally; they
+         should use a weighted average based on their alpha values. For example,
+         if a pixel is 1% opaque bright green and another pixel is 99% opaque
+         black and you average them, the average will be 50% opaque, but the
+         unweighted average and will be a middling green color, while the weighted
+         average will be nearly black. This means the unweighted version introduced
+         green energy that didn't exist in the source image.
+
+         (If you want to know why this makes sense, you can work out the math for
+         the following: consider what happens if you alpha composite a source image
+         over a fixed color and then average the output, vs. if you average the
+         source image pixels and then composite that over the same fixed color.
+         Only the weighted average produces the same result as the ground truth
+         composite-then-average result.)
+
+         Therefore, it is in general best to "alpha weight" the pixels when applying
+         filters to them. This essentially means multiplying the colors by the alpha
+         values before combining them, and then dividing by the alpha value at the
+         end.
+
+         The computer graphics industry introduced a technique called "premultiplied
+         alpha" or "associated alpha" in which image colors are stored in image files
+         already multiplied by their alpha. This saves some math when compositing,
+         and also avoids the need to divide by the alpha at the end (which is quite
+         inefficient). However, while premultiplied alpha is common in the movie CGI
+         industry, it is not commonplace in other industries like videogames, and most
+         consumer file formats are generally expected to contain not-premultiplied
+         colors. For example, Photoshop saves PNG files "unpremultiplied", and web
+         browsers like Chrome and Firefox expect PNG images to be unpremultiplied.
+
+         Note that there are three possibilities that might describe your image
+         and resize expectation:
+
+             1. images are not premultiplied, alpha weighting is desired
+             2. images are not premultiplied, alpha weighting is not desired
+             3. images are premultiplied
+
+         Both case #2 and case #3 require the exact same math: no alpha weighting
+         should be applied or removed. Only case 1 requires extra math operations;
+         the other two cases can be handled identically.
+
+         stb_image_resize expects case #1 by default, applying alpha weighting to
+         images, expecting the input images to be unpremultiplied. This is what the
+         COLOR+ALPHA buffer types tell the resizer to do.
+
+         When you use the pixel layouts STBIR_RGBA, STBIR_BGRA, STBIR_ARGB,
+         STBIR_ABGR, STBIR_RX, or STBIR_XR you are telling us that the pixels are
+         non-premultiplied. In these cases, the resizer will alpha weight the colors
+         (effectively creating the premultiplied image), do the filtering, and then
+         convert back to non-premult on exit.
+
+         When you use the pixel layouts STBIR_RGBA_PM, STBIR_RGBA_PM, STBIR_RGBA_PM,
+         STBIR_RGBA_PM, STBIR_RX_PM or STBIR_XR_PM, you are telling that the pixels
+         ARE premultiplied. In this case, the resizer doesn't have to do the
+         premultipling - it can filter directly on the input. This about twice as
+         fast as the non-premultiplied case, so it's the right option if your data is
+         already setup correctly.
+
+         When you use the pixel layout STBIR_4CHANNEL or STBIR_2CHANNEL, you are
+         telling us that there is no channel that represents transparency; it may be
+         RGB and some unrelated fourth channel that has been stored in the alpha
+         channel, but it is actually not alpha. No special processing will be
+         performed.
+
+         The difference between the generic 4 or 2 channel layouts, and the
+         specialized _PM versions is with the _PM versions you are telling us that
+         the data *is* alpha, just don't premultiply it. That's important when
+         using SRGB pixel formats, we need to know where the alpha is, because
+         it is converted linearly (rather than with the SRGB converters).
+
+         Because alpha weighting produces the same effect as premultiplying, you
+         even have the option with non-premultiplied inputs to let the resizer
+         produce a premultiplied output. Because the intially computed alpha-weighted
+         output image is effectively premultiplied, this is actually more performant
+         than the normal path which un-premultiplies the output image as a final step.
+
+         Finally, when converting both in and out of non-premulitplied space (for
+         example, when using STBIR_RGBA), we go to somewhat heroic measures to
+         ensure that areas with zero alpha value pixels get something reasonable
+         in the RGB values. If you don't care about the RGB values of zero alpha
+         pixels, you can call the stbir_set_non_pm_alpha_speed_over_quality()
+         function - this runs a premultiplied resize about 25% faster. That said,
+         when you really care about speed, using premultiplied pixels for both in
+         and out (STBIR_RGBA_PM, etc) much faster than both of these premultiplied
+         options.
+
+      PIXEL LAYOUT CONVERSION
+         The resizer can convert from some pixel layouts to others. When using the
+         stbir_set_pixel_layouts(), you can, for example, specify STBIR_RGBA
+         on input, and STBIR_ARGB on output, and it will re-organize the channels
+         during the resize. Currently, you can only convert between two pixel
+         layouts with the same number of channels.
+
+      DETERMINISM
+         We commit to being deterministic (from x64 to ARM to scalar to SIMD, etc).
+         This requires compiling with fast-math off (using at least /fp:precise).
+         Also, you must turn off fp-contracting (which turns mult+adds into fmas)!
+         We attempt to do this with pragmas, but with Clang, you usually want to add
+         -ffp-contract=off to the command line as well.
+
+         For 32-bit x86, you must use SSE and SSE2 codegen for determinism. That is,
+         if the scalar x87 unit gets used at all, we immediately lose determinism.
+         On Microsoft Visual Studio 2008 and earlier, from what we can tell there is
+         no way to be deterministic in 32-bit x86 (some x87 always leaks in, even
+         with fp:strict). On 32-bit x86 GCC, determinism requires both -msse2 and
+         -fpmath=sse.
+
+         Note that we will not be deterministic with float data containing NaNs -
+         the NaNs will propagate differently on different SIMD and platforms.
+
+         If you turn on STBIR_USE_FMA, then we will be deterministic with other
+         fma targets, but we will differ from non-fma targets (this is unavoidable,
+         because a fma isn't simply an add with a mult - it also introduces a
+         rounding difference compared to non-fma instruction sequences.
+
+      FLOAT PIXEL FORMAT RANGE
+         Any range of values can be used for the non-alpha float data that you pass
+         in (0 to 1, -1 to 1, whatever). However, if you are inputting float values
+         but *outputting* bytes or shorts, you must use a range of 0 to 1 so that we
+         scale back properly. The alpha channel must also be 0 to 1 for any format
+         that does premultiplication prior to resizing.
+
+         Note also that with float output, using filters with negative lobes, the
+         output filtered values might go slightly out of range. You can define
+         STBIR_FLOAT_LOW_CLAMP and/or STBIR_FLOAT_HIGH_CLAMP to specify the range
+         to clamp to on output, if that's important.
+
+      MAX/MIN SCALE FACTORS
+         The input pixel resolutions are in integers, and we do the internal pointer
+         resolution in size_t sized integers. However, the scale ratio from input
+         resolution to output resolution is calculated in float form. This means
+         the effective possible scale ratio is limited to 24 bits (or 16 million
+         to 1). As you get close to the size of the float resolution (again, 16
+         million pixels wide or high), you might start seeing float inaccuracy
+         issues in general in the pipeline. If you have to do extreme resizes,
+         you can usually do this is multiple stages (using float intermediate
+         buffers).
+
+      FLIPPED IMAGES
+         Stride is just the delta from one scanline to the next. This means you can
+         use a negative stride to handle inverted images (point to the final
+         scanline and use a negative stride). You can invert the input or output,
+         using negative strides.
+
+      DEFAULT FILTERS
+         For functions which don't provide explicit control over what filters to
+         use, you can change the compile-time defaults with:
+
+            #define STBIR_DEFAULT_FILTER_UPSAMPLE     STBIR_FILTER_something
+            #define STBIR_DEFAULT_FILTER_DOWNSAMPLE   STBIR_FILTER_something
+
+         See stbir_filter in the header-file section for the list of filters.
+
+      NEW FILTERS
+         A number of 1D filter kernels are supplied. For a list of supported
+         filters, see the stbir_filter enum. You can install your own filters by
+         using the stbir_set_filter_callbacks function.
+
+      PROGRESS
+         For interactive use with slow resize operations, you can use the the
+         scanline callbacks in the extended API. It would have to be a *very* large
+         image resample to need progress though - we're very fast.
+
+      CEIL and FLOOR
+         In scalar mode, the only functions we use from math.h are ceilf and floorf,
+         but if you have your own versions, you can define the STBIR_CEILF(v) and
+         STBIR_FLOORF(v) macros and we'll use them instead. In SIMD, we just use
+         our own versions.
+
+      ASSERT
+         Define STBIR_ASSERT(boolval) to override assert() and not use assert.h
+
+     PORTING FROM VERSION 1
+        The API has changed. You can continue to use the old version of stb_image_resize.h,
+        which is available in the "deprecated/" directory.
+
+        If you're using the old simple-to-use API, porting is straightforward.
+        (For more advanced APIs, read the documentation.)
+
+          stbir_resize_uint8():
+            - call `stbir_resize_uint8_linear`, cast channel count to `stbir_pixel_layout`
+
+          stbir_resize_float():
+            - call `stbir_resize_float_linear`, cast channel count to `stbir_pixel_layout`
+
+          stbir_resize_uint8_srgb():
+            - function name is unchanged
+            - cast channel count to `stbir_pixel_layout`
+            - above is sufficient unless your image has alpha and it's not RGBA/BGRA
+              - in that case, follow the below instructions for stbir_resize_uint8_srgb_edgemode
+
+          stbir_resize_uint8_srgb_edgemode()
+            - switch to the "medium complexity" API
+            - stbir_resize(), very similar API but a few more parameters:
+              - pixel_layout: cast channel count to `stbir_pixel_layout`
+              - data_type:    STBIR_TYPE_UINT8_SRGB
+              - edge:         unchanged (STBIR_EDGE_WRAP, etc.)
+              - filter:       STBIR_FILTER_DEFAULT
+            - which channel is alpha is specified in stbir_pixel_layout, see enum for details
+
+      FUTURE TODOS
+        *  For polyphase integral filters, we just memcpy the coeffs to dupe
+           them, but we should indirect and use the same coeff memory.
+        *  Add pixel layout conversions for sensible different channel counts
+           (maybe, 1->3/4, 3->4, 4->1, 3->1).
+         * For SIMD encode and decode scanline routines, do any pre-aligning
+           for bad input/output buffer alignments and pitch?
+         * For very wide scanlines, we should we do vertical strips to stay within
+           L2 cache. Maybe do chunks of 1K pixels at a time. There would be
+           some pixel reconversion, but probably dwarfed by things falling out
+           of cache. Probably also something possible with alternating between
+           scattering and gathering at high resize scales?
+         * Rewrite the coefficient generator to do many at once.
+         * AVX-512 vertical kernels - worried about downclocking here.
+         * Convert the reincludes to macros when we know they aren't changing.
+         * Experiment with pivoting the horizontal and always using the
+           vertical filters (which are faster, but perhaps not enough to overcome
+           the pivot cost and the extra memory touches). Need to buffer the whole
+           image so have to balance memory use.
+         * Most of our code is internally function pointers, should we compile
+           all the SIMD stuff always and dynamically dispatch?
+
+   CONTRIBUTORS
+      Jeff Roberts: 2.0 implementation, optimizations, SIMD
+      Martins Mozeiko: NEON simd, WASM simd, clang and GCC whisperer
+      Fabian Giesen: half float and srgb converters
+      Sean Barrett: API design, optimizations
+      Jorge L Rodriguez: Original 1.0 implementation
+      Aras Pranckevicius: bugfixes
+      Nathan Reed: warning fixes for 1.0
+
+   REVISIONS
+      2.11 (2024-09-08) fix harmless asan warnings in 2-channel and 3-channel mode
+                          with AVX-2, fix some weird scaling edge conditions with
+                          point sample mode.
+      2.10 (2024-07-27) fix the defines GCC and mingw for loop unroll control,
+                          fix MSVC 32-bit arm half float routines.
+      2.09 (2024-06-19) fix the defines for 32-bit ARM GCC builds (was selecting
+                          hardware half floats).
+      2.08 (2024-06-10) fix for RGB->BGR three channel flips and add SIMD (thanks
+                          to Ryan Salsbury), fix for sub-rect resizes, use the
+                          pragmas to control unrolling when they are available.
+      2.07 (2024-05-24) fix for slow final split during threaded conversions of very
+                          wide scanlines when downsampling (caused by extra input
+                          converting), fix for wide scanline resamples with many
+                          splits (int overflow), fix GCC warning.
+      2.06 (2024-02-10) fix for identical width/height 3x or more down-scaling
+                          undersampling a single row on rare resize ratios (about 1%).
+      2.05 (2024-02-07) fix for 2 pixel to 1 pixel resizes with wrap (thanks Aras),
+                        fix for output callback (thanks Julien Koenen).
+      2.04 (2023-11-17) fix for rare AVX bug, shadowed symbol (thanks Nikola Smiljanic).
+      2.03 (2023-11-01) ASAN and TSAN warnings fixed, minor tweaks.
+      2.00 (2023-10-10) mostly new source: new api, optimizations, simd, vertical-first, etc
+                          2x-5x faster without simd, 4x-12x faster with simd,
+                          in some cases, 20x to 40x faster esp resizing large to very small.
+      0.96 (2019-03-04) fixed warnings
+      0.95 (2017-07-23) fixed warnings
+      0.94 (2017-03-18) fixed warnings
+      0.93 (2017-03-03) fixed bug with certain combinations of heights
+      0.92 (2017-01-02) fix integer overflow on large (>2GB) images
+      0.91 (2016-04-02) fix warnings; fix handling of subpixel regions
+      0.90 (2014-09-17) first released version
+
+   LICENSE
+     See end of file for license information.
+*/
+
+#if !defined(STB_IMAGE_RESIZE_DO_HORIZONTALS) && !defined(STB_IMAGE_RESIZE_DO_VERTICALS) &&        \
+    !defined(STB_IMAGE_RESIZE_DO_CODERS)  // for internal re-includes
+
+#ifndef STBIR_INCLUDE_STB_IMAGE_RESIZE2_H
+#define STBIR_INCLUDE_STB_IMAGE_RESIZE2_H
+
+#include <stddef.h>
+#ifdef _MSC_VER
+typedef unsigned char stbir_uint8;
+typedef unsigned short stbir_uint16;
+typedef unsigned int stbir_uint32;
+typedef unsigned __int64 stbir_uint64;
+#else
+#include <stdint.h>
+typedef uint8_t stbir_uint8;
+typedef uint16_t stbir_uint16;
+typedef uint32_t stbir_uint32;
+typedef uint64_t stbir_uint64;
+#endif
+
+#ifdef _M_IX86_FP
+#if (_M_IX86_FP >= 1)
+#ifndef STBIR_SSE
+#define STBIR_SSE
+#endif
+#endif
+#endif
+
+#if defined(_x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__x86_64) ||             \
+    defined(_M_AMD64) || defined(__SSE2__) || defined(STBIR_SSE) || defined(STBIR_SSE2)
+#ifndef STBIR_SSE2
+#define STBIR_SSE2
+#endif
+#if defined(__AVX__) || defined(STBIR_AVX2)
+#ifndef STBIR_AVX
+#ifndef STBIR_NO_AVX
+#define STBIR_AVX
+#endif
+#endif
+#endif
+#if defined(__AVX2__) || defined(STBIR_AVX2)
+#ifndef STBIR_NO_AVX2
+#ifndef STBIR_AVX2
+#define STBIR_AVX2
+#endif
+#if defined(_MSC_VER) && !defined(__clang__)
+#ifndef STBIR_FP16C  // FP16C instructions are on all AVX2 cpus, so we can autoselect it here on
+                     // microsoft - clang needs -m16c
+#define STBIR_FP16C
+#endif
+#endif
+#endif
+#endif
+#ifdef __F16C__
+#ifndef STBIR_FP16C  // turn on FP16C instructions if the define is set (for clang and gcc)
+#define STBIR_FP16C
+#endif
+#endif
+#endif
+
+#if defined(_M_ARM64) || defined(__aarch64__) || defined(__arm64__) ||                             \
+    ((__ARM_NEON_FP & 4) != 0) || defined(__ARM_NEON__)
+#ifndef STBIR_NEON
+#define STBIR_NEON
+#endif
+#endif
+
+#if defined(_M_ARM) || defined(__arm__)
+#ifdef STBIR_USE_FMA
+#undef STBIR_USE_FMA  // no FMA for 32-bit arm on MSVC
+#endif
+#endif
+
+#if defined(__wasm__) && defined(__wasm_simd128__)
+#ifndef STBIR_WASM
+#define STBIR_WASM
+#endif
+#endif
+
+#ifndef STBIRDEF
+#ifdef STB_IMAGE_RESIZE_STATIC
+#define STBIRDEF static
+#else
+#ifdef __cplusplus
+#define STBIRDEF extern "C"
+#else
+#define STBIRDEF extern
+#endif
+#endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+////   start "header file" ///////////////////////////////////////////////////
+//
+// Easy-to-use API:
+//
+//     * stride is the offset between successive rows of image data
+//        in memory, in bytes. specify 0 for packed continuously in memory
+//     * colorspace is linear or sRGB as specified by function name
+//     * Uses the default filters
+//     * Uses edge mode clamped
+//     * returned result is 1 for success or 0 in case of an error.
+
+// stbir_pixel_layout specifies:
+//   number of channels
+//   order of channels
+//   whether color is premultiplied by alpha
+// for back compatibility, you can cast the old channel count to an stbir_pixel_layout
+typedef enum {
+    STBIR_1CHANNEL = 1,
+    STBIR_2CHANNEL = 2,
+    STBIR_RGB      = 3,  // 3-chan, with order specified (for channel flipping)
+    STBIR_BGR      = 0,  // 3-chan, with order specified (for channel flipping)
+    STBIR_4CHANNEL = 5,
+
+    STBIR_RGBA = 4,  // alpha formats, where alpha is NOT premultiplied into color channels
+    STBIR_BGRA = 6,
+    STBIR_ARGB = 7,
+    STBIR_ABGR = 8,
+    STBIR_RA   = 9,
+    STBIR_AR   = 10,
+
+    STBIR_RGBA_PM = 11,  // alpha formats, where alpha is premultiplied into color channels
+    STBIR_BGRA_PM = 12,
+    STBIR_ARGB_PM = 13,
+    STBIR_ABGR_PM = 14,
+    STBIR_RA_PM   = 15,
+    STBIR_AR_PM   = 16,
+
+    STBIR_RGBA_NO_AW = 11,  // alpha formats, where NO alpha weighting is applied at all!
+    STBIR_BGRA_NO_AW = 12,  //   these are just synonyms for the _PM flags (which also do
+    STBIR_ARGB_NO_AW = 13,  //   no alpha weighting). These names just make it more clear
+    STBIR_ABGR_NO_AW = 14,  //   for some folks).
+    STBIR_RA_NO_AW   = 15,
+    STBIR_AR_NO_AW   = 16,
+
+} stbir_pixel_layout;
+
+//===============================================================
+//  Simple-complexity API
+//
+//    If output_pixels is NULL (0), then we will allocate the buffer and return it to you.
+//--------------------------------
+
+STBIRDEF unsigned char *stbir_resize_uint8_srgb(const unsigned char *input_pixels, int input_w,
+                                                int input_h, int input_stride_in_bytes,
+                                                unsigned char *output_pixels, int output_w,
+                                                int output_h, int output_stride_in_bytes,
+                                                stbir_pixel_layout pixel_type);
+
+STBIRDEF unsigned char *stbir_resize_uint8_linear(const unsigned char *input_pixels, int input_w,
+                                                  int input_h, int input_stride_in_bytes,
+                                                  unsigned char *output_pixels, int output_w,
+                                                  int output_h, int output_stride_in_bytes,
+                                                  stbir_pixel_layout pixel_type);
+
+STBIRDEF float *stbir_resize_float_linear(const float *input_pixels, int input_w, int input_h,
+                                          int input_stride_in_bytes, float *output_pixels,
+                                          int output_w, int output_h, int output_stride_in_bytes,
+                                          stbir_pixel_layout pixel_type);
+//===============================================================
+
+//===============================================================
+// Medium-complexity API
+//
+// This extends the easy-to-use API as follows:
+//
+//     * Can specify the datatype - U8, U8_SRGB, U16, FLOAT, HALF_FLOAT
+//     * Edge wrap can selected explicitly
+//     * Filter can be selected explicitly
+//--------------------------------
+
+typedef enum {
+    STBIR_EDGE_CLAMP   = 0,
+    STBIR_EDGE_REFLECT = 1,
+    STBIR_EDGE_WRAP    = 2,  // this edge mode is slower and uses more memory
+    STBIR_EDGE_ZERO    = 3,
+} stbir_edge;
+
+typedef enum {
+    STBIR_FILTER_DEFAULT = 0,  // use same filter type that easy-to-use API chooses
+    STBIR_FILTER_BOX =
+        1,  // A trapezoid w/1-pixel wide ramps, same result as box for integer scale ratios
+    STBIR_FILTER_TRIANGLE =
+        2,  // On upsampling, produces same results as bilinear texture filtering
+    STBIR_FILTER_CUBICBSPLINE =
+        3,  // The cubic b-spline (aka Mitchell-Netrevalli with B=1,C=0), gaussian-esque
+    STBIR_FILTER_CATMULLROM   = 4,  // An interpolating cubic spline
+    STBIR_FILTER_MITCHELL     = 5,  // Mitchell-Netrevalli filter with B=1/3, C=1/3
+    STBIR_FILTER_POINT_SAMPLE = 6,  // Simple point sampling
+    STBIR_FILTER_OTHER        = 7,  // User callback specified
+} stbir_filter;
+
+typedef enum {
+    STBIR_TYPE_UINT8      = 0,
+    STBIR_TYPE_UINT8_SRGB = 1,
+    STBIR_TYPE_UINT8_SRGB_ALPHA =
+        2,  // alpha channel, when present, should also be SRGB (this is very unusual)
+    STBIR_TYPE_UINT16     = 3,
+    STBIR_TYPE_FLOAT      = 4,
+    STBIR_TYPE_HALF_FLOAT = 5
+} stbir_datatype;
+
+// medium api
+STBIRDEF void *stbir_resize(const void *input_pixels, int input_w, int input_h,
+                            int input_stride_in_bytes, void *output_pixels, int output_w,
+                            int output_h, int output_stride_in_bytes,
+                            stbir_pixel_layout pixel_layout, stbir_datatype data_type,
+                            stbir_edge edge, stbir_filter filter);
+//===============================================================
+
+//===============================================================
+// Extended-complexity API
+//
+// This API exposes all resize functionality.
+//
+//     * Separate filter types for each axis
+//     * Separate edge modes for each axis
+//     * Separate input and output data types
+//     * Can specify regions with subpixel correctness
+//     * Can specify alpha flags
+//     * Can specify a memory callback
+//     * Can specify a callback data type for pixel input and output
+//     * Can be threaded for a single resize
+//     * Can be used to resize many frames without recalculating the sampler info
+//
+//  Use this API as follows:
+//     1) Call the stbir_resize_init function on a local STBIR_RESIZE structure
+//     2) Call any of the stbir_set functions
+//     3) Optionally call stbir_build_samplers() if you are going to resample multiple times
+//        with the same input and output dimensions (like resizing video frames)
+//     4) Resample by calling stbir_resize_extended().
+//     5) Call stbir_free_samplers() if you called stbir_build_samplers()
+//--------------------------------
+
+// Types:
+
+// INPUT CALLBACK: this callback is used for input scanlines
+typedef void const *stbir_input_callback(void *optional_output, void const *input_ptr,
+                                         int num_pixels, int x, int y, void *context);
+
+// OUTPUT CALLBACK: this callback is used for output scanlines
+typedef void stbir_output_callback(void const *output_ptr, int num_pixels, int y, void *context);
+
+// callbacks for user installed filters
+typedef float stbir__kernel_callback(float x, float scale, void *user_data);  // centered at zero
+typedef float stbir__support_callback(float scale, void *user_data);
+
+// internal structure with precomputed scaling
+typedef struct stbir__info stbir__info;
+
+typedef struct STBIR_RESIZE  // use the stbir_resize_init and stbir_override functions to set these
+                             // values for future compatibility
+{
+    void *user_data;
+    void const *input_pixels;
+    int input_w, input_h;
+    double input_s0, input_t0, input_s1, input_t1;
+    stbir_input_callback *input_cb;
+    void *output_pixels;
+    int output_w, output_h;
+    int output_subx, output_suby, output_subw, output_subh;
+    stbir_output_callback *output_cb;
+    int input_stride_in_bytes;
+    int output_stride_in_bytes;
+    int splits;
+    int fast_alpha;
+    int needs_rebuild;
+    int called_alloc;
+    stbir_pixel_layout input_pixel_layout_public;
+    stbir_pixel_layout output_pixel_layout_public;
+    stbir_datatype input_data_type;
+    stbir_datatype output_data_type;
+    stbir_filter horizontal_filter, vertical_filter;
+    stbir_edge horizontal_edge, vertical_edge;
+    stbir__kernel_callback *horizontal_filter_kernel;
+    stbir__support_callback *horizontal_filter_support;
+    stbir__kernel_callback *vertical_filter_kernel;
+    stbir__support_callback *vertical_filter_support;
+    stbir__info *samplers;
+} STBIR_RESIZE;
+
+// extended complexity api
+
+// First off, you must ALWAYS call stbir_resize_init on your resize structure before any of the
+// other calls!
+STBIRDEF void stbir_resize_init(STBIR_RESIZE *resize, const void *input_pixels, int input_w,
+                                int input_h, int input_stride_in_bytes,  // stride can be zero
+                                void *output_pixels, int output_w, int output_h,
+                                int output_stride_in_bytes,  // stride can be zero
+                                stbir_pixel_layout pixel_layout, stbir_datatype data_type);
+
+//===============================================================
+// You can update these parameters any time after resize_init and there is no cost
+//--------------------------------
+
+STBIRDEF void stbir_set_datatypes(STBIR_RESIZE *resize, stbir_datatype input_type,
+                                  stbir_datatype output_type);
+STBIRDEF void
+stbir_set_pixel_callbacks(STBIR_RESIZE *resize, stbir_input_callback *input_cb,
+                          stbir_output_callback *output_cb);  // no callbacks by default
+STBIRDEF void stbir_set_user_data(STBIR_RESIZE *resize,
+                                  void *user_data);  // pass back STBIR_RESIZE* by default
+STBIRDEF void stbir_set_buffer_ptrs(STBIR_RESIZE *resize, const void *input_pixels,
+                                    int input_stride_in_bytes, void *output_pixels,
+                                    int output_stride_in_bytes);
+
+//===============================================================
+
+//===============================================================
+// If you call any of these functions, you will trigger a sampler rebuild!
+//--------------------------------
+
+STBIRDEF int
+stbir_set_pixel_layouts(STBIR_RESIZE *resize, stbir_pixel_layout input_pixel_layout,
+                        stbir_pixel_layout output_pixel_layout);  // sets new buffer layouts
+STBIRDEF int stbir_set_edgemodes(STBIR_RESIZE *resize, stbir_edge horizontal_edge,
+                                 stbir_edge vertical_edge);  // CLAMP by default
+
+STBIRDEF int stbir_set_filters(
+    STBIR_RESIZE *resize, stbir_filter horizontal_filter,
+    stbir_filter vertical_filter);  // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default
+STBIRDEF int stbir_set_filter_callbacks(STBIR_RESIZE *resize,
+                                        stbir__kernel_callback *horizontal_filter,
+                                        stbir__support_callback *horizontal_support,
+                                        stbir__kernel_callback *vertical_filter,
+                                        stbir__support_callback *vertical_support);
+
+STBIRDEF int stbir_set_pixel_subrect(STBIR_RESIZE *resize, int subx, int suby, int subw,
+                                     int subh);  // sets both sub-regions (full regions by default)
+STBIRDEF int stbir_set_input_subrect(STBIR_RESIZE *resize, double s0, double t0, double s1,
+                                     double t1);  // sets input sub-region (full region by default)
+STBIRDEF int
+stbir_set_output_pixel_subrect(STBIR_RESIZE *resize, int subx, int suby, int subw,
+                               int subh);  // sets output sub-region (full region by default)
+
+// when inputting AND outputting non-premultiplied alpha pixels, we use a slower but higher quality
+// technique
+//   that fills the zero alpha pixel's RGB values with something plausible.  If you don't care about
+//   areas of zero alpha, you can call this function to get about a 25% speed improvement for
+//   STBIR_RGBA to STBIR_RGBA types of resizes.
+STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality(STBIR_RESIZE *resize,
+                                                       int non_pma_alpha_speed_over_quality);
+//===============================================================
+
+//===============================================================
+// You can call build_samplers to prebuild all the internal data we need to resample.
+//   Then, if you call resize_extended many times with the same resize, you only pay the
+//   cost once.
+// If you do call build_samplers, you MUST call free_samplers eventually.
+//--------------------------------
+
+// This builds the samplers and does one allocation
+STBIRDEF int stbir_build_samplers(STBIR_RESIZE *resize);
+
+// You MUST call this, if you call stbir_build_samplers or stbir_build_samplers_with_splits
+STBIRDEF void stbir_free_samplers(STBIR_RESIZE *resize);
+//===============================================================
+
+// And this is the main function to perform the resize synchronously on one thread.
+STBIRDEF int stbir_resize_extended(STBIR_RESIZE *resize);
+
+//===============================================================
+// Use these functions for multithreading.
+//   1) You call stbir_build_samplers_with_splits first on the main thread
+//   2) Then stbir_resize_with_split on each thread
+//   3) stbir_free_samplers when done on the main thread
+//--------------------------------
+
+// This will build samplers for threading.
+//   You can pass in the number of threads you'd like to use (try_splits).
+//   It returns the number of splits (threads) that you can call it with.
+///  It might be less if the image resize can't be split up that many ways.
+
+STBIRDEF int stbir_build_samplers_with_splits(STBIR_RESIZE *resize, int try_splits);
+
+// This function does a split of the resizing (you call this fuction for each
+// split, on multiple threads). A split is a piece of the output resize pixel space.
+
+// Note that you MUST call stbir_build_samplers_with_splits before stbir_resize_extended_split!
+
+// Usually, you will always call stbir_resize_split with split_start as the thread_index
+//   and "1" for the split_count.
+// But, if you have a weird situation where you MIGHT want 8 threads, but sometimes
+//   only 4 threads, you can use 0,2,4,6 for the split_start's and use "2" for the
+//   split_count each time to turn in into a 4 thread resize. (This is unusual).
+
+STBIRDEF int stbir_resize_extended_split(STBIR_RESIZE *resize, int split_start, int split_count);
+//===============================================================
+
+//===============================================================
+// Pixel Callbacks info:
+//--------------------------------
+
+//   The input callback is super flexible - it calls you with the input address
+//   (based on the stride and base pointer), it gives you an optional_output
+//   pointer that you can fill, or you can just return your own pointer into
+//   your own data.
+//
+//   You can also do conversion from non-supported data types if necessary - in
+//   this case, you ignore the input_ptr and just use the x and y parameters to
+//   calculate your own input_ptr based on the size of each non-supported pixel.
+//   (Something like the third example below.)
+//
+//   You can also install just an input or just an output callback by setting the
+//   callback that you don't want to zero.
+//
+//     First example, progress: (getting a callback that you can monitor the progress):
+//        void const * my_callback( void * optional_output, void const * input_ptr, int num_pixels,
+//        int x, int y, void * context )
+//        {
+//           percentage_done = y / input_height;
+//           return input_ptr;  // use buffer from call
+//        }
+//
+//     Next example, copying: (copy from some other buffer or stream):
+//        void const * my_callback( void * optional_output, void const * input_ptr, int num_pixels,
+//        int x, int y, void * context )
+//        {
+//           CopyOrStreamData( optional_output, other_data_src, num_pixels * pixel_width_in_bytes );
+//           return optional_output;  // return the optional buffer that we filled
+//        }
+//
+//     Third example, input another buffer without copying: (zero-copy from other buffer):
+//        void const * my_callback( void * optional_output, void const * input_ptr, int num_pixels,
+//        int x, int y, void * context )
+//        {
+//           void * pixels = ( (char*) other_image_base ) + ( y * other_image_stride ) + ( x *
+//           other_pixel_width_in_bytes ); return pixels;       // return pointer to your data
+//           without copying
+//        }
+//
+//
+//   The output callback is considerably simpler - it just calls you so that you can dump
+//   out each scanline. You could even directly copy out to disk if you have a simple format
+//   like TGA or BMP. You can also convert to other output types here if you want.
+//
+//   Simple example:
+//        void const * my_output( void * output_ptr, int num_pixels, int y, void * context )
+//        {
+//           percentage_done = y / output_height;
+//           fwrite( output_ptr, pixel_width_in_bytes, num_pixels, output_file );
+//        }
+//===============================================================
+
+//===============================================================
+// optional built-in profiling API
+//--------------------------------
+
+#ifdef STBIR_PROFILE
+
+typedef struct STBIR_PROFILE_INFO {
+    stbir_uint64 total_clocks;
+
+    // how many clocks spent (of total_clocks) in the various resize routines, along with a string
+    // description
+    //    there are "resize_count" number of zones
+    stbir_uint64 clocks[8];
+    char const **descriptions;
+
+    // count of clocks and descriptions
+    stbir_uint32 count;
+} STBIR_PROFILE_INFO;
+
+// use after calling stbir_resize_extended (or stbir_build_samplers or
+// stbir_build_samplers_with_splits)
+STBIRDEF void stbir_resize_build_profile_info(STBIR_PROFILE_INFO *out_info,
+                                              STBIR_RESIZE const *resize);
+
+// use after calling stbir_resize_extended
+STBIRDEF void stbir_resize_extended_profile_info(STBIR_PROFILE_INFO *out_info,
+                                                 STBIR_RESIZE const *resize);
+
+// use after calling stbir_resize_extended_split
+STBIRDEF void stbir_resize_split_profile_info(STBIR_PROFILE_INFO *out_info,
+                                              STBIR_RESIZE const *resize, int split_start,
+                                              int split_num);
+
+//===============================================================
+
+#endif
+
+////   end header file   /////////////////////////////////////////////////////
+#endif  // STBIR_INCLUDE_STB_IMAGE_RESIZE2_H
+
+#if defined(STB_IMAGE_RESIZE_IMPLEMENTATION) || defined(STB_IMAGE_RESIZE2_IMPLEMENTATION)
+
+#ifndef STBIR_ASSERT
+#include <assert.h>
+#define STBIR_ASSERT(x) assert(x)
+#endif
+
+#ifndef STBIR_MALLOC
+#include <stdlib.h>
+#define STBIR_MALLOC(size, user_data) ((void)(user_data), malloc(size))
+#define STBIR_FREE(ptr, user_data)    ((void)(user_data), free(ptr))
+// (we used the comma operator to evaluate user_data, to avoid "unused parameter" warnings)
+#endif
+
+#ifdef _MSC_VER
+
+#define stbir__inline __forceinline
+
+#else
+
+#define stbir__inline __inline__
+
+// Clang address sanitizer
+#if defined(__has_feature)
+#if __has_feature(address_sanitizer) || __has_feature(memory_sanitizer)
+#ifndef STBIR__SEPARATE_ALLOCATIONS
+#define STBIR__SEPARATE_ALLOCATIONS
+#endif
+#endif
+#endif
+
+#endif
+
+// GCC and MSVC
+#if defined(__SANITIZE_ADDRESS__)
+#ifndef STBIR__SEPARATE_ALLOCATIONS
+#define STBIR__SEPARATE_ALLOCATIONS
+#endif
+#endif
+
+// Always turn off automatic FMA use - use STBIR_USE_FMA if you want.
+// Otherwise, this is a determinism disaster.
+#ifndef STBIR_DONT_CHANGE_FP_CONTRACT  // override in case you don't want this behavior
+#if defined(_MSC_VER) && !defined(__clang__)
+#if _MSC_VER > 1200
+#pragma fp_contract(off)
+#endif
+#elif defined(__GNUC__) && !defined(__clang__)
+#pragma GCC optimize("fp-contract=off")
+#else
+#pragma STDC FP_CONTRACT OFF
+#endif
+#endif
+
+#ifdef _MSC_VER
+#define STBIR__UNUSED(v) (void)(v)
+#else
+#define STBIR__UNUSED(v) (void)sizeof(v)
+#endif
+
+#define STBIR__ARRAY_SIZE(a) (sizeof((a)) / sizeof((a)[0]))
+
+#ifndef STBIR_DEFAULT_FILTER_UPSAMPLE
+#define STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_CATMULLROM
+#endif
+
+#ifndef STBIR_DEFAULT_FILTER_DOWNSAMPLE
+#define STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_MITCHELL
+#endif
+
+#ifndef STBIR__HEADER_FILENAME
+#define STBIR__HEADER_FILENAME "stb_image_resize2.h"
+#endif
+
+// the internal pixel layout enums are in a different order, so we can easily do range comparisons
+// of types
+//   the public pixel layout is ordered in a way that if you cast num_channels (1-4) to the enum,
+//   you get something sensible
+typedef enum {
+    STBIRI_1CHANNEL = 0,
+    STBIRI_2CHANNEL = 1,
+    STBIRI_RGB      = 2,
+    STBIRI_BGR      = 3,
+    STBIRI_4CHANNEL = 4,
+
+    STBIRI_RGBA = 5,
+    STBIRI_BGRA = 6,
+    STBIRI_ARGB = 7,
+    STBIRI_ABGR = 8,
+    STBIRI_RA   = 9,
+    STBIRI_AR   = 10,
+
+    STBIRI_RGBA_PM = 11,
+    STBIRI_BGRA_PM = 12,
+    STBIRI_ARGB_PM = 13,
+    STBIRI_ABGR_PM = 14,
+    STBIRI_RA_PM   = 15,
+    STBIRI_AR_PM   = 16,
+} stbir_internal_pixel_layout;
+
+// define the public pixel layouts to not compile inside the implementation (to avoid accidental
+// use)
+#define STBIR_BGR      bad_dont_use_in_implementation
+#define STBIR_1CHANNEL STBIR_BGR
+#define STBIR_2CHANNEL STBIR_BGR
+#define STBIR_RGB      STBIR_BGR
+#define STBIR_RGBA     STBIR_BGR
+#define STBIR_4CHANNEL STBIR_BGR
+#define STBIR_BGRA     STBIR_BGR
+#define STBIR_ARGB     STBIR_BGR
+#define STBIR_ABGR     STBIR_BGR
+#define STBIR_RA       STBIR_BGR
+#define STBIR_AR       STBIR_BGR
+#define STBIR_RGBA_PM  STBIR_BGR
+#define STBIR_BGRA_PM  STBIR_BGR
+#define STBIR_ARGB_PM  STBIR_BGR
+#define STBIR_ABGR_PM  STBIR_BGR
+#define STBIR_RA_PM    STBIR_BGR
+#define STBIR_AR_PM    STBIR_BGR
+
+// must match stbir_datatype
+static unsigned char stbir__type_size[] = {
+    1, 1, 1, 2,
+    4, 2  // STBIR_TYPE_UINT8,STBIR_TYPE_UINT8_SRGB,STBIR_TYPE_UINT8_SRGB_ALPHA,STBIR_TYPE_UINT16,STBIR_TYPE_FLOAT,STBIR_TYPE_HALF_FLOAT
+};
+
+// When gathering, the contributors are which source pixels contribute.
+// When scattering, the contributors are which destination pixels are contributed to.
+typedef struct {
+    int n0;  // First contributing pixel
+    int n1;  // Last contributing pixel
+} stbir__contributors;
+
+typedef struct {
+    int lowest;   // First sample index for whole filter
+    int highest;  // Last sample index for whole filter
+    int widest;   // widest single set of samples for an output
+} stbir__filter_extent_info;
+
+typedef struct {
+    int n0;                      // First pixel of decode buffer to write to
+    int n1;                      // Last pixel of decode that will be written to
+    int pixel_offset_for_input;  // Pixel offset into input_scanline
+} stbir__span;
+
+typedef struct stbir__scale_info {
+    int input_full_size;
+    int output_sub_size;
+    float scale;
+    float inv_scale;
+    float pixel_shift;  // starting shift in output pixel space (in pixels)
+    int scale_is_rational;
+    stbir_uint32 scale_numerator, scale_denominator;
+} stbir__scale_info;
+
+typedef struct {
+    stbir__contributors *contributors;
+    float *coefficients;
+    stbir__contributors *gather_prescatter_contributors;
+    float *gather_prescatter_coefficients;
+    stbir__scale_info scale_info;
+    float support;
+    stbir_filter filter_enum;
+    stbir__kernel_callback *filter_kernel;
+    stbir__support_callback *filter_support;
+    stbir_edge edge;
+    int coefficient_width;
+    int filter_pixel_width;
+    int filter_pixel_margin;
+    int num_contributors;
+    int contributors_size;
+    int coefficients_size;
+    stbir__filter_extent_info extent_info;
+    int is_gather;  // 0 = scatter, 1 = gather with scale >= 1, 2 = gather with scale < 1
+    int gather_prescatter_num_contributors;
+    int gather_prescatter_coefficient_width;
+    int gather_prescatter_contributors_size;
+    int gather_prescatter_coefficients_size;
+} stbir__sampler;
+
+typedef struct {
+    stbir__contributors conservative;
+    int edge_sizes[2];     // this can be less than filter_pixel_margin, if the filter and scaling
+                           // falls off
+    stbir__span spans[2];  // can be two spans, if doing input subrect with clamp mode WRAP
+} stbir__extents;
+
+typedef struct {
+#ifdef STBIR_PROFILE
+    union {
+        struct {
+            stbir_uint64 total, looping, vertical, horizontal, decode, encode, alpha, unalpha;
+        } named;
+        stbir_uint64 array[8];
+    } profile;
+    stbir_uint64 *current_zone_excluded_ptr;
+#endif
+    float *decode_buffer;
+
+    int ring_buffer_first_scanline;
+    int ring_buffer_last_scanline;
+    int ring_buffer_begin_index;  // first_scanline is at this index in the ring buffer
+    int start_output_y, end_output_y;
+    int start_input_y, end_input_y;  // used in scatter only
+
+#ifdef STBIR__SEPARATE_ALLOCATIONS
+    float **ring_buffers;  // one pointer for each ring buffer
+#else
+    float *ring_buffer;  // one big buffer that we index into
+#endif
+
+    float *vertical_buffer;
+
+    char no_cache_straddle[64];
+} stbir__per_split_info;
+
+typedef void stbir__decode_pixels_func(float *decode, int width_times_channels, void const *input);
+typedef void stbir__alpha_weight_func(float *decode_buffer, int width_times_channels);
+typedef void
+stbir__horizontal_gather_channels_func(float *output_buffer, unsigned int output_sub_size,
+                                       float const *decode_buffer,
+                                       stbir__contributors const *horizontal_contributors,
+                                       float const *horizontal_coefficients, int coefficient_width);
+typedef void stbir__alpha_unweight_func(float *encode_buffer, int width_times_channels);
+typedef void stbir__encode_pixels_func(void *output, int width_times_channels, float const *encode);
+
+struct stbir__info {
+#ifdef STBIR_PROFILE
+    union {
+        struct {
+            stbir_uint64 total, build, alloc, horizontal, vertical, cleanup, pivot;
+        } named;
+        stbir_uint64 array[7];
+    } profile;
+    stbir_uint64 *current_zone_excluded_ptr;
+#endif
+    stbir__sampler horizontal;
+    stbir__sampler vertical;
+
+    void const *input_data;
+    void *output_data;
+
+    int input_stride_bytes;
+    int output_stride_bytes;
+    int ring_buffer_length_bytes;  // The length of an individual entry in the ring buffer. The
+                                   // total number of ring buffers is
+                                   // stbir__get_filter_pixel_width(filter)
+    int ring_buffer_num_entries;   // Total number of entries in the ring buffer.
+
+    stbir_datatype input_type;
+    stbir_datatype output_type;
+
+    stbir_input_callback *in_pixels_cb;
+    void *user_data;
+    stbir_output_callback *out_pixels_cb;
+
+    stbir__extents scanline_extents;
+
+    void *alloced_mem;
+    stbir__per_split_info *split_info;  // by default 1, but there will be N of these allocated
+                                        // based on the thread init you did
+
+    stbir__decode_pixels_func *decode_pixels;
+    stbir__alpha_weight_func *alpha_weight;
+    stbir__horizontal_gather_channels_func *horizontal_gather_channels;
+    stbir__alpha_unweight_func *alpha_unweight;
+    stbir__encode_pixels_func *encode_pixels;
+
+    int alloc_ring_buffer_num_entries;  // Number of entries in the ring buffer that will be
+                                        // allocated
+    int splits;                         // count of splits
+
+    stbir_internal_pixel_layout input_pixel_layout_internal;
+    stbir_internal_pixel_layout output_pixel_layout_internal;
+
+    int input_color_and_type;
+    int offset_x, offset_y;  // offset within output_data
+    int vertical_first;
+    int channels;
+    int effective_channels;  // same as channels, except on RGBA/ARGB (7), or XA/AX (3)
+    size_t alloced_total;
+};
+
+#define stbir__max_uint8_as_float           255.0f
+#define stbir__max_uint16_as_float          65535.0f
+#define stbir__max_uint8_as_float_inverted  (1.0f / 255.0f)
+#define stbir__max_uint16_as_float_inverted (1.0f / 65535.0f)
+#define stbir__small_float                                                                         \
+    ((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20))
+
+// min/max friendly
+#define STBIR_CLAMP(x, xmin, xmax)                                                                 \
+    for (;;) {                                                                                     \
+        if ((x) < (xmin))                                                                          \
+            (x) = (xmin);                                                                          \
+        if ((x) > (xmax))                                                                          \
+            (x) = (xmax);                                                                          \
+        break;                                                                                     \
+    }
+
+static stbir__inline int stbir__min(int a, int b) { return a < b ? a : b; }
+
+static stbir__inline int stbir__max(int a, int b) { return a > b ? a : b; }
+
+static float stbir__srgb_uchar_to_linear_float[256] = {
+    0.000000f, 0.000304f, 0.000607f, 0.000911f, 0.001214f, 0.001518f, 0.001821f, 0.002125f,
+    0.002428f, 0.002732f, 0.003035f, 0.003347f, 0.003677f, 0.004025f, 0.004391f, 0.004777f,
+    0.005182f, 0.005605f, 0.006049f, 0.006512f, 0.006995f, 0.007499f, 0.008023f, 0.008568f,
+    0.009134f, 0.009721f, 0.010330f, 0.010960f, 0.011612f, 0.012286f, 0.012983f, 0.013702f,
+    0.014444f, 0.015209f, 0.015996f, 0.016807f, 0.017642f, 0.018500f, 0.019382f, 0.020289f,
+    0.021219f, 0.022174f, 0.023153f, 0.024158f, 0.025187f, 0.026241f, 0.027321f, 0.028426f,
+    0.029557f, 0.030713f, 0.031896f, 0.033105f, 0.034340f, 0.035601f, 0.036889f, 0.038204f,
+    0.039546f, 0.040915f, 0.042311f, 0.043735f, 0.045186f, 0.046665f, 0.048172f, 0.049707f,
+    0.051269f, 0.052861f, 0.054480f, 0.056128f, 0.057805f, 0.059511f, 0.061246f, 0.063010f,
+    0.064803f, 0.066626f, 0.068478f, 0.070360f, 0.072272f, 0.074214f, 0.076185f, 0.078187f,
+    0.080220f, 0.082283f, 0.084376f, 0.086500f, 0.088656f, 0.090842f, 0.093059f, 0.095307f,
+    0.097587f, 0.099899f, 0.102242f, 0.104616f, 0.107023f, 0.109462f, 0.111932f, 0.114435f,
+    0.116971f, 0.119538f, 0.122139f, 0.124772f, 0.127438f, 0.130136f, 0.132868f, 0.135633f,
+    0.138432f, 0.141263f, 0.144128f, 0.147027f, 0.149960f, 0.152926f, 0.155926f, 0.158961f,
+    0.162029f, 0.165132f, 0.168269f, 0.171441f, 0.174647f, 0.177888f, 0.181164f, 0.184475f,
+    0.187821f, 0.191202f, 0.194618f, 0.198069f, 0.201556f, 0.205079f, 0.208637f, 0.212231f,
+    0.215861f, 0.219526f, 0.223228f, 0.226966f, 0.230740f, 0.234551f, 0.238398f, 0.242281f,
+    0.246201f, 0.250158f, 0.254152f, 0.258183f, 0.262251f, 0.266356f, 0.270498f, 0.274677f,
+    0.278894f, 0.283149f, 0.287441f, 0.291771f, 0.296138f, 0.300544f, 0.304987f, 0.309469f,
+    0.313989f, 0.318547f, 0.323143f, 0.327778f, 0.332452f, 0.337164f, 0.341914f, 0.346704f,
+    0.351533f, 0.356400f, 0.361307f, 0.366253f, 0.371238f, 0.376262f, 0.381326f, 0.386430f,
+    0.391573f, 0.396755f, 0.401978f, 0.407240f, 0.412543f, 0.417885f, 0.423268f, 0.428691f,
+    0.434154f, 0.439657f, 0.445201f, 0.450786f, 0.456411f, 0.462077f, 0.467784f, 0.473532f,
+    0.479320f, 0.485150f, 0.491021f, 0.496933f, 0.502887f, 0.508881f, 0.514918f, 0.520996f,
+    0.527115f, 0.533276f, 0.539480f, 0.545725f, 0.552011f, 0.558340f, 0.564712f, 0.571125f,
+    0.577581f, 0.584078f, 0.590619f, 0.597202f, 0.603827f, 0.610496f, 0.617207f, 0.623960f,
+    0.630757f, 0.637597f, 0.644480f, 0.651406f, 0.658375f, 0.665387f, 0.672443f, 0.679543f,
+    0.686685f, 0.693872f, 0.701102f, 0.708376f, 0.715694f, 0.723055f, 0.730461f, 0.737911f,
+    0.745404f, 0.752942f, 0.760525f, 0.768151f, 0.775822f, 0.783538f, 0.791298f, 0.799103f,
+    0.806952f, 0.814847f, 0.822786f, 0.830770f, 0.838799f, 0.846873f, 0.854993f, 0.863157f,
+    0.871367f, 0.879622f, 0.887923f, 0.896269f, 0.904661f, 0.913099f, 0.921582f, 0.930111f,
+    0.938686f, 0.947307f, 0.955974f, 0.964686f, 0.973445f, 0.982251f, 0.991102f, 1.0f};
+
+typedef union {
+    unsigned int u;
+    float f;
+} stbir__FP32;
+
+// From https://gist.github.com/rygorous/2203834
+
+static const stbir_uint32 fp32_to_srgb8_tab4[104] = {
+    0x0073000d, 0x007a000d, 0x0080000d, 0x0087000d, 0x008d000d, 0x0094000d, 0x009a000d, 0x00a1000d,
+    0x00a7001a, 0x00b4001a, 0x00c1001a, 0x00ce001a, 0x00da001a, 0x00e7001a, 0x00f4001a, 0x0101001a,
+    0x010e0033, 0x01280033, 0x01410033, 0x015b0033, 0x01750033, 0x018f0033, 0x01a80033, 0x01c20033,
+    0x01dc0067, 0x020f0067, 0x02430067, 0x02760067, 0x02aa0067, 0x02dd0067, 0x03110067, 0x03440067,
+    0x037800ce, 0x03df00ce, 0x044600ce, 0x04ad00ce, 0x051400ce, 0x057b00c5, 0x05dd00bc, 0x063b00b5,
+    0x06970158, 0x07420142, 0x07e30130, 0x087b0120, 0x090b0112, 0x09940106, 0x0a1700fc, 0x0a9500f2,
+    0x0b0f01cb, 0x0bf401ae, 0x0ccb0195, 0x0d950180, 0x0e56016e, 0x0f0d015e, 0x0fbc0150, 0x10630143,
+    0x11070264, 0x1238023e, 0x1357021d, 0x14660201, 0x156601e9, 0x165a01d3, 0x174401c0, 0x182401af,
+    0x18fe0331, 0x1a9602fe, 0x1c1502d2, 0x1d7e02ad, 0x1ed4028d, 0x201a0270, 0x21520256, 0x227d0240,
+    0x239f0443, 0x25c003fe, 0x27bf03c4, 0x29a10392, 0x2b6a0367, 0x2d1d0341, 0x2ebe031f, 0x304d0300,
+    0x31d105b0, 0x34a80555, 0x37520507, 0x39d504c5, 0x3c37048b, 0x3e7c0458, 0x40a8042a, 0x42bd0401,
+    0x44c20798, 0x488e071e, 0x4c1c06b6, 0x4f76065d, 0x52a50610, 0x55ac05cc, 0x5892058f, 0x5b590559,
+    0x5e0c0a23, 0x631c0980, 0x67db08f6, 0x6c55087f, 0x70940818, 0x74a007bd, 0x787d076c, 0x7c330723,
+};
+
+static stbir__inline stbir_uint8 stbir__linear_to_srgb_uchar(float in) {
+    static const stbir__FP32 almostone = {0x3f7fffff};  // 1-eps
+    static const stbir__FP32 minval    = {(127 - 13) << 23};
+    stbir_uint32 tab, bias, scale, t;
+    stbir__FP32 f;
+
+    // Clamp to [2^(-13), 1-eps]; these two values map to 0 and 1, respectively.
+    // The tests are carefully written so that NaNs map to 0, same as in the reference
+    // implementation.
+    if (!(in > minval.f))  // written this way to catch NaNs
+        return 0;
+    if (in > almostone.f)
+        return 255;
+
+    // Do the table lookup and unpack bias, scale
+    f.f   = in;
+    tab   = fp32_to_srgb8_tab4[(f.u - minval.u) >> 20];
+    bias  = (tab >> 16) << 9;
+    scale = tab & 0xffff;
+
+    // Grab next-highest mantissa bits and perform linear interpolation
+    t = (f.u >> 12) & 0xff;
+    return (unsigned char)((bias + scale * t) >> 16);
+}
+
+#ifndef STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT
+#define STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT                                                 \
+    32  // when downsampling and <= 32 scanlines of buffering, use gather. gather used down to 1/8th
+        // scaling for 25% win.
+#endif
+
+#ifndef STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS
+#define STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS                                                   \
+    4  // when threading, what is the minimum number of scanlines for a split?
+#endif
+
+// restrict pointers for the output pointers, other loop and unroll control
+#if defined(_MSC_VER) && !defined(__clang__)
+#define STBIR_STREAMOUT_PTR(star) star __restrict
+#define STBIR_NO_UNROLL(ptr)      __assume(ptr)  // this oddly keeps msvc from unrolling a loop
+#if _MSC_VER >= 1900
+#define STBIR_NO_UNROLL_LOOP_START __pragma(loop(no_vector))
+#else
+#define STBIR_NO_UNROLL_LOOP_START
+#endif
+#elif defined(__clang__)
+#define STBIR_STREAMOUT_PTR(star) star __restrict__
+#define STBIR_NO_UNROLL(ptr)      __asm__("" ::"r"(ptr))
+#if (__clang_major__ >= 4) || ((__clang_major__ >= 3) && (__clang_minor__ >= 5))
+#define STBIR_NO_UNROLL_LOOP_START                                                                 \
+    _Pragma("clang loop unroll(disable)") _Pragma("clang loop vectorize(disable)")
+#else
+#define STBIR_NO_UNROLL_LOOP_START
+#endif
+#elif defined(__GNUC__)
+#define STBIR_STREAMOUT_PTR(star) star __restrict__
+#define STBIR_NO_UNROLL(ptr)      __asm__("" ::"r"(ptr))
+#if __GNUC__ >= 14
+#define STBIR_NO_UNROLL_LOOP_START _Pragma("GCC unroll 0") _Pragma("GCC novector")
+#else
+#define STBIR_NO_UNROLL_LOOP_START
+#endif
+#define STBIR_NO_UNROLL_LOOP_START_INF_FOR
+#else
+#define STBIR_STREAMOUT_PTR(star) star
+#define STBIR_NO_UNROLL(ptr)
+#define STBIR_NO_UNROLL_LOOP_START
+#endif
+
+#ifndef STBIR_NO_UNROLL_LOOP_START_INF_FOR
+#define STBIR_NO_UNROLL_LOOP_START_INF_FOR STBIR_NO_UNROLL_LOOP_START
+#endif
+
+#ifdef STBIR_NO_SIMD  // force simd off for whatever reason
+
+// force simd off overrides everything else, so clear it all
+
+#ifdef STBIR_SSE2
+#undef STBIR_SSE2
+#endif
+
+#ifdef STBIR_AVX
+#undef STBIR_AVX
+#endif
+
+#ifdef STBIR_NEON
+#undef STBIR_NEON
+#endif
+
+#ifdef STBIR_AVX2
+#undef STBIR_AVX2
+#endif
+
+#ifdef STBIR_FP16C
+#undef STBIR_FP16C
+#endif
+
+#ifdef STBIR_WASM
+#undef STBIR_WASM
+#endif
+
+#ifdef STBIR_SIMD
+#undef STBIR_SIMD
+#endif
+
+#else  // STBIR_SIMD
+
+#ifdef STBIR_SSE2
+#include <emmintrin.h>
+
+#define stbir__simdf __m128
+#define stbir__simdi __m128i
+
+#define stbir_simdi_castf(reg) _mm_castps_si128(reg)
+#define stbir_simdf_casti(reg) _mm_castsi128_ps(reg)
+
+#define stbir__simdf_load(reg, ptr) (reg) = _mm_loadu_ps((float const *)(ptr))
+#define stbir__simdi_load(reg, ptr) (reg) = _mm_loadu_si128((stbir__simdi const *)(ptr))
+#define stbir__simdf_load1(out, ptr)                                                               \
+    (out) = _mm_load_ss(                                                                           \
+        (float const *)(ptr))  // top values can be random (not denormal or nan for perf)
+#define stbir__simdi_load1(out, ptr) (out) = _mm_castps_si128(_mm_load_ss((float const *)(ptr)))
+#define stbir__simdf_load1z(out, ptr)                                                              \
+    (out) = _mm_load_ss((float const *)(ptr))  // top values must be zero
+#define stbir__simdf_frep4(fvar)           _mm_set_ps1(fvar)
+#define stbir__simdf_load1frep4(out, fvar) (out) = _mm_set_ps1(fvar)
+#define stbir__simdf_load2(out, ptr)                                                               \
+    (out) = _mm_castsi128_ps(_mm_loadl_epi64(                                                      \
+        (__m128i *)(ptr)))  // top values can be random (not denormal or nan for perf)
+#define stbir__simdf_load2z(out, ptr)                                                              \
+    (out) = _mm_castsi128_ps(_mm_loadl_epi64((__m128i *)(ptr)))  // top values must be zero
+#define stbir__simdf_load2hmerge(out, reg, ptr)                                                    \
+    (out) = _mm_castpd_ps(_mm_loadh_pd(_mm_castps_pd(reg), (double *)(ptr)))
+
+#define stbir__simdf_zeroP()   _mm_setzero_ps()
+#define stbir__simdf_zero(reg) (reg) = _mm_setzero_ps()
+
+#define stbir__simdf_store(ptr, reg)   _mm_storeu_ps((float *)(ptr), reg)
+#define stbir__simdf_store1(ptr, reg)  _mm_store_ss((float *)(ptr), reg)
+#define stbir__simdf_store2(ptr, reg)  _mm_storel_epi64((__m128i *)(ptr), _mm_castps_si128(reg))
+#define stbir__simdf_store2h(ptr, reg) _mm_storeh_pd((double *)(ptr), _mm_castps_pd(reg))
+
+#define stbir__simdi_store(ptr, reg)  _mm_storeu_si128((__m128i *)(ptr), reg)
+#define stbir__simdi_store1(ptr, reg) _mm_store_ss((float *)(ptr), _mm_castsi128_ps(reg))
+#define stbir__simdi_store2(ptr, reg) _mm_storel_epi64((__m128i *)(ptr), (reg))
+
+#define stbir__prefetch(ptr) _mm_prefetch((char *)(ptr), _MM_HINT_T0)
+
+#define stbir__simdi_expand_u8_to_u32(out0, out1, out2, out3, ireg)                                \
+    {                                                                                              \
+        stbir__simdi zero = _mm_setzero_si128();                                                   \
+        out2              = _mm_unpacklo_epi8(ireg, zero);                                         \
+        out3              = _mm_unpackhi_epi8(ireg, zero);                                         \
+        out0              = _mm_unpacklo_epi16(out2, zero);                                        \
+        out1              = _mm_unpackhi_epi16(out2, zero);                                        \
+        out2              = _mm_unpacklo_epi16(out3, zero);                                        \
+        out3              = _mm_unpackhi_epi16(out3, zero);                                        \
+    }
+
+#define stbir__simdi_expand_u8_to_1u32(out, ireg)                                                  \
+    {                                                                                              \
+        stbir__simdi zero = _mm_setzero_si128();                                                   \
+        out               = _mm_unpacklo_epi8(ireg, zero);                                         \
+        out               = _mm_unpacklo_epi16(out, zero);                                         \
+    }
+
+#define stbir__simdi_expand_u16_to_u32(out0, out1, ireg)                                           \
+    {                                                                                              \
+        stbir__simdi zero = _mm_setzero_si128();                                                   \
+        out0              = _mm_unpacklo_epi16(ireg, zero);                                        \
+        out1              = _mm_unpackhi_epi16(ireg, zero);                                        \
+    }
+
+#define stbir__simdf_convert_float_to_i32(i, f) (i) = _mm_cvttps_epi32(f)
+#define stbir__simdf_convert_float_to_int(f)    _mm_cvtt_ss2si(f)
+#define stbir__simdf_convert_float_to_uint8(f)                                                     \
+    ((unsigned char)_mm_cvtsi128_si32(_mm_cvttps_epi32(                                            \
+        _mm_max_ps(_mm_min_ps(f, STBIR__CONSTF(STBIR_max_uint8_as_float)), _mm_setzero_ps()))))
+#define stbir__simdf_convert_float_to_short(f)                                                     \
+    ((unsigned short)_mm_cvtsi128_si32(_mm_cvttps_epi32(                                           \
+        _mm_max_ps(_mm_min_ps(f, STBIR__CONSTF(STBIR_max_uint16_as_float)), _mm_setzero_ps()))))
+
+#define stbir__simdi_to_int(i)                       _mm_cvtsi128_si32(i)
+#define stbir__simdi_convert_i32_to_float(out, ireg) (out) = _mm_cvtepi32_ps(ireg)
+#define stbir__simdf_add(out, reg0, reg1)            (out) = _mm_add_ps(reg0, reg1)
+#define stbir__simdf_mult(out, reg0, reg1)           (out) = _mm_mul_ps(reg0, reg1)
+#define stbir__simdf_mult_mem(out, reg, ptr)                                                       \
+    (out) = _mm_mul_ps(reg, _mm_loadu_ps((float const *)(ptr)))
+#define stbir__simdf_mult1_mem(out, reg, ptr)                                                      \
+    (out) = _mm_mul_ss(reg, _mm_load_ss((float const *)(ptr)))
+#define stbir__simdf_add_mem(out, reg, ptr)                                                        \
+    (out) = _mm_add_ps(reg, _mm_loadu_ps((float const *)(ptr)))
+#define stbir__simdf_add1_mem(out, reg, ptr)                                                       \
+    (out) = _mm_add_ss(reg, _mm_load_ss((float const *)(ptr)))
+
+#ifdef STBIR_USE_FMA  // not on by default to maintain bit identical simd to non-simd
+#include <immintrin.h>
+#define stbir__simdf_madd(out, add, mul1, mul2)  (out) = _mm_fmadd_ps(mul1, mul2, add)
+#define stbir__simdf_madd1(out, add, mul1, mul2) (out) = _mm_fmadd_ss(mul1, mul2, add)
+#define stbir__simdf_madd_mem(out, add, mul, ptr)                                                  \
+    (out) = _mm_fmadd_ps(mul, _mm_loadu_ps((float const *)(ptr)), add)
+#define stbir__simdf_madd1_mem(out, add, mul, ptr)                                                 \
+    (out) = _mm_fmadd_ss(mul, _mm_load_ss((float const *)(ptr)), add)
+#else
+#define stbir__simdf_madd(out, add, mul1, mul2)  (out) = _mm_add_ps(add, _mm_mul_ps(mul1, mul2))
+#define stbir__simdf_madd1(out, add, mul1, mul2) (out) = _mm_add_ss(add, _mm_mul_ss(mul1, mul2))
+#define stbir__simdf_madd_mem(out, add, mul, ptr)                                                  \
+    (out) = _mm_add_ps(add, _mm_mul_ps(mul, _mm_loadu_ps((float const *)(ptr))))
+#define stbir__simdf_madd1_mem(out, add, mul, ptr)                                                 \
+    (out) = _mm_add_ss(add, _mm_mul_ss(mul, _mm_load_ss((float const *)(ptr))))
+#endif
+
+#define stbir__simdf_add1(out, reg0, reg1)  (out) = _mm_add_ss(reg0, reg1)
+#define stbir__simdf_mult1(out, reg0, reg1) (out) = _mm_mul_ss(reg0, reg1)
+
+#define stbir__simdf_and(out, reg0, reg1) (out) = _mm_and_ps(reg0, reg1)
+#define stbir__simdf_or(out, reg0, reg1)  (out) = _mm_or_ps(reg0, reg1)
+
+#define stbir__simdf_min(out, reg0, reg1)  (out) = _mm_min_ps(reg0, reg1)
+#define stbir__simdf_max(out, reg0, reg1)  (out) = _mm_max_ps(reg0, reg1)
+#define stbir__simdf_min1(out, reg0, reg1) (out) = _mm_min_ss(reg0, reg1)
+#define stbir__simdf_max1(out, reg0, reg1) (out) = _mm_max_ss(reg0, reg1)
+
+#define stbir__simdf_0123ABCDto3ABx(out, reg0, reg1)                                               \
+    (out) = _mm_castsi128_ps(_mm_shuffle_epi32(                                                    \
+        _mm_castps_si128(_mm_shuffle_ps(reg1, reg0, (0 << 0) + (1 << 2) + (2 << 4) + (3 << 6))),   \
+        (3 << 0) + (0 << 2) + (1 << 4) + (2 << 6)))
+#define stbir__simdf_0123ABCDto23Ax(out, reg0, reg1)                                               \
+    (out) = _mm_castsi128_ps(_mm_shuffle_epi32(                                                    \
+        _mm_castps_si128(_mm_shuffle_ps(reg1, reg0, (0 << 0) + (1 << 2) + (2 << 4) + (3 << 6))),   \
+        (2 << 0) + (3 << 2) + (0 << 4) + (1 << 6)))
+
+static const stbir__simdf STBIR_zeroones = {0.0f, 1.0f, 0.0f, 1.0f};
+static const stbir__simdf STBIR_onezeros = {1.0f, 0.0f, 1.0f, 0.0f};
+#define stbir__simdf_aaa1(out, alp, ones)                                                          \
+    (out) = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(_mm_movehl_ps(ones, alp)),         \
+                                               (1 << 0) + (1 << 2) + (1 << 4) + (2 << 6)))
+#define stbir__simdf_1aaa(out, alp, ones)                                                          \
+    (out) = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(_mm_movelh_ps(ones, alp)),         \
+                                               (0 << 0) + (2 << 2) + (2 << 4) + (2 << 6)))
+#define stbir__simdf_a1a1(out, alp, ones)                                                          \
+    (out) = _mm_or_ps(_mm_castsi128_ps(_mm_srli_epi64(_mm_castps_si128(alp), 32)), STBIR_zeroones)
+#define stbir__simdf_1a1a(out, alp, ones)                                                          \
+    (out) = _mm_or_ps(_mm_castsi128_ps(_mm_slli_epi64(_mm_castps_si128(alp), 32)), STBIR_onezeros)
+
+#define stbir__simdf_swiz(reg, one, two, three, four)                                              \
+    _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(reg),                                      \
+                                       (one << 0) + (two << 2) + (three << 4) + (four << 6)))
+
+#define stbir__simdi_and(out, reg0, reg1)    (out) = _mm_and_si128(reg0, reg1)
+#define stbir__simdi_or(out, reg0, reg1)     (out) = _mm_or_si128(reg0, reg1)
+#define stbir__simdi_16madd(out, reg0, reg1) (out) = _mm_madd_epi16(reg0, reg1)
+
+#define stbir__simdf_pack_to_8bytes(out, aa, bb)                                                   \
+    {                                                                                              \
+        stbir__simdf af, bf;                                                                       \
+        stbir__simdi a, b;                                                                         \
+        af  = _mm_min_ps(aa, STBIR_max_uint8_as_float);                                            \
+        bf  = _mm_min_ps(bb, STBIR_max_uint8_as_float);                                            \
+        af  = _mm_max_ps(af, _mm_setzero_ps());                                                    \
+        bf  = _mm_max_ps(bf, _mm_setzero_ps());                                                    \
+        a   = _mm_cvttps_epi32(af);                                                                \
+        b   = _mm_cvttps_epi32(bf);                                                                \
+        a   = _mm_packs_epi32(a, b);                                                               \
+        out = _mm_packus_epi16(a, a);                                                              \
+    }
+
+#define stbir__simdf_load4_transposed(o0, o1, o2, o3, ptr)                                         \
+    stbir__simdf_load(o0, (ptr));                                                                  \
+    stbir__simdf_load(o1, (ptr) + 4);                                                              \
+    stbir__simdf_load(o2, (ptr) + 8);                                                              \
+    stbir__simdf_load(o3, (ptr) + 12);                                                             \
+    {                                                                                              \
+        __m128 tmp0, tmp1, tmp2, tmp3;                                                             \
+        tmp0 = _mm_unpacklo_ps(o0, o1);                                                            \
+        tmp2 = _mm_unpacklo_ps(o2, o3);                                                            \
+        tmp1 = _mm_unpackhi_ps(o0, o1);                                                            \
+        tmp3 = _mm_unpackhi_ps(o2, o3);                                                            \
+        o0   = _mm_movelh_ps(tmp0, tmp2);                                                          \
+        o1   = _mm_movehl_ps(tmp2, tmp0);                                                          \
+        o2   = _mm_movelh_ps(tmp1, tmp3);                                                          \
+        o3   = _mm_movehl_ps(tmp3, tmp1);                                                          \
+    }
+
+#define stbir__interleave_pack_and_store_16_u8(ptr, r0, r1, r2, r3)                                \
+    r0 = _mm_packs_epi32(r0, r1);                                                                  \
+    r2 = _mm_packs_epi32(r2, r3);                                                                  \
+    r1 = _mm_unpacklo_epi16(r0, r2);                                                               \
+    r3 = _mm_unpackhi_epi16(r0, r2);                                                               \
+    r0 = _mm_unpacklo_epi16(r1, r3);                                                               \
+    r2 = _mm_unpackhi_epi16(r1, r3);                                                               \
+    r0 = _mm_packus_epi16(r0, r2);                                                                 \
+    stbir__simdi_store(ptr, r0);
+
+#define stbir__simdi_32shr(out, reg, imm) out = _mm_srli_epi32(reg, imm)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+// msvc inits with 8 bytes
+#define STBIR__CONST_32_TO_8(v)                                                                    \
+    (char)(unsigned char)((v) & 255), (char)(unsigned char)(((v) >> 8) & 255),                     \
+        (char)(unsigned char)(((v) >> 16) & 255), (char)(unsigned char)(((v) >> 24) & 255)
+#define STBIR__CONST_4_32i(v)                                                                      \
+    STBIR__CONST_32_TO_8(v), STBIR__CONST_32_TO_8(v), STBIR__CONST_32_TO_8(v),                     \
+        STBIR__CONST_32_TO_8(v)
+#define STBIR__CONST_4d_32i(v0, v1, v2, v3)                                                        \
+    STBIR__CONST_32_TO_8(v0), STBIR__CONST_32_TO_8(v1), STBIR__CONST_32_TO_8(v2),                  \
+        STBIR__CONST_32_TO_8(v3)
+#else
+// everything else inits with long long's
+#define STBIR__CONST_4_32i(v)                                                                      \
+    (long long)((((stbir_uint64)(stbir_uint32)(v)) << 32) | ((stbir_uint64)(stbir_uint32)(v))),    \
+        (long long)((((stbir_uint64)(stbir_uint32)(v)) << 32) | ((stbir_uint64)(stbir_uint32)(v)))
+#define STBIR__CONST_4d_32i(v0, v1, v2, v3)                                                        \
+    (long long)((((stbir_uint64)(stbir_uint32)(v1)) << 32) | ((stbir_uint64)(stbir_uint32)(v0))),  \
+        (long long)((((stbir_uint64)(stbir_uint32)(v3)) << 32) |                                   \
+                    ((stbir_uint64)(stbir_uint32)(v2)))
+#endif
+
+#define STBIR__SIMDF_CONST(var, x) stbir__simdf var = {x, x, x, x}
+#define STBIR__SIMDI_CONST(var, x) stbir__simdi var = {STBIR__CONST_4_32i(x)}
+#define STBIR__CONSTF(var)         (var)
+#define STBIR__CONSTI(var)         (var)
+
+#if defined(STBIR_AVX) || defined(__SSE4_1__)
+#include <smmintrin.h>
+#define stbir__simdf_pack_to_8words(out, reg0, reg1)                                               \
+    out = _mm_packus_epi32(                                                                        \
+        _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg0, STBIR__CONSTF(STBIR_max_uint16_as_float)),    \
+                                    _mm_setzero_ps())),                                            \
+        _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg1, STBIR__CONSTF(STBIR_max_uint16_as_float)),    \
+                                    _mm_setzero_ps())))
+#else
+STBIR__SIMDI_CONST(stbir__s32_32768, 32768);
+STBIR__SIMDI_CONST(stbir__s16_32768, ((32768 << 16) | 32768));
+
+#define stbir__simdf_pack_to_8words(out, reg0, reg1)                                               \
+    {                                                                                              \
+        stbir__simdi tmp0, tmp1;                                                                   \
+        tmp0 = _mm_cvttps_epi32(_mm_max_ps(                                                        \
+            _mm_min_ps(reg0, STBIR__CONSTF(STBIR_max_uint16_as_float)), _mm_setzero_ps()));        \
+        tmp1 = _mm_cvttps_epi32(_mm_max_ps(                                                        \
+            _mm_min_ps(reg1, STBIR__CONSTF(STBIR_max_uint16_as_float)), _mm_setzero_ps()));        \
+        tmp0 = _mm_sub_epi32(tmp0, stbir__s32_32768);                                              \
+        tmp1 = _mm_sub_epi32(tmp1, stbir__s32_32768);                                              \
+        out  = _mm_packs_epi32(tmp0, tmp1);                                                        \
+        out  = _mm_sub_epi16(out, stbir__s16_32768);                                               \
+    }
+
+#endif
+
+#define STBIR_SIMD
+
+// if we detect AVX, set the simd8 defines
+#ifdef STBIR_AVX
+#include <immintrin.h>
+#define STBIR_SIMD8
+#define stbir__simdf8                 __m256
+#define stbir__simdi8                 __m256i
+#define stbir__simdf8_load(out, ptr)  (out) = _mm256_loadu_ps((float const *)(ptr))
+#define stbir__simdi8_load(out, ptr)  (out) = _mm256_loadu_si256((__m256i const *)(ptr))
+#define stbir__simdf8_mult(out, a, b) (out) = _mm256_mul_ps((a), (b))
+#define stbir__simdf8_store(ptr, out) _mm256_storeu_ps((float *)(ptr), out)
+#define stbir__simdi8_store(ptr, reg) _mm256_storeu_si256((__m256i *)(ptr), reg)
+#define stbir__simdf8_frep8(fval)     _mm256_set1_ps(fval)
+
+#define stbir__simdf8_min(out, reg0, reg1) (out) = _mm256_min_ps(reg0, reg1)
+#define stbir__simdf8_max(out, reg0, reg1) (out) = _mm256_max_ps(reg0, reg1)
+
+#define stbir__simdf8_add4halves(out, bot4, top8)                                                  \
+    (out) = _mm_add_ps(bot4, _mm256_extractf128_ps(top8, 1))
+#define stbir__simdf8_mult_mem(out, reg, ptr)                                                      \
+    (out) = _mm256_mul_ps(reg, _mm256_loadu_ps((float const *)(ptr)))
+#define stbir__simdf8_add_mem(out, reg, ptr)                                                       \
+    (out) = _mm256_add_ps(reg, _mm256_loadu_ps((float const *)(ptr)))
+#define stbir__simdf8_add(out, a, b)     (out) = _mm256_add_ps(a, b)
+#define stbir__simdf8_load1b(out, ptr)   (out) = _mm256_broadcast_ss(ptr)
+#define stbir__simdf_load1rep4(out, ptr) (out) = _mm_broadcast_ss(ptr)  // avx load instruction
+
+#define stbir__simdi8_convert_i32_to_float(out, ireg) (out) = _mm256_cvtepi32_ps(ireg)
+#define stbir__simdf8_convert_float_to_i32(i, f)      (i) = _mm256_cvttps_epi32(f)
+
+#define stbir__simdf8_bot4s(out, a, b) (out) = _mm256_permute2f128_ps(a, b, (0 << 0) + (2 << 4))
+#define stbir__simdf8_top4s(out, a, b) (out) = _mm256_permute2f128_ps(a, b, (1 << 0) + (3 << 4))
+
+#define stbir__simdf8_gettop4(reg) _mm256_extractf128_ps(reg, 1)
+
+#ifdef STBIR_AVX2
+
+#define stbir__simdi8_expand_u8_to_u32(out0, out1, ireg)                                           \
+    {                                                                                              \
+        stbir__simdi8 a, zero = _mm256_setzero_si256();                                            \
+        a = _mm256_permute4x64_epi64(                                                              \
+            _mm256_unpacklo_epi8(                                                                  \
+                _mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),                             \
+                                         (0 << 0) + (2 << 2) + (1 << 4) + (3 << 6)),               \
+                zero),                                                                             \
+            (0 << 0) + (2 << 2) + (1 << 4) + (3 << 6));                                            \
+        out0 = _mm256_unpacklo_epi16(a, zero);                                                     \
+        out1 = _mm256_unpackhi_epi16(a, zero);                                                     \
+    }
+
+#define stbir__simdf8_pack_to_16bytes(out, aa, bb)                                                 \
+    {                                                                                              \
+        stbir__simdi8 t;                                                                           \
+        stbir__simdf8 af, bf;                                                                      \
+        stbir__simdi8 a, b;                                                                        \
+        af  = _mm256_min_ps(aa, STBIR_max_uint8_as_floatX);                                        \
+        bf  = _mm256_min_ps(bb, STBIR_max_uint8_as_floatX);                                        \
+        af  = _mm256_max_ps(af, _mm256_setzero_ps());                                              \
+        bf  = _mm256_max_ps(bf, _mm256_setzero_ps());                                              \
+        a   = _mm256_cvttps_epi32(af);                                                             \
+        b   = _mm256_cvttps_epi32(bf);                                                             \
+        t   = _mm256_permute4x64_epi64(_mm256_packs_epi32(a, b),                                   \
+                                       (0 << 0) + (2 << 2) + (1 << 4) + (3 << 6));                 \
+        out = _mm256_castsi256_si128(_mm256_permute4x64_epi64(                                     \
+            _mm256_packus_epi16(t, t), (0 << 0) + (2 << 2) + (1 << 4) + (3 << 6)));                \
+    }
+
+#define stbir__simdi8_expand_u16_to_u32(out, ireg)                                                 \
+    out =                                                                                          \
+        _mm256_unpacklo_epi16(_mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),               \
+                                                       (0 << 0) + (2 << 2) + (1 << 4) + (3 << 6)), \
+                              _mm256_setzero_si256());
+
+#define stbir__simdf8_pack_to_16words(out, aa, bb)                                                 \
+    {                                                                                              \
+        stbir__simdf8 af, bf;                                                                      \
+        stbir__simdi8 a, b;                                                                        \
+        af    = _mm256_min_ps(aa, STBIR_max_uint16_as_floatX);                                     \
+        bf    = _mm256_min_ps(bb, STBIR_max_uint16_as_floatX);                                     \
+        af    = _mm256_max_ps(af, _mm256_setzero_ps());                                            \
+        bf    = _mm256_max_ps(bf, _mm256_setzero_ps());                                            \
+        a     = _mm256_cvttps_epi32(af);                                                           \
+        b     = _mm256_cvttps_epi32(bf);                                                           \
+        (out) = _mm256_permute4x64_epi64(_mm256_packus_epi32(a, b),                                \
+                                         (0 << 0) + (2 << 2) + (1 << 4) + (3 << 6));               \
+    }
+
+#else
+
+#define stbir__simdi8_expand_u8_to_u32(out0, out1, ireg)                                           \
+    {                                                                                              \
+        stbir__simdi a, zero = _mm_setzero_si128();                                                \
+        a    = _mm_unpacklo_epi8(ireg, zero);                                                      \
+        out0 = _mm256_setr_m128i(_mm_unpacklo_epi16(a, zero), _mm_unpackhi_epi16(a, zero));        \
+        a    = _mm_unpackhi_epi8(ireg, zero);                                                      \
+        out1 = _mm256_setr_m128i(_mm_unpacklo_epi16(a, zero), _mm_unpackhi_epi16(a, zero));        \
+    }
+
+#define stbir__simdf8_pack_to_16bytes(out, aa, bb)                                                 \
+    {                                                                                              \
+        stbir__simdi t;                                                                            \
+        stbir__simdf8 af, bf;                                                                      \
+        stbir__simdi8 a, b;                                                                        \
+        af  = _mm256_min_ps(aa, STBIR_max_uint8_as_floatX);                                        \
+        bf  = _mm256_min_ps(bb, STBIR_max_uint8_as_floatX);                                        \
+        af  = _mm256_max_ps(af, _mm256_setzero_ps());                                              \
+        bf  = _mm256_max_ps(bf, _mm256_setzero_ps());                                              \
+        a   = _mm256_cvttps_epi32(af);                                                             \
+        b   = _mm256_cvttps_epi32(bf);                                                             \
+        out = _mm_packs_epi32(_mm256_castsi256_si128(a), _mm256_extractf128_si256(a, 1));          \
+        out = _mm_packus_epi16(out, out);                                                          \
+        t   = _mm_packs_epi32(_mm256_castsi256_si128(b), _mm256_extractf128_si256(b, 1));          \
+        t   = _mm_packus_epi16(t, t);                                                              \
+        out = _mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps(out), _mm_castsi128_ps(t),          \
+                                              (0 << 0) + (1 << 2) + (0 << 4) + (1 << 6)));         \
+    }
+
+#define stbir__simdi8_expand_u16_to_u32(out, ireg)                                                 \
+    {                                                                                              \
+        stbir__simdi a, b, zero = _mm_setzero_si128();                                             \
+        a   = _mm_unpacklo_epi16(ireg, zero);                                                      \
+        b   = _mm_unpackhi_epi16(ireg, zero);                                                      \
+        out = _mm256_insertf128_si256(_mm256_castsi128_si256(a), b, 1);                            \
+    }
+
+#define stbir__simdf8_pack_to_16words(out, aa, bb)                                                 \
+    {                                                                                              \
+        stbir__simdi t0, t1;                                                                       \
+        stbir__simdf8 af, bf;                                                                      \
+        stbir__simdi8 a, b;                                                                        \
+        af  = _mm256_min_ps(aa, STBIR_max_uint16_as_floatX);                                       \
+        bf  = _mm256_min_ps(bb, STBIR_max_uint16_as_floatX);                                       \
+        af  = _mm256_max_ps(af, _mm256_setzero_ps());                                              \
+        bf  = _mm256_max_ps(bf, _mm256_setzero_ps());                                              \
+        a   = _mm256_cvttps_epi32(af);                                                             \
+        b   = _mm256_cvttps_epi32(bf);                                                             \
+        t0  = _mm_packus_epi32(_mm256_castsi256_si128(a), _mm256_extractf128_si256(a, 1));         \
+        t1  = _mm_packus_epi32(_mm256_castsi256_si128(b), _mm256_extractf128_si256(b, 1));         \
+        out = _mm256_setr_m128i(t0, t1);                                                           \
+    }
+
+#endif
+
+static __m256i stbir_00001111 = {STBIR__CONST_4d_32i(0, 0, 0, 0), STBIR__CONST_4d_32i(1, 1, 1, 1)};
+#define stbir__simdf8_0123to00001111(out, in) (out) = _mm256_permutevar_ps(in, stbir_00001111)
+
+static __m256i stbir_22223333 = {STBIR__CONST_4d_32i(2, 2, 2, 2), STBIR__CONST_4d_32i(3, 3, 3, 3)};
+#define stbir__simdf8_0123to22223333(out, in) (out) = _mm256_permutevar_ps(in, stbir_22223333)
+
+#define stbir__simdf8_0123to2222(out, in)                                                          \
+    (out) = stbir__simdf_swiz(_mm256_castps256_ps128(in), 2, 2, 2, 2)
+
+#define stbir__simdf8_load4b(out, ptr)        (out) = _mm256_broadcast_ps((__m128 const *)(ptr))
+
+static __m256i stbir_00112233 = {STBIR__CONST_4d_32i(0, 0, 1, 1), STBIR__CONST_4d_32i(2, 2, 3, 3)};
+#define stbir__simdf8_0123to00112233(out, in) (out) = _mm256_permutevar_ps(in, stbir_00112233)
+#define stbir__simdf8_add4(out, a8, b)        (out) = _mm256_add_ps(a8, _mm256_castps128_ps256(b))
+
+static __m256i stbir_load6 = {STBIR__CONST_4_32i(0x80000000),
+                              STBIR__CONST_4d_32i(0x80000000, 0x80000000, 0, 0)};
+#define stbir__simdf8_load6z(out, ptr)        (out) = _mm256_maskload_ps(ptr, stbir_load6)
+
+#define stbir__simdf8_0123to00000000(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (0 << 0) + (0 << 2) + (0 << 4) + (0 << 6))
+#define stbir__simdf8_0123to11111111(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (1 << 0) + (1 << 2) + (1 << 4) + (1 << 6))
+#define stbir__simdf8_0123to22222222(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (2 << 0) + (2 << 2) + (2 << 4) + (2 << 6))
+#define stbir__simdf8_0123to33333333(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (3 << 0) + (3 << 2) + (3 << 4) + (3 << 6))
+#define stbir__simdf8_0123to21032103(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (2 << 0) + (1 << 2) + (0 << 4) + (3 << 6))
+#define stbir__simdf8_0123to32103210(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (3 << 0) + (2 << 2) + (1 << 4) + (0 << 6))
+#define stbir__simdf8_0123to12301230(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (1 << 0) + (2 << 2) + (3 << 4) + (0 << 6))
+#define stbir__simdf8_0123to10321032(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (1 << 0) + (0 << 2) + (3 << 4) + (2 << 6))
+#define stbir__simdf8_0123to30123012(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (3 << 0) + (0 << 2) + (1 << 4) + (2 << 6))
+
+#define stbir__simdf8_0123to11331133(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (1 << 0) + (1 << 2) + (3 << 4) + (3 << 6))
+#define stbir__simdf8_0123to00220022(out, in)                                                      \
+    (out) = _mm256_shuffle_ps(in, in, (0 << 0) + (0 << 2) + (2 << 4) + (2 << 6))
+
+#define stbir__simdf8_aaa1(out, alp, ones)                                                         \
+    (out) = _mm256_blend_ps(alp, ones,                                                             \
+                            (1 << 0) + (1 << 1) + (1 << 2) + (0 << 3) + (1 << 4) + (1 << 5) +      \
+                                (1 << 6) + (0 << 7));                                              \
+    (out) = _mm256_shuffle_ps(out, out, (3 << 0) + (3 << 2) + (3 << 4) + (0 << 6))
+#define stbir__simdf8_1aaa(out, alp, ones)                                                         \
+    (out) = _mm256_blend_ps(alp, ones,                                                             \
+                            (0 << 0) + (1 << 1) + (1 << 2) + (1 << 3) + (0 << 4) + (1 << 5) +      \
+                                (1 << 6) + (1 << 7));                                              \
+    (out) = _mm256_shuffle_ps(out, out, (1 << 0) + (0 << 2) + (0 << 4) + (0 << 6))
+#define stbir__simdf8_a1a1(out, alp, ones)                                                         \
+    (out) = _mm256_blend_ps(alp, ones,                                                             \
+                            (1 << 0) + (0 << 1) + (1 << 2) + (0 << 3) + (1 << 4) + (0 << 5) +      \
+                                (1 << 6) + (0 << 7));                                              \
+    (out) = _mm256_shuffle_ps(out, out, (1 << 0) + (0 << 2) + (3 << 4) + (2 << 6))
+#define stbir__simdf8_1a1a(out, alp, ones)                                                         \
+    (out) = _mm256_blend_ps(alp, ones,                                                             \
+                            (0 << 0) + (1 << 1) + (0 << 2) + (1 << 3) + (0 << 4) + (1 << 5) +      \
+                                (0 << 6) + (1 << 7));                                              \
+    (out) = _mm256_shuffle_ps(out, out, (1 << 0) + (0 << 2) + (3 << 4) + (2 << 6))
+
+#define stbir__simdf8_zero(reg) (reg) = _mm256_setzero_ps()
+
+#ifdef STBIR_USE_FMA  // not on by default to maintain bit identical simd to non-simd
+#define stbir__simdf8_madd(out, add, mul1, mul2) (out) = _mm256_fmadd_ps(mul1, mul2, add)
+#define stbir__simdf8_madd_mem(out, add, mul, ptr)                                                 \
+    (out) = _mm256_fmadd_ps(mul, _mm256_loadu_ps((float const *)(ptr)), add)
+#define stbir__simdf8_madd_mem4(out, add, mul, ptr)                                                \
+    (out) = _mm256_fmadd_ps(                                                                       \
+        _mm256_setr_m128(mul, _mm_setzero_ps()),                                                   \
+        _mm256_setr_m128(_mm_loadu_ps((float const *)(ptr)), _mm_setzero_ps()), add)
+#else
+#define stbir__simdf8_madd(out, add, mul1, mul2)                                                   \
+    (out) = _mm256_add_ps(add, _mm256_mul_ps(mul1, mul2))
+#define stbir__simdf8_madd_mem(out, add, mul, ptr)                                                 \
+    (out) = _mm256_add_ps(add, _mm256_mul_ps(mul, _mm256_loadu_ps((float const *)(ptr))))
+#define stbir__simdf8_madd_mem4(out, add, mul, ptr)                                                \
+    (out) =                                                                                        \
+        _mm256_add_ps(add, _mm256_setr_m128(_mm_mul_ps(mul, _mm_loadu_ps((float const *)(ptr))),   \
+                                            _mm_setzero_ps()))
+#endif
+#define stbir__if_simdf8_cast_to_simdf4(val) _mm256_castps256_ps128(val)
+
+#endif
+
+#ifdef STBIR_FLOORF
+#undef STBIR_FLOORF
+#endif
+#define STBIR_FLOORF stbir_simd_floorf
+static stbir__inline float stbir_simd_floorf(float x)  // martins floorf
+{
+#if defined(STBIR_AVX) || defined(__SSE4_1__) || defined(STBIR_SSE41)
+    __m128 t = _mm_set_ss(x);
+    return _mm_cvtss_f32(_mm_floor_ss(t, t));
+#else
+    __m128 f = _mm_set_ss(x);
+    __m128 t = _mm_cvtepi32_ps(_mm_cvttps_epi32(f));
+    __m128 r = _mm_add_ss(t, _mm_and_ps(_mm_cmplt_ss(f, t), _mm_set_ss(-1.0f)));
+    return _mm_cvtss_f32(r);
+#endif
+}
+
+#ifdef STBIR_CEILF
+#undef STBIR_CEILF
+#endif
+#define STBIR_CEILF stbir_simd_ceilf
+static stbir__inline float stbir_simd_ceilf(float x)  // martins ceilf
+{
+#if defined(STBIR_AVX) || defined(__SSE4_1__) || defined(STBIR_SSE41)
+    __m128 t = _mm_set_ss(x);
+    return _mm_cvtss_f32(_mm_ceil_ss(t, t));
+#else
+    __m128 f = _mm_set_ss(x);
+    __m128 t = _mm_cvtepi32_ps(_mm_cvttps_epi32(f));
+    __m128 r = _mm_add_ss(t, _mm_and_ps(_mm_cmplt_ss(t, f), _mm_set_ss(1.0f)));
+    return _mm_cvtss_f32(r);
+#endif
+}
+
+#elif defined(STBIR_NEON)
+
+#include <arm_neon.h>
+
+#define stbir__simdf float32x4_t
+#define stbir__simdi uint32x4_t
+
+#define stbir_simdi_castf(reg) vreinterpretq_u32_f32(reg)
+#define stbir_simdf_casti(reg) vreinterpretq_f32_u32(reg)
+
+#define stbir__simdf_load(reg, ptr) (reg) = vld1q_f32((float const *)(ptr))
+#define stbir__simdi_load(reg, ptr) (reg) = vld1q_u32((uint32_t const *)(ptr))
+#define stbir__simdf_load1(out, ptr)                                                               \
+    (out) = vld1q_dup_f32(                                                                         \
+        (float const *)(ptr))  // top values can be random (not denormal or nan for perf)
+#define stbir__simdi_load1(out, ptr) (out) = vld1q_dup_u32((uint32_t const *)(ptr))
+#define stbir__simdf_load1z(out, ptr)                                                              \
+    (out) = vld1q_lane_f32((float const *)(ptr), vdupq_n_f32(0), 0)  // top values must be zero
+#define stbir__simdf_frep4(fvar)           vdupq_n_f32(fvar)
+#define stbir__simdf_load1frep4(out, fvar) (out) = vdupq_n_f32(fvar)
+#define stbir__simdf_load2(out, ptr)                                                               \
+    (out) =                                                                                        \
+        vcombine_f32(vld1_f32((float const *)(ptr)),                                               \
+                     vcreate_f32(0))  // top values can be random (not denormal or nan for perf)
+#define stbir__simdf_load2z(out, ptr)                                                              \
+    (out) = vcombine_f32(vld1_f32((float const *)(ptr)), vcreate_f32(0))  // top values must be zero
+#define stbir__simdf_load2hmerge(out, reg, ptr)                                                    \
+    (out) = vcombine_f32(vget_low_f32(reg), vld1_f32((float const *)(ptr)))
+
+#define stbir__simdf_zeroP()   vdupq_n_f32(0)
+#define stbir__simdf_zero(reg) (reg) = vdupq_n_f32(0)
+
+#define stbir__simdf_store(ptr, reg)   vst1q_f32((float *)(ptr), reg)
+#define stbir__simdf_store1(ptr, reg)  vst1q_lane_f32((float *)(ptr), reg, 0)
+#define stbir__simdf_store2(ptr, reg)  vst1_f32((float *)(ptr), vget_low_f32(reg))
+#define stbir__simdf_store2h(ptr, reg) vst1_f32((float *)(ptr), vget_high_f32(reg))
+
+#define stbir__simdi_store(ptr, reg)  vst1q_u32((uint32_t *)(ptr), reg)
+#define stbir__simdi_store1(ptr, reg) vst1q_lane_u32((uint32_t *)(ptr), reg, 0)
+#define stbir__simdi_store2(ptr, reg) vst1_u32((uint32_t *)(ptr), vget_low_u32(reg))
+
+#define stbir__prefetch(ptr)
+
+#define stbir__simdi_expand_u8_to_u32(out0, out1, out2, out3, ireg)                                \
+    {                                                                                              \
+        uint16x8_t l = vmovl_u8(vget_low_u8(vreinterpretq_u8_u32(ireg)));                          \
+        uint16x8_t h = vmovl_u8(vget_high_u8(vreinterpretq_u8_u32(ireg)));                         \
+        out0         = vmovl_u16(vget_low_u16(l));                                                 \
+        out1         = vmovl_u16(vget_high_u16(l));                                                \
+        out2         = vmovl_u16(vget_low_u16(h));                                                 \
+        out3         = vmovl_u16(vget_high_u16(h));                                                \
+    }
+
+#define stbir__simdi_expand_u8_to_1u32(out, ireg)                                                  \
+    {                                                                                              \
+        uint16x8_t tmp = vmovl_u8(vget_low_u8(vreinterpretq_u8_u32(ireg)));                        \
+        out            = vmovl_u16(vget_low_u16(tmp));                                             \
+    }
+
+#define stbir__simdi_expand_u16_to_u32(out0, out1, ireg)                                           \
+    {                                                                                              \
+        uint16x8_t tmp = vreinterpretq_u16_u32(ireg);                                              \
+        out0           = vmovl_u16(vget_low_u16(tmp));                                             \
+        out1           = vmovl_u16(vget_high_u16(tmp));                                            \
+    }
+
+#define stbir__simdf_convert_float_to_i32(i, f) (i) = vreinterpretq_u32_s32(vcvtq_s32_f32(f))
+#define stbir__simdf_convert_float_to_int(f)    vgetq_lane_s32(vcvtq_s32_f32(f), 0)
+#define stbir__simdi_to_int(i)                  (int)vgetq_lane_u32(i, 0)
+#define stbir__simdf_convert_float_to_uint8(f)                                                     \
+    ((unsigned char)vgetq_lane_s32(                                                                \
+        vcvtq_s32_f32(                                                                             \
+            vmaxq_f32(vminq_f32(f, STBIR__CONSTF(STBIR_max_uint8_as_float)), vdupq_n_f32(0))),     \
+        0))
+#define stbir__simdf_convert_float_to_short(f)                                                     \
+    ((unsigned short)vgetq_lane_s32(                                                               \
+        vcvtq_s32_f32(                                                                             \
+            vmaxq_f32(vminq_f32(f, STBIR__CONSTF(STBIR_max_uint16_as_float)), vdupq_n_f32(0))),    \
+        0))
+#define stbir__simdi_convert_i32_to_float(out, ireg)                                               \
+    (out) = vcvtq_f32_s32(vreinterpretq_s32_u32(ireg))
+#define stbir__simdf_add(out, reg0, reg1)    (out) = vaddq_f32(reg0, reg1)
+#define stbir__simdf_mult(out, reg0, reg1)   (out) = vmulq_f32(reg0, reg1)
+#define stbir__simdf_mult_mem(out, reg, ptr) (out) = vmulq_f32(reg, vld1q_f32((float const *)(ptr)))
+#define stbir__simdf_mult1_mem(out, reg, ptr)                                                      \
+    (out) = vmulq_f32(reg, vld1q_dup_f32((float const *)(ptr)))
+#define stbir__simdf_add_mem(out, reg, ptr) (out) = vaddq_f32(reg, vld1q_f32((float const *)(ptr)))
+#define stbir__simdf_add1_mem(out, reg, ptr)                                                       \
+    (out) = vaddq_f32(reg, vld1q_dup_f32((float const *)(ptr)))
+
+#ifdef STBIR_USE_FMA  // not on by default to maintain bit identical simd to non-simd (and also x64
+                      // no madd to arm madd)
+#define stbir__simdf_madd(out, add, mul1, mul2)  (out) = vfmaq_f32(add, mul1, mul2)
+#define stbir__simdf_madd1(out, add, mul1, mul2) (out) = vfmaq_f32(add, mul1, mul2)
+#define stbir__simdf_madd_mem(out, add, mul, ptr)                                                  \
+    (out) = vfmaq_f32(add, mul, vld1q_f32((float const *)(ptr)))
+#define stbir__simdf_madd1_mem(out, add, mul, ptr)                                                 \
+    (out) = vfmaq_f32(add, mul, vld1q_dup_f32((float const *)(ptr)))
+#else
+#define stbir__simdf_madd(out, add, mul1, mul2)  (out) = vaddq_f32(add, vmulq_f32(mul1, mul2))
+#define stbir__simdf_madd1(out, add, mul1, mul2) (out) = vaddq_f32(add, vmulq_f32(mul1, mul2))
+#define stbir__simdf_madd_mem(out, add, mul, ptr)                                                  \
+    (out) = vaddq_f32(add, vmulq_f32(mul, vld1q_f32((float const *)(ptr))))
+#define stbir__simdf_madd1_mem(out, add, mul, ptr)                                                 \
+    (out) = vaddq_f32(add, vmulq_f32(mul, vld1q_dup_f32((float const *)(ptr))))
+#endif
+
+#define stbir__simdf_add1(out, reg0, reg1)  (out) = vaddq_f32(reg0, reg1)
+#define stbir__simdf_mult1(out, reg0, reg1) (out) = vmulq_f32(reg0, reg1)
+
+#define stbir__simdf_and(out, reg0, reg1)                                                          \
+    (out) =                                                                                        \
+        vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1)))
+#define stbir__simdf_or(out, reg0, reg1)                                                           \
+    (out) =                                                                                        \
+        vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1)))
+
+#define stbir__simdf_min(out, reg0, reg1)  (out) = vminq_f32(reg0, reg1)
+#define stbir__simdf_max(out, reg0, reg1)  (out) = vmaxq_f32(reg0, reg1)
+#define stbir__simdf_min1(out, reg0, reg1) (out) = vminq_f32(reg0, reg1)
+#define stbir__simdf_max1(out, reg0, reg1) (out) = vmaxq_f32(reg0, reg1)
+
+#define stbir__simdf_0123ABCDto3ABx(out, reg0, reg1) (out) = vextq_f32(reg0, reg1, 3)
+#define stbir__simdf_0123ABCDto23Ax(out, reg0, reg1) (out) = vextq_f32(reg0, reg1, 2)
+
+#define stbir__simdf_a1a1(out, alp, ones) (out) = vzipq_f32(vuzpq_f32(alp, alp).val[1], ones).val[0]
+#define stbir__simdf_1a1a(out, alp, ones) (out) = vzipq_f32(ones, vuzpq_f32(alp, alp).val[0]).val[0]
+
+#if defined(_M_ARM64) || defined(__aarch64__) || defined(__arm64__)
+
+#define stbir__simdf_aaa1(out, alp, ones)                                                          \
+    (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3, ones, 3)
+#define stbir__simdf_1aaa(out, alp, ones)                                                          \
+    (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0, ones, 0)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define stbir_make16(a, b, c, d)                                                                   \
+    vcombine_u8(                                                                                   \
+        vcreate_u8((4 * a + 0) | ((4 * a + 1) << 8) | ((4 * a + 2) << 16) | ((4 * a + 3) << 24) |  \
+                   ((stbir_uint64)(4 * b + 0) << 32) | ((stbir_uint64)(4 * b + 1) << 40) |         \
+                   ((stbir_uint64)(4 * b + 2) << 48) | ((stbir_uint64)(4 * b + 3) << 56)),         \
+        vcreate_u8((4 * c + 0) | ((4 * c + 1) << 8) | ((4 * c + 2) << 16) | ((4 * c + 3) << 24) |  \
+                   ((stbir_uint64)(4 * d + 0) << 32) | ((stbir_uint64)(4 * d + 1) << 40) |         \
+                   ((stbir_uint64)(4 * d + 2) << 48) | ((stbir_uint64)(4 * d + 3) << 56)))
+
+static stbir__inline uint8x16x2_t stbir_make16x2(float32x4_t rega, float32x4_t regb) {
+    uint8x16x2_t r = {vreinterpretq_u8_f32(rega), vreinterpretq_u8_f32(regb)};
+    return r;
+}
+#else
+#define stbir_make16(a, b, c, d)                                                                   \
+    (uint8x16_t) {                                                                                 \
+        4 * a + 0, 4 * a + 1, 4 * a + 2, 4 * a + 3, 4 * b + 0, 4 * b + 1, 4 * b + 2, 4 * b + 3,    \
+            4 * c + 0, 4 * c + 1, 4 * c + 2, 4 * c + 3, 4 * d + 0, 4 * d + 1, 4 * d + 2, 4 * d + 3 \
+    }
+#define stbir_make16x2(a, b)                                                                       \
+    (uint8x16x2_t) {                                                                               \
+        { vreinterpretq_u8_f32(a), vreinterpretq_u8_f32(b) }                                       \
+    }
+#endif
+
+#define stbir__simdf_swiz(reg, one, two, three, four)                                              \
+    vreinterpretq_f32_u8(vqtbl1q_u8(vreinterpretq_u8_f32(reg), stbir_make16(one, two, three, four)))
+#define stbir__simdf_swiz2(rega, regb, one, two, three, four)                                      \
+    vreinterpretq_f32_u8(                                                                          \
+        vqtbl2q_u8(stbir_make16x2(rega, regb), stbir_make16(one, two, three, four)))
+
+#define stbir__simdi_16madd(out, reg0, reg1)                                                       \
+    {                                                                                              \
+        int16x8_t r0   = vreinterpretq_s16_u32(reg0);                                              \
+        int16x8_t r1   = vreinterpretq_s16_u32(reg1);                                              \
+        int32x4_t tmp0 = vmull_s16(vget_low_s16(r0), vget_low_s16(r1));                            \
+        int32x4_t tmp1 = vmull_s16(vget_high_s16(r0), vget_high_s16(r1));                          \
+        (out)          = vreinterpretq_u32_s32(vpaddq_s32(tmp0, tmp1));                            \
+    }
+
+#else
+
+#define stbir__simdf_aaa1(out, alp, ones)                                                          \
+    (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3)
+#define stbir__simdf_1aaa(out, alp, ones)                                                          \
+    (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+static stbir__inline uint8x8x2_t stbir_make8x2(float32x4_t reg) {
+    uint8x8x2_t r = {
+        {vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg))}
+    };
+    return r;
+}
+#define stbir_make8(a, b)                                                                          \
+    vcreate_u8((4 * a + 0) | ((4 * a + 1) << 8) | ((4 * a + 2) << 16) | ((4 * a + 3) << 24) |      \
+               ((stbir_uint64)(4 * b + 0) << 32) | ((stbir_uint64)(4 * b + 1) << 40) |             \
+               ((stbir_uint64)(4 * b + 2) << 48) | ((stbir_uint64)(4 * b + 3) << 56))
+#else
+#define stbir_make8x2(reg)                                                                         \
+    (uint8x8x2_t) {                                                                                \
+        { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) }        \
+    }
+#define stbir_make8(a, b)                                                                          \
+    (uint8x8_t) {                                                                                  \
+        4 * a + 0, 4 * a + 1, 4 * a + 2, 4 * a + 3, 4 * b + 0, 4 * b + 1, 4 * b + 2, 4 * b + 3     \
+    }
+#endif
+
+#define stbir__simdf_swiz(reg, one, two, three, four)                                              \
+    vreinterpretq_f32_u8(vcombine_u8(vtbl2_u8(stbir_make8x2(reg), stbir_make8(one, two)),          \
+                                     vtbl2_u8(stbir_make8x2(reg), stbir_make8(three, four))))
+
+#define stbir__simdi_16madd(out, reg0, reg1)                                                       \
+    {                                                                                              \
+        int16x8_t r0   = vreinterpretq_s16_u32(reg0);                                              \
+        int16x8_t r1   = vreinterpretq_s16_u32(reg1);                                              \
+        int32x4_t tmp0 = vmull_s16(vget_low_s16(r0), vget_low_s16(r1));                            \
+        int32x4_t tmp1 = vmull_s16(vget_high_s16(r0), vget_high_s16(r1));                          \
+        int32x2_t out0 = vpadd_s32(vget_low_s32(tmp0), vget_high_s32(tmp0));                       \
+        int32x2_t out1 = vpadd_s32(vget_low_s32(tmp1), vget_high_s32(tmp1));                       \
+        (out)          = vreinterpretq_u32_s32(vcombine_s32(out0, out1));                          \
+    }
+
+#endif
+
+#define stbir__simdi_and(out, reg0, reg1) (out) = vandq_u32(reg0, reg1)
+#define stbir__simdi_or(out, reg0, reg1)  (out) = vorrq_u32(reg0, reg1)
+
+#define stbir__simdf_pack_to_8bytes(out, aa, bb)                                                   \
+    {                                                                                              \
+        float32x4_t af =                                                                           \
+            vmaxq_f32(vminq_f32(aa, STBIR__CONSTF(STBIR_max_uint8_as_float)), vdupq_n_f32(0));     \
+        float32x4_t bf =                                                                           \
+            vmaxq_f32(vminq_f32(bb, STBIR__CONSTF(STBIR_max_uint8_as_float)), vdupq_n_f32(0));     \
+        int16x4_t ai   = vqmovn_s32(vcvtq_s32_f32(af));                                            \
+        int16x4_t bi   = vqmovn_s32(vcvtq_s32_f32(bf));                                            \
+        uint8x8_t out8 = vqmovun_s16(vcombine_s16(ai, bi));                                        \
+        out            = vreinterpretq_u32_u8(vcombine_u8(out8, out8));                            \
+    }
+
+#define stbir__simdf_pack_to_8words(out, aa, bb)                                                   \
+    {                                                                                              \
+        float32x4_t af =                                                                           \
+            vmaxq_f32(vminq_f32(aa, STBIR__CONSTF(STBIR_max_uint16_as_float)), vdupq_n_f32(0));    \
+        float32x4_t bf =                                                                           \
+            vmaxq_f32(vminq_f32(bb, STBIR__CONSTF(STBIR_max_uint16_as_float)), vdupq_n_f32(0));    \
+        int32x4_t ai = vcvtq_s32_f32(af);                                                          \
+        int32x4_t bi = vcvtq_s32_f32(bf);                                                          \
+        out          = vreinterpretq_u32_u16(vcombine_u16(vqmovun_s32(ai), vqmovun_s32(bi)));      \
+    }
+
+#define stbir__interleave_pack_and_store_16_u8(ptr, r0, r1, r2, r3)                                \
+    {                                                                                              \
+        int16x4x2_t tmp0 = vzip_s16(vqmovn_s32(vreinterpretq_s32_u32(r0)),                         \
+                                    vqmovn_s32(vreinterpretq_s32_u32(r2)));                        \
+        int16x4x2_t tmp1 = vzip_s16(vqmovn_s32(vreinterpretq_s32_u32(r1)),                         \
+                                    vqmovn_s32(vreinterpretq_s32_u32(r3)));                        \
+        uint8x8x2_t out  = {                                                                       \
+            {                                                                                     \
+             vqmovun_s16(vcombine_s16(tmp0.val[0], tmp0.val[1])),                              \
+             vqmovun_s16(vcombine_s16(tmp1.val[0], tmp1.val[1])),                              \
+             }
+        };                                                                                   \
+        vst2_u8(ptr, out);                                                                         \
+    }
+
+#define stbir__simdf_load4_transposed(o0, o1, o2, o3, ptr)                                         \
+    {                                                                                              \
+        float32x4x4_t tmp = vld4q_f32(ptr);                                                        \
+        o0                = tmp.val[0];                                                            \
+        o1                = tmp.val[1];                                                            \
+        o2                = tmp.val[2];                                                            \
+        o3                = tmp.val[3];                                                            \
+    }
+
+#define stbir__simdi_32shr(out, reg, imm) out = vshrq_n_u32(reg, imm)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define STBIR__SIMDF_CONST(var, x) __declspec(align(8)) float var[] = {x, x, x, x}
+#define STBIR__SIMDI_CONST(var, x) __declspec(align(8)) uint32_t var[] = {x, x, x, x}
+#define STBIR__CONSTF(var)         (*(const float32x4_t *)var)
+#define STBIR__CONSTI(var)         (*(const uint32x4_t *)var)
+#else
+#define STBIR__SIMDF_CONST(var, x) stbir__simdf var = {x, x, x, x}
+#define STBIR__SIMDI_CONST(var, x) stbir__simdi var = {x, x, x, x}
+#define STBIR__CONSTF(var)         (var)
+#define STBIR__CONSTI(var)         (var)
+#endif
+
+#ifdef STBIR_FLOORF
+#undef STBIR_FLOORF
+#endif
+#define STBIR_FLOORF stbir_simd_floorf
+static stbir__inline float stbir_simd_floorf(float x) {
+#if defined(_M_ARM64) || defined(__aarch64__) || defined(__arm64__)
+    return vget_lane_f32(vrndm_f32(vdup_n_f32(x)), 0);
+#else
+    float32x2_t f = vdup_n_f32(x);
+    float32x2_t t = vcvt_f32_s32(vcvt_s32_f32(f));
+    uint32x2_t a  = vclt_f32(f, t);
+    uint32x2_t b  = vreinterpret_u32_f32(vdup_n_f32(-1.0f));
+    float32x2_t r = vadd_f32(t, vreinterpret_f32_u32(vand_u32(a, b)));
+    return vget_lane_f32(r, 0);
+#endif
+}
+
+#ifdef STBIR_CEILF
+#undef STBIR_CEILF
+#endif
+#define STBIR_CEILF stbir_simd_ceilf
+static stbir__inline float stbir_simd_ceilf(float x) {
+#if defined(_M_ARM64) || defined(__aarch64__) || defined(__arm64__)
+    return vget_lane_f32(vrndp_f32(vdup_n_f32(x)), 0);
+#else
+    float32x2_t f = vdup_n_f32(x);
+    float32x2_t t = vcvt_f32_s32(vcvt_s32_f32(f));
+    uint32x2_t a  = vclt_f32(t, f);
+    uint32x2_t b  = vreinterpret_u32_f32(vdup_n_f32(1.0f));
+    float32x2_t r = vadd_f32(t, vreinterpret_f32_u32(vand_u32(a, b)));
+    return vget_lane_f32(r, 0);
+#endif
+}
+
+#define STBIR_SIMD
+
+#elif defined(STBIR_WASM)
+
+#include <wasm_simd128.h>
+
+#define stbir__simdf v128_t
+#define stbir__simdi v128_t
+
+#define stbir_simdi_castf(reg) (reg)
+#define stbir_simdf_casti(reg) (reg)
+
+#define stbir__simdf_load(reg, ptr) (reg) = wasm_v128_load((void const *)(ptr))
+#define stbir__simdi_load(reg, ptr) (reg) = wasm_v128_load((void const *)(ptr))
+#define stbir__simdf_load1(out, ptr)                                                               \
+    (out) = wasm_v128_load32_splat(                                                                \
+        (void const *)(ptr))  // top values can be random (not denormal or nan for perf)
+#define stbir__simdi_load1(out, ptr) (out) = wasm_v128_load32_splat((void const *)(ptr))
+#define stbir__simdf_load1z(out, ptr)                                                              \
+    (out) = wasm_v128_load32_zero((void const *)(ptr))  // top values must be zero
+#define stbir__simdf_frep4(fvar)           wasm_f32x4_splat(fvar)
+#define stbir__simdf_load1frep4(out, fvar) (out) = wasm_f32x4_splat(fvar)
+#define stbir__simdf_load2(out, ptr)                                                               \
+    (out) = wasm_v128_load64_splat(                                                                \
+        (void const *)(ptr))  // top values can be random (not denormal or nan for perf)
+#define stbir__simdf_load2z(out, ptr)                                                              \
+    (out) = wasm_v128_load64_zero((void const *)(ptr))  // top values must be zero
+#define stbir__simdf_load2hmerge(out, reg, ptr)                                                    \
+    (out) = wasm_v128_load64_lane((void const *)(ptr), reg, 1)
+
+#define stbir__simdf_zeroP()   wasm_f32x4_const_splat(0)
+#define stbir__simdf_zero(reg) (reg) = wasm_f32x4_const_splat(0)
+
+#define stbir__simdf_store(ptr, reg)   wasm_v128_store((void *)(ptr), reg)
+#define stbir__simdf_store1(ptr, reg)  wasm_v128_store32_lane((void *)(ptr), reg, 0)
+#define stbir__simdf_store2(ptr, reg)  wasm_v128_store64_lane((void *)(ptr), reg, 0)
+#define stbir__simdf_store2h(ptr, reg) wasm_v128_store64_lane((void *)(ptr), reg, 1)
+
+#define stbir__simdi_store(ptr, reg)  wasm_v128_store((void *)(ptr), reg)
+#define stbir__simdi_store1(ptr, reg) wasm_v128_store32_lane((void *)(ptr), reg, 0)
+#define stbir__simdi_store2(ptr, reg) wasm_v128_store64_lane((void *)(ptr), reg, 0)
+
+#define stbir__prefetch(ptr)
+
+#define stbir__simdi_expand_u8_to_u32(out0, out1, out2, out3, ireg)                                \
+    {                                                                                              \
+        v128_t l = wasm_u16x8_extend_low_u8x16(ireg);                                              \
+        v128_t h = wasm_u16x8_extend_high_u8x16(ireg);                                             \
+        out0     = wasm_u32x4_extend_low_u16x8(l);                                                 \
+        out1     = wasm_u32x4_extend_high_u16x8(l);                                                \
+        out2     = wasm_u32x4_extend_low_u16x8(h);                                                 \
+        out3     = wasm_u32x4_extend_high_u16x8(h);                                                \
+    }
+
+#define stbir__simdi_expand_u8_to_1u32(out, ireg)                                                  \
+    {                                                                                              \
+        v128_t tmp = wasm_u16x8_extend_low_u8x16(ireg);                                            \
+        out        = wasm_u32x4_extend_low_u16x8(tmp);                                             \
+    }
+
+#define stbir__simdi_expand_u16_to_u32(out0, out1, ireg)                                           \
+    {                                                                                              \
+        out0 = wasm_u32x4_extend_low_u16x8(ireg);                                                  \
+        out1 = wasm_u32x4_extend_high_u16x8(ireg);                                                 \
+    }
+
+#define stbir__simdf_convert_float_to_i32(i, f) (i) = wasm_i32x4_trunc_sat_f32x4(f)
+#define stbir__simdf_convert_float_to_int(f)                                                       \
+    wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(f), 0)
+#define stbir__simdi_to_int(i) wasm_i32x4_extract_lane(i, 0)
+#define stbir__simdf_convert_float_to_uint8(f)                                                     \
+    ((unsigned char)wasm_i32x4_extract_lane(                                                       \
+        wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f, STBIR_max_uint8_as_float),     \
+                                                  wasm_f32x4_const_splat(0))),                     \
+        0))
+#define stbir__simdf_convert_float_to_short(f)                                                     \
+    ((unsigned short)wasm_i32x4_extract_lane(                                                      \
+        wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f, STBIR_max_uint16_as_float),    \
+                                                  wasm_f32x4_const_splat(0))),                     \
+        0))
+#define stbir__simdi_convert_i32_to_float(out, ireg) (out) = wasm_f32x4_convert_i32x4(ireg)
+#define stbir__simdf_add(out, reg0, reg1)            (out) = wasm_f32x4_add(reg0, reg1)
+#define stbir__simdf_mult(out, reg0, reg1)           (out) = wasm_f32x4_mul(reg0, reg1)
+#define stbir__simdf_mult_mem(out, reg, ptr)                                                       \
+    (out) = wasm_f32x4_mul(reg, wasm_v128_load((void const *)(ptr)))
+#define stbir__simdf_mult1_mem(out, reg, ptr)                                                      \
+    (out) = wasm_f32x4_mul(reg, wasm_v128_load32_splat((void const *)(ptr)))
+#define stbir__simdf_add_mem(out, reg, ptr)                                                        \
+    (out) = wasm_f32x4_add(reg, wasm_v128_load((void const *)(ptr)))
+#define stbir__simdf_add1_mem(out, reg, ptr)                                                       \
+    (out) = wasm_f32x4_add(reg, wasm_v128_load32_splat((void const *)(ptr)))
+
+#define stbir__simdf_madd(out, add, mul1, mul2)                                                    \
+    (out) = wasm_f32x4_add(add, wasm_f32x4_mul(mul1, mul2))
+#define stbir__simdf_madd1(out, add, mul1, mul2)                                                   \
+    (out) = wasm_f32x4_add(add, wasm_f32x4_mul(mul1, mul2))
+#define stbir__simdf_madd_mem(out, add, mul, ptr)                                                  \
+    (out) = wasm_f32x4_add(add, wasm_f32x4_mul(mul, wasm_v128_load((void const *)(ptr))))
+#define stbir__simdf_madd1_mem(out, add, mul, ptr)                                                 \
+    (out) = wasm_f32x4_add(add, wasm_f32x4_mul(mul, wasm_v128_load32_splat((void const *)(ptr))))
+
+#define stbir__simdf_add1(out, reg0, reg1)  (out) = wasm_f32x4_add(reg0, reg1)
+#define stbir__simdf_mult1(out, reg0, reg1) (out) = wasm_f32x4_mul(reg0, reg1)
+
+#define stbir__simdf_and(out, reg0, reg1) (out) = wasm_v128_and(reg0, reg1)
+#define stbir__simdf_or(out, reg0, reg1)  (out) = wasm_v128_or(reg0, reg1)
+
+#define stbir__simdf_min(out, reg0, reg1)  (out) = wasm_f32x4_min(reg0, reg1)
+#define stbir__simdf_max(out, reg0, reg1)  (out) = wasm_f32x4_max(reg0, reg1)
+#define stbir__simdf_min1(out, reg0, reg1) (out) = wasm_f32x4_min(reg0, reg1)
+#define stbir__simdf_max1(out, reg0, reg1) (out) = wasm_f32x4_max(reg0, reg1)
+
+#define stbir__simdf_0123ABCDto3ABx(out, reg0, reg1)                                               \
+    (out) = wasm_i32x4_shuffle(reg0, reg1, 3, 4, 5, -1)
+#define stbir__simdf_0123ABCDto23Ax(out, reg0, reg1)                                               \
+    (out) = wasm_i32x4_shuffle(reg0, reg1, 2, 3, 4, -1)
+
+#define stbir__simdf_aaa1(out, alp, ones) (out) = wasm_i32x4_shuffle(alp, ones, 3, 3, 3, 4)
+#define stbir__simdf_1aaa(out, alp, ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 0, 0)
+#define stbir__simdf_a1a1(out, alp, ones) (out) = wasm_i32x4_shuffle(alp, ones, 1, 4, 3, 4)
+#define stbir__simdf_1a1a(out, alp, ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 4, 2)
+
+#define stbir__simdf_swiz(reg, one, two, three, four)                                              \
+    wasm_i32x4_shuffle(reg, reg, one, two, three, four)
+
+#define stbir__simdi_and(out, reg0, reg1)    (out) = wasm_v128_and(reg0, reg1)
+#define stbir__simdi_or(out, reg0, reg1)     (out) = wasm_v128_or(reg0, reg1)
+#define stbir__simdi_16madd(out, reg0, reg1) (out) = wasm_i32x4_dot_i16x8(reg0, reg1)
+
+#define stbir__simdf_pack_to_8bytes(out, aa, bb)                                                   \
+    {                                                                                              \
+        v128_t af    = wasm_f32x4_max(wasm_f32x4_min(aa, STBIR_max_uint8_as_float),                \
+                                      wasm_f32x4_const_splat(0));                                  \
+        v128_t bf    = wasm_f32x4_max(wasm_f32x4_min(bb, STBIR_max_uint8_as_float),                \
+                                      wasm_f32x4_const_splat(0));                                  \
+        v128_t ai    = wasm_i32x4_trunc_sat_f32x4(af);                                             \
+        v128_t bi    = wasm_i32x4_trunc_sat_f32x4(bf);                                             \
+        v128_t out16 = wasm_i16x8_narrow_i32x4(ai, bi);                                            \
+        out          = wasm_u8x16_narrow_i16x8(out16, out16);                                      \
+    }
+
+#define stbir__simdf_pack_to_8words(out, aa, bb)                                                   \
+    {                                                                                              \
+        v128_t af = wasm_f32x4_max(wasm_f32x4_min(aa, STBIR_max_uint16_as_float),                  \
+                                   wasm_f32x4_const_splat(0));                                     \
+        v128_t bf = wasm_f32x4_max(wasm_f32x4_min(bb, STBIR_max_uint16_as_float),                  \
+                                   wasm_f32x4_const_splat(0));                                     \
+        v128_t ai = wasm_i32x4_trunc_sat_f32x4(af);                                                \
+        v128_t bi = wasm_i32x4_trunc_sat_f32x4(bf);                                                \
+        out       = wasm_u16x8_narrow_i32x4(ai, bi);                                               \
+    }
+
+#define stbir__interleave_pack_and_store_16_u8(ptr, r0, r1, r2, r3)                                \
+    {                                                                                              \
+        v128_t tmp0 = wasm_i16x8_narrow_i32x4(r0, r1);                                             \
+        v128_t tmp1 = wasm_i16x8_narrow_i32x4(r2, r3);                                             \
+        v128_t tmp  = wasm_u8x16_narrow_i16x8(tmp0, tmp1);                                         \
+        tmp = wasm_i8x16_shuffle(tmp, tmp, 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15);  \
+        wasm_v128_store((void *)(ptr), tmp);                                                       \
+    }
+
+#define stbir__simdf_load4_transposed(o0, o1, o2, o3, ptr)                                         \
+    {                                                                                              \
+        v128_t t0 = wasm_v128_load(ptr);                                                           \
+        v128_t t1 = wasm_v128_load(ptr + 4);                                                       \
+        v128_t t2 = wasm_v128_load(ptr + 8);                                                       \
+        v128_t t3 = wasm_v128_load(ptr + 12);                                                      \
+        v128_t s0 = wasm_i32x4_shuffle(t0, t1, 0, 4, 2, 6);                                        \
+        v128_t s1 = wasm_i32x4_shuffle(t0, t1, 1, 5, 3, 7);                                        \
+        v128_t s2 = wasm_i32x4_shuffle(t2, t3, 0, 4, 2, 6);                                        \
+        v128_t s3 = wasm_i32x4_shuffle(t2, t3, 1, 5, 3, 7);                                        \
+        o0        = wasm_i32x4_shuffle(s0, s2, 0, 1, 4, 5);                                        \
+        o1        = wasm_i32x4_shuffle(s1, s3, 0, 1, 4, 5);                                        \
+        o2        = wasm_i32x4_shuffle(s0, s2, 2, 3, 6, 7);                                        \
+        o3        = wasm_i32x4_shuffle(s1, s3, 2, 3, 6, 7);                                        \
+    }
+
+#define stbir__simdi_32shr(out, reg, imm) out = wasm_u32x4_shr(reg, imm)
+
+typedef float stbir__f32x4 __attribute__((__vector_size__(16), __aligned__(16)));
+#define STBIR__SIMDF_CONST(var, x)                                                                 \
+    stbir__simdf var = (v128_t)(stbir__f32x4) { x, x, x, x }
+#define STBIR__SIMDI_CONST(var, x) stbir__simdi var = {x, x, x, x}
+#define STBIR__CONSTF(var)         (var)
+#define STBIR__CONSTI(var)         (var)
+
+#ifdef STBIR_FLOORF
+#undef STBIR_FLOORF
+#endif
+#define STBIR_FLOORF stbir_simd_floorf
+static stbir__inline float stbir_simd_floorf(float x) {
+    return wasm_f32x4_extract_lane(wasm_f32x4_floor(wasm_f32x4_splat(x)), 0);
+}
+
+#ifdef STBIR_CEILF
+#undef STBIR_CEILF
+#endif
+#define STBIR_CEILF stbir_simd_ceilf
+static stbir__inline float stbir_simd_ceilf(float x) {
+    return wasm_f32x4_extract_lane(wasm_f32x4_ceil(wasm_f32x4_splat(x)), 0);
+}
+
+#define STBIR_SIMD
+
+#endif  // SSE2/NEON/WASM
+
+#endif  // NO SIMD
+
+#ifdef STBIR_SIMD8
+#define stbir__simdfX                      stbir__simdf8
+#define stbir__simdiX                      stbir__simdi8
+#define stbir__simdfX_load                 stbir__simdf8_load
+#define stbir__simdiX_load                 stbir__simdi8_load
+#define stbir__simdfX_mult                 stbir__simdf8_mult
+#define stbir__simdfX_add_mem              stbir__simdf8_add_mem
+#define stbir__simdfX_madd_mem             stbir__simdf8_madd_mem
+#define stbir__simdfX_store                stbir__simdf8_store
+#define stbir__simdiX_store                stbir__simdi8_store
+#define stbir__simdf_frepX                 stbir__simdf8_frep8
+#define stbir__simdfX_madd                 stbir__simdf8_madd
+#define stbir__simdfX_min                  stbir__simdf8_min
+#define stbir__simdfX_max                  stbir__simdf8_max
+#define stbir__simdfX_aaa1                 stbir__simdf8_aaa1
+#define stbir__simdfX_1aaa                 stbir__simdf8_1aaa
+#define stbir__simdfX_a1a1                 stbir__simdf8_a1a1
+#define stbir__simdfX_1a1a                 stbir__simdf8_1a1a
+#define stbir__simdfX_convert_float_to_i32 stbir__simdf8_convert_float_to_i32
+#define stbir__simdfX_pack_to_words        stbir__simdf8_pack_to_16words
+#define stbir__simdfX_zero                 stbir__simdf8_zero
+#define STBIR_onesX                        STBIR_ones8
+#define STBIR_max_uint8_as_floatX          STBIR_max_uint8_as_float8
+#define STBIR_max_uint16_as_floatX         STBIR_max_uint16_as_float8
+#define STBIR_simd_point5X                 STBIR_simd_point58
+#define stbir__simdfX_float_count          8
+#define stbir__simdfX_0123to1230           stbir__simdf8_0123to12301230
+#define stbir__simdfX_0123to2103           stbir__simdf8_0123to21032103
+static const stbir__simdf8 STBIR_max_uint16_as_float_inverted8 = {
+    stbir__max_uint16_as_float_inverted, stbir__max_uint16_as_float_inverted,
+    stbir__max_uint16_as_float_inverted, stbir__max_uint16_as_float_inverted,
+    stbir__max_uint16_as_float_inverted, stbir__max_uint16_as_float_inverted,
+    stbir__max_uint16_as_float_inverted, stbir__max_uint16_as_float_inverted};
+static const stbir__simdf8 STBIR_max_uint8_as_float_inverted8 = {
+    stbir__max_uint8_as_float_inverted, stbir__max_uint8_as_float_inverted,
+    stbir__max_uint8_as_float_inverted, stbir__max_uint8_as_float_inverted,
+    stbir__max_uint8_as_float_inverted, stbir__max_uint8_as_float_inverted,
+    stbir__max_uint8_as_float_inverted, stbir__max_uint8_as_float_inverted};
+static const stbir__simdf8 STBIR_ones8               = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
+static const stbir__simdf8 STBIR_simd_point58        = {0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5};
+static const stbir__simdf8 STBIR_max_uint8_as_float8 = {
+    stbir__max_uint8_as_float, stbir__max_uint8_as_float, stbir__max_uint8_as_float,
+    stbir__max_uint8_as_float, stbir__max_uint8_as_float, stbir__max_uint8_as_float,
+    stbir__max_uint8_as_float, stbir__max_uint8_as_float};
+static const stbir__simdf8 STBIR_max_uint16_as_float8 = {
+    stbir__max_uint16_as_float, stbir__max_uint16_as_float, stbir__max_uint16_as_float,
+    stbir__max_uint16_as_float, stbir__max_uint16_as_float, stbir__max_uint16_as_float,
+    stbir__max_uint16_as_float, stbir__max_uint16_as_float};
+#else
+#define stbir__simdfX                        stbir__simdf
+#define stbir__simdiX                        stbir__simdi
+#define stbir__simdfX_load                   stbir__simdf_load
+#define stbir__simdiX_load                   stbir__simdi_load
+#define stbir__simdfX_mult                   stbir__simdf_mult
+#define stbir__simdfX_add_mem                stbir__simdf_add_mem
+#define stbir__simdfX_madd_mem               stbir__simdf_madd_mem
+#define stbir__simdfX_store                  stbir__simdf_store
+#define stbir__simdiX_store                  stbir__simdi_store
+#define stbir__simdf_frepX                   stbir__simdf_frep4
+#define stbir__simdfX_madd                   stbir__simdf_madd
+#define stbir__simdfX_min                    stbir__simdf_min
+#define stbir__simdfX_max                    stbir__simdf_max
+#define stbir__simdfX_aaa1                   stbir__simdf_aaa1
+#define stbir__simdfX_1aaa                   stbir__simdf_1aaa
+#define stbir__simdfX_a1a1                   stbir__simdf_a1a1
+#define stbir__simdfX_1a1a                   stbir__simdf_1a1a
+#define stbir__simdfX_convert_float_to_i32   stbir__simdf_convert_float_to_i32
+#define stbir__simdfX_pack_to_words          stbir__simdf_pack_to_8words
+#define stbir__simdfX_zero                   stbir__simdf_zero
+#define STBIR_onesX                          STBIR__CONSTF(STBIR_ones)
+#define STBIR_simd_point5X                   STBIR__CONSTF(STBIR_simd_point5)
+#define STBIR_max_uint8_as_floatX            STBIR__CONSTF(STBIR_max_uint8_as_float)
+#define STBIR_max_uint16_as_floatX           STBIR__CONSTF(STBIR_max_uint16_as_float)
+#define stbir__simdfX_float_count            4
+#define stbir__if_simdf8_cast_to_simdf4(val) (val)
+#define stbir__simdfX_0123to1230             stbir__simdf_0123to1230
+#define stbir__simdfX_0123to2103             stbir__simdf_0123to2103
+#endif
+
+#if defined(STBIR_NEON) && !defined(_M_ARM) && !defined(__arm__)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+typedef __int16 stbir__FP16;
+#else
+typedef float16_t stbir__FP16;
+#endif
+
+#else  // no NEON, or 32-bit ARM for MSVC
+
+typedef union stbir__FP16 {
+    unsigned short u;
+} stbir__FP16;
+
+#endif
+
+#if (!defined(STBIR_NEON) && !defined(STBIR_FP16C)) || (defined(STBIR_NEON) && defined(_M_ARM)) || \
+    (defined(STBIR_NEON) && defined(__arm__))
+
+// Fabian's half float routines, see: https://gist.github.com/rygorous/2156668
+
+static stbir__inline float stbir__half_to_float(stbir__FP16 h) {
+    static const stbir__FP32 magic      = {(254 - 15) << 23};
+    static const stbir__FP32 was_infnan = {(127 + 16) << 23};
+    stbir__FP32 o;
+
+    o.u = (h.u & 0x7fff) << 13;  // exponent/mantissa bits
+    o.f *= magic.f;              // exponent adjust
+    if (o.f >= was_infnan.f)     // make sure Inf/NaN survive
+        o.u |= 255 << 23;
+    o.u |= (h.u & 0x8000) << 16;  // sign bit
+    return o.f;
+}
+
+static stbir__inline stbir__FP16 stbir__float_to_half(float val) {
+    stbir__FP32 f32infty     = {255 << 23};
+    stbir__FP32 f16max       = {(127 + 16) << 23};
+    stbir__FP32 denorm_magic = {((127 - 15) + (23 - 10) + 1) << 23};
+    unsigned int sign_mask   = 0x80000000u;
+    stbir__FP16 o            = {0};
+    stbir__FP32 f;
+    unsigned int sign;
+
+    f.f  = val;
+    sign = f.u & sign_mask;
+    f.u ^= sign;
+
+    if (f.u >= f16max.u)                             // result is Inf or NaN (all exponent bits set)
+        o.u = (f.u > f32infty.u) ? 0x7e00 : 0x7c00;  // NaN->qNaN and Inf->Inf
+    else                                             // (De)normalized number or zero
+    {
+        if (f.u < (113 << 23))  // resulting FP16 is subnormal or zero
+        {
+            // use a magic value to align our 10 mantissa bits at the bottom of
+            // the float. as long as FP addition is round-to-nearest-even this
+            // just works.
+            f.f += denorm_magic.f;
+            // and one integer subtract of the bias later, we have our final float!
+            o.u = (unsigned short)(f.u - denorm_magic.u);
+        } else {
+            unsigned int mant_odd = (f.u >> 13) & 1;  // resulting mantissa is odd
+            // update exponent, rounding bias part 1
+            f.u = f.u + ((15u - 127) << 23) + 0xfff;
+            // rounding bias part 2
+            f.u += mant_odd;
+            // take the bits!
+            o.u = (unsigned short)(f.u >> 13);
+        }
+    }
+
+    o.u |= sign >> 16;
+    return o;
+}
+
+#endif
+
+#if defined(STBIR_FP16C)
+
+#include <immintrin.h>
+
+static stbir__inline void stbir__half_to_float_SIMD(float *output, stbir__FP16 const *input) {
+    _mm256_storeu_ps((float *)output, _mm256_cvtph_ps(_mm_loadu_si128((__m128i const *)input)));
+}
+
+static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 *output, float const *input) {
+    _mm_storeu_si128((__m128i *)output, _mm256_cvtps_ph(_mm256_loadu_ps(input), 0));
+}
+
+static stbir__inline float stbir__half_to_float(stbir__FP16 h) {
+    return _mm_cvtss_f32(_mm_cvtph_ps(_mm_cvtsi32_si128((int)h.u)));
+}
+
+static stbir__inline stbir__FP16 stbir__float_to_half(float f) {
+    stbir__FP16 h;
+    h.u = (unsigned short)_mm_cvtsi128_si32(_mm_cvtps_ph(_mm_set_ss(f), 0));
+    return h;
+}
+
+#elif defined(STBIR_SSE2)
+
+// Fabian's half float routines, see: https://gist.github.com/rygorous/2156668
+stbir__inline static void stbir__half_to_float_SIMD(float *output, void const *input) {
+    static const STBIR__SIMDI_CONST(mask_nosign, 0x7fff);
+    static const STBIR__SIMDI_CONST(smallest_normal, 0x0400);
+    static const STBIR__SIMDI_CONST(infinity, 0x7c00);
+    static const STBIR__SIMDI_CONST(expadjust_normal, (127 - 15) << 23);
+    static const STBIR__SIMDI_CONST(magic_denorm, 113 << 23);
+
+    __m128i i           = _mm_loadu_si128((__m128i const *)(input));
+    __m128i h           = _mm_unpacklo_epi16(i, _mm_setzero_si128());
+    __m128i mnosign     = STBIR__CONSTI(mask_nosign);
+    __m128i eadjust     = STBIR__CONSTI(expadjust_normal);
+    __m128i smallest    = STBIR__CONSTI(smallest_normal);
+    __m128i infty       = STBIR__CONSTI(infinity);
+    __m128i expmant     = _mm_and_si128(mnosign, h);
+    __m128i justsign    = _mm_xor_si128(h, expmant);
+    __m128i b_notinfnan = _mm_cmpgt_epi32(infty, expmant);
+    __m128i b_isdenorm  = _mm_cmpgt_epi32(smallest, expmant);
+    __m128i shifted     = _mm_slli_epi32(expmant, 13);
+    __m128i adj_infnan  = _mm_andnot_si128(b_notinfnan, eadjust);
+    __m128i adjusted    = _mm_add_epi32(eadjust, shifted);
+    __m128i den1        = _mm_add_epi32(shifted, STBIR__CONSTI(magic_denorm));
+    __m128i adjusted2   = _mm_add_epi32(adjusted, adj_infnan);
+    __m128 den2         = _mm_sub_ps(_mm_castsi128_ps(den1), *(const __m128 *)&magic_denorm);
+    __m128 adjusted3    = _mm_and_ps(den2, _mm_castsi128_ps(b_isdenorm));
+    __m128 adjusted4    = _mm_andnot_ps(_mm_castsi128_ps(b_isdenorm), _mm_castsi128_ps(adjusted2));
+    __m128 adjusted5    = _mm_or_ps(adjusted3, adjusted4);
+    __m128i sign        = _mm_slli_epi32(justsign, 16);
+    __m128 final        = _mm_or_ps(adjusted5, _mm_castsi128_ps(sign));
+    stbir__simdf_store(output + 0, final);
+
+    h           = _mm_unpackhi_epi16(i, _mm_setzero_si128());
+    expmant     = _mm_and_si128(mnosign, h);
+    justsign    = _mm_xor_si128(h, expmant);
+    b_notinfnan = _mm_cmpgt_epi32(infty, expmant);
+    b_isdenorm  = _mm_cmpgt_epi32(smallest, expmant);
+    shifted     = _mm_slli_epi32(expmant, 13);
+    adj_infnan  = _mm_andnot_si128(b_notinfnan, eadjust);
+    adjusted    = _mm_add_epi32(eadjust, shifted);
+    den1        = _mm_add_epi32(shifted, STBIR__CONSTI(magic_denorm));
+    adjusted2   = _mm_add_epi32(adjusted, adj_infnan);
+    den2        = _mm_sub_ps(_mm_castsi128_ps(den1), *(const __m128 *)&magic_denorm);
+    adjusted3   = _mm_and_ps(den2, _mm_castsi128_ps(b_isdenorm));
+    adjusted4   = _mm_andnot_ps(_mm_castsi128_ps(b_isdenorm), _mm_castsi128_ps(adjusted2));
+    adjusted5   = _mm_or_ps(adjusted3, adjusted4);
+    sign        = _mm_slli_epi32(justsign, 16);
+    final       = _mm_or_ps(adjusted5, _mm_castsi128_ps(sign));
+    stbir__simdf_store(output + 4, final);
+
+    // ~38 SSE2 ops for 8 values
+}
+
+// Fabian's round-to-nearest-even float to half
+// ~48 SSE2 ops for 8 output
+stbir__inline static void stbir__float_to_half_SIMD(void *output, float const *input) {
+    static const STBIR__SIMDI_CONST(mask_sign, 0x80000000u);
+    static const STBIR__SIMDI_CONST(c_f16max, (127 + 16)
+                                                  << 23);  // all FP32 values >=this round to +inf
+    static const STBIR__SIMDI_CONST(c_nanbit, 0x200);
+    static const STBIR__SIMDI_CONST(c_infty_as_fp16, 0x7c00);
+    static const STBIR__SIMDI_CONST(
+        c_min_normal, (127 - 14) << 23);  // smallest FP32 that yields a normalized FP16
+    static const STBIR__SIMDI_CONST(c_subnorm_magic, ((127 - 15) + (23 - 10) + 1) << 23);
+    static const STBIR__SIMDI_CONST(
+        c_normal_bias, 0xfff - ((127 - 15) << 23));  // adjust exponent and add mantissa rounding
+
+    __m128 f        = _mm_loadu_ps(input);
+    __m128 msign    = _mm_castsi128_ps(STBIR__CONSTI(mask_sign));
+    __m128 justsign = _mm_and_ps(msign, f);
+    __m128 absf     = _mm_xor_ps(f, justsign);
+    __m128i absf_int =
+        _mm_castps_si128(absf);  // the cast is "free" (extra bypass latency, but no thruput hit)
+    __m128i f16max      = STBIR__CONSTI(c_f16max);
+    __m128 b_isnan      = _mm_cmpunord_ps(absf, absf);        // is this a NaN?
+    __m128i b_isregular = _mm_cmpgt_epi32(f16max, absf_int);  // (sub)normalized or special?
+    __m128i nanbit      = _mm_and_si128(_mm_castps_si128(b_isnan), STBIR__CONSTI(c_nanbit));
+    __m128i inf_or_nan =
+        _mm_or_si128(nanbit, STBIR__CONSTI(c_infty_as_fp16));  // output for specials
+
+    __m128i min_normal = STBIR__CONSTI(c_min_normal);
+    __m128i b_issub    = _mm_cmpgt_epi32(min_normal, absf_int);
+
+    // "result is subnormal" path
+    __m128 subnorm1 = _mm_add_ps(
+        absf,
+        _mm_castsi128_ps(STBIR__CONSTI(c_subnorm_magic)));  // magic value to round output mantissa
+    __m128i subnorm2 = _mm_sub_epi32(_mm_castps_si128(subnorm1),
+                                     STBIR__CONSTI(c_subnorm_magic));  // subtract out bias
+
+    // "result is normal" path
+    __m128i mantoddbit = _mm_slli_epi32(absf_int, 31 - 13);  // shift bit 13 (mantissa LSB) to sign
+    __m128i mantodd    = _mm_srai_epi32(mantoddbit, 31);     // -1 if FP16 mantissa odd, else 0
+
+    __m128i round1 = _mm_add_epi32(absf_int, STBIR__CONSTI(c_normal_bias));
+    __m128i round2 =
+        _mm_sub_epi32(round1, mantodd);  // if mantissa LSB odd, bias towards rounding up (RTNE)
+    __m128i normal = _mm_srli_epi32(round2, 13);  // rounded result
+
+    // combine the two non-specials
+    __m128i nonspecial =
+        _mm_or_si128(_mm_and_si128(subnorm2, b_issub), _mm_andnot_si128(b_issub, normal));
+
+    // merge in specials as well
+    __m128i joined = _mm_or_si128(_mm_and_si128(nonspecial, b_isregular),
+                                  _mm_andnot_si128(b_isregular, inf_or_nan));
+
+    __m128i sign_shift = _mm_srai_epi32(_mm_castps_si128(justsign), 16);
+    __m128i final2, final = _mm_or_si128(joined, sign_shift);
+
+    f        = _mm_loadu_ps(input + 4);
+    justsign = _mm_and_ps(msign, f);
+    absf     = _mm_xor_ps(f, justsign);
+    absf_int =
+        _mm_castps_si128(absf);  // the cast is "free" (extra bypass latency, but no thruput hit)
+    b_isnan     = _mm_cmpunord_ps(absf, absf);        // is this a NaN?
+    b_isregular = _mm_cmpgt_epi32(f16max, absf_int);  // (sub)normalized or special?
+    nanbit      = _mm_and_si128(_mm_castps_si128(b_isnan), c_nanbit);
+    inf_or_nan  = _mm_or_si128(nanbit, STBIR__CONSTI(c_infty_as_fp16));  // output for specials
+
+    b_issub = _mm_cmpgt_epi32(min_normal, absf_int);
+
+    // "result is subnormal" path
+    subnorm1 = _mm_add_ps(absf, _mm_castsi128_ps(STBIR__CONSTI(
+                                    c_subnorm_magic)));  // magic value to round output mantissa
+    subnorm2 = _mm_sub_epi32(_mm_castps_si128(subnorm1),
+                             STBIR__CONSTI(c_subnorm_magic));  // subtract out bias
+
+    // "result is normal" path
+    mantoddbit = _mm_slli_epi32(absf_int, 31 - 13);  // shift bit 13 (mantissa LSB) to sign
+    mantodd    = _mm_srai_epi32(mantoddbit, 31);     // -1 if FP16 mantissa odd, else 0
+
+    round1 = _mm_add_epi32(absf_int, STBIR__CONSTI(c_normal_bias));
+    round2 =
+        _mm_sub_epi32(round1, mantodd);   // if mantissa LSB odd, bias towards rounding up (RTNE)
+    normal = _mm_srli_epi32(round2, 13);  // rounded result
+
+    // combine the two non-specials
+    nonspecial = _mm_or_si128(_mm_and_si128(subnorm2, b_issub), _mm_andnot_si128(b_issub, normal));
+
+    // merge in specials as well
+    joined = _mm_or_si128(_mm_and_si128(nonspecial, b_isregular),
+                          _mm_andnot_si128(b_isregular, inf_or_nan));
+
+    sign_shift = _mm_srai_epi32(_mm_castps_si128(justsign), 16);
+    final2     = _mm_or_si128(joined, sign_shift);
+    final      = _mm_packs_epi32(final, final2);
+    stbir__simdi_store(output, final);
+}
+
+#elif defined(STBIR_NEON) && defined(_MSC_VER) && defined(_M_ARM64) &&                             \
+    !defined(__clang__)  // 64-bit ARM on MSVC (not clang)
+
+static stbir__inline void stbir__half_to_float_SIMD(float *output, stbir__FP16 const *input) {
+    float16x4_t in0 = vld1_f16(input + 0);
+    float16x4_t in1 = vld1_f16(input + 4);
+    vst1q_f32(output + 0, vcvt_f32_f16(in0));
+    vst1q_f32(output + 4, vcvt_f32_f16(in1));
+}
+
+static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 *output, float const *input) {
+    float16x4_t out0 = vcvt_f16_f32(vld1q_f32(input + 0));
+    float16x4_t out1 = vcvt_f16_f32(vld1q_f32(input + 4));
+    vst1_f16(output + 0, out0);
+    vst1_f16(output + 4, out1);
+}
+
+static stbir__inline float stbir__half_to_float(stbir__FP16 h) {
+    return vgetq_lane_f32(vcvt_f32_f16(vld1_dup_f16(&h)), 0);
+}
+
+static stbir__inline stbir__FP16 stbir__float_to_half(float f) {
+    return vget_lane_f16(vcvt_f16_f32(vdupq_n_f32(f)), 0).n16_u16[0];
+}
+
+#elif defined(STBIR_NEON) &&                                                                       \
+    (defined(_M_ARM64) || defined(__aarch64__) || defined(__arm64__))  // 64-bit ARM
+
+static stbir__inline void stbir__half_to_float_SIMD(float *output, stbir__FP16 const *input) {
+    float16x8_t in = vld1q_f16(input);
+    vst1q_f32(output + 0, vcvt_f32_f16(vget_low_f16(in)));
+    vst1q_f32(output + 4, vcvt_f32_f16(vget_high_f16(in)));
+}
+
+static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 *output, float const *input) {
+    float16x4_t out0 = vcvt_f16_f32(vld1q_f32(input + 0));
+    float16x4_t out1 = vcvt_f16_f32(vld1q_f32(input + 4));
+    vst1q_f16(output, vcombine_f16(out0, out1));
+}
+
+static stbir__inline float stbir__half_to_float(stbir__FP16 h) {
+    return vgetq_lane_f32(vcvt_f32_f16(vdup_n_f16(h)), 0);
+}
+
+static stbir__inline stbir__FP16 stbir__float_to_half(float f) {
+    return vget_lane_f16(vcvt_f16_f32(vdupq_n_f32(f)), 0);
+}
+
+#elif defined(STBIR_WASM) ||                                                                       \
+    (defined(STBIR_NEON) && (defined(_MSC_VER) || defined(_M_ARM) ||                               \
+                             defined(__arm__)))  // WASM or 32-bit ARM on MSVC/clang
+
+static stbir__inline void stbir__half_to_float_SIMD(float *output, stbir__FP16 const *input) {
+    for (int i = 0; i < 8; i++) {
+        output[i] = stbir__half_to_float(input[i]);
+    }
+}
+static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 *output, float const *input) {
+    for (int i = 0; i < 8; i++) {
+        output[i] = stbir__float_to_half(input[i]);
+    }
+}
+
+#endif
+
+#ifdef STBIR_SIMD
+
+#define stbir__simdf_0123to3333(out, reg) (out) = stbir__simdf_swiz(reg, 3, 3, 3, 3)
+#define stbir__simdf_0123to2222(out, reg) (out) = stbir__simdf_swiz(reg, 2, 2, 2, 2)
+#define stbir__simdf_0123to1111(out, reg) (out) = stbir__simdf_swiz(reg, 1, 1, 1, 1)
+#define stbir__simdf_0123to0000(out, reg) (out) = stbir__simdf_swiz(reg, 0, 0, 0, 0)
+#define stbir__simdf_0123to0003(out, reg) (out) = stbir__simdf_swiz(reg, 0, 0, 0, 3)
+#define stbir__simdf_0123to0001(out, reg) (out) = stbir__simdf_swiz(reg, 0, 0, 0, 1)
+#define stbir__simdf_0123to1122(out, reg) (out) = stbir__simdf_swiz(reg, 1, 1, 2, 2)
+#define stbir__simdf_0123to2333(out, reg) (out) = stbir__simdf_swiz(reg, 2, 3, 3, 3)
+#define stbir__simdf_0123to0023(out, reg) (out) = stbir__simdf_swiz(reg, 0, 0, 2, 3)
+#define stbir__simdf_0123to1230(out, reg) (out) = stbir__simdf_swiz(reg, 1, 2, 3, 0)
+#define stbir__simdf_0123to2103(out, reg) (out) = stbir__simdf_swiz(reg, 2, 1, 0, 3)
+#define stbir__simdf_0123to3210(out, reg) (out) = stbir__simdf_swiz(reg, 3, 2, 1, 0)
+#define stbir__simdf_0123to2301(out, reg) (out) = stbir__simdf_swiz(reg, 2, 3, 0, 1)
+#define stbir__simdf_0123to3012(out, reg) (out) = stbir__simdf_swiz(reg, 3, 0, 1, 2)
+#define stbir__simdf_0123to0011(out, reg) (out) = stbir__simdf_swiz(reg, 0, 0, 1, 1)
+#define stbir__simdf_0123to1100(out, reg) (out) = stbir__simdf_swiz(reg, 1, 1, 0, 0)
+#define stbir__simdf_0123to2233(out, reg) (out) = stbir__simdf_swiz(reg, 2, 2, 3, 3)
+#define stbir__simdf_0123to1133(out, reg) (out) = stbir__simdf_swiz(reg, 1, 1, 3, 3)
+#define stbir__simdf_0123to0022(out, reg) (out) = stbir__simdf_swiz(reg, 0, 0, 2, 2)
+#define stbir__simdf_0123to1032(out, reg) (out) = stbir__simdf_swiz(reg, 1, 0, 3, 2)
+
+typedef union stbir__simdi_u32 {
+    stbir_uint32 m128i_u32[4];
+    int m128i_i32[4];
+    stbir__simdi m128i_i128;
+} stbir__simdi_u32;
+
+static const int STBIR_mask[9] = {0, 0, 0, -1, -1, -1, 0, 0, 0};
+
+static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float, stbir__max_uint8_as_float);
+static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float, stbir__max_uint16_as_float);
+static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float_inverted,
+                                stbir__max_uint8_as_float_inverted);
+static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float_inverted,
+                                stbir__max_uint16_as_float_inverted);
+
+static const STBIR__SIMDF_CONST(STBIR_simd_point5, 0.5f);
+static const STBIR__SIMDF_CONST(STBIR_ones, 1.0f);
+static const STBIR__SIMDI_CONST(STBIR_almost_zero, (127 - 13) << 23);
+static const STBIR__SIMDI_CONST(STBIR_almost_one, 0x3f7fffff);
+static const STBIR__SIMDI_CONST(STBIR_mastissa_mask, 0xff);
+static const STBIR__SIMDI_CONST(STBIR_topscale, 0x02000000);
+
+//   Basically, in simd mode, we unroll the proper amount, and we don't want
+//   the non-simd remnant loops to be unroll because they only run a few times
+//   Adding this switch saves about 5K on clang which is Captain Unroll the 3rd.
+#define STBIR_SIMD_STREAMOUT_PTR(star)          STBIR_STREAMOUT_PTR(star)
+#define STBIR_SIMD_NO_UNROLL(ptr)               STBIR_NO_UNROLL(ptr)
+#define STBIR_SIMD_NO_UNROLL_LOOP_START         STBIR_NO_UNROLL_LOOP_START
+#define STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR STBIR_NO_UNROLL_LOOP_START_INF_FOR
+
+#ifdef STBIR_MEMCPY
+#undef STBIR_MEMCPY
+#endif
+#define STBIR_MEMCPY stbir_simd_memcpy
+
+// override normal use of memcpy with much simpler copy (faster and smaller with our sized copies)
+static void stbir_simd_memcpy(void *dest, void const *src, size_t bytes) {
+    char STBIR_SIMD_STREAMOUT_PTR(*) d     = (char *)dest;
+    char STBIR_SIMD_STREAMOUT_PTR(*) d_end = ((char *)dest) + bytes;
+    ptrdiff_t ofs_to_src                   = (char *)src - (char *)dest;
+
+    // check overlaps
+    STBIR_ASSERT(((d >= ((char *)src) + bytes)) || ((d + bytes) <= (char *)src));
+
+    if (bytes < (16 * stbir__simdfX_float_count)) {
+        if (bytes < 16) {
+            if (bytes) {
+                STBIR_SIMD_NO_UNROLL_LOOP_START
+                do {
+                    STBIR_SIMD_NO_UNROLL(d);
+                    d[0] = d[ofs_to_src];
+                    ++d;
+                } while (d < d_end);
+            }
+        } else {
+            stbir__simdf x;
+            // do one unaligned to get us aligned for the stream out below
+            stbir__simdf_load(x, (d + ofs_to_src));
+            stbir__simdf_store(d, x);
+            d = (char *)((((size_t)d) + 16) & ~15);
+
+            STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+            for (;;) {
+                STBIR_SIMD_NO_UNROLL(d);
+
+                if (d > (d_end - 16)) {
+                    if (d == d_end)
+                        return;
+                    d = d_end - 16;
+                }
+
+                stbir__simdf_load(x, (d + ofs_to_src));
+                stbir__simdf_store(d, x);
+                d += 16;
+            }
+        }
+    } else {
+        stbir__simdfX x0, x1, x2, x3;
+
+        // do one unaligned to get us aligned for the stream out below
+        stbir__simdfX_load(x0, (d + ofs_to_src) + 0 * stbir__simdfX_float_count);
+        stbir__simdfX_load(x1, (d + ofs_to_src) + 4 * stbir__simdfX_float_count);
+        stbir__simdfX_load(x2, (d + ofs_to_src) + 8 * stbir__simdfX_float_count);
+        stbir__simdfX_load(x3, (d + ofs_to_src) + 12 * stbir__simdfX_float_count);
+        stbir__simdfX_store(d + 0 * stbir__simdfX_float_count, x0);
+        stbir__simdfX_store(d + 4 * stbir__simdfX_float_count, x1);
+        stbir__simdfX_store(d + 8 * stbir__simdfX_float_count, x2);
+        stbir__simdfX_store(d + 12 * stbir__simdfX_float_count, x3);
+        d = (char *)((((size_t)d) + (16 * stbir__simdfX_float_count)) &
+                     ~((16 * stbir__simdfX_float_count) - 1));
+
+        STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+            STBIR_SIMD_NO_UNROLL(d);
+
+            if (d > (d_end - (16 * stbir__simdfX_float_count))) {
+                if (d == d_end)
+                    return;
+                d = d_end - (16 * stbir__simdfX_float_count);
+            }
+
+            stbir__simdfX_load(x0, (d + ofs_to_src) + 0 * stbir__simdfX_float_count);
+            stbir__simdfX_load(x1, (d + ofs_to_src) + 4 * stbir__simdfX_float_count);
+            stbir__simdfX_load(x2, (d + ofs_to_src) + 8 * stbir__simdfX_float_count);
+            stbir__simdfX_load(x3, (d + ofs_to_src) + 12 * stbir__simdfX_float_count);
+            stbir__simdfX_store(d + 0 * stbir__simdfX_float_count, x0);
+            stbir__simdfX_store(d + 4 * stbir__simdfX_float_count, x1);
+            stbir__simdfX_store(d + 8 * stbir__simdfX_float_count, x2);
+            stbir__simdfX_store(d + 12 * stbir__simdfX_float_count, x3);
+            d += (16 * stbir__simdfX_float_count);
+        }
+    }
+}
+
+// memcpy that is specically intentionally overlapping (src is smaller then dest, so can be
+//   a normal forward copy, bytes is divisible by 4 and bytes is greater than or equal to
+//   the diff between dest and src)
+static void stbir_overlapping_memcpy(void *dest, void const *src, size_t bytes) {
+    char STBIR_SIMD_STREAMOUT_PTR(*) sd    = (char *)src;
+    char STBIR_SIMD_STREAMOUT_PTR(*) s_end = ((char *)src) + bytes;
+    ptrdiff_t ofs_to_dest                  = (char *)dest - (char *)src;
+
+    if (ofs_to_dest >= 16)  // is the overlap more than 16 away?
+    {
+        char STBIR_SIMD_STREAMOUT_PTR(*) s_end16 = ((char *)src) + (bytes & ~15);
+        STBIR_SIMD_NO_UNROLL_LOOP_START
+        do {
+            stbir__simdf x;
+            STBIR_SIMD_NO_UNROLL(sd);
+            stbir__simdf_load(x, sd);
+            stbir__simdf_store((sd + ofs_to_dest), x);
+            sd += 16;
+        } while (sd < s_end16);
+
+        if (sd == s_end)
+            return;
+    }
+
+    do {
+        STBIR_SIMD_NO_UNROLL(sd);
+        *(int *)(sd + ofs_to_dest) = *(int *)sd;
+        sd += 4;
+    } while (sd < s_end);
+}
+
+#else  // no SSE2
+
+// when in scalar mode, we let unrolling happen, so this macro just does the __restrict
+#define STBIR_SIMD_STREAMOUT_PTR(star) STBIR_STREAMOUT_PTR(star)
+#define STBIR_SIMD_NO_UNROLL(ptr)
+#define STBIR_SIMD_NO_UNROLL_LOOP_START
+#define STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+
+#endif  // SSE2
+
+#ifdef STBIR_PROFILE
+
+#ifndef STBIR_PROFILE_FUNC
+
+#if defined(_x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__x86_64) ||             \
+    defined(__SSE2__) || defined(STBIR_SSE) || defined(_M_IX86_FP) || defined(__i386) ||           \
+    defined(__i386__) || defined(_M_IX86) || defined(_X86_)
+
+#ifdef _MSC_VER
+
+STBIRDEF stbir_uint64 __rdtsc();
+#define STBIR_PROFILE_FUNC() __rdtsc()
+
+#else  // non msvc
+
+static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC() {
+    stbir_uint32 lo, hi;
+    asm volatile("rdtsc" : "=a"(lo), "=d"(hi));
+    return (((stbir_uint64)hi) << 32) | ((stbir_uint64)lo);
+}
+
+#endif  // msvc
+
+#elif defined(_M_ARM64) || defined(__aarch64__) || defined(__arm64__) || defined(__ARM_NEON__)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#define STBIR_PROFILE_FUNC() _ReadStatusReg(ARM64_CNTVCT)
+
+#else
+
+static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC() {
+    stbir_uint64 tsc;
+    asm volatile("mrs %0, cntvct_el0" : "=r"(tsc));
+    return tsc;
+}
+
+#endif
+
+#else  // x64, arm
+
+#error Unknown platform for profiling.
+
+#endif  // x64, arm
+
+#endif  // STBIR_PROFILE_FUNC
+
+#define STBIR_ONLY_PROFILE_GET_SPLIT_INFO , stbir__per_split_info *split_info
+#define STBIR_ONLY_PROFILE_SET_SPLIT_INFO , split_info
+
+#define STBIR_ONLY_PROFILE_BUILD_GET_INFO , stbir__info *profile_info
+#define STBIR_ONLY_PROFILE_BUILD_SET_INFO , profile_info
+
+// super light-weight micro profiler
+#define STBIR_PROFILE_START_ll(info, wh)                                                           \
+    {                                                                                              \
+        stbir_uint64 wh##thiszonetime              = STBIR_PROFILE_FUNC();                         \
+        stbir_uint64 *wh##save_parent_excluded_ptr = info->current_zone_excluded_ptr;              \
+        stbir_uint64 wh##current_zone_excluded     = 0;                                            \
+        info->current_zone_excluded_ptr            = &wh##current_zone_excluded;
+#define STBIR_PROFILE_END_ll(info, wh)                                                             \
+    wh##thiszonetime = STBIR_PROFILE_FUNC() - wh##thiszonetime;                                    \
+    info->profile.named.wh += wh##thiszonetime - wh##current_zone_excluded;                        \
+    *wh##save_parent_excluded_ptr += wh##thiszonetime;                                             \
+    info->current_zone_excluded_ptr = wh##save_parent_excluded_ptr;                                \
+    }
+#define STBIR_PROFILE_FIRST_START_ll(info, wh)                                                     \
+    {                                                                                              \
+        int i;                                                                                     \
+        info->current_zone_excluded_ptr = &info->profile.named.total;                              \
+        for (i = 0; i < STBIR__ARRAY_SIZE(info->profile.array); i++)                               \
+            info->profile.array[i] = 0;                                                            \
+    }                                                                                              \
+    STBIR_PROFILE_START_ll(info, wh);
+#define STBIR_PROFILE_CLEAR_EXTRAS_ll(info, num)                                                   \
+    {                                                                                              \
+        int extra;                                                                                 \
+        for (extra = 1; extra < (num); extra++) {                                                  \
+            int i;                                                                                 \
+            for (i = 0; i < STBIR__ARRAY_SIZE((info)->profile.array); i++)                         \
+                (info)[extra].profile.array[i] = 0;                                                \
+        }                                                                                          \
+    }
+
+// for thread data
+#define STBIR_PROFILE_START(wh)       STBIR_PROFILE_START_ll(split_info, wh)
+#define STBIR_PROFILE_END(wh)         STBIR_PROFILE_END_ll(split_info, wh)
+#define STBIR_PROFILE_FIRST_START(wh) STBIR_PROFILE_FIRST_START_ll(split_info, wh)
+#define STBIR_PROFILE_CLEAR_EXTRAS()  STBIR_PROFILE_CLEAR_EXTRAS_ll(split_info, split_count)
+
+// for build data
+#define STBIR_PROFILE_BUILD_START(wh)       STBIR_PROFILE_START_ll(profile_info, wh)
+#define STBIR_PROFILE_BUILD_END(wh)         STBIR_PROFILE_END_ll(profile_info, wh)
+#define STBIR_PROFILE_BUILD_FIRST_START(wh) STBIR_PROFILE_FIRST_START_ll(profile_info, wh)
+#define STBIR_PROFILE_BUILD_CLEAR(info)                                                            \
+    {                                                                                              \
+        int i;                                                                                     \
+        for (i = 0; i < STBIR__ARRAY_SIZE(info->profile.array); i++)                               \
+            info->profile.array[i] = 0;                                                            \
+    }
+
+#else  // no profile
+
+#define STBIR_ONLY_PROFILE_GET_SPLIT_INFO
+#define STBIR_ONLY_PROFILE_SET_SPLIT_INFO
+
+#define STBIR_ONLY_PROFILE_BUILD_GET_INFO
+#define STBIR_ONLY_PROFILE_BUILD_SET_INFO
+
+#define STBIR_PROFILE_START(wh)
+#define STBIR_PROFILE_END(wh)
+#define STBIR_PROFILE_FIRST_START(wh)
+#define STBIR_PROFILE_CLEAR_EXTRAS()
+
+#define STBIR_PROFILE_BUILD_START(wh)
+#define STBIR_PROFILE_BUILD_END(wh)
+#define STBIR_PROFILE_BUILD_FIRST_START(wh)
+#define STBIR_PROFILE_BUILD_CLEAR(info)
+
+#endif  // stbir_profile
+
+#ifndef STBIR_CEILF
+#include <math.h>
+#if _MSC_VER <= 1200  // support VC6 for Sean
+#define STBIR_CEILF(x)  ((float)ceil((float)(x)))
+#define STBIR_FLOORF(x) ((float)floor((float)(x)))
+#else
+#define STBIR_CEILF(x)  ceilf(x)
+#define STBIR_FLOORF(x) floorf(x)
+#endif
+#endif
+
+#ifndef STBIR_MEMCPY
+// For memcpy
+#include <string.h>
+#define STBIR_MEMCPY(dest, src, len) memcpy(dest, src, len)
+#endif
+
+#ifndef STBIR_SIMD
+
+// memcpy that is specifically intentionally overlapping (src is smaller then dest, so can be
+//   a normal forward copy, bytes is divisible by 4 and bytes is greater than or equal to
+//   the diff between dest and src)
+static void stbir_overlapping_memcpy(void *dest, void const *src, size_t bytes) {
+    char STBIR_SIMD_STREAMOUT_PTR(*) sd    = (char *)src;
+    char STBIR_SIMD_STREAMOUT_PTR(*) s_end = ((char *)src) + bytes;
+    ptrdiff_t ofs_to_dest                  = (char *)dest - (char *)src;
+
+    if (ofs_to_dest >= 8)  // is the overlap more than 8 away?
+    {
+        char STBIR_SIMD_STREAMOUT_PTR(*) s_end8 = ((char *)src) + (bytes & ~7);
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+            STBIR_NO_UNROLL(sd);
+            *(stbir_uint64 *)(sd + ofs_to_dest) = *(stbir_uint64 *)sd;
+            sd += 8;
+        } while (sd < s_end8);
+
+        if (sd == s_end)
+            return;
+    }
+
+    STBIR_NO_UNROLL_LOOP_START
+    do {
+        STBIR_NO_UNROLL(sd);
+        *(int *)(sd + ofs_to_dest) = *(int *)sd;
+        sd += 4;
+    } while (sd < s_end);
+}
+
+#endif
+
+static float stbir__filter_trapezoid(float x, float scale, void *user_data) {
+    float halfscale = scale / 2;
+    float t         = 0.5f + halfscale;
+    STBIR_ASSERT(scale <= 1);
+    STBIR__UNUSED(user_data);
+
+    if (x < 0.0f)
+        x = -x;
+
+    if (x >= t)
+        return 0.0f;
+    else {
+        float r = 0.5f - halfscale;
+        if (x <= r)
+            return 1.0f;
+        else
+            return (t - x) / scale;
+    }
+}
+
+static float stbir__support_trapezoid(float scale, void *user_data) {
+    STBIR__UNUSED(user_data);
+    return 0.5f + scale / 2.0f;
+}
+
+static float stbir__filter_triangle(float x, float s, void *user_data) {
+    STBIR__UNUSED(s);
+    STBIR__UNUSED(user_data);
+
+    if (x < 0.0f)
+        x = -x;
+
+    if (x <= 1.0f)
+        return 1.0f - x;
+    else
+        return 0.0f;
+}
+
+static float stbir__filter_point(float x, float s, void *user_data) {
+    STBIR__UNUSED(x);
+    STBIR__UNUSED(s);
+    STBIR__UNUSED(user_data);
+
+    return 1.0f;
+}
+
+static float stbir__filter_cubic(float x, float s, void *user_data) {
+    STBIR__UNUSED(s);
+    STBIR__UNUSED(user_data);
+
+    if (x < 0.0f)
+        x = -x;
+
+    if (x < 1.0f)
+        return (4.0f + x * x * (3.0f * x - 6.0f)) / 6.0f;
+    else if (x < 2.0f)
+        return (8.0f + x * (-12.0f + x * (6.0f - x))) / 6.0f;
+
+    return (0.0f);
+}
+
+static float stbir__filter_catmullrom(float x, float s, void *user_data) {
+    STBIR__UNUSED(s);
+    STBIR__UNUSED(user_data);
+
+    if (x < 0.0f)
+        x = -x;
+
+    if (x < 1.0f)
+        return 1.0f - x * x * (2.5f - 1.5f * x);
+    else if (x < 2.0f)
+        return 2.0f - x * (4.0f + x * (0.5f * x - 2.5f));
+
+    return (0.0f);
+}
+
+static float stbir__filter_mitchell(float x, float s, void *user_data) {
+    STBIR__UNUSED(s);
+    STBIR__UNUSED(user_data);
+
+    if (x < 0.0f)
+        x = -x;
+
+    if (x < 1.0f)
+        return (16.0f + x * x * (21.0f * x - 36.0f)) / 18.0f;
+    else if (x < 2.0f)
+        return (32.0f + x * (-60.0f + x * (36.0f - 7.0f * x))) / 18.0f;
+
+    return (0.0f);
+}
+
+static float stbir__support_zeropoint5(float s, void *user_data) {
+    STBIR__UNUSED(s);
+    STBIR__UNUSED(user_data);
+    return 0.5f;
+}
+
+static float stbir__support_one(float s, void *user_data) {
+    STBIR__UNUSED(s);
+    STBIR__UNUSED(user_data);
+    return 1;
+}
+
+static float stbir__support_two(float s, void *user_data) {
+    STBIR__UNUSED(s);
+    STBIR__UNUSED(user_data);
+    return 2;
+}
+
+// This is the maximum number of input samples that can affect an output sample
+// with the given filter from the output pixel's perspective
+static int stbir__get_filter_pixel_width(stbir__support_callback *support, float scale,
+                                         void *user_data) {
+    STBIR_ASSERT(support != 0);
+
+    if (scale >= (1.0f - stbir__small_float))  // upscale
+        return (int)STBIR_CEILF(support(1.0f / scale, user_data) * 2.0f);
+    else
+        return (int)STBIR_CEILF(support(scale, user_data) * 2.0f / scale);
+}
+
+// this is how many coefficents per run of the filter (which is different
+//   from the filter_pixel_width depending on if we are scattering or gathering)
+static int stbir__get_coefficient_width(stbir__sampler *samp, int is_gather, void *user_data) {
+    float scale                      = samp->scale_info.scale;
+    stbir__support_callback *support = samp->filter_support;
+
+    switch (is_gather) {
+    case 1:
+        return (int)STBIR_CEILF(support(1.0f / scale, user_data) * 2.0f);
+    case 2:
+        return (int)STBIR_CEILF(support(scale, user_data) * 2.0f / scale);
+    case 0:
+        return (int)STBIR_CEILF(support(scale, user_data) * 2.0f);
+    default:
+        STBIR_ASSERT((is_gather >= 0) && (is_gather <= 2));
+        return 0;
+    }
+}
+
+static int stbir__get_contributors(stbir__sampler *samp, int is_gather) {
+    if (is_gather)
+        return samp->scale_info.output_sub_size;
+    else
+        return (samp->scale_info.input_full_size + samp->filter_pixel_margin * 2);
+}
+
+static int stbir__edge_zero_full(int n, int max) {
+    STBIR__UNUSED(n);
+    STBIR__UNUSED(max);
+    return 0;  // NOTREACHED
+}
+
+static int stbir__edge_clamp_full(int n, int max) {
+    if (n < 0)
+        return 0;
+
+    if (n >= max)
+        return max - 1;
+
+    return n;  // NOTREACHED
+}
+
+static int stbir__edge_reflect_full(int n, int max) {
+    if (n < 0) {
+        if (n > -max)
+            return -n;
+        else
+            return max - 1;
+    }
+
+    if (n >= max) {
+        int max2 = max * 2;
+        if (n >= max2)
+            return 0;
+        else
+            return max2 - n - 1;
+    }
+
+    return n;  // NOTREACHED
+}
+
+static int stbir__edge_wrap_full(int n, int max) {
+    if (n >= 0)
+        return (n % max);
+    else {
+        int m = (-n) % max;
+
+        if (m != 0)
+            m = max - m;
+
+        return (m);
+    }
+}
+
+typedef int stbir__edge_wrap_func(int n, int max);
+static stbir__edge_wrap_func *stbir__edge_wrap_slow[] = {
+    stbir__edge_clamp_full,    // STBIR_EDGE_CLAMP
+    stbir__edge_reflect_full,  // STBIR_EDGE_REFLECT
+    stbir__edge_wrap_full,     // STBIR_EDGE_WRAP
+    stbir__edge_zero_full,     // STBIR_EDGE_ZERO
+};
+
+stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max) {
+    // avoid per-pixel switch
+    if (n >= 0 && n < max)
+        return n;
+    return stbir__edge_wrap_slow[edge](n, max);
+}
+
+#define STBIR__MERGE_RUNS_PIXEL_THRESHOLD 16
+
+// get information on the extents of a sampler
+static void stbir__get_extents(stbir__sampler *samp, stbir__extents *scanline_extents) {
+    int j, stop;
+    int left_margin, right_margin;
+    int min_n = 0x7fffffff, max_n = -0x7fffffff;
+    int min_left = 0x7fffffff, max_left = -0x7fffffff;
+    int min_right = 0x7fffffff, max_right = -0x7fffffff;
+    stbir_edge edge                   = samp->edge;
+    stbir__contributors *contributors = samp->contributors;
+    int output_sub_size               = samp->scale_info.output_sub_size;
+    int input_full_size               = samp->scale_info.input_full_size;
+    int filter_pixel_margin           = samp->filter_pixel_margin;
+
+    STBIR_ASSERT(samp->is_gather);
+
+    stop = output_sub_size;
+    for (j = 0; j < stop; j++) {
+        STBIR_ASSERT(contributors[j].n1 >= contributors[j].n0);
+        if (contributors[j].n0 < min_n) {
+            min_n = contributors[j].n0;
+            stop = j + filter_pixel_margin;  // if we find a new min, only scan another filter width
+            if (stop > output_sub_size)
+                stop = output_sub_size;
+        }
+    }
+
+    stop = 0;
+    for (j = output_sub_size - 1; j >= stop; j--) {
+        STBIR_ASSERT(contributors[j].n1 >= contributors[j].n0);
+        if (contributors[j].n1 > max_n) {
+            max_n = contributors[j].n1;
+            stop = j - filter_pixel_margin;  // if we find a new max, only scan another filter width
+            if (stop < 0)
+                stop = 0;
+        }
+    }
+
+    STBIR_ASSERT(scanline_extents->conservative.n0 <= min_n);
+    STBIR_ASSERT(scanline_extents->conservative.n1 >= max_n);
+
+    // now calculate how much into the margins we really read
+    left_margin = 0;
+    if (min_n < 0) {
+        left_margin = -min_n;
+        min_n       = 0;
+    }
+
+    right_margin = 0;
+    if (max_n >= input_full_size) {
+        right_margin = max_n - input_full_size + 1;
+        max_n        = input_full_size - 1;
+    }
+
+    // index 1 is margin pixel extents (how many pixels we hang over the edge)
+    scanline_extents->edge_sizes[0] = left_margin;
+    scanline_extents->edge_sizes[1] = right_margin;
+
+    // index 2 is pixels read from the input
+    scanline_extents->spans[0].n0                     = min_n;
+    scanline_extents->spans[0].n1                     = max_n;
+    scanline_extents->spans[0].pixel_offset_for_input = min_n;
+
+    // default to no other input range
+    scanline_extents->spans[1].n0                     = 0;
+    scanline_extents->spans[1].n1                     = -1;
+    scanline_extents->spans[1].pixel_offset_for_input = 0;
+
+    // don't have to do edge calc for zero clamp
+    if (edge == STBIR_EDGE_ZERO)
+        return;
+
+    // convert margin pixels to the pixels within the input (min and max)
+    for (j = -left_margin; j < 0; j++) {
+        int p = stbir__edge_wrap(edge, j, input_full_size);
+        if (p < min_left)
+            min_left = p;
+        if (p > max_left)
+            max_left = p;
+    }
+
+    for (j = input_full_size; j < (input_full_size + right_margin); j++) {
+        int p = stbir__edge_wrap(edge, j, input_full_size);
+        if (p < min_right)
+            min_right = p;
+        if (p > max_right)
+            max_right = p;
+    }
+
+    // merge the left margin pixel region if it connects within 4 pixels of main pixel region
+    if (min_left != 0x7fffffff) {
+        if (((min_left <= min_n) && ((max_left + STBIR__MERGE_RUNS_PIXEL_THRESHOLD) >= min_n)) ||
+            ((min_n <= min_left) && ((max_n + STBIR__MERGE_RUNS_PIXEL_THRESHOLD) >= max_left))) {
+            scanline_extents->spans[0].n0 = min_n = stbir__min(min_n, min_left);
+            scanline_extents->spans[0].n1 = max_n             = stbir__max(max_n, max_left);
+            scanline_extents->spans[0].pixel_offset_for_input = min_n;
+            left_margin                                       = 0;
+        }
+    }
+
+    // merge the right margin pixel region if it connects within 4 pixels of main pixel region
+    if (min_right != 0x7fffffff) {
+        if (((min_right <= min_n) && ((max_right + STBIR__MERGE_RUNS_PIXEL_THRESHOLD) >= min_n)) ||
+            ((min_n <= min_right) && ((max_n + STBIR__MERGE_RUNS_PIXEL_THRESHOLD) >= max_right))) {
+            scanline_extents->spans[0].n0 = min_n = stbir__min(min_n, min_right);
+            scanline_extents->spans[0].n1 = max_n             = stbir__max(max_n, max_right);
+            scanline_extents->spans[0].pixel_offset_for_input = min_n;
+            right_margin                                      = 0;
+        }
+    }
+
+    STBIR_ASSERT(scanline_extents->conservative.n0 <= min_n);
+    STBIR_ASSERT(scanline_extents->conservative.n1 >= max_n);
+
+    // you get two ranges when you have the WRAP edge mode and you are doing just the a piece of the
+    // resize
+    //   so you need to get a second run of pixels from the opposite side of the scanline (which you
+    //   wouldn't need except for WRAP)
+
+    // if we can't merge the min_left range, add it as a second range
+    if ((left_margin) && (min_left != 0x7fffffff)) {
+        stbir__span *newspan = scanline_extents->spans + 1;
+        STBIR_ASSERT(right_margin == 0);
+        if (min_left < scanline_extents->spans[0].n0) {
+            scanline_extents->spans[1].pixel_offset_for_input = scanline_extents->spans[0].n0;
+            scanline_extents->spans[1].n0                     = scanline_extents->spans[0].n0;
+            scanline_extents->spans[1].n1                     = scanline_extents->spans[0].n1;
+            --newspan;
+        }
+        newspan->pixel_offset_for_input = min_left;
+        newspan->n0                     = -left_margin;
+        newspan->n1                     = (max_left - min_left) - left_margin;
+        scanline_extents->edge_sizes[0] = 0;  // don't need to copy the left margin, since we are
+                                              // directly decoding into the margin
+        return;
+    }
+
+    // if we can't merge the min_left range, add it as a second range
+    if ((right_margin) && (min_right != 0x7fffffff)) {
+        stbir__span *newspan = scanline_extents->spans + 1;
+        if (min_right < scanline_extents->spans[0].n0) {
+            scanline_extents->spans[1].pixel_offset_for_input = scanline_extents->spans[0].n0;
+            scanline_extents->spans[1].n0                     = scanline_extents->spans[0].n0;
+            scanline_extents->spans[1].n1                     = scanline_extents->spans[0].n1;
+            --newspan;
+        }
+        newspan->pixel_offset_for_input = min_right;
+        newspan->n0                     = scanline_extents->spans[1].n1 + 1;
+        newspan->n1 = scanline_extents->spans[1].n1 + 1 + (max_right - min_right);
+        scanline_extents->edge_sizes[1] = 0;  // don't need to copy the right margin, since we are
+                                              // directly decoding into the margin
+        return;
+    }
+}
+
+static void stbir__calculate_in_pixel_range(int *first_pixel, int *last_pixel,
+                                            float out_pixel_center, float out_filter_radius,
+                                            float inv_scale, float out_shift, int input_size,
+                                            stbir_edge edge) {
+    int first, last;
+    float out_pixel_influence_lowerbound = out_pixel_center - out_filter_radius;
+    float out_pixel_influence_upperbound = out_pixel_center + out_filter_radius;
+
+    float in_pixel_influence_lowerbound = (out_pixel_influence_lowerbound + out_shift) * inv_scale;
+    float in_pixel_influence_upperbound = (out_pixel_influence_upperbound + out_shift) * inv_scale;
+
+    first = (int)(STBIR_FLOORF(in_pixel_influence_lowerbound + 0.5f));
+    last  = (int)(STBIR_FLOORF(in_pixel_influence_upperbound - 0.5f));
+    if (last < first)
+        last =
+            first;  // point sample mode can span a value *right* at 0.5, and cause these to cross
+
+    if (edge == STBIR_EDGE_WRAP) {
+        if (first < -input_size)
+            first = -input_size;
+        if (last >= (input_size * 2))
+            last = (input_size * 2) - 1;
+    }
+
+    *first_pixel = first;
+    *last_pixel  = last;
+}
+
+static void stbir__calculate_coefficients_for_gather_upsample(
+    float out_filter_radius, stbir__kernel_callback *kernel, stbir__scale_info *scale_info,
+    int num_contributors, stbir__contributors *contributors, float *coefficient_group,
+    int coefficient_width, stbir_edge edge, void *user_data) {
+    int n, end;
+    float inv_scale = scale_info->inv_scale;
+    float out_shift = scale_info->pixel_shift;
+    int input_size  = scale_info->input_full_size;
+    int numerator   = scale_info->scale_numerator;
+    int polyphase   = ((scale_info->scale_is_rational) && (numerator < num_contributors));
+
+    // Looping through out pixels
+    end = num_contributors;
+    if (polyphase)
+        end = numerator;
+    for (n = 0; n < end; n++) {
+        int i;
+        int last_non_zero;
+        float out_pixel_center = (float)n + 0.5f;
+        float in_center_of_out = (out_pixel_center + out_shift) * inv_scale;
+
+        int in_first_pixel, in_last_pixel;
+
+        stbir__calculate_in_pixel_range(&in_first_pixel, &in_last_pixel, out_pixel_center,
+                                        out_filter_radius, inv_scale, out_shift, input_size, edge);
+
+        // make sure we never generate a range larger than our precalculated coeff width
+        //   this only happens in point sample mode, but it's a good safe thing to do anyway
+        if ((in_last_pixel - in_first_pixel + 1) > coefficient_width)
+            in_last_pixel = in_first_pixel + coefficient_width - 1;
+
+        last_non_zero = -1;
+        for (i = 0; i <= in_last_pixel - in_first_pixel; i++) {
+            float in_pixel_center = (float)(i + in_first_pixel) + 0.5f;
+            float coeff = kernel(in_center_of_out - in_pixel_center, inv_scale, user_data);
+
+            // kill denormals
+            if (((coeff < stbir__small_float) && (coeff > -stbir__small_float))) {
+                if (i == 0)  // if we're at the front, just eat zero contributors
+                {
+                    STBIR_ASSERT((in_last_pixel - in_first_pixel) !=
+                                 0);  // there should be at least one contrib
+                    ++in_first_pixel;
+                    i--;
+                    continue;
+                }
+                coeff = 0;  // make sure is fully zero (should keep denormals away)
+            } else
+                last_non_zero = i;
+
+            coefficient_group[i] = coeff;
+        }
+
+        in_last_pixel    = last_non_zero + in_first_pixel;  // kills trailing zeros
+        contributors->n0 = in_first_pixel;
+        contributors->n1 = in_last_pixel;
+
+        STBIR_ASSERT(contributors->n1 >= contributors->n0);
+
+        ++contributors;
+        coefficient_group += coefficient_width;
+    }
+}
+
+static void stbir__insert_coeff(stbir__contributors *contribs, float *coeffs, int new_pixel,
+                                float new_coeff, int max_width) {
+    if (new_pixel <= contribs->n1)  // before the end
+    {
+        if (new_pixel < contribs->n0)  // before the front?
+        {
+            if ((contribs->n1 - new_pixel + 1) <= max_width) {
+                int j, o = contribs->n0 - new_pixel;
+                for (j = contribs->n1 - contribs->n0; j <= 0; j--)
+                    coeffs[j + o] = coeffs[j];
+                for (j = 1; j < o; j--)
+                    coeffs[j] = coeffs[0];
+                coeffs[0]    = new_coeff;
+                contribs->n0 = new_pixel;
+            }
+        } else {
+            coeffs[new_pixel - contribs->n0] += new_coeff;
+        }
+    } else {
+        if ((new_pixel - contribs->n0 + 1) <= max_width) {
+            int j, e = new_pixel - contribs->n0;
+            for (j = (contribs->n1 - contribs->n0) + 1; j < e;
+                 j++)  // clear in-betweens coeffs if there are any
+                coeffs[j] = 0;
+
+            coeffs[e]    = new_coeff;
+            contribs->n1 = new_pixel;
+        }
+    }
+}
+
+static void stbir__calculate_out_pixel_range(int *first_pixel, int *last_pixel,
+                                             float in_pixel_center, float in_pixels_radius,
+                                             float scale, float out_shift, int out_size) {
+    float in_pixel_influence_lowerbound  = in_pixel_center - in_pixels_radius;
+    float in_pixel_influence_upperbound  = in_pixel_center + in_pixels_radius;
+    float out_pixel_influence_lowerbound = in_pixel_influence_lowerbound * scale - out_shift;
+    float out_pixel_influence_upperbound = in_pixel_influence_upperbound * scale - out_shift;
+    int out_first_pixel = (int)(STBIR_FLOORF(out_pixel_influence_lowerbound + 0.5f));
+    int out_last_pixel  = (int)(STBIR_FLOORF(out_pixel_influence_upperbound - 0.5f));
+
+    if (out_first_pixel < 0)
+        out_first_pixel = 0;
+    if (out_last_pixel >= out_size)
+        out_last_pixel = out_size - 1;
+    *first_pixel = out_first_pixel;
+    *last_pixel  = out_last_pixel;
+}
+
+static void stbir__calculate_coefficients_for_gather_downsample(
+    int start, int end, float in_pixels_radius, stbir__kernel_callback *kernel,
+    stbir__scale_info *scale_info, int coefficient_width, int num_contributors,
+    stbir__contributors *contributors, float *coefficient_group, void *user_data) {
+    int in_pixel;
+    int i;
+    int first_out_inited = -1;
+    float scale          = scale_info->scale;
+    float out_shift      = scale_info->pixel_shift;
+    int out_size         = scale_info->output_sub_size;
+    int numerator        = scale_info->scale_numerator;
+    int polyphase        = ((scale_info->scale_is_rational) && (numerator < out_size));
+
+    STBIR__UNUSED(num_contributors);
+
+    // Loop through the input pixels
+    for (in_pixel = start; in_pixel < end; in_pixel++) {
+        float in_pixel_center  = (float)in_pixel + 0.5f;
+        float out_center_of_in = in_pixel_center * scale - out_shift;
+        int out_first_pixel, out_last_pixel;
+
+        stbir__calculate_out_pixel_range(&out_first_pixel, &out_last_pixel, in_pixel_center,
+                                         in_pixels_radius, scale, out_shift, out_size);
+
+        if (out_first_pixel > out_last_pixel)
+            continue;
+
+        // clamp or exit if we are using polyphase filtering, and the limit is up
+        if (polyphase) {
+            // when polyphase, you only have to do coeffs up to the numerator count
+            if (out_first_pixel == numerator)
+                break;
+
+            // don't do any extra work, clamp last pixel at numerator too
+            if (out_last_pixel >= numerator)
+                out_last_pixel = numerator - 1;
+        }
+
+        for (i = 0; i <= out_last_pixel - out_first_pixel; i++) {
+            float out_pixel_center = (float)(i + out_first_pixel) + 0.5f;
+            float x                = out_pixel_center - out_center_of_in;
+            float coeff            = kernel(x, scale, user_data) * scale;
+
+            // kill the coeff if it's too small (avoid denormals)
+            if (((coeff < stbir__small_float) && (coeff > -stbir__small_float)))
+                coeff = 0.0f;
+
+            {
+                int out                       = i + out_first_pixel;
+                float *coeffs                 = coefficient_group + out * coefficient_width;
+                stbir__contributors *contribs = contributors + out;
+
+                // is this the first time this output pixel has been seen?  Init it.
+                if (out > first_out_inited) {
+                    STBIR_ASSERT(
+                        out == (first_out_inited + 1));  // ensure we have only advanced one at time
+                    first_out_inited = out;
+                    contribs->n0     = in_pixel;
+                    contribs->n1     = in_pixel;
+                    coeffs[0]        = coeff;
+                } else {
+                    // insert on end (always in order)
+                    if (coeffs[0] ==
+                        0.0f)  // if the first coefficent is zero, then zap it for this coeffs
+                    {
+                        STBIR_ASSERT((in_pixel - contribs->n0) ==
+                                     1);  // ensure that when we zap, we're at the 2nd pos
+                        contribs->n0 = in_pixel;
+                    }
+                    contribs->n1 = in_pixel;
+                    STBIR_ASSERT((in_pixel - contribs->n0) < coefficient_width);
+                    coeffs[in_pixel - contribs->n0] = coeff;
+                }
+            }
+        }
+    }
+}
+
+#ifdef STBIR_RENORMALIZE_IN_FLOAT
+#define STBIR_RENORM_TYPE float
+#else
+#define STBIR_RENORM_TYPE double
+#endif
+
+static void stbir__cleanup_gathered_coefficients(stbir_edge edge,
+                                                 stbir__filter_extent_info *filter_info,
+                                                 stbir__scale_info *scale_info,
+                                                 int num_contributors,
+                                                 stbir__contributors *contributors,
+                                                 float *coefficient_group, int coefficient_width) {
+    int input_size    = scale_info->input_full_size;
+    int input_last_n1 = input_size - 1;
+    int n, end;
+    int lowest      = 0x7fffffff;
+    int highest     = -0x7fffffff;
+    int widest      = -1;
+    int numerator   = scale_info->scale_numerator;
+    int denominator = scale_info->scale_denominator;
+    int polyphase   = ((scale_info->scale_is_rational) && (numerator < num_contributors));
+    float *coeffs;
+    stbir__contributors *contribs;
+
+    // weight all the coeffs for each sample
+    coeffs   = coefficient_group;
+    contribs = contributors;
+    end      = num_contributors;
+    if (polyphase)
+        end = numerator;
+    for (n = 0; n < end; n++) {
+        int i;
+        STBIR_RENORM_TYPE filter_scale, total_filter = 0;
+        int e;
+
+        // add all contribs
+        e = contribs->n1 - contribs->n0;
+        for (i = 0; i <= e; i++) {
+            total_filter += (STBIR_RENORM_TYPE)coeffs[i];
+            STBIR_ASSERT((coeffs[i] >= -2.0f) && (coeffs[i] <= 2.0f));  // check for wonky weights
+        }
+
+        // rescale
+        if ((total_filter < stbir__small_float) && (total_filter > -stbir__small_float)) {
+            // all coeffs are extremely small, just zero it
+            contribs->n1 = contribs->n0;
+            coeffs[0]    = 0.0f;
+        } else {
+            // if the total isn't 1.0, rescale everything
+            if ((total_filter < (1.0f - stbir__small_float)) ||
+                (total_filter > (1.0f + stbir__small_float))) {
+                filter_scale = ((STBIR_RENORM_TYPE)1.0) / total_filter;
+
+                // scale them all
+                for (i = 0; i <= e; i++)
+                    coeffs[i] = (float)(coeffs[i] * filter_scale);
+            }
+        }
+        ++contribs;
+        coeffs += coefficient_width;
+    }
+
+    // if we have a rational for the scale, we can exploit the polyphaseness to not calculate
+    //   most of the coefficients, so we copy them here
+    if (polyphase) {
+        stbir__contributors *prev_contribs = contributors;
+        stbir__contributors *cur_contribs  = contributors + numerator;
+
+        for (n = numerator; n < num_contributors; n++) {
+            cur_contribs->n0 = prev_contribs->n0 + denominator;
+            cur_contribs->n1 = prev_contribs->n1 + denominator;
+            ++cur_contribs;
+            ++prev_contribs;
+        }
+        stbir_overlapping_memcpy(
+            coefficient_group + numerator * coefficient_width, coefficient_group,
+            (num_contributors - numerator) * coefficient_width * sizeof(coeffs[0]));
+    }
+
+    coeffs   = coefficient_group;
+    contribs = contributors;
+
+    for (n = 0; n < num_contributors; n++) {
+        int i;
+
+        // in zero edge mode, just remove out of bounds contribs completely (since their weights are
+        // accounted for now)
+        if (edge == STBIR_EDGE_ZERO) {
+            // shrink the right side if necessary
+            if (contribs->n1 > input_last_n1)
+                contribs->n1 = input_last_n1;
+
+            // shrink the left side
+            if (contribs->n0 < 0) {
+                int j, left, skips = 0;
+
+                skips        = -contribs->n0;
+                contribs->n0 = 0;
+
+                // now move down the weights
+                left = contribs->n1 - contribs->n0 + 1;
+                if (left > 0) {
+                    for (j = 0; j < left; j++)
+                        coeffs[j] = coeffs[j + skips];
+                }
+            }
+        } else if ((edge == STBIR_EDGE_CLAMP) || (edge == STBIR_EDGE_REFLECT)) {
+            // for clamp and reflect, calculate the true inbounds position (based on edge type) and
+            // just add that to the existing weight
+
+            // right hand side first
+            if (contribs->n1 > input_last_n1) {
+                int start    = contribs->n0;
+                int endi     = contribs->n1;
+                contribs->n1 = input_last_n1;
+                for (i = input_size; i <= endi; i++)
+                    stbir__insert_coeff(contribs, coeffs,
+                                        stbir__edge_wrap_slow[edge](i, input_size),
+                                        coeffs[i - start], coefficient_width);
+            }
+
+            // now check left hand edge
+            if (contribs->n0 < 0) {
+                int save_n0;
+                float save_n0_coeff;
+                float *c = coeffs - (contribs->n0 + 1);
+
+                // reinsert the coeffs with it reflected or clamped (insert accumulates, if the
+                // coeffs exist)
+                for (i = -1; i > contribs->n0; i--)
+                    stbir__insert_coeff(contribs, coeffs,
+                                        stbir__edge_wrap_slow[edge](i, input_size), *c--,
+                                        coefficient_width);
+                save_n0       = contribs->n0;
+                save_n0_coeff = c[0];  // save it, since we didn't do the final one (i==n0), because
+                                       // there might be too many coeffs to hold (before we resize)!
+
+                // now slide all the coeffs down (since we have accumulated them in the positive
+                // contribs) and reset the first contrib
+                contribs->n0 = 0;
+                for (i = 0; i <= contribs->n1; i++)
+                    coeffs[i] = coeffs[i - save_n0];
+
+                // now that we have shrunk down the contribs, we insert the first one safely
+                stbir__insert_coeff(contribs, coeffs,
+                                    stbir__edge_wrap_slow[edge](save_n0, input_size), save_n0_coeff,
+                                    coefficient_width);
+            }
+        }
+
+        if (contribs->n0 <= contribs->n1) {
+            int diff = contribs->n1 - contribs->n0 + 1;
+            while (diff && (coeffs[diff - 1] == 0.0f))
+                --diff;
+
+            contribs->n1 = contribs->n0 + diff - 1;
+
+            if (contribs->n0 <= contribs->n1) {
+                if (contribs->n0 < lowest)
+                    lowest = contribs->n0;
+                if (contribs->n1 > highest)
+                    highest = contribs->n1;
+                if (diff > widest)
+                    widest = diff;
+            }
+
+            // re-zero out unused coefficients (if any)
+            for (i = diff; i < coefficient_width; i++)
+                coeffs[i] = 0.0f;
+        }
+
+        ++contribs;
+        coeffs += coefficient_width;
+    }
+    filter_info->lowest  = lowest;
+    filter_info->highest = highest;
+    filter_info->widest  = widest;
+}
+
+#undef STBIR_RENORM_TYPE
+
+static int stbir__pack_coefficients(int num_contributors, stbir__contributors *contributors,
+                                    float *coefficents, int coefficient_width, int widest, int row0,
+                                    int row1) {
+#define STBIR_MOVE_1(dest, src)                                                                    \
+    {                                                                                              \
+        STBIR_NO_UNROLL(dest);                                                                     \
+        ((stbir_uint32 *)(dest))[0] = ((stbir_uint32 *)(src))[0];                                  \
+    }
+#define STBIR_MOVE_2(dest, src)                                                                    \
+    {                                                                                              \
+        STBIR_NO_UNROLL(dest);                                                                     \
+        ((stbir_uint64 *)(dest))[0] = ((stbir_uint64 *)(src))[0];                                  \
+    }
+#ifdef STBIR_SIMD
+#define STBIR_MOVE_4(dest, src)                                                                    \
+    {                                                                                              \
+        stbir__simdf t;                                                                            \
+        STBIR_NO_UNROLL(dest);                                                                     \
+        stbir__simdf_load(t, src);                                                                 \
+        stbir__simdf_store(dest, t);                                                               \
+    }
+#else
+#define STBIR_MOVE_4(dest, src)                                                                    \
+    {                                                                                              \
+        STBIR_NO_UNROLL(dest);                                                                     \
+        ((stbir_uint64 *)(dest))[0] = ((stbir_uint64 *)(src))[0];                                  \
+        ((stbir_uint64 *)(dest))[1] = ((stbir_uint64 *)(src))[1];                                  \
+    }
+#endif
+
+    int row_end = row1 + 1;
+    STBIR__UNUSED(row0);  // only used in an assert
+
+    if (coefficient_width != widest) {
+        float *pc     = coefficents;
+        float *coeffs = coefficents;
+        float *pc_end = coefficents + num_contributors * widest;
+        switch (widest) {
+        case 1:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_1(pc, coeffs);
+                ++pc;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 2:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_2(pc, coeffs);
+                pc += 2;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 3:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_2(pc, coeffs);
+                STBIR_MOVE_1(pc + 2, coeffs + 2);
+                pc += 3;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 4:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_4(pc, coeffs);
+                pc += 4;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 5:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_4(pc, coeffs);
+                STBIR_MOVE_1(pc + 4, coeffs + 4);
+                pc += 5;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 6:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_4(pc, coeffs);
+                STBIR_MOVE_2(pc + 4, coeffs + 4);
+                pc += 6;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 7:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_4(pc, coeffs);
+                STBIR_MOVE_2(pc + 4, coeffs + 4);
+                STBIR_MOVE_1(pc + 6, coeffs + 6);
+                pc += 7;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 8:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_4(pc, coeffs);
+                STBIR_MOVE_4(pc + 4, coeffs + 4);
+                pc += 8;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 9:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_4(pc, coeffs);
+                STBIR_MOVE_4(pc + 4, coeffs + 4);
+                STBIR_MOVE_1(pc + 8, coeffs + 8);
+                pc += 9;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 10:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_4(pc, coeffs);
+                STBIR_MOVE_4(pc + 4, coeffs + 4);
+                STBIR_MOVE_2(pc + 8, coeffs + 8);
+                pc += 10;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 11:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_4(pc, coeffs);
+                STBIR_MOVE_4(pc + 4, coeffs + 4);
+                STBIR_MOVE_2(pc + 8, coeffs + 8);
+                STBIR_MOVE_1(pc + 10, coeffs + 10);
+                pc += 11;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        case 12:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                STBIR_MOVE_4(pc, coeffs);
+                STBIR_MOVE_4(pc + 4, coeffs + 4);
+                STBIR_MOVE_4(pc + 8, coeffs + 8);
+                pc += 12;
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        default:
+            STBIR_NO_UNROLL_LOOP_START
+            do {
+                float *copy_end = pc + widest - 4;
+                float *c        = coeffs;
+                do {
+                    STBIR_NO_UNROLL(pc);
+                    STBIR_MOVE_4(pc, c);
+                    pc += 4;
+                    c += 4;
+                } while (pc <= copy_end);
+                copy_end += 4;
+                STBIR_NO_UNROLL_LOOP_START
+                while (pc < copy_end) {
+                    STBIR_MOVE_1(pc, c);
+                    ++pc;
+                    ++c;
+                }
+                coeffs += coefficient_width;
+            } while (pc < pc_end);
+            break;
+        }
+    }
+
+    // some horizontal routines read one float off the end (which is then masked off), so put in a
+    // sentinal so we don't read an snan or denormal
+    coefficents[widest * num_contributors] = 8888.0f;
+
+    // the minimum we might read for unrolled filters widths is 12. So, we need to
+    //   make sure we never read outside the decode buffer, by possibly moving
+    //   the sample area back into the scanline, and putting zeros weights first.
+    // we start on the right edge and check until we're well past the possible
+    //   clip area (2*widest).
+    {
+        stbir__contributors *contribs = contributors + num_contributors - 1;
+        float *coeffs                 = coefficents + widest * (num_contributors - 1);
+
+        // go until no chance of clipping (this is usually less than 8 lops)
+        while ((contribs >= contributors) && ((contribs->n0 + widest * 2) >= row_end)) {
+            // might we clip??
+            if ((contribs->n0 + widest) > row_end) {
+                int stop_range = widest;
+
+                // if range is larger than 12, it will be handled by generic loops that can
+                // terminate on the exact length
+                //   of this contrib n1, instead of a fixed widest amount - so calculate this
+                if (widest > 12) {
+                    int mod;
+
+                    // how far will be read in the n_coeff loop (which depends on the widest count
+                    // mod4);
+                    mod        = widest & 3;
+                    stop_range = (((contribs->n1 - contribs->n0 + 1) - mod + 3) & ~3) + mod;
+
+                    // the n_coeff loops do a minimum amount of coeffs, so factor that in!
+                    if (stop_range < (8 + mod))
+                        stop_range = 8 + mod;
+                }
+
+                // now see if we still clip with the refined range
+                if ((contribs->n0 + stop_range) > row_end) {
+                    int new_n0     = row_end - stop_range;
+                    int num        = contribs->n1 - contribs->n0 + 1;
+                    int backup     = contribs->n0 - new_n0;
+                    float *from_co = coeffs + num - 1;
+                    float *to_co   = from_co + backup;
+
+                    STBIR_ASSERT((new_n0 >= row0) && (new_n0 < contribs->n0));
+
+                    // move the coeffs over
+                    while (num) {
+                        *to_co-- = *from_co--;
+                        --num;
+                    }
+                    // zero new positions
+                    while (to_co >= coeffs)
+                        *to_co-- = 0;
+                    // set new start point
+                    contribs->n0 = new_n0;
+                    if (widest > 12) {
+                        int mod;
+
+                        // how far will be read in the n_coeff loop (which depends on the widest
+                        // count mod4);
+                        mod        = widest & 3;
+                        stop_range = (((contribs->n1 - contribs->n0 + 1) - mod + 3) & ~3) + mod;
+
+                        // the n_coeff loops do a minimum amount of coeffs, so factor that in!
+                        if (stop_range < (8 + mod))
+                            stop_range = 8 + mod;
+                    }
+                }
+            }
+            --contribs;
+            coeffs -= widest;
+        }
+    }
+
+    return widest;
+#undef STBIR_MOVE_1
+#undef STBIR_MOVE_2
+#undef STBIR_MOVE_4
+}
+
+static void stbir__calculate_filters(stbir__sampler *samp, stbir__sampler *other_axis_for_pivot,
+                                     void *user_data STBIR_ONLY_PROFILE_BUILD_GET_INFO) {
+    int n;
+    float scale                              = samp->scale_info.scale;
+    stbir__kernel_callback *kernel           = samp->filter_kernel;
+    stbir__support_callback *support         = samp->filter_support;
+    float inv_scale                          = samp->scale_info.inv_scale;
+    int input_full_size                      = samp->scale_info.input_full_size;
+    int gather_num_contributors              = samp->num_contributors;
+    stbir__contributors *gather_contributors = samp->contributors;
+    float *gather_coeffs                     = samp->coefficients;
+    int gather_coefficient_width             = samp->coefficient_width;
+
+    switch (samp->is_gather) {
+    case 1:  // gather upsample
+    {
+        float out_pixels_radius = support(inv_scale, user_data) * scale;
+
+        stbir__calculate_coefficients_for_gather_upsample(
+            out_pixels_radius, kernel, &samp->scale_info, gather_num_contributors,
+            gather_contributors, gather_coeffs, gather_coefficient_width, samp->edge, user_data);
+
+        STBIR_PROFILE_BUILD_START(cleanup);
+        stbir__cleanup_gathered_coefficients(samp->edge, &samp->extent_info, &samp->scale_info,
+                                             gather_num_contributors, gather_contributors,
+                                             gather_coeffs, gather_coefficient_width);
+        STBIR_PROFILE_BUILD_END(cleanup);
+    } break;
+
+    case 0:  // scatter downsample (only on vertical)
+    case 2:  // gather downsample
+    {
+        float in_pixels_radius  = support(scale, user_data) * inv_scale;
+        int filter_pixel_margin = samp->filter_pixel_margin;
+        int input_end           = input_full_size + filter_pixel_margin;
+
+        // if this is a scatter, we do a downsample gather to get the coeffs, and then pivot after
+        if (!samp->is_gather) {
+            // check if we are using the same gather downsample on the horizontal as this vertical,
+            //   if so, then we don't have to generate them, we can just pivot from the horizontal.
+            if (other_axis_for_pivot) {
+                gather_contributors       = other_axis_for_pivot->contributors;
+                gather_coeffs             = other_axis_for_pivot->coefficients;
+                gather_coefficient_width  = other_axis_for_pivot->coefficient_width;
+                gather_num_contributors   = other_axis_for_pivot->num_contributors;
+                samp->extent_info.lowest  = other_axis_for_pivot->extent_info.lowest;
+                samp->extent_info.highest = other_axis_for_pivot->extent_info.highest;
+                samp->extent_info.widest  = other_axis_for_pivot->extent_info.widest;
+                goto jump_right_to_pivot;
+            }
+
+            gather_contributors      = samp->gather_prescatter_contributors;
+            gather_coeffs            = samp->gather_prescatter_coefficients;
+            gather_coefficient_width = samp->gather_prescatter_coefficient_width;
+            gather_num_contributors  = samp->gather_prescatter_num_contributors;
+        }
+
+        stbir__calculate_coefficients_for_gather_downsample(
+            -filter_pixel_margin, input_end, in_pixels_radius, kernel, &samp->scale_info,
+            gather_coefficient_width, gather_num_contributors, gather_contributors, gather_coeffs,
+            user_data);
+
+        STBIR_PROFILE_BUILD_START(cleanup);
+        stbir__cleanup_gathered_coefficients(samp->edge, &samp->extent_info, &samp->scale_info,
+                                             gather_num_contributors, gather_contributors,
+                                             gather_coeffs, gather_coefficient_width);
+        STBIR_PROFILE_BUILD_END(cleanup);
+
+        if (!samp->is_gather) {
+            // if this is a scatter (vertical only), then we need to pivot the coeffs
+            stbir__contributors *scatter_contributors;
+            int highest_set;
+
+        jump_right_to_pivot:
+
+            STBIR_PROFILE_BUILD_START(pivot);
+
+            highest_set = (-filter_pixel_margin) - 1;
+            for (n = 0; n < gather_num_contributors; n++) {
+                int k;
+                int gn0 = gather_contributors->n0, gn1 = gather_contributors->n1;
+                int scatter_coefficient_width = samp->coefficient_width;
+                float *scatter_coeffs =
+                    samp->coefficients + (gn0 + filter_pixel_margin) * scatter_coefficient_width;
+                float *g_coeffs      = gather_coeffs;
+                scatter_contributors = samp->contributors + (gn0 + filter_pixel_margin);
+
+                for (k = gn0; k <= gn1; k++) {
+                    float gc = *g_coeffs++;
+
+                    // skip zero and denormals - must skip zeros to avoid adding coeffs beyond
+                    // scatter_coefficient_width
+                    //   (which happens when pivoting from horizontal, which might have dummy zeros)
+                    if (((gc >= stbir__small_float) || (gc <= -stbir__small_float))) {
+                        if ((k > highest_set) ||
+                            (scatter_contributors->n0 > scatter_contributors->n1)) {
+                            {
+                                // if we are skipping over several contributors, we need to clear
+                                // the skipped ones
+                                stbir__contributors *clear_contributors =
+                                    samp->contributors + (highest_set + filter_pixel_margin + 1);
+                                while (clear_contributors < scatter_contributors) {
+                                    clear_contributors->n0 = 0;
+                                    clear_contributors->n1 = -1;
+                                    ++clear_contributors;
+                                }
+                            }
+                            scatter_contributors->n0 = n;
+                            scatter_contributors->n1 = n;
+                            scatter_coeffs[0]        = gc;
+                            highest_set              = k;
+                        } else {
+                            stbir__insert_coeff(scatter_contributors, scatter_coeffs, n, gc,
+                                                scatter_coefficient_width);
+                        }
+                        STBIR_ASSERT((scatter_contributors->n1 - scatter_contributors->n0 + 1) <=
+                                     scatter_coefficient_width);
+                    }
+                    ++scatter_contributors;
+                    scatter_coeffs += scatter_coefficient_width;
+                }
+
+                ++gather_contributors;
+                gather_coeffs += gather_coefficient_width;
+            }
+
+            // now clear any unset contribs
+            {
+                stbir__contributors *clear_contributors =
+                    samp->contributors + (highest_set + filter_pixel_margin + 1);
+                stbir__contributors *end_contributors = samp->contributors + samp->num_contributors;
+                while (clear_contributors < end_contributors) {
+                    clear_contributors->n0 = 0;
+                    clear_contributors->n1 = -1;
+                    ++clear_contributors;
+                }
+            }
+
+            STBIR_PROFILE_BUILD_END(pivot);
+        }
+    } break;
+    }
+}
+
+//========================================================================================================
+// scanline decoders and encoders
+
+#define stbir__coder_min_num 1
+#define STB_IMAGE_RESIZE_DO_CODERS
+#include STBIR__HEADER_FILENAME
+
+#define stbir__decode_suffix BGRA
+#define stbir__decode_swizzle
+#define stbir__decode_order0 2
+#define stbir__decode_order1 1
+#define stbir__decode_order2 0
+#define stbir__decode_order3 3
+#define stbir__encode_order0 2
+#define stbir__encode_order1 1
+#define stbir__encode_order2 0
+#define stbir__encode_order3 3
+#define stbir__coder_min_num 4
+#define STB_IMAGE_RESIZE_DO_CODERS
+#include STBIR__HEADER_FILENAME
+
+#define stbir__decode_suffix ARGB
+#define stbir__decode_swizzle
+#define stbir__decode_order0 1
+#define stbir__decode_order1 2
+#define stbir__decode_order2 3
+#define stbir__decode_order3 0
+#define stbir__encode_order0 3
+#define stbir__encode_order1 0
+#define stbir__encode_order2 1
+#define stbir__encode_order3 2
+#define stbir__coder_min_num 4
+#define STB_IMAGE_RESIZE_DO_CODERS
+#include STBIR__HEADER_FILENAME
+
+#define stbir__decode_suffix ABGR
+#define stbir__decode_swizzle
+#define stbir__decode_order0 3
+#define stbir__decode_order1 2
+#define stbir__decode_order2 1
+#define stbir__decode_order3 0
+#define stbir__encode_order0 3
+#define stbir__encode_order1 2
+#define stbir__encode_order2 1
+#define stbir__encode_order3 0
+#define stbir__coder_min_num 4
+#define STB_IMAGE_RESIZE_DO_CODERS
+#include STBIR__HEADER_FILENAME
+
+#define stbir__decode_suffix AR
+#define stbir__decode_swizzle
+#define stbir__decode_order0 1
+#define stbir__decode_order1 0
+#define stbir__decode_order2 3
+#define stbir__decode_order3 2
+#define stbir__encode_order0 1
+#define stbir__encode_order1 0
+#define stbir__encode_order2 3
+#define stbir__encode_order3 2
+#define stbir__coder_min_num 2
+#define STB_IMAGE_RESIZE_DO_CODERS
+#include STBIR__HEADER_FILENAME
+
+// fancy alpha means we expand to keep both premultipied and non-premultiplied color channels
+static void stbir__fancy_alpha_weight_4ch(float *out_buffer, int width_times_channels) {
+    float STBIR_STREAMOUT_PTR(*) out = out_buffer;
+    float const *end_decode =
+        out_buffer + (width_times_channels / 4) * 7;  // decode buffer aligned to end of out_buffer
+    float STBIR_STREAMOUT_PTR(*) decode = (float *)end_decode - width_times_channels;
+
+    // fancy alpha is stored internally as R G B A Rpm Gpm Bpm
+
+#ifdef STBIR_SIMD
+
+#ifdef STBIR_SIMD8
+    decode += 16;
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode <= end_decode) {
+        stbir__simdf8 d0, d1, a0, a1, p0, p1;
+        STBIR_NO_UNROLL(decode);
+        stbir__simdf8_load(d0, decode - 16);
+        stbir__simdf8_load(d1, decode - 16 + 8);
+        stbir__simdf8_0123to33333333(a0, d0);
+        stbir__simdf8_0123to33333333(a1, d1);
+        stbir__simdf8_mult(p0, a0, d0);
+        stbir__simdf8_mult(p1, a1, d1);
+        stbir__simdf8_bot4s(a0, d0, p0);
+        stbir__simdf8_bot4s(a1, d1, p1);
+        stbir__simdf8_top4s(d0, d0, p0);
+        stbir__simdf8_top4s(d1, d1, p1);
+        stbir__simdf8_store(out, a0);
+        stbir__simdf8_store(out + 7, d0);
+        stbir__simdf8_store(out + 14, a1);
+        stbir__simdf8_store(out + 21, d1);
+        decode += 16;
+        out += 28;
+    }
+    decode -= 16;
+#else
+    decode += 8;
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode <= end_decode) {
+        stbir__simdf d0, a0, d1, a1, p0, p1;
+        STBIR_NO_UNROLL(decode);
+        stbir__simdf_load(d0, decode - 8);
+        stbir__simdf_load(d1, decode - 8 + 4);
+        stbir__simdf_0123to3333(a0, d0);
+        stbir__simdf_0123to3333(a1, d1);
+        stbir__simdf_mult(p0, a0, d0);
+        stbir__simdf_mult(p1, a1, d1);
+        stbir__simdf_store(out, d0);
+        stbir__simdf_store(out + 4, p0);
+        stbir__simdf_store(out + 7, d1);
+        stbir__simdf_store(out + 7 + 4, p1);
+        decode += 8;
+        out += 14;
+    }
+    decode -= 8;
+#endif
+
+// might be one last odd pixel
+#ifdef STBIR_SIMD8
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode < end_decode)
+#else
+    if (decode < end_decode)
+#endif
+    {
+        stbir__simdf d, a, p;
+        STBIR_NO_UNROLL(decode);
+        stbir__simdf_load(d, decode);
+        stbir__simdf_0123to3333(a, d);
+        stbir__simdf_mult(p, a, d);
+        stbir__simdf_store(out, d);
+        stbir__simdf_store(out + 4, p);
+        decode += 4;
+        out += 7;
+    }
+
+#else
+
+    while (decode < end_decode) {
+        float r = decode[0], g = decode[1], b = decode[2], alpha = decode[3];
+        out[0] = r;
+        out[1] = g;
+        out[2] = b;
+        out[3] = alpha;
+        out[4] = r * alpha;
+        out[5] = g * alpha;
+        out[6] = b * alpha;
+        out += 7;
+        decode += 4;
+    }
+
+#endif
+}
+
+static void stbir__fancy_alpha_weight_2ch(float *out_buffer, int width_times_channels) {
+    float STBIR_STREAMOUT_PTR(*) out    = out_buffer;
+    float const *end_decode             = out_buffer + (width_times_channels / 2) * 3;
+    float STBIR_STREAMOUT_PTR(*) decode = (float *)end_decode - width_times_channels;
+
+    //  for fancy alpha, turns into: [X A Xpm][X A Xpm],etc
+
+#ifdef STBIR_SIMD
+
+    decode += 8;
+    if (decode <= end_decode) {
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+#ifdef STBIR_SIMD8
+            stbir__simdf8 d0, a0, p0;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdf8_load(d0, decode - 8);
+            stbir__simdf8_0123to11331133(p0, d0);
+            stbir__simdf8_0123to00220022(a0, d0);
+            stbir__simdf8_mult(p0, p0, a0);
+
+            stbir__simdf_store2(out, stbir__if_simdf8_cast_to_simdf4(d0));
+            stbir__simdf_store(out + 2, stbir__if_simdf8_cast_to_simdf4(p0));
+            stbir__simdf_store2h(out + 3, stbir__if_simdf8_cast_to_simdf4(d0));
+
+            stbir__simdf_store2(out + 6, stbir__simdf8_gettop4(d0));
+            stbir__simdf_store(out + 8, stbir__simdf8_gettop4(p0));
+            stbir__simdf_store2h(out + 9, stbir__simdf8_gettop4(d0));
+#else
+            stbir__simdf d0, a0, d1, a1, p0, p1;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdf_load(d0, decode - 8);
+            stbir__simdf_load(d1, decode - 8 + 4);
+            stbir__simdf_0123to1133(p0, d0);
+            stbir__simdf_0123to1133(p1, d1);
+            stbir__simdf_0123to0022(a0, d0);
+            stbir__simdf_0123to0022(a1, d1);
+            stbir__simdf_mult(p0, p0, a0);
+            stbir__simdf_mult(p1, p1, a1);
+
+            stbir__simdf_store2(out, d0);
+            stbir__simdf_store(out + 2, p0);
+            stbir__simdf_store2h(out + 3, d0);
+
+            stbir__simdf_store2(out + 6, d1);
+            stbir__simdf_store(out + 8, p1);
+            stbir__simdf_store2h(out + 9, d1);
+#endif
+            decode += 8;
+            out += 12;
+        } while (decode <= end_decode);
+    }
+    decode -= 8;
+#endif
+
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (decode < end_decode) {
+        float x = decode[0], y = decode[1];
+        STBIR_SIMD_NO_UNROLL(decode);
+        out[0] = x;
+        out[1] = y;
+        out[2] = x * y;
+        out += 3;
+        decode += 2;
+    }
+}
+
+static void stbir__fancy_alpha_unweight_4ch(float *encode_buffer, int width_times_channels) {
+    float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer;
+    float STBIR_SIMD_STREAMOUT_PTR(*) input  = encode_buffer;
+    float const *end_output                  = encode_buffer + width_times_channels;
+
+    // fancy RGBA is stored internally as R G B A Rpm Gpm Bpm
+
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float alpha = input[3];
+#ifdef STBIR_SIMD
+        stbir__simdf i, ia;
+        STBIR_SIMD_NO_UNROLL(encode);
+        if (alpha < stbir__small_float) {
+            stbir__simdf_load(i, input);
+            stbir__simdf_store(encode, i);
+        } else {
+            stbir__simdf_load1frep4(ia, 1.0f / alpha);
+            stbir__simdf_load(i, input + 4);
+            stbir__simdf_mult(i, i, ia);
+            stbir__simdf_store(encode, i);
+            encode[3] = alpha;
+        }
+#else
+        if (alpha < stbir__small_float) {
+            encode[0] = input[0];
+            encode[1] = input[1];
+            encode[2] = input[2];
+        } else {
+            float ialpha = 1.0f / alpha;
+            encode[0]    = input[4] * ialpha;
+            encode[1]    = input[5] * ialpha;
+            encode[2]    = input[6] * ialpha;
+        }
+        encode[3] = alpha;
+#endif
+
+        input += 7;
+        encode += 4;
+    } while (encode < end_output);
+}
+
+//  format: [X A Xpm][X A Xpm] etc
+static void stbir__fancy_alpha_unweight_2ch(float *encode_buffer, int width_times_channels) {
+    float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer;
+    float STBIR_SIMD_STREAMOUT_PTR(*) input  = encode_buffer;
+    float const *end_output                  = encode_buffer + width_times_channels;
+
+    do {
+        float alpha = input[1];
+        encode[0]   = input[0];
+        if (alpha >= stbir__small_float)
+            encode[0] = input[2] / alpha;
+        encode[1] = alpha;
+
+        input += 3;
+        encode += 2;
+    } while (encode < end_output);
+}
+
+static void stbir__simple_alpha_weight_4ch(float *decode_buffer, int width_times_channels) {
+    float STBIR_STREAMOUT_PTR(*) decode = decode_buffer;
+    float const *end_decode             = decode_buffer + width_times_channels;
+
+#ifdef STBIR_SIMD
+    {
+        decode += 2 * stbir__simdfX_float_count;
+        STBIR_NO_UNROLL_LOOP_START
+        while (decode <= end_decode) {
+            stbir__simdfX d0, a0, d1, a1;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdfX_load(d0, decode - 2 * stbir__simdfX_float_count);
+            stbir__simdfX_load(d1,
+                               decode - 2 * stbir__simdfX_float_count + stbir__simdfX_float_count);
+            stbir__simdfX_aaa1(a0, d0, STBIR_onesX);
+            stbir__simdfX_aaa1(a1, d1, STBIR_onesX);
+            stbir__simdfX_mult(d0, d0, a0);
+            stbir__simdfX_mult(d1, d1, a1);
+            stbir__simdfX_store(decode - 2 * stbir__simdfX_float_count, d0);
+            stbir__simdfX_store(decode - 2 * stbir__simdfX_float_count + stbir__simdfX_float_count,
+                                d1);
+            decode += 2 * stbir__simdfX_float_count;
+        }
+        decode -= 2 * stbir__simdfX_float_count;
+
+// few last pixels remnants
+#ifdef STBIR_SIMD8
+        STBIR_NO_UNROLL_LOOP_START
+        while (decode < end_decode)
+#else
+        if (decode < end_decode)
+#endif
+        {
+            stbir__simdf d, a;
+            stbir__simdf_load(d, decode);
+            stbir__simdf_aaa1(a, d, STBIR__CONSTF(STBIR_ones));
+            stbir__simdf_mult(d, d, a);
+            stbir__simdf_store(decode, d);
+            decode += 4;
+        }
+    }
+
+#else
+
+    while (decode < end_decode) {
+        float alpha = decode[3];
+        decode[0] *= alpha;
+        decode[1] *= alpha;
+        decode[2] *= alpha;
+        decode += 4;
+    }
+
+#endif
+}
+
+static void stbir__simple_alpha_weight_2ch(float *decode_buffer, int width_times_channels) {
+    float STBIR_STREAMOUT_PTR(*) decode = decode_buffer;
+    float const *end_decode             = decode_buffer + width_times_channels;
+
+#ifdef STBIR_SIMD
+    decode += 2 * stbir__simdfX_float_count;
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode <= end_decode) {
+        stbir__simdfX d0, a0, d1, a1;
+        STBIR_NO_UNROLL(decode);
+        stbir__simdfX_load(d0, decode - 2 * stbir__simdfX_float_count);
+        stbir__simdfX_load(d1, decode - 2 * stbir__simdfX_float_count + stbir__simdfX_float_count);
+        stbir__simdfX_a1a1(a0, d0, STBIR_onesX);
+        stbir__simdfX_a1a1(a1, d1, STBIR_onesX);
+        stbir__simdfX_mult(d0, d0, a0);
+        stbir__simdfX_mult(d1, d1, a1);
+        stbir__simdfX_store(decode - 2 * stbir__simdfX_float_count, d0);
+        stbir__simdfX_store(decode - 2 * stbir__simdfX_float_count + stbir__simdfX_float_count, d1);
+        decode += 2 * stbir__simdfX_float_count;
+    }
+    decode -= 2 * stbir__simdfX_float_count;
+#endif
+
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (decode < end_decode) {
+        float alpha = decode[1];
+        STBIR_SIMD_NO_UNROLL(decode);
+        decode[0] *= alpha;
+        decode += 2;
+    }
+}
+
+static void stbir__simple_alpha_unweight_4ch(float *encode_buffer, int width_times_channels) {
+    float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer;
+    float const *end_output                  = encode_buffer + width_times_channels;
+
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float alpha = encode[3];
+
+#ifdef STBIR_SIMD
+        stbir__simdf i, ia;
+        STBIR_SIMD_NO_UNROLL(encode);
+        if (alpha >= stbir__small_float) {
+            stbir__simdf_load1frep4(ia, 1.0f / alpha);
+            stbir__simdf_load(i, encode);
+            stbir__simdf_mult(i, i, ia);
+            stbir__simdf_store(encode, i);
+            encode[3] = alpha;
+        }
+#else
+        if (alpha >= stbir__small_float) {
+            float ialpha = 1.0f / alpha;
+            encode[0] *= ialpha;
+            encode[1] *= ialpha;
+            encode[2] *= ialpha;
+        }
+#endif
+        encode += 4;
+    } while (encode < end_output);
+}
+
+static void stbir__simple_alpha_unweight_2ch(float *encode_buffer, int width_times_channels) {
+    float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer;
+    float const *end_output                  = encode_buffer + width_times_channels;
+
+    do {
+        float alpha = encode[1];
+        if (alpha >= stbir__small_float)
+            encode[0] /= alpha;
+        encode += 2;
+    } while (encode < end_output);
+}
+
+// only used in RGB->BGR or BGR->RGB
+static void stbir__simple_flip_3ch(float *decode_buffer, int width_times_channels) {
+    float STBIR_STREAMOUT_PTR(*) decode = decode_buffer;
+    float const *end_decode             = decode_buffer + width_times_channels;
+
+#ifdef STBIR_SIMD
+#ifdef stbir__simdf_swiz2  // do we have two argument swizzles?
+    end_decode -= 12;
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode <= end_decode) {
+        // on arm64 8 instructions, no overlapping stores
+        stbir__simdf a, b, c, na, nb;
+        STBIR_SIMD_NO_UNROLL(decode);
+        stbir__simdf_load(a, decode);
+        stbir__simdf_load(b, decode + 4);
+        stbir__simdf_load(c, decode + 8);
+
+        na = stbir__simdf_swiz2(a, b, 2, 1, 0, 5);
+        b  = stbir__simdf_swiz2(a, b, 4, 3, 6, 7);
+        nb = stbir__simdf_swiz2(b, c, 0, 1, 4, 3);
+        c  = stbir__simdf_swiz2(b, c, 2, 7, 6, 5);
+
+        stbir__simdf_store(decode, na);
+        stbir__simdf_store(decode + 4, nb);
+        stbir__simdf_store(decode + 8, c);
+        decode += 12;
+    }
+    end_decode += 12;
+#else
+    end_decode -= 24;
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode <= end_decode) {
+        // 26 instructions on x64
+        stbir__simdf a, b, c, d, e, f, g;
+        float i21, i23;
+        STBIR_SIMD_NO_UNROLL(decode);
+        stbir__simdf_load(a, decode);
+        stbir__simdf_load(b, decode + 3);
+        stbir__simdf_load(c, decode + 6);
+        stbir__simdf_load(d, decode + 9);
+        stbir__simdf_load(e, decode + 12);
+        stbir__simdf_load(f, decode + 15);
+        stbir__simdf_load(g, decode + 18);
+
+        a = stbir__simdf_swiz(a, 2, 1, 0, 3);
+        b = stbir__simdf_swiz(b, 2, 1, 0, 3);
+        c = stbir__simdf_swiz(c, 2, 1, 0, 3);
+        d = stbir__simdf_swiz(d, 2, 1, 0, 3);
+        e = stbir__simdf_swiz(e, 2, 1, 0, 3);
+        f = stbir__simdf_swiz(f, 2, 1, 0, 3);
+        g = stbir__simdf_swiz(g, 2, 1, 0, 3);
+
+        // stores overlap, need to be in order,
+        stbir__simdf_store(decode, a);
+        i21 = decode[21];
+        stbir__simdf_store(decode + 3, b);
+        i23 = decode[23];
+        stbir__simdf_store(decode + 6, c);
+        stbir__simdf_store(decode + 9, d);
+        stbir__simdf_store(decode + 12, e);
+        stbir__simdf_store(decode + 15, f);
+        stbir__simdf_store(decode + 18, g);
+        decode[21] = i23;
+        decode[23] = i21;
+        decode += 24;
+    }
+    end_decode += 24;
+#endif
+#else
+    end_decode -= 12;
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode <= end_decode) {
+        // 16 instructions
+        float t0, t1, t2, t3;
+        STBIR_NO_UNROLL(decode);
+        t0         = decode[0];
+        t1         = decode[3];
+        t2         = decode[6];
+        t3         = decode[9];
+        decode[0]  = decode[2];
+        decode[3]  = decode[5];
+        decode[6]  = decode[8];
+        decode[9]  = decode[11];
+        decode[2]  = t0;
+        decode[5]  = t1;
+        decode[8]  = t2;
+        decode[11] = t3;
+        decode += 12;
+    }
+    end_decode += 12;
+#endif
+
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode < end_decode) {
+        float t = decode[0];
+        STBIR_NO_UNROLL(decode);
+        decode[0] = decode[2];
+        decode[2] = t;
+        decode += 3;
+    }
+}
+
+static void stbir__decode_scanline(stbir__info const *stbir_info, int n,
+                                   float *output_buffer STBIR_ONLY_PROFILE_GET_SPLIT_INFO) {
+    int channels               = stbir_info->channels;
+    int effective_channels     = stbir_info->effective_channels;
+    int input_sample_in_bytes  = stbir__type_size[stbir_info->input_type] * channels;
+    stbir_edge edge_horizontal = stbir_info->horizontal.edge;
+    stbir_edge edge_vertical   = stbir_info->vertical.edge;
+    int row = stbir__edge_wrap(edge_vertical, n, stbir_info->vertical.scale_info.input_full_size);
+    const void *input_plane_data =
+        ((char *)stbir_info->input_data) + (size_t)row * (size_t)stbir_info->input_stride_bytes;
+    stbir__span const *spans = stbir_info->scanline_extents.spans;
+    float *full_decode_buffer =
+        output_buffer - stbir_info->scanline_extents.conservative.n0 * effective_channels;
+
+    // if we are on edge_zero, and we get in here with an out of bounds n, then the calculate
+    // filters has failed
+    STBIR_ASSERT(!(edge_vertical == STBIR_EDGE_ZERO &&
+                   (n < 0 || n >= stbir_info->vertical.scale_info.input_full_size)));
+
+    do {
+        float *decode_buffer;
+        void const *input_data;
+        float *end_decode;
+        int width_times_channels;
+        int width;
+
+        if (spans->n1 < spans->n0)
+            break;
+
+        width                = spans->n1 + 1 - spans->n0;
+        decode_buffer        = full_decode_buffer + spans->n0 * effective_channels;
+        end_decode           = full_decode_buffer + (spans->n1 + 1) * effective_channels;
+        width_times_channels = width * channels;
+
+        // read directly out of input plane by default
+        input_data =
+            ((char *)input_plane_data) + spans->pixel_offset_for_input * input_sample_in_bytes;
+
+        // if we have an input callback, call it to get the input data
+        if (stbir_info->in_pixels_cb) {
+            // call the callback with a temp buffer (that they can choose to use or not).  the temp
+            // is just right aligned memory in the decode_buffer itself
+            input_data = stbir_info->in_pixels_cb(
+                ((char *)end_decode) - (width * input_sample_in_bytes), input_plane_data, width,
+                spans->pixel_offset_for_input, row, stbir_info->user_data);
+        }
+
+        STBIR_PROFILE_START(decode);
+        // convert the pixels info the float decode_buffer, (we index from end_decode, so that when
+        // channels<effective_channels, we are right justified in the buffer)
+        stbir_info->decode_pixels((float *)end_decode - width_times_channels, width_times_channels,
+                                  input_data);
+        STBIR_PROFILE_END(decode);
+
+        if (stbir_info->alpha_weight) {
+            STBIR_PROFILE_START(alpha);
+            stbir_info->alpha_weight(decode_buffer, width_times_channels);
+            STBIR_PROFILE_END(alpha);
+        }
+
+        ++spans;
+    } while (spans <= (&stbir_info->scanline_extents.spans[1]));
+
+    // handle the edge_wrap filter (all other types are handled back out at the calculate_filter
+    // stage) basically the idea here is that if we have the whole scanline in memory, we don't
+    // redecode the
+    //   wrapped edge pixels, and instead just memcpy them from the scanline into the edge positions
+    if ((edge_horizontal == STBIR_EDGE_WRAP) &&
+        (stbir_info->scanline_extents.edge_sizes[0] | stbir_info->scanline_extents.edge_sizes[1])) {
+        // this code only runs if we're in edge_wrap, and we're doing the entire scanline
+        int e, start_x[2];
+        int input_full_size = stbir_info->horizontal.scale_info.input_full_size;
+
+        start_x[0] = -stbir_info->scanline_extents.edge_sizes[0];  // left edge start x
+        start_x[1] = input_full_size;                              // right edge
+
+        for (e = 0; e < 2; e++) {
+            // do each margin
+            int margin = stbir_info->scanline_extents.edge_sizes[e];
+            if (margin) {
+                int x       = start_x[e];
+                float *marg = full_decode_buffer + x * effective_channels;
+                float const *src =
+                    full_decode_buffer +
+                    stbir__edge_wrap(edge_horizontal, x, input_full_size) * effective_channels;
+                STBIR_MEMCPY(marg, src, margin * effective_channels * sizeof(float));
+            }
+        }
+    }
+}
+
+//=================
+// Do 1 channel horizontal routines
+
+#ifdef STBIR_SIMD
+
+#define stbir__1_coeff_only()                                                                      \
+    stbir__simdf tot, c;                                                                           \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load1(c, hc);                                                                     \
+    stbir__simdf_mult1_mem(tot, c, decode);
+
+#define stbir__2_coeff_only()                                                                      \
+    stbir__simdf tot, c, d;                                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load2z(c, hc);                                                                    \
+    stbir__simdf_load2(d, decode);                                                                 \
+    stbir__simdf_mult(tot, c, d);                                                                  \
+    stbir__simdf_0123to1230(c, tot);                                                               \
+    stbir__simdf_add1(tot, tot, c);
+
+#define stbir__3_coeff_only()                                                                      \
+    stbir__simdf tot, c, t;                                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(c, hc);                                                                      \
+    stbir__simdf_mult_mem(tot, c, decode);                                                         \
+    stbir__simdf_0123to1230(c, tot);                                                               \
+    stbir__simdf_0123to2301(t, tot);                                                               \
+    stbir__simdf_add1(tot, tot, c);                                                                \
+    stbir__simdf_add1(tot, tot, t);
+
+#define stbir__store_output_tiny()                                                                 \
+    stbir__simdf_store1(output, tot);                                                              \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 1;
+
+#define stbir__4_coeff_start()                                                                     \
+    stbir__simdf tot, c;                                                                           \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(c, hc);                                                                      \
+    stbir__simdf_mult_mem(tot, c, decode);
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(c, hc + (ofs));                                                              \
+    stbir__simdf_madd_mem(tot, tot, c, decode + (ofs));
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    {                                                                                              \
+        stbir__simdf d;                                                                            \
+        stbir__simdf_load1z(c, hc + (ofs));                                                        \
+        stbir__simdf_load1(d, decode + (ofs));                                                     \
+        stbir__simdf_madd(tot, tot, d, c);                                                         \
+    }
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    {                                                                                              \
+        stbir__simdf d;                                                                            \
+        stbir__simdf_load2z(c, hc + (ofs));                                                        \
+        stbir__simdf_load2(d, decode + (ofs));                                                     \
+        stbir__simdf_madd(tot, tot, d, c);                                                         \
+    }
+
+#define stbir__3_coeff_setup()                                                                     \
+    stbir__simdf mask;                                                                             \
+    stbir__simdf_load(mask, STBIR_mask + 3);
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    stbir__simdf_load(c, hc + (ofs));                                                              \
+    stbir__simdf_and(c, c, mask);                                                                  \
+    stbir__simdf_madd_mem(tot, tot, c, decode + (ofs));
+
+#define stbir__store_output()                                                                      \
+    stbir__simdf_0123to2301(c, tot);                                                               \
+    stbir__simdf_add(tot, tot, c);                                                                 \
+    stbir__simdf_0123to1230(c, tot);                                                               \
+    stbir__simdf_add1(tot, tot, c);                                                                \
+    stbir__simdf_store1(output, tot);                                                              \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 1;
+
+#else
+
+#define stbir__1_coeff_only()                                                                      \
+    float tot;                                                                                     \
+    tot = decode[0] * hc[0];
+
+#define stbir__2_coeff_only()                                                                      \
+    float tot;                                                                                     \
+    tot = decode[0] * hc[0];                                                                       \
+    tot += decode[1] * hc[1];
+
+#define stbir__3_coeff_only()                                                                      \
+    float tot;                                                                                     \
+    tot = decode[0] * hc[0];                                                                       \
+    tot += decode[1] * hc[1];                                                                      \
+    tot += decode[2] * hc[2];
+
+#define stbir__store_output_tiny()                                                                 \
+    output[0] = tot;                                                                               \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 1;
+
+#define stbir__4_coeff_start()                                                                     \
+    float tot0, tot1, tot2, tot3;                                                                  \
+    tot0 = decode[0] * hc[0];                                                                      \
+    tot1 = decode[1] * hc[1];                                                                      \
+    tot2 = decode[2] * hc[2];                                                                      \
+    tot3 = decode[3] * hc[3];
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    tot0 += decode[0 + (ofs)] * hc[0 + (ofs)];                                                     \
+    tot1 += decode[1 + (ofs)] * hc[1 + (ofs)];                                                     \
+    tot2 += decode[2 + (ofs)] * hc[2 + (ofs)];                                                     \
+    tot3 += decode[3 + (ofs)] * hc[3 + (ofs)];
+
+#define stbir__1_coeff_remnant(ofs) tot0 += decode[0 + (ofs)] * hc[0 + (ofs)];
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    tot0 += decode[0 + (ofs)] * hc[0 + (ofs)];                                                     \
+    tot1 += decode[1 + (ofs)] * hc[1 + (ofs)];
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    tot0 += decode[0 + (ofs)] * hc[0 + (ofs)];                                                     \
+    tot1 += decode[1 + (ofs)] * hc[1 + (ofs)];                                                     \
+    tot2 += decode[2 + (ofs)] * hc[2 + (ofs)];
+
+#define stbir__store_output()                                                                      \
+    output[0] = (tot0 + tot2) + (tot1 + tot3);                                                     \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 1;
+
+#endif
+
+#define STBIR__horizontal_channels 1
+#define STB_IMAGE_RESIZE_DO_HORIZONTALS
+#include STBIR__HEADER_FILENAME
+
+//=================
+// Do 2 channel horizontal routines
+
+#ifdef STBIR_SIMD
+
+#define stbir__1_coeff_only()                                                                      \
+    stbir__simdf tot, c, d;                                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load1z(c, hc);                                                                    \
+    stbir__simdf_0123to0011(c, c);                                                                 \
+    stbir__simdf_load2(d, decode);                                                                 \
+    stbir__simdf_mult(tot, d, c);
+
+#define stbir__2_coeff_only()                                                                      \
+    stbir__simdf tot, c;                                                                           \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load2(c, hc);                                                                     \
+    stbir__simdf_0123to0011(c, c);                                                                 \
+    stbir__simdf_mult_mem(tot, c, decode);
+
+#define stbir__3_coeff_only()                                                                      \
+    stbir__simdf tot, c, cs, d;                                                                    \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc);                                                                     \
+    stbir__simdf_0123to0011(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot, c, decode);                                                         \
+    stbir__simdf_0123to2222(c, cs);                                                                \
+    stbir__simdf_load2z(d, decode + 4);                                                            \
+    stbir__simdf_madd(tot, tot, d, c);
+
+#define stbir__store_output_tiny()                                                                 \
+    stbir__simdf_0123to2301(c, tot);                                                               \
+    stbir__simdf_add(tot, tot, c);                                                                 \
+    stbir__simdf_store2(output, tot);                                                              \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 2;
+
+#ifdef STBIR_SIMD8
+
+#define stbir__4_coeff_start()                                                                     \
+    stbir__simdf8 tot0, c, cs;                                                                     \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc);                                                                  \
+    stbir__simdf8_0123to00112233(c, cs);                                                           \
+    stbir__simdf8_mult_mem(tot0, c, decode);
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc + (ofs));                                                          \
+    stbir__simdf8_0123to00112233(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 2);
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    {                                                                                              \
+        stbir__simdf t, d;                                                                         \
+        stbir__simdf_load1z(t, hc + (ofs));                                                        \
+        stbir__simdf_load2(d, decode + (ofs) * 2);                                                 \
+        stbir__simdf_0123to0011(t, t);                                                             \
+        stbir__simdf_mult(t, t, d);                                                                \
+        stbir__simdf8_add4(tot0, tot0, t);                                                         \
+    }
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    {                                                                                              \
+        stbir__simdf t;                                                                            \
+        stbir__simdf_load2(t, hc + (ofs));                                                         \
+        stbir__simdf_0123to0011(t, t);                                                             \
+        stbir__simdf_mult_mem(t, t, decode + (ofs) * 2);                                           \
+        stbir__simdf8_add4(tot0, tot0, t);                                                         \
+    }
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    {                                                                                              \
+        stbir__simdf8 d;                                                                           \
+        stbir__simdf8_load4b(cs, hc + (ofs));                                                      \
+        stbir__simdf8_0123to00112233(c, cs);                                                       \
+        stbir__simdf8_load6z(d, decode + (ofs) * 2);                                               \
+        stbir__simdf8_madd(tot0, tot0, c, d);                                                      \
+    }
+
+#define stbir__store_output()                                                                      \
+    {                                                                                              \
+        stbir__simdf t, d;                                                                         \
+        stbir__simdf8_add4halves(t, stbir__if_simdf8_cast_to_simdf4(tot0), tot0);                  \
+        stbir__simdf_0123to2301(d, t);                                                             \
+        stbir__simdf_add(t, t, d);                                                                 \
+        stbir__simdf_store2(output, t);                                                            \
+        horizontal_coefficients += coefficient_width;                                              \
+        ++horizontal_contributors;                                                                 \
+        output += 2;                                                                               \
+    }
+
+#else
+
+#define stbir__4_coeff_start()                                                                     \
+    stbir__simdf tot0, tot1, c, cs;                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc);                                                                     \
+    stbir__simdf_0123to0011(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot0, c, decode);                                                        \
+    stbir__simdf_0123to2233(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot1, c, decode + 4);
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc + (ofs));                                                             \
+    stbir__simdf_0123to0011(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 2);                                      \
+    stbir__simdf_0123to2233(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 2 + 4);
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    {                                                                                              \
+        stbir__simdf d;                                                                            \
+        stbir__simdf_load1z(cs, hc + (ofs));                                                       \
+        stbir__simdf_0123to0011(c, cs);                                                            \
+        stbir__simdf_load2(d, decode + (ofs) * 2);                                                 \
+        stbir__simdf_madd(tot0, tot0, d, c);                                                       \
+    }
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    stbir__simdf_load2(cs, hc + (ofs));                                                            \
+    stbir__simdf_0123to0011(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 2);
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    {                                                                                              \
+        stbir__simdf d;                                                                            \
+        stbir__simdf_load(cs, hc + (ofs));                                                         \
+        stbir__simdf_0123to0011(c, cs);                                                            \
+        stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 2);                                  \
+        stbir__simdf_0123to2222(c, cs);                                                            \
+        stbir__simdf_load2z(d, decode + (ofs) * 2 + 4);                                            \
+        stbir__simdf_madd(tot1, tot1, d, c);                                                       \
+    }
+
+#define stbir__store_output()                                                                      \
+    stbir__simdf_add(tot0, tot0, tot1);                                                            \
+    stbir__simdf_0123to2301(c, tot0);                                                              \
+    stbir__simdf_add(tot0, tot0, c);                                                               \
+    stbir__simdf_store2(output, tot0);                                                             \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 2;
+
+#endif
+
+#else
+
+#define stbir__1_coeff_only()                                                                      \
+    float tota, totb, c;                                                                           \
+    c    = hc[0];                                                                                  \
+    tota = decode[0] * c;                                                                          \
+    totb = decode[1] * c;
+
+#define stbir__2_coeff_only()                                                                      \
+    float tota, totb, c;                                                                           \
+    c    = hc[0];                                                                                  \
+    tota = decode[0] * c;                                                                          \
+    totb = decode[1] * c;                                                                          \
+    c    = hc[1];                                                                                  \
+    tota += decode[2] * c;                                                                         \
+    totb += decode[3] * c;
+
+// this weird order of add matches the simd
+#define stbir__3_coeff_only()                                                                      \
+    float tota, totb, c;                                                                           \
+    c    = hc[0];                                                                                  \
+    tota = decode[0] * c;                                                                          \
+    totb = decode[1] * c;                                                                          \
+    c    = hc[2];                                                                                  \
+    tota += decode[4] * c;                                                                         \
+    totb += decode[5] * c;                                                                         \
+    c = hc[1];                                                                                     \
+    tota += decode[2] * c;                                                                         \
+    totb += decode[3] * c;
+
+#define stbir__store_output_tiny()                                                                 \
+    output[0] = tota;                                                                              \
+    output[1] = totb;                                                                              \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 2;
+
+#define stbir__4_coeff_start()                                                                     \
+    float tota0, tota1, tota2, tota3, totb0, totb1, totb2, totb3, c;                               \
+    c     = hc[0];                                                                                 \
+    tota0 = decode[0] * c;                                                                         \
+    totb0 = decode[1] * c;                                                                         \
+    c     = hc[1];                                                                                 \
+    tota1 = decode[2] * c;                                                                         \
+    totb1 = decode[3] * c;                                                                         \
+    c     = hc[2];                                                                                 \
+    tota2 = decode[4] * c;                                                                         \
+    totb2 = decode[5] * c;                                                                         \
+    c     = hc[3];                                                                                 \
+    tota3 = decode[6] * c;                                                                         \
+    totb3 = decode[7] * c;
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    c = hc[0 + (ofs)];                                                                             \
+    tota0 += decode[0 + (ofs) * 2] * c;                                                            \
+    totb0 += decode[1 + (ofs) * 2] * c;                                                            \
+    c = hc[1 + (ofs)];                                                                             \
+    tota1 += decode[2 + (ofs) * 2] * c;                                                            \
+    totb1 += decode[3 + (ofs) * 2] * c;                                                            \
+    c = hc[2 + (ofs)];                                                                             \
+    tota2 += decode[4 + (ofs) * 2] * c;                                                            \
+    totb2 += decode[5 + (ofs) * 2] * c;                                                            \
+    c = hc[3 + (ofs)];                                                                             \
+    tota3 += decode[6 + (ofs) * 2] * c;                                                            \
+    totb3 += decode[7 + (ofs) * 2] * c;
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    c = hc[0 + (ofs)];                                                                             \
+    tota0 += decode[0 + (ofs) * 2] * c;                                                            \
+    totb0 += decode[1 + (ofs) * 2] * c;
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    c = hc[0 + (ofs)];                                                                             \
+    tota0 += decode[0 + (ofs) * 2] * c;                                                            \
+    totb0 += decode[1 + (ofs) * 2] * c;                                                            \
+    c = hc[1 + (ofs)];                                                                             \
+    tota1 += decode[2 + (ofs) * 2] * c;                                                            \
+    totb1 += decode[3 + (ofs) * 2] * c;
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    c = hc[0 + (ofs)];                                                                             \
+    tota0 += decode[0 + (ofs) * 2] * c;                                                            \
+    totb0 += decode[1 + (ofs) * 2] * c;                                                            \
+    c = hc[1 + (ofs)];                                                                             \
+    tota1 += decode[2 + (ofs) * 2] * c;                                                            \
+    totb1 += decode[3 + (ofs) * 2] * c;                                                            \
+    c = hc[2 + (ofs)];                                                                             \
+    tota2 += decode[4 + (ofs) * 2] * c;                                                            \
+    totb2 += decode[5 + (ofs) * 2] * c;
+
+#define stbir__store_output()                                                                      \
+    output[0] = (tota0 + tota2) + (tota1 + tota3);                                                 \
+    output[1] = (totb0 + totb2) + (totb1 + totb3);                                                 \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 2;
+
+#endif
+
+#define STBIR__horizontal_channels 2
+#define STB_IMAGE_RESIZE_DO_HORIZONTALS
+#include STBIR__HEADER_FILENAME
+
+//=================
+// Do 3 channel horizontal routines
+
+#ifdef STBIR_SIMD
+
+#define stbir__1_coeff_only()                                                                      \
+    stbir__simdf tot, c, d;                                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load1z(c, hc);                                                                    \
+    stbir__simdf_0123to0001(c, c);                                                                 \
+    stbir__simdf_load(d, decode);                                                                  \
+    stbir__simdf_mult(tot, d, c);
+
+#define stbir__2_coeff_only()                                                                      \
+    stbir__simdf tot, c, cs, d;                                                                    \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load2(cs, hc);                                                                    \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_load(d, decode);                                                                  \
+    stbir__simdf_mult(tot, d, c);                                                                  \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_load(d, decode + 3);                                                              \
+    stbir__simdf_madd(tot, tot, d, c);
+
+#define stbir__3_coeff_only()                                                                      \
+    stbir__simdf tot, c, d, cs;                                                                    \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc);                                                                     \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_load(d, decode);                                                                  \
+    stbir__simdf_mult(tot, d, c);                                                                  \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_load(d, decode + 3);                                                              \
+    stbir__simdf_madd(tot, tot, d, c);                                                             \
+    stbir__simdf_0123to2222(c, cs);                                                                \
+    stbir__simdf_load(d, decode + 6);                                                              \
+    stbir__simdf_madd(tot, tot, d, c);
+
+#define stbir__store_output_tiny()                                                                 \
+    stbir__simdf_store2(output, tot);                                                              \
+    stbir__simdf_0123to2301(tot, tot);                                                             \
+    stbir__simdf_store1(output + 2, tot);                                                          \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 3;
+
+#ifdef STBIR_SIMD8
+
+// we're loading from the XXXYYY decode by -1 to get the XXXYYY into different halves of the AVX reg
+// fyi
+#define stbir__4_coeff_start()                                                                     \
+    stbir__simdf8 tot0, tot1, c, cs;                                                               \
+    stbir__simdf t;                                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc);                                                                  \
+    stbir__simdf8_0123to00001111(c, cs);                                                           \
+    stbir__simdf8_mult_mem(tot0, c, decode - 1);                                                   \
+    stbir__simdf8_0123to22223333(c, cs);                                                           \
+    stbir__simdf8_mult_mem(tot1, c, decode + 6 - 1);
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc + (ofs));                                                          \
+    stbir__simdf8_0123to00001111(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 3 - 1);                                 \
+    stbir__simdf8_0123to22223333(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot1, tot1, c, decode + (ofs) * 3 + 6 - 1);
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load1rep4(t, hc + (ofs));                                                         \
+    stbir__simdf8_madd_mem4(tot0, tot0, t, decode + (ofs) * 3 - 1);
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc + (ofs)-2);                                                        \
+    stbir__simdf8_0123to22223333(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 3 - 1);
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc + (ofs));                                                          \
+    stbir__simdf8_0123to00001111(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 3 - 1);                                 \
+    stbir__simdf8_0123to2222(t, cs);                                                               \
+    stbir__simdf8_madd_mem4(tot1, tot1, t, decode + (ofs) * 3 + 6 - 1);
+
+#define stbir__store_output()                                                                      \
+    stbir__simdf8_add(tot0, tot0, tot1);                                                           \
+    stbir__simdf_0123to1230(t, stbir__if_simdf8_cast_to_simdf4(tot0));                             \
+    stbir__simdf8_add4halves(t, t, tot0);                                                          \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 3;                                                                                   \
+    if (output < output_end) {                                                                     \
+        stbir__simdf_store(output - 3, t);                                                         \
+        continue;                                                                                  \
+    }                                                                                              \
+    {                                                                                              \
+        stbir__simdf tt;                                                                           \
+        stbir__simdf_0123to2301(tt, t);                                                            \
+        stbir__simdf_store2(output - 3, t);                                                        \
+        stbir__simdf_store1(output + 2 - 3, tt);                                                   \
+    }                                                                                              \
+    break;
+
+#else
+
+#define stbir__4_coeff_start()                                                                     \
+    stbir__simdf tot0, tot1, tot2, c, cs;                                                          \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc);                                                                     \
+    stbir__simdf_0123to0001(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot0, c, decode);                                                        \
+    stbir__simdf_0123to1122(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot1, c, decode + 4);                                                    \
+    stbir__simdf_0123to2333(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot2, c, decode + 8);
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc + (ofs));                                                             \
+    stbir__simdf_0123to0001(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 3);                                      \
+    stbir__simdf_0123to1122(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 3 + 4);                                  \
+    stbir__simdf_0123to2333(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot2, tot2, c, decode + (ofs) * 3 + 8);
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load1z(c, hc + (ofs));                                                            \
+    stbir__simdf_0123to0001(c, c);                                                                 \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 3);
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    {                                                                                              \
+        stbir__simdf d;                                                                            \
+        STBIR_SIMD_NO_UNROLL(decode);                                                              \
+        stbir__simdf_load2z(cs, hc + (ofs));                                                       \
+        stbir__simdf_0123to0001(c, cs);                                                            \
+        stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 3);                                  \
+        stbir__simdf_0123to1122(c, cs);                                                            \
+        stbir__simdf_load2z(d, decode + (ofs) * 3 + 4);                                            \
+        stbir__simdf_madd(tot1, tot1, c, d);                                                       \
+    }
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    {                                                                                              \
+        stbir__simdf d;                                                                            \
+        STBIR_SIMD_NO_UNROLL(decode);                                                              \
+        stbir__simdf_load(cs, hc + (ofs));                                                         \
+        stbir__simdf_0123to0001(c, cs);                                                            \
+        stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 3);                                  \
+        stbir__simdf_0123to1122(c, cs);                                                            \
+        stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 3 + 4);                              \
+        stbir__simdf_0123to2222(c, cs);                                                            \
+        stbir__simdf_load1z(d, decode + (ofs) * 3 + 8);                                            \
+        stbir__simdf_madd(tot2, tot2, c, d);                                                       \
+    }
+
+#define stbir__store_output()                                                                      \
+    stbir__simdf_0123ABCDto3ABx(c, tot0, tot1);                                                    \
+    stbir__simdf_0123ABCDto23Ax(cs, tot1, tot2);                                                   \
+    stbir__simdf_0123to1230(tot2, tot2);                                                           \
+    stbir__simdf_add(tot0, tot0, cs);                                                              \
+    stbir__simdf_add(c, c, tot2);                                                                  \
+    stbir__simdf_add(tot0, tot0, c);                                                               \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 3;                                                                                   \
+    if (output < output_end) {                                                                     \
+        stbir__simdf_store(output - 3, tot0);                                                      \
+        continue;                                                                                  \
+    }                                                                                              \
+    stbir__simdf_0123to2301(tot1, tot0);                                                           \
+    stbir__simdf_store2(output - 3, tot0);                                                         \
+    stbir__simdf_store1(output + 2 - 3, tot1);                                                     \
+    break;
+
+#endif
+
+#else
+
+#define stbir__1_coeff_only()                                                                      \
+    float tot0, tot1, tot2, c;                                                                     \
+    c    = hc[0];                                                                                  \
+    tot0 = decode[0] * c;                                                                          \
+    tot1 = decode[1] * c;                                                                          \
+    tot2 = decode[2] * c;
+
+#define stbir__2_coeff_only()                                                                      \
+    float tot0, tot1, tot2, c;                                                                     \
+    c    = hc[0];                                                                                  \
+    tot0 = decode[0] * c;                                                                          \
+    tot1 = decode[1] * c;                                                                          \
+    tot2 = decode[2] * c;                                                                          \
+    c    = hc[1];                                                                                  \
+    tot0 += decode[3] * c;                                                                         \
+    tot1 += decode[4] * c;                                                                         \
+    tot2 += decode[5] * c;
+
+#define stbir__3_coeff_only()                                                                      \
+    float tot0, tot1, tot2, c;                                                                     \
+    c    = hc[0];                                                                                  \
+    tot0 = decode[0] * c;                                                                          \
+    tot1 = decode[1] * c;                                                                          \
+    tot2 = decode[2] * c;                                                                          \
+    c    = hc[1];                                                                                  \
+    tot0 += decode[3] * c;                                                                         \
+    tot1 += decode[4] * c;                                                                         \
+    tot2 += decode[5] * c;                                                                         \
+    c = hc[2];                                                                                     \
+    tot0 += decode[6] * c;                                                                         \
+    tot1 += decode[7] * c;                                                                         \
+    tot2 += decode[8] * c;
+
+#define stbir__store_output_tiny()                                                                 \
+    output[0] = tot0;                                                                              \
+    output[1] = tot1;                                                                              \
+    output[2] = tot2;                                                                              \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 3;
+
+#define stbir__4_coeff_start()                                                                     \
+    float tota0, tota1, tota2, totb0, totb1, totb2, totc0, totc1, totc2, totd0, totd1, totd2, c;   \
+    c     = hc[0];                                                                                 \
+    tota0 = decode[0] * c;                                                                         \
+    tota1 = decode[1] * c;                                                                         \
+    tota2 = decode[2] * c;                                                                         \
+    c     = hc[1];                                                                                 \
+    totb0 = decode[3] * c;                                                                         \
+    totb1 = decode[4] * c;                                                                         \
+    totb2 = decode[5] * c;                                                                         \
+    c     = hc[2];                                                                                 \
+    totc0 = decode[6] * c;                                                                         \
+    totc1 = decode[7] * c;                                                                         \
+    totc2 = decode[8] * c;                                                                         \
+    c     = hc[3];                                                                                 \
+    totd0 = decode[9] * c;                                                                         \
+    totd1 = decode[10] * c;                                                                        \
+    totd2 = decode[11] * c;
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    c = hc[0 + (ofs)];                                                                             \
+    tota0 += decode[0 + (ofs) * 3] * c;                                                            \
+    tota1 += decode[1 + (ofs) * 3] * c;                                                            \
+    tota2 += decode[2 + (ofs) * 3] * c;                                                            \
+    c = hc[1 + (ofs)];                                                                             \
+    totb0 += decode[3 + (ofs) * 3] * c;                                                            \
+    totb1 += decode[4 + (ofs) * 3] * c;                                                            \
+    totb2 += decode[5 + (ofs) * 3] * c;                                                            \
+    c = hc[2 + (ofs)];                                                                             \
+    totc0 += decode[6 + (ofs) * 3] * c;                                                            \
+    totc1 += decode[7 + (ofs) * 3] * c;                                                            \
+    totc2 += decode[8 + (ofs) * 3] * c;                                                            \
+    c = hc[3 + (ofs)];                                                                             \
+    totd0 += decode[9 + (ofs) * 3] * c;                                                            \
+    totd1 += decode[10 + (ofs) * 3] * c;                                                           \
+    totd2 += decode[11 + (ofs) * 3] * c;
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    c = hc[0 + (ofs)];                                                                             \
+    tota0 += decode[0 + (ofs) * 3] * c;                                                            \
+    tota1 += decode[1 + (ofs) * 3] * c;                                                            \
+    tota2 += decode[2 + (ofs) * 3] * c;
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    c = hc[0 + (ofs)];                                                                             \
+    tota0 += decode[0 + (ofs) * 3] * c;                                                            \
+    tota1 += decode[1 + (ofs) * 3] * c;                                                            \
+    tota2 += decode[2 + (ofs) * 3] * c;                                                            \
+    c = hc[1 + (ofs)];                                                                             \
+    totb0 += decode[3 + (ofs) * 3] * c;                                                            \
+    totb1 += decode[4 + (ofs) * 3] * c;                                                            \
+    totb2 += decode[5 + (ofs) * 3] * c;
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    c = hc[0 + (ofs)];                                                                             \
+    tota0 += decode[0 + (ofs) * 3] * c;                                                            \
+    tota1 += decode[1 + (ofs) * 3] * c;                                                            \
+    tota2 += decode[2 + (ofs) * 3] * c;                                                            \
+    c = hc[1 + (ofs)];                                                                             \
+    totb0 += decode[3 + (ofs) * 3] * c;                                                            \
+    totb1 += decode[4 + (ofs) * 3] * c;                                                            \
+    totb2 += decode[5 + (ofs) * 3] * c;                                                            \
+    c = hc[2 + (ofs)];                                                                             \
+    totc0 += decode[6 + (ofs) * 3] * c;                                                            \
+    totc1 += decode[7 + (ofs) * 3] * c;                                                            \
+    totc2 += decode[8 + (ofs) * 3] * c;
+
+#define stbir__store_output()                                                                      \
+    output[0] = (tota0 + totc0) + (totb0 + totd0);                                                 \
+    output[1] = (tota1 + totc1) + (totb1 + totd1);                                                 \
+    output[2] = (tota2 + totc2) + (totb2 + totd2);                                                 \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 3;
+
+#endif
+
+#define STBIR__horizontal_channels 3
+#define STB_IMAGE_RESIZE_DO_HORIZONTALS
+#include STBIR__HEADER_FILENAME
+
+//=================
+// Do 4 channel horizontal routines
+
+#ifdef STBIR_SIMD
+
+#define stbir__1_coeff_only()                                                                      \
+    stbir__simdf tot, c;                                                                           \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load1(c, hc);                                                                     \
+    stbir__simdf_0123to0000(c, c);                                                                 \
+    stbir__simdf_mult_mem(tot, c, decode);
+
+#define stbir__2_coeff_only()                                                                      \
+    stbir__simdf tot, c, cs;                                                                       \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load2(cs, hc);                                                                    \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot, c, decode);                                                         \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot, tot, c, decode + 4);
+
+#define stbir__3_coeff_only()                                                                      \
+    stbir__simdf tot, c, cs;                                                                       \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc);                                                                     \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot, c, decode);                                                         \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot, tot, c, decode + 4);                                                \
+    stbir__simdf_0123to2222(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot, tot, c, decode + 8);
+
+#define stbir__store_output_tiny()                                                                 \
+    stbir__simdf_store(output, tot);                                                               \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 4;
+
+#ifdef STBIR_SIMD8
+
+#define stbir__4_coeff_start()                                                                     \
+    stbir__simdf8 tot0, c, cs;                                                                     \
+    stbir__simdf t;                                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc);                                                                  \
+    stbir__simdf8_0123to00001111(c, cs);                                                           \
+    stbir__simdf8_mult_mem(tot0, c, decode);                                                       \
+    stbir__simdf8_0123to22223333(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + 8);
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc + (ofs));                                                          \
+    stbir__simdf8_0123to00001111(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 4);                                     \
+    stbir__simdf8_0123to22223333(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 4 + 8);
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load1rep4(t, hc + (ofs));                                                         \
+    stbir__simdf8_madd_mem4(tot0, tot0, t, decode + (ofs) * 4);
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc + (ofs)-2);                                                        \
+    stbir__simdf8_0123to22223333(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 4);
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc + (ofs));                                                          \
+    stbir__simdf8_0123to00001111(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 4);                                     \
+    stbir__simdf8_0123to2222(t, cs);                                                               \
+    stbir__simdf8_madd_mem4(tot0, tot0, t, decode + (ofs) * 4 + 8);
+
+#define stbir__store_output()                                                                      \
+    stbir__simdf8_add4halves(t, stbir__if_simdf8_cast_to_simdf4(tot0), tot0);                      \
+    stbir__simdf_store(output, t);                                                                 \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 4;
+
+#else
+
+#define stbir__4_coeff_start()                                                                     \
+    stbir__simdf tot0, tot1, c, cs;                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc);                                                                     \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot0, c, decode);                                                        \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot1, c, decode + 4);                                                    \
+    stbir__simdf_0123to2222(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + 8);                                              \
+    stbir__simdf_0123to3333(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + 12);
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc + (ofs));                                                             \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 4);                                      \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 4 + 4);                                  \
+    stbir__simdf_0123to2222(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 4 + 8);                                  \
+    stbir__simdf_0123to3333(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 4 + 12);
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load1(c, hc + (ofs));                                                             \
+    stbir__simdf_0123to0000(c, c);                                                                 \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 4);
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load2(cs, hc + (ofs));                                                            \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 4);                                      \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 4 + 4);
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc + (ofs));                                                             \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 4);                                      \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 4 + 4);                                  \
+    stbir__simdf_0123to2222(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 4 + 8);
+
+#define stbir__store_output()                                                                      \
+    stbir__simdf_add(tot0, tot0, tot1);                                                            \
+    stbir__simdf_store(output, tot0);                                                              \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 4;
+
+#endif
+
+#else
+
+#define stbir__1_coeff_only()                                                                      \
+    float p0, p1, p2, p3, c;                                                                       \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c  = hc[0];                                                                                    \
+    p0 = decode[0] * c;                                                                            \
+    p1 = decode[1] * c;                                                                            \
+    p2 = decode[2] * c;                                                                            \
+    p3 = decode[3] * c;
+
+#define stbir__2_coeff_only()                                                                      \
+    float p0, p1, p2, p3, c;                                                                       \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c  = hc[0];                                                                                    \
+    p0 = decode[0] * c;                                                                            \
+    p1 = decode[1] * c;                                                                            \
+    p2 = decode[2] * c;                                                                            \
+    p3 = decode[3] * c;                                                                            \
+    c  = hc[1];                                                                                    \
+    p0 += decode[4] * c;                                                                           \
+    p1 += decode[5] * c;                                                                           \
+    p2 += decode[6] * c;                                                                           \
+    p3 += decode[7] * c;
+
+#define stbir__3_coeff_only()                                                                      \
+    float p0, p1, p2, p3, c;                                                                       \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c  = hc[0];                                                                                    \
+    p0 = decode[0] * c;                                                                            \
+    p1 = decode[1] * c;                                                                            \
+    p2 = decode[2] * c;                                                                            \
+    p3 = decode[3] * c;                                                                            \
+    c  = hc[1];                                                                                    \
+    p0 += decode[4] * c;                                                                           \
+    p1 += decode[5] * c;                                                                           \
+    p2 += decode[6] * c;                                                                           \
+    p3 += decode[7] * c;                                                                           \
+    c = hc[2];                                                                                     \
+    p0 += decode[8] * c;                                                                           \
+    p1 += decode[9] * c;                                                                           \
+    p2 += decode[10] * c;                                                                          \
+    p3 += decode[11] * c;
+
+#define stbir__store_output_tiny()                                                                 \
+    output[0] = p0;                                                                                \
+    output[1] = p1;                                                                                \
+    output[2] = p2;                                                                                \
+    output[3] = p3;                                                                                \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 4;
+
+#define stbir__4_coeff_start()                                                                     \
+    float x0, x1, x2, x3, y0, y1, y2, y3, c;                                                       \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c  = hc[0];                                                                                    \
+    x0 = decode[0] * c;                                                                            \
+    x1 = decode[1] * c;                                                                            \
+    x2 = decode[2] * c;                                                                            \
+    x3 = decode[3] * c;                                                                            \
+    c  = hc[1];                                                                                    \
+    y0 = decode[4] * c;                                                                            \
+    y1 = decode[5] * c;                                                                            \
+    y2 = decode[6] * c;                                                                            \
+    y3 = decode[7] * c;                                                                            \
+    c  = hc[2];                                                                                    \
+    x0 += decode[8] * c;                                                                           \
+    x1 += decode[9] * c;                                                                           \
+    x2 += decode[10] * c;                                                                          \
+    x3 += decode[11] * c;                                                                          \
+    c = hc[3];                                                                                     \
+    y0 += decode[12] * c;                                                                          \
+    y1 += decode[13] * c;                                                                          \
+    y2 += decode[14] * c;                                                                          \
+    y3 += decode[15] * c;
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c = hc[0 + (ofs)];                                                                             \
+    x0 += decode[0 + (ofs) * 4] * c;                                                               \
+    x1 += decode[1 + (ofs) * 4] * c;                                                               \
+    x2 += decode[2 + (ofs) * 4] * c;                                                               \
+    x3 += decode[3 + (ofs) * 4] * c;                                                               \
+    c = hc[1 + (ofs)];                                                                             \
+    y0 += decode[4 + (ofs) * 4] * c;                                                               \
+    y1 += decode[5 + (ofs) * 4] * c;                                                               \
+    y2 += decode[6 + (ofs) * 4] * c;                                                               \
+    y3 += decode[7 + (ofs) * 4] * c;                                                               \
+    c = hc[2 + (ofs)];                                                                             \
+    x0 += decode[8 + (ofs) * 4] * c;                                                               \
+    x1 += decode[9 + (ofs) * 4] * c;                                                               \
+    x2 += decode[10 + (ofs) * 4] * c;                                                              \
+    x3 += decode[11 + (ofs) * 4] * c;                                                              \
+    c = hc[3 + (ofs)];                                                                             \
+    y0 += decode[12 + (ofs) * 4] * c;                                                              \
+    y1 += decode[13 + (ofs) * 4] * c;                                                              \
+    y2 += decode[14 + (ofs) * 4] * c;                                                              \
+    y3 += decode[15 + (ofs) * 4] * c;
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c = hc[0 + (ofs)];                                                                             \
+    x0 += decode[0 + (ofs) * 4] * c;                                                               \
+    x1 += decode[1 + (ofs) * 4] * c;                                                               \
+    x2 += decode[2 + (ofs) * 4] * c;                                                               \
+    x3 += decode[3 + (ofs) * 4] * c;
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c = hc[0 + (ofs)];                                                                             \
+    x0 += decode[0 + (ofs) * 4] * c;                                                               \
+    x1 += decode[1 + (ofs) * 4] * c;                                                               \
+    x2 += decode[2 + (ofs) * 4] * c;                                                               \
+    x3 += decode[3 + (ofs) * 4] * c;                                                               \
+    c = hc[1 + (ofs)];                                                                             \
+    y0 += decode[4 + (ofs) * 4] * c;                                                               \
+    y1 += decode[5 + (ofs) * 4] * c;                                                               \
+    y2 += decode[6 + (ofs) * 4] * c;                                                               \
+    y3 += decode[7 + (ofs) * 4] * c;
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c = hc[0 + (ofs)];                                                                             \
+    x0 += decode[0 + (ofs) * 4] * c;                                                               \
+    x1 += decode[1 + (ofs) * 4] * c;                                                               \
+    x2 += decode[2 + (ofs) * 4] * c;                                                               \
+    x3 += decode[3 + (ofs) * 4] * c;                                                               \
+    c = hc[1 + (ofs)];                                                                             \
+    y0 += decode[4 + (ofs) * 4] * c;                                                               \
+    y1 += decode[5 + (ofs) * 4] * c;                                                               \
+    y2 += decode[6 + (ofs) * 4] * c;                                                               \
+    y3 += decode[7 + (ofs) * 4] * c;                                                               \
+    c = hc[2 + (ofs)];                                                                             \
+    x0 += decode[8 + (ofs) * 4] * c;                                                               \
+    x1 += decode[9 + (ofs) * 4] * c;                                                               \
+    x2 += decode[10 + (ofs) * 4] * c;                                                              \
+    x3 += decode[11 + (ofs) * 4] * c;
+
+#define stbir__store_output()                                                                      \
+    output[0] = x0 + y0;                                                                           \
+    output[1] = x1 + y1;                                                                           \
+    output[2] = x2 + y2;                                                                           \
+    output[3] = x3 + y3;                                                                           \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 4;
+
+#endif
+
+#define STBIR__horizontal_channels 4
+#define STB_IMAGE_RESIZE_DO_HORIZONTALS
+#include STBIR__HEADER_FILENAME
+
+//=================
+// Do 7 channel horizontal routines
+
+#ifdef STBIR_SIMD
+
+#define stbir__1_coeff_only()                                                                      \
+    stbir__simdf tot0, tot1, c;                                                                    \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load1(c, hc);                                                                     \
+    stbir__simdf_0123to0000(c, c);                                                                 \
+    stbir__simdf_mult_mem(tot0, c, decode);                                                        \
+    stbir__simdf_mult_mem(tot1, c, decode + 3);
+
+#define stbir__2_coeff_only()                                                                      \
+    stbir__simdf tot0, tot1, c, cs;                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load2(cs, hc);                                                                    \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot0, c, decode);                                                        \
+    stbir__simdf_mult_mem(tot1, c, decode + 3);                                                    \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + 7);                                              \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + 10);
+
+#define stbir__3_coeff_only()                                                                      \
+    stbir__simdf tot0, tot1, c, cs;                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc);                                                                     \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot0, c, decode);                                                        \
+    stbir__simdf_mult_mem(tot1, c, decode + 3);                                                    \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + 7);                                              \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + 10);                                             \
+    stbir__simdf_0123to2222(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + 14);                                             \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + 17);
+
+#define stbir__store_output_tiny()                                                                 \
+    stbir__simdf_store(output + 3, tot1);                                                          \
+    stbir__simdf_store(output, tot0);                                                              \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 7;
+
+#ifdef STBIR_SIMD8
+
+#define stbir__4_coeff_start()                                                                     \
+    stbir__simdf8 tot0, tot1, c, cs;                                                               \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc);                                                                  \
+    stbir__simdf8_0123to00000000(c, cs);                                                           \
+    stbir__simdf8_mult_mem(tot0, c, decode);                                                       \
+    stbir__simdf8_0123to11111111(c, cs);                                                           \
+    stbir__simdf8_mult_mem(tot1, c, decode + 7);                                                   \
+    stbir__simdf8_0123to22222222(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + 14);                                            \
+    stbir__simdf8_0123to33333333(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot1, tot1, c, decode + 21);
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc + (ofs));                                                          \
+    stbir__simdf8_0123to00000000(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 7);                                     \
+    stbir__simdf8_0123to11111111(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot1, tot1, c, decode + (ofs) * 7 + 7);                                 \
+    stbir__simdf8_0123to22222222(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 7 + 14);                                \
+    stbir__simdf8_0123to33333333(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot1, tot1, c, decode + (ofs) * 7 + 21);
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load1b(c, hc + (ofs));                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 7);
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load1b(c, hc + (ofs));                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 7);                                     \
+    stbir__simdf8_load1b(c, hc + (ofs) + 1);                                                       \
+    stbir__simdf8_madd_mem(tot1, tot1, c, decode + (ofs) * 7 + 7);
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf8_load4b(cs, hc + (ofs));                                                          \
+    stbir__simdf8_0123to00000000(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 7);                                     \
+    stbir__simdf8_0123to11111111(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot1, tot1, c, decode + (ofs) * 7 + 7);                                 \
+    stbir__simdf8_0123to22222222(c, cs);                                                           \
+    stbir__simdf8_madd_mem(tot0, tot0, c, decode + (ofs) * 7 + 14);
+
+#define stbir__store_output()                                                                      \
+    stbir__simdf8_add(tot0, tot0, tot1);                                                           \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 7;                                                                                   \
+    if (output < output_end) {                                                                     \
+        stbir__simdf8_store(output - 7, tot0);                                                     \
+        continue;                                                                                  \
+    }                                                                                              \
+    stbir__simdf_store(output - 7 + 3,                                                             \
+                       stbir__simdf_swiz(stbir__simdf8_gettop4(tot0), 0, 0, 1, 2));                \
+    stbir__simdf_store(output - 7, stbir__if_simdf8_cast_to_simdf4(tot0));                         \
+    break;
+
+#else
+
+#define stbir__4_coeff_start()                                                                     \
+    stbir__simdf tot0, tot1, tot2, tot3, c, cs;                                                    \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc);                                                                     \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot0, c, decode);                                                        \
+    stbir__simdf_mult_mem(tot1, c, decode + 3);                                                    \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_mult_mem(tot2, c, decode + 7);                                                    \
+    stbir__simdf_mult_mem(tot3, c, decode + 10);                                                   \
+    stbir__simdf_0123to2222(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + 14);                                             \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + 17);                                             \
+    stbir__simdf_0123to3333(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot2, tot2, c, decode + 21);                                             \
+    stbir__simdf_madd_mem(tot3, tot3, c, decode + 24);
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc + (ofs));                                                             \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 7);                                      \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 7 + 3);                                  \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot2, tot2, c, decode + (ofs) * 7 + 7);                                  \
+    stbir__simdf_madd_mem(tot3, tot3, c, decode + (ofs) * 7 + 10);                                 \
+    stbir__simdf_0123to2222(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 7 + 14);                                 \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 7 + 17);                                 \
+    stbir__simdf_0123to3333(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot2, tot2, c, decode + (ofs) * 7 + 21);                                 \
+    stbir__simdf_madd_mem(tot3, tot3, c, decode + (ofs) * 7 + 24);
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load1(c, hc + (ofs));                                                             \
+    stbir__simdf_0123to0000(c, c);                                                                 \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 7);                                      \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 7 + 3);
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load2(cs, hc + (ofs));                                                            \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 7);                                      \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 7 + 3);                                  \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot2, tot2, c, decode + (ofs) * 7 + 7);                                  \
+    stbir__simdf_madd_mem(tot3, tot3, c, decode + (ofs) * 7 + 10);
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    stbir__simdf_load(cs, hc + (ofs));                                                             \
+    stbir__simdf_0123to0000(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 7);                                      \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 7 + 3);                                  \
+    stbir__simdf_0123to1111(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot2, tot2, c, decode + (ofs) * 7 + 7);                                  \
+    stbir__simdf_madd_mem(tot3, tot3, c, decode + (ofs) * 7 + 10);                                 \
+    stbir__simdf_0123to2222(c, cs);                                                                \
+    stbir__simdf_madd_mem(tot0, tot0, c, decode + (ofs) * 7 + 14);                                 \
+    stbir__simdf_madd_mem(tot1, tot1, c, decode + (ofs) * 7 + 17);
+
+#define stbir__store_output()                                                                      \
+    stbir__simdf_add(tot0, tot0, tot2);                                                            \
+    stbir__simdf_add(tot1, tot1, tot3);                                                            \
+    stbir__simdf_store(output + 3, tot1);                                                          \
+    stbir__simdf_store(output, tot0);                                                              \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 7;
+
+#endif
+
+#else
+
+#define stbir__1_coeff_only()                                                                      \
+    float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c;                                             \
+    c    = hc[0];                                                                                  \
+    tot0 = decode[0] * c;                                                                          \
+    tot1 = decode[1] * c;                                                                          \
+    tot2 = decode[2] * c;                                                                          \
+    tot3 = decode[3] * c;                                                                          \
+    tot4 = decode[4] * c;                                                                          \
+    tot5 = decode[5] * c;                                                                          \
+    tot6 = decode[6] * c;
+
+#define stbir__2_coeff_only()                                                                      \
+    float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c;                                             \
+    c    = hc[0];                                                                                  \
+    tot0 = decode[0] * c;                                                                          \
+    tot1 = decode[1] * c;                                                                          \
+    tot2 = decode[2] * c;                                                                          \
+    tot3 = decode[3] * c;                                                                          \
+    tot4 = decode[4] * c;                                                                          \
+    tot5 = decode[5] * c;                                                                          \
+    tot6 = decode[6] * c;                                                                          \
+    c    = hc[1];                                                                                  \
+    tot0 += decode[7] * c;                                                                         \
+    tot1 += decode[8] * c;                                                                         \
+    tot2 += decode[9] * c;                                                                         \
+    tot3 += decode[10] * c;                                                                        \
+    tot4 += decode[11] * c;                                                                        \
+    tot5 += decode[12] * c;                                                                        \
+    tot6 += decode[13] * c;
+
+#define stbir__3_coeff_only()                                                                      \
+    float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c;                                             \
+    c    = hc[0];                                                                                  \
+    tot0 = decode[0] * c;                                                                          \
+    tot1 = decode[1] * c;                                                                          \
+    tot2 = decode[2] * c;                                                                          \
+    tot3 = decode[3] * c;                                                                          \
+    tot4 = decode[4] * c;                                                                          \
+    tot5 = decode[5] * c;                                                                          \
+    tot6 = decode[6] * c;                                                                          \
+    c    = hc[1];                                                                                  \
+    tot0 += decode[7] * c;                                                                         \
+    tot1 += decode[8] * c;                                                                         \
+    tot2 += decode[9] * c;                                                                         \
+    tot3 += decode[10] * c;                                                                        \
+    tot4 += decode[11] * c;                                                                        \
+    tot5 += decode[12] * c;                                                                        \
+    tot6 += decode[13] * c;                                                                        \
+    c = hc[2];                                                                                     \
+    tot0 += decode[14] * c;                                                                        \
+    tot1 += decode[15] * c;                                                                        \
+    tot2 += decode[16] * c;                                                                        \
+    tot3 += decode[17] * c;                                                                        \
+    tot4 += decode[18] * c;                                                                        \
+    tot5 += decode[19] * c;                                                                        \
+    tot6 += decode[20] * c;
+
+#define stbir__store_output_tiny()                                                                 \
+    output[0] = tot0;                                                                              \
+    output[1] = tot1;                                                                              \
+    output[2] = tot2;                                                                              \
+    output[3] = tot3;                                                                              \
+    output[4] = tot4;                                                                              \
+    output[5] = tot5;                                                                              \
+    output[6] = tot6;                                                                              \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 7;
+
+#define stbir__4_coeff_start()                                                                     \
+    float x0, x1, x2, x3, x4, x5, x6, y0, y1, y2, y3, y4, y5, y6, c;                               \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c  = hc[0];                                                                                    \
+    x0 = decode[0] * c;                                                                            \
+    x1 = decode[1] * c;                                                                            \
+    x2 = decode[2] * c;                                                                            \
+    x3 = decode[3] * c;                                                                            \
+    x4 = decode[4] * c;                                                                            \
+    x5 = decode[5] * c;                                                                            \
+    x6 = decode[6] * c;                                                                            \
+    c  = hc[1];                                                                                    \
+    y0 = decode[7] * c;                                                                            \
+    y1 = decode[8] * c;                                                                            \
+    y2 = decode[9] * c;                                                                            \
+    y3 = decode[10] * c;                                                                           \
+    y4 = decode[11] * c;                                                                           \
+    y5 = decode[12] * c;                                                                           \
+    y6 = decode[13] * c;                                                                           \
+    c  = hc[2];                                                                                    \
+    x0 += decode[14] * c;                                                                          \
+    x1 += decode[15] * c;                                                                          \
+    x2 += decode[16] * c;                                                                          \
+    x3 += decode[17] * c;                                                                          \
+    x4 += decode[18] * c;                                                                          \
+    x5 += decode[19] * c;                                                                          \
+    x6 += decode[20] * c;                                                                          \
+    c = hc[3];                                                                                     \
+    y0 += decode[21] * c;                                                                          \
+    y1 += decode[22] * c;                                                                          \
+    y2 += decode[23] * c;                                                                          \
+    y3 += decode[24] * c;                                                                          \
+    y4 += decode[25] * c;                                                                          \
+    y5 += decode[26] * c;                                                                          \
+    y6 += decode[27] * c;
+
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c = hc[0 + (ofs)];                                                                             \
+    x0 += decode[0 + (ofs) * 7] * c;                                                               \
+    x1 += decode[1 + (ofs) * 7] * c;                                                               \
+    x2 += decode[2 + (ofs) * 7] * c;                                                               \
+    x3 += decode[3 + (ofs) * 7] * c;                                                               \
+    x4 += decode[4 + (ofs) * 7] * c;                                                               \
+    x5 += decode[5 + (ofs) * 7] * c;                                                               \
+    x6 += decode[6 + (ofs) * 7] * c;                                                               \
+    c = hc[1 + (ofs)];                                                                             \
+    y0 += decode[7 + (ofs) * 7] * c;                                                               \
+    y1 += decode[8 + (ofs) * 7] * c;                                                               \
+    y2 += decode[9 + (ofs) * 7] * c;                                                               \
+    y3 += decode[10 + (ofs) * 7] * c;                                                              \
+    y4 += decode[11 + (ofs) * 7] * c;                                                              \
+    y5 += decode[12 + (ofs) * 7] * c;                                                              \
+    y6 += decode[13 + (ofs) * 7] * c;                                                              \
+    c = hc[2 + (ofs)];                                                                             \
+    x0 += decode[14 + (ofs) * 7] * c;                                                              \
+    x1 += decode[15 + (ofs) * 7] * c;                                                              \
+    x2 += decode[16 + (ofs) * 7] * c;                                                              \
+    x3 += decode[17 + (ofs) * 7] * c;                                                              \
+    x4 += decode[18 + (ofs) * 7] * c;                                                              \
+    x5 += decode[19 + (ofs) * 7] * c;                                                              \
+    x6 += decode[20 + (ofs) * 7] * c;                                                              \
+    c = hc[3 + (ofs)];                                                                             \
+    y0 += decode[21 + (ofs) * 7] * c;                                                              \
+    y1 += decode[22 + (ofs) * 7] * c;                                                              \
+    y2 += decode[23 + (ofs) * 7] * c;                                                              \
+    y3 += decode[24 + (ofs) * 7] * c;                                                              \
+    y4 += decode[25 + (ofs) * 7] * c;                                                              \
+    y5 += decode[26 + (ofs) * 7] * c;                                                              \
+    y6 += decode[27 + (ofs) * 7] * c;
+
+#define stbir__1_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c = hc[0 + (ofs)];                                                                             \
+    x0 += decode[0 + (ofs) * 7] * c;                                                               \
+    x1 += decode[1 + (ofs) * 7] * c;                                                               \
+    x2 += decode[2 + (ofs) * 7] * c;                                                               \
+    x3 += decode[3 + (ofs) * 7] * c;                                                               \
+    x4 += decode[4 + (ofs) * 7] * c;                                                               \
+    x5 += decode[5 + (ofs) * 7] * c;                                                               \
+    x6 += decode[6 + (ofs) * 7] * c;
+
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c = hc[0 + (ofs)];                                                                             \
+    x0 += decode[0 + (ofs) * 7] * c;                                                               \
+    x1 += decode[1 + (ofs) * 7] * c;                                                               \
+    x2 += decode[2 + (ofs) * 7] * c;                                                               \
+    x3 += decode[3 + (ofs) * 7] * c;                                                               \
+    x4 += decode[4 + (ofs) * 7] * c;                                                               \
+    x5 += decode[5 + (ofs) * 7] * c;                                                               \
+    x6 += decode[6 + (ofs) * 7] * c;                                                               \
+    c = hc[1 + (ofs)];                                                                             \
+    y0 += decode[7 + (ofs) * 7] * c;                                                               \
+    y1 += decode[8 + (ofs) * 7] * c;                                                               \
+    y2 += decode[9 + (ofs) * 7] * c;                                                               \
+    y3 += decode[10 + (ofs) * 7] * c;                                                              \
+    y4 += decode[11 + (ofs) * 7] * c;                                                              \
+    y5 += decode[12 + (ofs) * 7] * c;                                                              \
+    y6 += decode[13 + (ofs) * 7] * c;
+
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    STBIR_SIMD_NO_UNROLL(decode);                                                                  \
+    c = hc[0 + (ofs)];                                                                             \
+    x0 += decode[0 + (ofs) * 7] * c;                                                               \
+    x1 += decode[1 + (ofs) * 7] * c;                                                               \
+    x2 += decode[2 + (ofs) * 7] * c;                                                               \
+    x3 += decode[3 + (ofs) * 7] * c;                                                               \
+    x4 += decode[4 + (ofs) * 7] * c;                                                               \
+    x5 += decode[5 + (ofs) * 7] * c;                                                               \
+    x6 += decode[6 + (ofs) * 7] * c;                                                               \
+    c = hc[1 + (ofs)];                                                                             \
+    y0 += decode[7 + (ofs) * 7] * c;                                                               \
+    y1 += decode[8 + (ofs) * 7] * c;                                                               \
+    y2 += decode[9 + (ofs) * 7] * c;                                                               \
+    y3 += decode[10 + (ofs) * 7] * c;                                                              \
+    y4 += decode[11 + (ofs) * 7] * c;                                                              \
+    y5 += decode[12 + (ofs) * 7] * c;                                                              \
+    y6 += decode[13 + (ofs) * 7] * c;                                                              \
+    c = hc[2 + (ofs)];                                                                             \
+    x0 += decode[14 + (ofs) * 7] * c;                                                              \
+    x1 += decode[15 + (ofs) * 7] * c;                                                              \
+    x2 += decode[16 + (ofs) * 7] * c;                                                              \
+    x3 += decode[17 + (ofs) * 7] * c;                                                              \
+    x4 += decode[18 + (ofs) * 7] * c;                                                              \
+    x5 += decode[19 + (ofs) * 7] * c;                                                              \
+    x6 += decode[20 + (ofs) * 7] * c;
+
+#define stbir__store_output()                                                                      \
+    output[0] = x0 + y0;                                                                           \
+    output[1] = x1 + y1;                                                                           \
+    output[2] = x2 + y2;                                                                           \
+    output[3] = x3 + y3;                                                                           \
+    output[4] = x4 + y4;                                                                           \
+    output[5] = x5 + y5;                                                                           \
+    output[6] = x6 + y6;                                                                           \
+    horizontal_coefficients += coefficient_width;                                                  \
+    ++horizontal_contributors;                                                                     \
+    output += 7;
+
+#endif
+
+#define STBIR__horizontal_channels 7
+#define STB_IMAGE_RESIZE_DO_HORIZONTALS
+#include STBIR__HEADER_FILENAME
+
+// include all of the vertical resamplers (both scatter and gather versions)
+
+#define STBIR__vertical_channels 1
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 1
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 2
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 2
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 3
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 3
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 4
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 4
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 5
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 5
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 6
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 6
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 7
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 7
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 8
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 8
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+typedef void STBIR_VERTICAL_GATHERFUNC(float *output, float const *coeffs, float const **inputs,
+                                       float const *input0_end);
+
+static STBIR_VERTICAL_GATHERFUNC *stbir__vertical_gathers[8] = {
+    stbir__vertical_gather_with_1_coeffs, stbir__vertical_gather_with_2_coeffs,
+    stbir__vertical_gather_with_3_coeffs, stbir__vertical_gather_with_4_coeffs,
+    stbir__vertical_gather_with_5_coeffs, stbir__vertical_gather_with_6_coeffs,
+    stbir__vertical_gather_with_7_coeffs, stbir__vertical_gather_with_8_coeffs};
+
+static STBIR_VERTICAL_GATHERFUNC *stbir__vertical_gathers_continues[8] = {
+    stbir__vertical_gather_with_1_coeffs_cont, stbir__vertical_gather_with_2_coeffs_cont,
+    stbir__vertical_gather_with_3_coeffs_cont, stbir__vertical_gather_with_4_coeffs_cont,
+    stbir__vertical_gather_with_5_coeffs_cont, stbir__vertical_gather_with_6_coeffs_cont,
+    stbir__vertical_gather_with_7_coeffs_cont, stbir__vertical_gather_with_8_coeffs_cont};
+
+typedef void STBIR_VERTICAL_SCATTERFUNC(float **outputs, float const *coeffs, float const *input,
+                                        float const *input_end);
+
+static STBIR_VERTICAL_SCATTERFUNC *stbir__vertical_scatter_sets[8] = {
+    stbir__vertical_scatter_with_1_coeffs, stbir__vertical_scatter_with_2_coeffs,
+    stbir__vertical_scatter_with_3_coeffs, stbir__vertical_scatter_with_4_coeffs,
+    stbir__vertical_scatter_with_5_coeffs, stbir__vertical_scatter_with_6_coeffs,
+    stbir__vertical_scatter_with_7_coeffs, stbir__vertical_scatter_with_8_coeffs};
+
+static STBIR_VERTICAL_SCATTERFUNC *stbir__vertical_scatter_blends[8] = {
+    stbir__vertical_scatter_with_1_coeffs_cont, stbir__vertical_scatter_with_2_coeffs_cont,
+    stbir__vertical_scatter_with_3_coeffs_cont, stbir__vertical_scatter_with_4_coeffs_cont,
+    stbir__vertical_scatter_with_5_coeffs_cont, stbir__vertical_scatter_with_6_coeffs_cont,
+    stbir__vertical_scatter_with_7_coeffs_cont, stbir__vertical_scatter_with_8_coeffs_cont};
+
+static void stbir__encode_scanline(stbir__info const *stbir_info, void *output_buffer_data,
+                                   float *encode_buffer,
+                                   int row STBIR_ONLY_PROFILE_GET_SPLIT_INFO) {
+    int num_pixels           = stbir_info->horizontal.scale_info.output_sub_size;
+    int channels             = stbir_info->channels;
+    int width_times_channels = num_pixels * channels;
+    void *output_buffer;
+
+    // un-alpha weight if we need to
+    if (stbir_info->alpha_unweight) {
+        STBIR_PROFILE_START(unalpha);
+        stbir_info->alpha_unweight(encode_buffer, width_times_channels);
+        STBIR_PROFILE_END(unalpha);
+    }
+
+    // write directly into output by default
+    output_buffer = output_buffer_data;
+
+    // if we have an output callback, we first convert the decode buffer in place (and then hand
+    // that to the callback)
+    if (stbir_info->out_pixels_cb)
+        output_buffer = encode_buffer;
+
+    STBIR_PROFILE_START(encode);
+    // convert into the output buffer
+    stbir_info->encode_pixels(output_buffer, width_times_channels, encode_buffer);
+    STBIR_PROFILE_END(encode);
+
+    // if we have an output callback, call it to send the data
+    if (stbir_info->out_pixels_cb)
+        stbir_info->out_pixels_cb(output_buffer, num_pixels, row, stbir_info->user_data);
+}
+
+// Get the ring buffer pointer for an index
+static float *stbir__get_ring_buffer_entry(stbir__info const *stbir_info,
+                                           stbir__per_split_info const *split_info, int index) {
+    STBIR_ASSERT(index < stbir_info->ring_buffer_num_entries);
+
+#ifdef STBIR__SEPARATE_ALLOCATIONS
+    return split_info->ring_buffers[index];
+#else
+    return (float *)(((char *)split_info->ring_buffer) +
+                     (index * stbir_info->ring_buffer_length_bytes));
+#endif
+}
+
+// Get the specified scan line from the ring buffer
+static float *stbir__get_ring_buffer_scanline(stbir__info const *stbir_info,
+                                              stbir__per_split_info const *split_info,
+                                              int get_scanline) {
+    int ring_buffer_index = (split_info->ring_buffer_begin_index +
+                             (get_scanline - split_info->ring_buffer_first_scanline)) %
+                            stbir_info->ring_buffer_num_entries;
+    return stbir__get_ring_buffer_entry(stbir_info, split_info, ring_buffer_index);
+}
+
+static void
+stbir__resample_horizontal_gather(stbir__info const *stbir_info, float *output_buffer,
+                                  float const *input_buffer STBIR_ONLY_PROFILE_GET_SPLIT_INFO) {
+    float const *decode_buffer = input_buffer - (stbir_info->scanline_extents.conservative.n0 *
+                                                 stbir_info->effective_channels);
+
+    STBIR_PROFILE_START(horizontal);
+    if ((stbir_info->horizontal.filter_enum == STBIR_FILTER_POINT_SAMPLE) &&
+        (stbir_info->horizontal.scale_info.scale == 1.0f))
+        STBIR_MEMCPY(output_buffer, input_buffer,
+                     stbir_info->horizontal.scale_info.output_sub_size * sizeof(float) *
+                         stbir_info->effective_channels);
+    else
+        stbir_info->horizontal_gather_channels(
+            output_buffer, stbir_info->horizontal.scale_info.output_sub_size, decode_buffer,
+            stbir_info->horizontal.contributors, stbir_info->horizontal.coefficients,
+            stbir_info->horizontal.coefficient_width);
+    STBIR_PROFILE_END(horizontal);
+}
+
+static void stbir__resample_vertical_gather(stbir__info const *stbir_info,
+                                            stbir__per_split_info *split_info, int n,
+                                            int contrib_n0, int contrib_n1,
+                                            float const *vertical_coefficients) {
+    float *encode_buffer     = split_info->vertical_buffer;
+    float *decode_buffer     = split_info->decode_buffer;
+    int vertical_first       = stbir_info->vertical_first;
+    int width                = (vertical_first) ? (stbir_info->scanline_extents.conservative.n1 -
+                                    stbir_info->scanline_extents.conservative.n0 + 1)
+                                                : stbir_info->horizontal.scale_info.output_sub_size;
+    int width_times_channels = stbir_info->effective_channels * width;
+
+    STBIR_ASSERT(stbir_info->vertical.is_gather);
+
+    // loop over the contributing scanlines and scale into the buffer
+    STBIR_PROFILE_START(vertical);
+    {
+        int k = 0, total = contrib_n1 - contrib_n0 + 1;
+        STBIR_ASSERT(total > 0);
+        do {
+            float const *inputs[8];
+            int i, cnt = total;
+            if (cnt > 8)
+                cnt = 8;
+            for (i = 0; i < cnt; i++)
+                inputs[i] =
+                    stbir__get_ring_buffer_scanline(stbir_info, split_info, k + i + contrib_n0);
+
+            // call the N scanlines at a time function (up to 8 scanlines of blending at once)
+            ((k == 0) ? stbir__vertical_gathers : stbir__vertical_gathers_continues)[cnt - 1](
+                (vertical_first) ? decode_buffer : encode_buffer, vertical_coefficients + k, inputs,
+                inputs[0] + width_times_channels);
+            k += cnt;
+            total -= cnt;
+        } while (total);
+    }
+    STBIR_PROFILE_END(vertical);
+
+    if (vertical_first) {
+        // Now resample the gathered vertical data in the horizontal axis into the encode buffer
+        stbir__resample_horizontal_gather(stbir_info, encode_buffer,
+                                          decode_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO);
+    }
+
+    stbir__encode_scanline(stbir_info,
+                           ((char *)stbir_info->output_data) +
+                               ((size_t)n * (size_t)stbir_info->output_stride_bytes),
+                           encode_buffer, n STBIR_ONLY_PROFILE_SET_SPLIT_INFO);
+}
+
+static void stbir__decode_and_resample_for_vertical_gather_loop(stbir__info const *stbir_info,
+                                                                stbir__per_split_info *split_info,
+                                                                int n) {
+    int ring_buffer_index;
+    float *ring_buffer;
+
+    // Decode the nth scanline from the source image into the decode buffer.
+    stbir__decode_scanline(stbir_info, n,
+                           split_info->decode_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO);
+
+    // update new end scanline
+    split_info->ring_buffer_last_scanline = n;
+
+    // get ring buffer
+    ring_buffer_index =
+        (split_info->ring_buffer_begin_index +
+         (split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline)) %
+        stbir_info->ring_buffer_num_entries;
+    ring_buffer = stbir__get_ring_buffer_entry(stbir_info, split_info, ring_buffer_index);
+
+    // Now resample it into the ring buffer.
+    stbir__resample_horizontal_gather(stbir_info, ring_buffer,
+                                      split_info->decode_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO);
+
+    // Now it's sitting in the ring buffer ready to be used as source for the vertical sampling.
+}
+
+static void stbir__vertical_gather_loop(stbir__info const *stbir_info,
+                                        stbir__per_split_info *split_info, int split_count) {
+    int y, start_output_y, end_output_y;
+    stbir__contributors *vertical_contributors = stbir_info->vertical.contributors;
+    float const *vertical_coefficients         = stbir_info->vertical.coefficients;
+
+    STBIR_ASSERT(stbir_info->vertical.is_gather);
+
+    start_output_y = split_info->start_output_y;
+    end_output_y   = split_info[split_count - 1].end_output_y;
+
+    vertical_contributors += start_output_y;
+    vertical_coefficients += start_output_y * stbir_info->vertical.coefficient_width;
+
+    // initialize the ring buffer for gathering
+    split_info->ring_buffer_begin_index    = 0;
+    split_info->ring_buffer_first_scanline = vertical_contributors->n0;
+    split_info->ring_buffer_last_scanline =
+        split_info->ring_buffer_first_scanline - 1;  // means "empty"
+
+    for (y = start_output_y; y < end_output_y; y++) {
+        int in_first_scanline, in_last_scanline;
+
+        in_first_scanline = vertical_contributors->n0;
+        in_last_scanline  = vertical_contributors->n1;
+
+        // make sure the indexing hasn't broken
+        STBIR_ASSERT(in_first_scanline >= split_info->ring_buffer_first_scanline);
+
+        // Load in new scanlines
+        while (in_last_scanline > split_info->ring_buffer_last_scanline) {
+            STBIR_ASSERT((split_info->ring_buffer_last_scanline -
+                          split_info->ring_buffer_first_scanline + 1) <=
+                         stbir_info->ring_buffer_num_entries);
+
+            // make sure there was room in the ring buffer when we add new scanlines
+            if ((split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline +
+                 1) == stbir_info->ring_buffer_num_entries) {
+                split_info->ring_buffer_first_scanline++;
+                split_info->ring_buffer_begin_index++;
+            }
+
+            if (stbir_info->vertical_first) {
+                float *ring_buffer = stbir__get_ring_buffer_scanline(
+                    stbir_info, split_info, ++split_info->ring_buffer_last_scanline);
+                // Decode the nth scanline from the source image into the decode buffer.
+                stbir__decode_scanline(stbir_info, split_info->ring_buffer_last_scanline,
+                                       ring_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO);
+            } else {
+                stbir__decode_and_resample_for_vertical_gather_loop(
+                    stbir_info, split_info, split_info->ring_buffer_last_scanline + 1);
+            }
+        }
+
+        // Now all buffers should be ready to write a row of vertical sampling, so do it.
+        stbir__resample_vertical_gather(stbir_info, split_info, y, in_first_scanline,
+                                        in_last_scanline, vertical_coefficients);
+
+        ++vertical_contributors;
+        vertical_coefficients += stbir_info->vertical.coefficient_width;
+    }
+}
+
+#define STBIR__FLOAT_EMPTY_MARKER         3.0e+38F
+#define STBIR__FLOAT_BUFFER_IS_EMPTY(ptr) ((ptr)[0] == STBIR__FLOAT_EMPTY_MARKER)
+
+static void stbir__encode_first_scanline_from_scatter(stbir__info const *stbir_info,
+                                                      stbir__per_split_info *split_info) {
+    // evict a scanline out into the output buffer
+    float *ring_buffer_entry =
+        stbir__get_ring_buffer_entry(stbir_info, split_info, split_info->ring_buffer_begin_index);
+
+    // dump the scanline out
+    stbir__encode_scanline(
+        stbir_info,
+        ((char *)stbir_info->output_data) + ((size_t)split_info->ring_buffer_first_scanline *
+                                             (size_t)stbir_info->output_stride_bytes),
+        ring_buffer_entry,
+        split_info->ring_buffer_first_scanline STBIR_ONLY_PROFILE_SET_SPLIT_INFO);
+
+    // mark it as empty
+    ring_buffer_entry[0] = STBIR__FLOAT_EMPTY_MARKER;
+
+    // advance the first scanline
+    split_info->ring_buffer_first_scanline++;
+    if (++split_info->ring_buffer_begin_index == stbir_info->ring_buffer_num_entries)
+        split_info->ring_buffer_begin_index = 0;
+}
+
+static void stbir__horizontal_resample_and_encode_first_scanline_from_scatter(
+    stbir__info const *stbir_info, stbir__per_split_info *split_info) {
+    // evict a scanline out into the output buffer
+
+    float *ring_buffer_entry =
+        stbir__get_ring_buffer_entry(stbir_info, split_info, split_info->ring_buffer_begin_index);
+
+    // Now resample it into the buffer.
+    stbir__resample_horizontal_gather(stbir_info, split_info->vertical_buffer,
+                                      ring_buffer_entry STBIR_ONLY_PROFILE_SET_SPLIT_INFO);
+
+    // dump the scanline out
+    stbir__encode_scanline(
+        stbir_info,
+        ((char *)stbir_info->output_data) + ((size_t)split_info->ring_buffer_first_scanline *
+                                             (size_t)stbir_info->output_stride_bytes),
+        split_info->vertical_buffer,
+        split_info->ring_buffer_first_scanline STBIR_ONLY_PROFILE_SET_SPLIT_INFO);
+
+    // mark it as empty
+    ring_buffer_entry[0] = STBIR__FLOAT_EMPTY_MARKER;
+
+    // advance the first scanline
+    split_info->ring_buffer_first_scanline++;
+    if (++split_info->ring_buffer_begin_index == stbir_info->ring_buffer_num_entries)
+        split_info->ring_buffer_begin_index = 0;
+}
+
+static void stbir__resample_vertical_scatter(stbir__info const *stbir_info,
+                                             stbir__per_split_info *split_info, int n0, int n1,
+                                             float const *vertical_coefficients,
+                                             float const *vertical_buffer,
+                                             float const *vertical_buffer_end) {
+    STBIR_ASSERT(!stbir_info->vertical.is_gather);
+
+    STBIR_PROFILE_START(vertical);
+    {
+        int k = 0, total = n1 - n0 + 1;
+        STBIR_ASSERT(total > 0);
+        do {
+            float *outputs[8];
+            int i, n = total;
+            if (n > 8)
+                n = 8;
+            for (i = 0; i < n; i++) {
+                outputs[i] = stbir__get_ring_buffer_scanline(stbir_info, split_info, k + i + n0);
+                if ((i) && (STBIR__FLOAT_BUFFER_IS_EMPTY(outputs[i]) !=
+                            STBIR__FLOAT_BUFFER_IS_EMPTY(
+                                outputs[0])))  // make sure runs are of the same type
+                {
+                    n = i;
+                    break;
+                }
+            }
+            // call the scatter to N scanlines at a time function (up to 8 scanlines of scattering
+            // at once)
+            ((STBIR__FLOAT_BUFFER_IS_EMPTY(outputs[0])) ? stbir__vertical_scatter_sets
+                                                        : stbir__vertical_scatter_blends)[n - 1](
+                outputs, vertical_coefficients + k, vertical_buffer, vertical_buffer_end);
+            k += n;
+            total -= n;
+        } while (total);
+    }
+
+    STBIR_PROFILE_END(vertical);
+}
+
+typedef void stbir__handle_scanline_for_scatter_func(stbir__info const *stbir_info,
+                                                     stbir__per_split_info *split_info);
+
+static void stbir__vertical_scatter_loop(stbir__info const *stbir_info,
+                                         stbir__per_split_info *split_info, int split_count) {
+    int y, start_output_y, end_output_y, start_input_y, end_input_y;
+    stbir__contributors *vertical_contributors = stbir_info->vertical.contributors;
+    float const *vertical_coefficients         = stbir_info->vertical.coefficients;
+    stbir__handle_scanline_for_scatter_func *handle_scanline_for_scatter;
+    void *scanline_scatter_buffer;
+    void *scanline_scatter_buffer_end;
+    int on_first_input_y, last_input_y;
+
+    STBIR_ASSERT(!stbir_info->vertical.is_gather);
+
+    start_output_y = split_info->start_output_y;
+    end_output_y   = split_info[split_count - 1].end_output_y;  // may do multiple split counts
+
+    start_input_y = split_info->start_input_y;
+    end_input_y   = split_info[split_count - 1].end_input_y;
+
+    // adjust for starting offset start_input_y
+    y = start_input_y + stbir_info->vertical.filter_pixel_margin;
+    vertical_contributors += y;
+    vertical_coefficients += stbir_info->vertical.coefficient_width * y;
+
+    if (stbir_info->vertical_first) {
+        handle_scanline_for_scatter =
+            stbir__horizontal_resample_and_encode_first_scanline_from_scatter;
+        scanline_scatter_buffer     = split_info->decode_buffer;
+        scanline_scatter_buffer_end = ((char *)scanline_scatter_buffer) +
+                                      sizeof(float) * stbir_info->effective_channels *
+                                          (stbir_info->scanline_extents.conservative.n1 -
+                                           stbir_info->scanline_extents.conservative.n0 + 1);
+    } else {
+        handle_scanline_for_scatter = stbir__encode_first_scanline_from_scatter;
+        scanline_scatter_buffer     = split_info->vertical_buffer;
+        scanline_scatter_buffer_end = ((char *)scanline_scatter_buffer) +
+                                      sizeof(float) * stbir_info->effective_channels *
+                                          stbir_info->horizontal.scale_info.output_sub_size;
+    }
+
+    // initialize the ring buffer for scattering
+    split_info->ring_buffer_first_scanline = start_output_y;
+    split_info->ring_buffer_last_scanline  = -1;
+    split_info->ring_buffer_begin_index    = -1;
+
+    // mark all the buffers as empty to start
+    for (y = 0; y < stbir_info->ring_buffer_num_entries; y++)
+        stbir__get_ring_buffer_entry(stbir_info, split_info, y)[0] =
+            STBIR__FLOAT_EMPTY_MARKER;  // only used on scatter
+
+    // do the loop in input space
+    on_first_input_y = 1;
+    last_input_y     = start_input_y;
+    for (y = start_input_y; y < end_input_y; y++) {
+        int out_first_scanline, out_last_scanline;
+
+        out_first_scanline = vertical_contributors->n0;
+        out_last_scanline  = vertical_contributors->n1;
+
+        STBIR_ASSERT(out_last_scanline - out_first_scanline + 1 <=
+                     stbir_info->ring_buffer_num_entries);
+
+        if ((out_last_scanline >= out_first_scanline) &&
+            (((out_first_scanline >= start_output_y) && (out_first_scanline < end_output_y)) ||
+             ((out_last_scanline >= start_output_y) && (out_last_scanline < end_output_y)))) {
+            float const *vc = vertical_coefficients;
+
+            // keep track of the range actually seen for the next resize
+            last_input_y = y;
+            if ((on_first_input_y) && (y > start_input_y))
+                split_info->start_input_y = y;
+            on_first_input_y = 0;
+
+            // clip the region
+            if (out_first_scanline < start_output_y) {
+                vc += start_output_y - out_first_scanline;
+                out_first_scanline = start_output_y;
+            }
+
+            if (out_last_scanline >= end_output_y)
+                out_last_scanline = end_output_y - 1;
+
+            // if very first scanline, init the index
+            if (split_info->ring_buffer_begin_index < 0)
+                split_info->ring_buffer_begin_index = out_first_scanline - start_output_y;
+
+            STBIR_ASSERT(split_info->ring_buffer_begin_index <= out_first_scanline);
+
+            // Decode the nth scanline from the source image into the decode buffer.
+            stbir__decode_scanline(stbir_info, y,
+                                   split_info->decode_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO);
+
+            // When horizontal first, we resample horizontally into the vertical buffer before we
+            // scatter it out
+            if (!stbir_info->vertical_first)
+                stbir__resample_horizontal_gather(
+                    stbir_info, split_info->vertical_buffer,
+                    split_info->decode_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO);
+
+            // Now it's sitting in the buffer ready to be distributed into the ring buffers.
+
+            // evict from the ringbuffer, if we need are full
+            if (((split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline +
+                  1) == stbir_info->ring_buffer_num_entries) &&
+                (out_last_scanline > split_info->ring_buffer_last_scanline))
+                handle_scanline_for_scatter(stbir_info, split_info);
+
+            // Now the horizontal buffer is ready to write to all ring buffer rows, so do it.
+            stbir__resample_vertical_scatter(
+                stbir_info, split_info, out_first_scanline, out_last_scanline, vc,
+                (float *)scanline_scatter_buffer, (float *)scanline_scatter_buffer_end);
+
+            // update the end of the buffer
+            if (out_last_scanline > split_info->ring_buffer_last_scanline)
+                split_info->ring_buffer_last_scanline = out_last_scanline;
+        }
+        ++vertical_contributors;
+        vertical_coefficients += stbir_info->vertical.coefficient_width;
+    }
+
+    // now evict the scanlines that are left over in the ring buffer
+    while (split_info->ring_buffer_first_scanline < end_output_y)
+        handle_scanline_for_scatter(stbir_info, split_info);
+
+    // update the end_input_y if we do multiple resizes with the same data
+    ++last_input_y;
+    for (y = 0; y < split_count; y++)
+        if (split_info[y].end_input_y > last_input_y)
+            split_info[y].end_input_y = last_input_y;
+}
+
+static stbir__kernel_callback *stbir__builtin_kernels[]   = {0,
+                                                             stbir__filter_trapezoid,
+                                                             stbir__filter_triangle,
+                                                             stbir__filter_cubic,
+                                                             stbir__filter_catmullrom,
+                                                             stbir__filter_mitchell,
+                                                             stbir__filter_point};
+static stbir__support_callback *stbir__builtin_supports[] = {0,
+                                                             stbir__support_trapezoid,
+                                                             stbir__support_one,
+                                                             stbir__support_two,
+                                                             stbir__support_two,
+                                                             stbir__support_two,
+                                                             stbir__support_zeropoint5};
+
+static void stbir__set_sampler(stbir__sampler *samp, stbir_filter filter,
+                               stbir__kernel_callback *kernel, stbir__support_callback *support,
+                               stbir_edge edge, stbir__scale_info *scale_info, int always_gather,
+                               void *user_data) {
+    // set filter
+    if (filter == 0) {
+        filter = STBIR_DEFAULT_FILTER_DOWNSAMPLE;  // default to downsample
+        if (scale_info->scale >= (1.0f - stbir__small_float)) {
+            if ((scale_info->scale <= (1.0f + stbir__small_float)) &&
+                (STBIR_CEILF(scale_info->pixel_shift) == scale_info->pixel_shift))
+                filter = STBIR_FILTER_POINT_SAMPLE;
+            else
+                filter = STBIR_DEFAULT_FILTER_UPSAMPLE;
+        }
+    }
+    samp->filter_enum = filter;
+
+    STBIR_ASSERT(samp->filter_enum != 0);
+    STBIR_ASSERT((unsigned)samp->filter_enum < STBIR_FILTER_OTHER);
+    samp->filter_kernel  = stbir__builtin_kernels[filter];
+    samp->filter_support = stbir__builtin_supports[filter];
+
+    if (kernel && support) {
+        samp->filter_kernel  = kernel;
+        samp->filter_support = support;
+        samp->filter_enum    = STBIR_FILTER_OTHER;
+    }
+
+    samp->edge = edge;
+    samp->filter_pixel_width =
+        stbir__get_filter_pixel_width(samp->filter_support, scale_info->scale, user_data);
+    // Gather is always better, but in extreme downsamples, you have to most or all of the data in
+    // memory
+    //    For horizontal, we always have all the pixels, so we always use gather here
+    //    (always_gather==1). For vertical, we use gather if scaling up (which means we will have
+    //    samp->filter_pixel_width scanlines in memory at once).
+    samp->is_gather = 0;
+    if (scale_info->scale >= (1.0f - stbir__small_float))
+        samp->is_gather = 1;
+    else if ((always_gather) ||
+             (samp->filter_pixel_width <= STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT))
+        samp->is_gather = 2;
+
+    // pre calculate stuff based on the above
+    samp->coefficient_width = stbir__get_coefficient_width(samp, samp->is_gather, user_data);
+
+    // filter_pixel_width is the conservative size in pixels of input that affect an output pixel.
+    //   In rare cases (only with 2 pix to 1 pix with the default filters), it's possible that the
+    //   filter will extend before or after the scanline beyond just one extra entire copy of the
+    //   scanline (we would hit the edge twice). We don't let you do that, so we clamp the total
+    //   width to 3x the total of input pixel (once for the scanline, once for the left side
+    //   overhang, and once for the right side). We only do this for edge mode, since the other
+    //   modes can just re-edge clamp back in again.
+    if (edge == STBIR_EDGE_WRAP)
+        if (samp->filter_pixel_width > (scale_info->input_full_size * 3))
+            samp->filter_pixel_width = scale_info->input_full_size * 3;
+
+    // This is how much to expand buffers to account for filters seeking outside
+    // the image boundaries.
+    samp->filter_pixel_margin = samp->filter_pixel_width / 2;
+
+    // filter_pixel_margin is the amount that this filter can overhang on just one side of either
+    //   end of the scanline (left or the right). Since we only allow you to overhang 1 scanline's
+    //   worth of pixels, we clamp this one side of overhang to the input scanline size. Again,
+    //   this clamping only happens in rare cases with the default filters (2 pix to 1 pix).
+    if (edge == STBIR_EDGE_WRAP)
+        if (samp->filter_pixel_margin > scale_info->input_full_size)
+            samp->filter_pixel_margin = scale_info->input_full_size;
+
+    samp->num_contributors = stbir__get_contributors(samp, samp->is_gather);
+
+    samp->contributors_size = samp->num_contributors * sizeof(stbir__contributors);
+    samp->coefficients_size = samp->num_contributors * samp->coefficient_width * sizeof(float) +
+                              sizeof(float);  // extra sizeof(float) is padding
+
+    samp->gather_prescatter_contributors = 0;
+    samp->gather_prescatter_coefficients = 0;
+    if (samp->is_gather == 0) {
+        samp->gather_prescatter_coefficient_width = samp->filter_pixel_width;
+        samp->gather_prescatter_num_contributors  = stbir__get_contributors(samp, 2);
+        samp->gather_prescatter_contributors_size =
+            samp->gather_prescatter_num_contributors * sizeof(stbir__contributors);
+        samp->gather_prescatter_coefficients_size = samp->gather_prescatter_num_contributors *
+                                                    samp->gather_prescatter_coefficient_width *
+                                                    sizeof(float);
+    }
+}
+
+static void stbir__get_conservative_extents(stbir__sampler *samp, stbir__contributors *range,
+                                            void *user_data) {
+    float scale                      = samp->scale_info.scale;
+    float out_shift                  = samp->scale_info.pixel_shift;
+    stbir__support_callback *support = samp->filter_support;
+    int input_full_size              = samp->scale_info.input_full_size;
+    stbir_edge edge                  = samp->edge;
+    float inv_scale                  = samp->scale_info.inv_scale;
+
+    STBIR_ASSERT(samp->is_gather != 0);
+
+    if (samp->is_gather == 1) {
+        int in_first_pixel, in_last_pixel;
+        float out_filter_radius = support(inv_scale, user_data) * scale;
+
+        stbir__calculate_in_pixel_range(&in_first_pixel, &in_last_pixel, 0.5, out_filter_radius,
+                                        inv_scale, out_shift, input_full_size, edge);
+        range->n0 = in_first_pixel;
+        stbir__calculate_in_pixel_range(
+            &in_first_pixel, &in_last_pixel, ((float)(samp->scale_info.output_sub_size - 1)) + 0.5f,
+            out_filter_radius, inv_scale, out_shift, input_full_size, edge);
+        range->n1 = in_last_pixel;
+    } else if (samp->is_gather == 2)  // downsample gather, refine
+    {
+        float in_pixels_radius  = support(scale, user_data) * inv_scale;
+        int filter_pixel_margin = samp->filter_pixel_margin;
+        int output_sub_size     = samp->scale_info.output_sub_size;
+        int input_end;
+        int n;
+        int in_first_pixel, in_last_pixel;
+
+        // get a conservative area of the input range
+        stbir__calculate_in_pixel_range(&in_first_pixel, &in_last_pixel, 0, 0, inv_scale, out_shift,
+                                        input_full_size, edge);
+        range->n0 = in_first_pixel;
+        stbir__calculate_in_pixel_range(&in_first_pixel, &in_last_pixel, (float)output_sub_size, 0,
+                                        inv_scale, out_shift, input_full_size, edge);
+        range->n1 = in_last_pixel;
+
+        // now go through the margin to the start of area to find bottom
+        n         = range->n0 + 1;
+        input_end = -filter_pixel_margin;
+        while (n >= input_end) {
+            int out_first_pixel, out_last_pixel;
+            stbir__calculate_out_pixel_range(&out_first_pixel, &out_last_pixel, ((float)n) + 0.5f,
+                                             in_pixels_radius, scale, out_shift, output_sub_size);
+            if (out_first_pixel > out_last_pixel)
+                break;
+
+            if ((out_first_pixel < output_sub_size) || (out_last_pixel >= 0))
+                range->n0 = n;
+            --n;
+        }
+
+        // now go through the end of the area through the margin to find top
+        n         = range->n1 - 1;
+        input_end = n + 1 + filter_pixel_margin;
+        while (n <= input_end) {
+            int out_first_pixel, out_last_pixel;
+            stbir__calculate_out_pixel_range(&out_first_pixel, &out_last_pixel, ((float)n) + 0.5f,
+                                             in_pixels_radius, scale, out_shift, output_sub_size);
+            if (out_first_pixel > out_last_pixel)
+                break;
+            if ((out_first_pixel < output_sub_size) || (out_last_pixel >= 0))
+                range->n1 = n;
+            ++n;
+        }
+    }
+
+    if (samp->edge == STBIR_EDGE_WRAP) {
+        // if we are wrapping, and we are very close to the image size (so the edges might merge),
+        // just use the scanline up to the edge
+        if ((range->n0 > 0) && (range->n1 >= input_full_size)) {
+            int marg = range->n1 - input_full_size + 1;
+            if ((marg + STBIR__MERGE_RUNS_PIXEL_THRESHOLD) >= range->n0)
+                range->n0 = 0;
+        }
+        if ((range->n0 < 0) && (range->n1 < (input_full_size - 1))) {
+            int marg = -range->n0;
+            if ((input_full_size - marg - STBIR__MERGE_RUNS_PIXEL_THRESHOLD - 1) <= range->n1)
+                range->n1 = input_full_size - 1;
+        }
+    } else {
+        // for non-edge-wrap modes, we never read over the edge, so clamp
+        if (range->n0 < 0)
+            range->n0 = 0;
+        if (range->n1 >= input_full_size)
+            range->n1 = input_full_size - 1;
+    }
+}
+
+static void stbir__get_split_info(stbir__per_split_info *split_info, int splits, int output_height,
+                                  int vertical_pixel_margin, int input_full_height) {
+    int i, cur;
+    int left = output_height;
+
+    cur = 0;
+    for (i = 0; i < splits; i++) {
+        int each;
+        split_info[i].start_output_y = cur;
+        each                         = left / (splits - i);
+        split_info[i].end_output_y   = cur + each;
+        cur += each;
+        left -= each;
+
+        // scatter range (updated to minimum as you run it)
+        split_info[i].start_input_y = -vertical_pixel_margin;
+        split_info[i].end_input_y   = input_full_height + vertical_pixel_margin;
+    }
+}
+
+static void stbir__free_internal_mem(stbir__info *info) {
+#define STBIR__FREE_AND_CLEAR(ptr)                                                                 \
+    {                                                                                              \
+        if (ptr) {                                                                                 \
+            void *p = (ptr);                                                                       \
+            (ptr)   = 0;                                                                           \
+            STBIR_FREE(p, info->user_data);                                                        \
+        }                                                                                          \
+    }
+
+    if (info) {
+#ifndef STBIR__SEPARATE_ALLOCATIONS
+        STBIR__FREE_AND_CLEAR(info->alloced_mem);
+#else
+        int i, j;
+
+        if ((info->vertical.gather_prescatter_contributors) &&
+            ((void *)info->vertical.gather_prescatter_contributors !=
+             (void *)info->split_info[0].decode_buffer)) {
+            STBIR__FREE_AND_CLEAR(info->vertical.gather_prescatter_coefficients);
+            STBIR__FREE_AND_CLEAR(info->vertical.gather_prescatter_contributors);
+        }
+        for (i = 0; i < info->splits; i++) {
+            for (j = 0; j < info->alloc_ring_buffer_num_entries; j++) {
+#ifdef STBIR_SIMD8
+                if (info->effective_channels == 3)
+                    --info->split_info[i].ring_buffers[j];  // avx in 3 channel mode needs one float
+                                                            // at the start of the buffer
+#endif
+                STBIR__FREE_AND_CLEAR(info->split_info[i].ring_buffers[j]);
+            }
+
+#ifdef STBIR_SIMD8
+            if (info->effective_channels == 3)
+                --info->split_info[i].decode_buffer;  // avx in 3 channel mode needs one float at
+                                                      // the start of the buffer
+#endif
+            STBIR__FREE_AND_CLEAR(info->split_info[i].decode_buffer);
+            STBIR__FREE_AND_CLEAR(info->split_info[i].ring_buffers);
+            STBIR__FREE_AND_CLEAR(info->split_info[i].vertical_buffer);
+        }
+        STBIR__FREE_AND_CLEAR(info->split_info);
+        if (info->vertical.coefficients != info->horizontal.coefficients) {
+            STBIR__FREE_AND_CLEAR(info->vertical.coefficients);
+            STBIR__FREE_AND_CLEAR(info->vertical.contributors);
+        }
+        STBIR__FREE_AND_CLEAR(info->horizontal.coefficients);
+        STBIR__FREE_AND_CLEAR(info->horizontal.contributors);
+        STBIR__FREE_AND_CLEAR(info->alloced_mem);
+        STBIR__FREE_AND_CLEAR(info);
+#endif
+    }
+
+#undef STBIR__FREE_AND_CLEAR
+}
+
+static int stbir__get_max_split(int splits, int height) {
+    int i;
+    int max = 0;
+
+    for (i = 0; i < splits; i++) {
+        int each = height / (splits - i);
+        if (each > max)
+            max = each;
+        height -= each;
+    }
+    return max;
+}
+
+static stbir__horizontal_gather_channels_func **stbir__horizontal_gather_n_coeffs_funcs[8] = {
+    0,
+    stbir__horizontal_gather_1_channels_with_n_coeffs_funcs,
+    stbir__horizontal_gather_2_channels_with_n_coeffs_funcs,
+    stbir__horizontal_gather_3_channels_with_n_coeffs_funcs,
+    stbir__horizontal_gather_4_channels_with_n_coeffs_funcs,
+    0,
+    0,
+    stbir__horizontal_gather_7_channels_with_n_coeffs_funcs};
+
+static stbir__horizontal_gather_channels_func **stbir__horizontal_gather_channels_funcs[8] = {
+    0,
+    stbir__horizontal_gather_1_channels_funcs,
+    stbir__horizontal_gather_2_channels_funcs,
+    stbir__horizontal_gather_3_channels_funcs,
+    stbir__horizontal_gather_4_channels_funcs,
+    0,
+    0,
+    stbir__horizontal_gather_7_channels_funcs};
+
+// there are six resize classifications: 0 == vertical scatter, 1 == vertical gather < 1x scale, 2
+// == vertical gather 1x-2x scale, 4 == vertical gather < 3x scale, 4 == vertical gather > 3x scale,
+// 5 == <=4 pixel height, 6 == <=4 pixel wide column
+#define STBIR_RESIZE_CLASSIFICATIONS 8
+
+static float stbir__compute_weights[5][STBIR_RESIZE_CLASSIFICATIONS]
+                                   [4] =  // 5 = 0=1chan, 1=2chan, 2=3chan, 3=4chan, 4=7chan
+    {
+        {
+         {1.00000f, 1.00000f, 0.31250f, 1.00000f},
+         {0.56250f, 0.59375f, 0.00000f, 0.96875f},
+         {1.00000f, 0.06250f, 0.00000f, 1.00000f},
+         {0.00000f, 0.09375f, 1.00000f, 1.00000f},
+         {1.00000f, 1.00000f, 1.00000f, 1.00000f},
+         {0.03125f, 0.12500f, 1.00000f, 1.00000f},
+         {0.06250f, 0.12500f, 0.00000f, 1.00000f},
+         {0.00000f, 1.00000f, 0.00000f, 0.03125f},
+         },
+        {
+         {0.00000f, 0.84375f, 0.00000f, 0.03125f},
+         {0.09375f, 0.93750f, 0.00000f, 0.78125f},
+         {0.87500f, 0.21875f, 0.00000f, 0.96875f},
+         {0.09375f, 0.09375f, 1.00000f, 1.00000f},
+         {1.00000f, 1.00000f, 1.00000f, 1.00000f},
+         {0.03125f, 0.12500f, 1.00000f, 1.00000f},
+         {0.06250f, 0.12500f, 0.00000f, 1.00000f},
+         {0.00000f, 1.00000f, 0.00000f, 0.53125f},
+         },
+        {
+         {0.00000f, 0.53125f, 0.00000f, 0.03125f},
+         {0.06250f, 0.96875f, 0.00000f, 0.53125f},
+         {0.87500f, 0.18750f, 0.00000f, 0.93750f},
+         {0.00000f, 0.09375f, 1.00000f, 1.00000f},
+         {1.00000f, 1.00000f, 1.00000f, 1.00000f},
+         {0.03125f, 0.12500f, 1.00000f, 1.00000f},
+         {0.06250f, 0.12500f, 0.00000f, 1.00000f},
+         {0.00000f, 1.00000f, 0.00000f, 0.56250f},
+         },
+        {
+         {0.00000f, 0.50000f, 0.00000f, 0.71875f},
+         {0.06250f, 0.84375f, 0.00000f, 0.87500f},
+         {1.00000f, 0.50000f, 0.50000f, 0.96875f},
+         {1.00000f, 0.09375f, 0.31250f, 0.50000f},
+         {1.00000f, 1.00000f, 1.00000f, 1.00000f},
+         {1.00000f, 0.03125f, 0.03125f, 0.53125f},
+         {0.18750f, 0.12500f, 0.00000f, 1.00000f},
+         {0.00000f, 1.00000f, 0.03125f, 0.18750f},
+         },
+        {
+         {0.00000f, 0.59375f, 0.00000f, 0.96875f},
+         {0.06250f, 0.81250f, 0.06250f, 0.59375f},
+         {0.75000f, 0.43750f, 0.12500f, 0.96875f},
+         {0.87500f, 0.06250f, 0.18750f, 0.43750f},
+         {1.00000f, 1.00000f, 1.00000f, 1.00000f},
+         {0.15625f, 0.12500f, 1.00000f, 1.00000f},
+         {0.06250f, 0.12500f, 0.00000f, 1.00000f},
+         {0.00000f, 1.00000f, 0.03125f, 0.34375f},
+         }
+};
+
+// structure that allow us to query and override info for training the costs
+typedef struct STBIR__V_FIRST_INFO {
+    double v_cost, h_cost;
+    int control_v_first;  // 0 = no control, 1 = force hori, 2 = force vert
+    int v_first;
+    int v_resize_classification;
+    int is_gather;
+} STBIR__V_FIRST_INFO;
+
+#ifdef STBIR__V_FIRST_INFO_BUFFER
+static STBIR__V_FIRST_INFO STBIR__V_FIRST_INFO_BUFFER = {0};
+#define STBIR__V_FIRST_INFO_POINTER &STBIR__V_FIRST_INFO_BUFFER
+#else
+#define STBIR__V_FIRST_INFO_POINTER 0
+#endif
+
+// Figure out whether to scale along the horizontal or vertical first.
+//   This only *super* important when you are scaling by a massively
+//   different amount in the vertical vs the horizontal (for example, if
+//   you are scaling by 2x in the width, and 0.5x in the height, then you
+//   want to do the vertical scale first, because it's around 3x faster
+//   in that order.
+//
+//   In more normal circumstances, this makes a 20-40% differences, so
+//     it's good to get right, but not critical. The normal way that you
+//     decide which direction goes first is just figuring out which
+//     direction does more multiplies. But with modern CPUs with their
+//     fancy caches and SIMD and high IPC abilities, so there's just a lot
+//     more that goes into it.
+//
+//   My handwavy sort of solution is to have an app that does a whole
+//     bunch of timing for both vertical and horizontal first modes,
+//     and then another app that can read lots of these timing files
+//     and try to search for the best weights to use. Dotimings.c
+//     is the app that does a bunch of timings, and vf_train.c is the
+//     app that solves for the best weights (and shows how well it
+//     does currently).
+
+static int stbir__should_do_vertical_first(float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4],
+                                           int horizontal_filter_pixel_width,
+                                           float horizontal_scale, int horizontal_output_size,
+                                           int vertical_filter_pixel_width, float vertical_scale,
+                                           int vertical_output_size, int is_gather,
+                                           STBIR__V_FIRST_INFO *info) {
+    double v_cost, h_cost;
+    float *weights;
+    int vertical_first;
+    int v_classification;
+
+    // categorize the resize into buckets
+    if ((vertical_output_size <= 4) || (horizontal_output_size <= 4))
+        v_classification = (vertical_output_size < horizontal_output_size) ? 6 : 7;
+    else if (vertical_scale <= 1.0f)
+        v_classification = (is_gather) ? 1 : 0;
+    else if (vertical_scale <= 2.0f)
+        v_classification = 2;
+    else if (vertical_scale <= 3.0f)
+        v_classification = 3;
+    else if (vertical_scale <= 4.0f)
+        v_classification = 5;
+    else
+        v_classification = 6;
+
+    // use the right weights
+    weights = weights_table[v_classification];
+
+    // this is the costs when you don't take into account modern CPUs with high ipc and simd and
+    // caches - wish we had a better estimate
+    h_cost = (float)horizontal_filter_pixel_width * weights[0] +
+             horizontal_scale * (float)vertical_filter_pixel_width * weights[1];
+    v_cost = (float)vertical_filter_pixel_width * weights[2] +
+             vertical_scale * (float)horizontal_filter_pixel_width * weights[3];
+
+    // use computation estimate to decide vertical first or not
+    vertical_first = (v_cost <= h_cost) ? 1 : 0;
+
+    // save these, if requested
+    if (info) {
+        info->h_cost                  = h_cost;
+        info->v_cost                  = v_cost;
+        info->v_resize_classification = v_classification;
+        info->v_first                 = vertical_first;
+        info->is_gather               = is_gather;
+    }
+
+    // and this allows us to override everything for testing (see dotiming.c)
+    if ((info) && (info->control_v_first))
+        vertical_first = (info->control_v_first == 2) ? 1 : 0;
+
+    return vertical_first;
+}
+
+// layout lookups - must match stbir_internal_pixel_layout
+static unsigned char stbir__pixel_channels[] = {
+    1, 2, 3, 3, 4,     // 1ch, 2ch, rgb, bgr, 4ch
+    4, 4, 4, 4, 2, 2,  // RGBA,BGRA,ARGB,ABGR,RA,AR
+    4, 4, 4, 4, 2, 2,  // RGBA_PM,BGRA_PM,ARGB_PM,ABGR_PM,RA_PM,AR_PM
+};
+
+// the internal pixel layout enums are in a different order, so we can easily do range comparisons
+// of types
+//   the public pixel layout is ordered in a way that if you cast num_channels (1-4) to the enum,
+//   you get something sensible
+static stbir_internal_pixel_layout stbir__pixel_layout_convert_public_to_internal[] = {
+    STBIRI_BGR,     STBIRI_1CHANNEL, STBIRI_2CHANNEL, STBIRI_RGB,   STBIRI_RGBA,  STBIRI_4CHANNEL,
+    STBIRI_BGRA,    STBIRI_ARGB,     STBIRI_ABGR,     STBIRI_RA,    STBIRI_AR,    STBIRI_RGBA_PM,
+    STBIRI_BGRA_PM, STBIRI_ARGB_PM,  STBIRI_ABGR_PM,  STBIRI_RA_PM, STBIRI_AR_PM,
+};
+
+static stbir__info *stbir__alloc_internal_mem_and_build_samplers(
+    stbir__sampler *horizontal, stbir__sampler *vertical, stbir__contributors *conservative,
+    stbir_pixel_layout input_pixel_layout_public, stbir_pixel_layout output_pixel_layout_public,
+    int splits, int new_x, int new_y, int fast_alpha,
+    void *user_data STBIR_ONLY_PROFILE_BUILD_GET_INFO) {
+    static char stbir_channel_count_index[8] = {9, 0, 1, 2, 3, 9, 9, 4};
+
+    stbir__info *info    = 0;
+    void *alloced        = 0;
+    size_t alloced_total = 0;
+    int vertical_first;
+    int decode_buffer_size, ring_buffer_length_bytes, ring_buffer_size, vertical_buffer_size,
+        alloc_ring_buffer_num_entries;
+
+    int alpha_weighting_type = 0;  // 0=none, 1=simple, 2=fancy
+    int conservative_split_output_size =
+        stbir__get_max_split(splits, vertical->scale_info.output_sub_size);
+    stbir_internal_pixel_layout input_pixel_layout =
+        stbir__pixel_layout_convert_public_to_internal[input_pixel_layout_public];
+    stbir_internal_pixel_layout output_pixel_layout =
+        stbir__pixel_layout_convert_public_to_internal[output_pixel_layout_public];
+    int channels           = stbir__pixel_channels[input_pixel_layout];
+    int effective_channels = channels;
+
+    // first figure out what type of alpha weighting to use (if any)
+    if ((horizontal->filter_enum != STBIR_FILTER_POINT_SAMPLE) ||
+        (vertical->filter_enum !=
+         STBIR_FILTER_POINT_SAMPLE))  // no alpha weighting on point sampling
+    {
+        if ((input_pixel_layout >= STBIRI_RGBA) && (input_pixel_layout <= STBIRI_AR) &&
+            (output_pixel_layout >= STBIRI_RGBA) && (output_pixel_layout <= STBIRI_AR)) {
+            if (fast_alpha) {
+                alpha_weighting_type = 4;
+            } else {
+                static int fancy_alpha_effective_cnts[6] = {7, 7, 7, 7, 3, 3};
+                alpha_weighting_type                     = 2;
+                effective_channels = fancy_alpha_effective_cnts[input_pixel_layout - STBIRI_RGBA];
+            }
+        } else if ((input_pixel_layout >= STBIRI_RGBA_PM) && (input_pixel_layout <= STBIRI_AR_PM) &&
+                   (output_pixel_layout >= STBIRI_RGBA) && (output_pixel_layout <= STBIRI_AR)) {
+            // input premult, output non-premult
+            alpha_weighting_type = 3;
+        } else if ((input_pixel_layout >= STBIRI_RGBA) && (input_pixel_layout <= STBIRI_AR) &&
+                   (output_pixel_layout >= STBIRI_RGBA_PM) &&
+                   (output_pixel_layout <= STBIRI_AR_PM)) {
+            // input non-premult, output premult
+            alpha_weighting_type = 1;
+        }
+    }
+
+    // channel in and out count must match currently
+    if (channels != stbir__pixel_channels[output_pixel_layout])
+        return 0;
+
+    // get vertical first
+    vertical_first = stbir__should_do_vertical_first(
+        stbir__compute_weights[(int)stbir_channel_count_index[effective_channels]],
+        horizontal->filter_pixel_width, horizontal->scale_info.scale,
+        horizontal->scale_info.output_sub_size, vertical->filter_pixel_width,
+        vertical->scale_info.scale, vertical->scale_info.output_sub_size, vertical->is_gather,
+        STBIR__V_FIRST_INFO_POINTER);
+
+    // sometimes read one float off in some of the unrolled loops (with a weight of zero coeff, so
+    // it doesn't have an effect)
+    decode_buffer_size =
+        (conservative->n1 - conservative->n0 + 1) * effective_channels * sizeof(float) +
+        sizeof(float);  // extra float for padding
+
+#if defined(STBIR__SEPARATE_ALLOCATIONS) && defined(STBIR_SIMD8)
+    if (effective_channels == 3)
+        decode_buffer_size += sizeof(float);  // avx in 3 channel mode needs one float at the start
+                                              // of the buffer (only with separate allocations)
+#endif
+
+    ring_buffer_length_bytes =
+        horizontal->scale_info.output_sub_size * effective_channels * sizeof(float) +
+        sizeof(float);  // extra float for padding
+
+    // if we do vertical first, the ring buffer holds a whole decoded line
+    if (vertical_first)
+        ring_buffer_length_bytes = (decode_buffer_size + 15) & ~15;
+
+    if ((ring_buffer_length_bytes & 4095) == 0)
+        ring_buffer_length_bytes += 64 * 3;  // avoid 4k alias
+
+    // One extra entry because floating point precision problems sometimes cause an extra to be
+    // necessary.
+    alloc_ring_buffer_num_entries = vertical->filter_pixel_width + 1;
+
+    // we never need more ring buffer entries than the scanlines we're outputting when in scatter
+    // mode
+    if ((!vertical->is_gather) && (alloc_ring_buffer_num_entries > conservative_split_output_size))
+        alloc_ring_buffer_num_entries = conservative_split_output_size;
+
+    ring_buffer_size = alloc_ring_buffer_num_entries * ring_buffer_length_bytes;
+
+    // The vertical buffer is used differently, depending on whether we are scattering
+    //   the vertical scanlines, or gathering them.
+    //   If scattering, it's used at the temp buffer to accumulate each output.
+    //   If gathering, it's just the output buffer.
+    vertical_buffer_size =
+        horizontal->scale_info.output_sub_size * effective_channels * sizeof(float) +
+        sizeof(float);  // extra float for padding
+
+    // we make two passes through this loop, 1st to add everything up, 2nd to allocate and init
+    for (;;) {
+        int i;
+        void *advance_mem                                 = alloced;
+        int copy_horizontal                               = 0;
+        stbir__sampler *possibly_use_horizontal_for_pivot = 0;
+
+#ifdef STBIR__SEPARATE_ALLOCATIONS
+#define STBIR__NEXT_PTR(ptr, size, ntype)                                                          \
+    if (alloced) {                                                                                 \
+        void *p = STBIR_MALLOC(size, user_data);                                                   \
+        if (p == 0) {                                                                              \
+            stbir__free_internal_mem(info);                                                        \
+            return 0;                                                                              \
+        }                                                                                          \
+        (ptr) = (ntype *)p;                                                                        \
+    }
+#else
+#define STBIR__NEXT_PTR(ptr, size, ntype)                                                          \
+    advance_mem = (void *)((((size_t)advance_mem) + 15) & ~15);                                    \
+    if (alloced)                                                                                   \
+        ptr = (ntype *)advance_mem;                                                                \
+    advance_mem = ((char *)advance_mem) + (size);
+#endif
+
+        STBIR__NEXT_PTR(info, sizeof(stbir__info), stbir__info);
+
+        STBIR__NEXT_PTR(info->split_info, sizeof(stbir__per_split_info) * splits,
+                        stbir__per_split_info);
+
+        if (info) {
+            static stbir__alpha_weight_func *fancy_alpha_weights[6] = {
+                stbir__fancy_alpha_weight_4ch, stbir__fancy_alpha_weight_4ch,
+                stbir__fancy_alpha_weight_4ch, stbir__fancy_alpha_weight_4ch,
+                stbir__fancy_alpha_weight_2ch, stbir__fancy_alpha_weight_2ch};
+            static stbir__alpha_unweight_func *fancy_alpha_unweights[6] = {
+                stbir__fancy_alpha_unweight_4ch, stbir__fancy_alpha_unweight_4ch,
+                stbir__fancy_alpha_unweight_4ch, stbir__fancy_alpha_unweight_4ch,
+                stbir__fancy_alpha_unweight_2ch, stbir__fancy_alpha_unweight_2ch};
+            static stbir__alpha_weight_func *simple_alpha_weights[6] = {
+                stbir__simple_alpha_weight_4ch, stbir__simple_alpha_weight_4ch,
+                stbir__simple_alpha_weight_4ch, stbir__simple_alpha_weight_4ch,
+                stbir__simple_alpha_weight_2ch, stbir__simple_alpha_weight_2ch};
+            static stbir__alpha_unweight_func *simple_alpha_unweights[6] = {
+                stbir__simple_alpha_unweight_4ch, stbir__simple_alpha_unweight_4ch,
+                stbir__simple_alpha_unweight_4ch, stbir__simple_alpha_unweight_4ch,
+                stbir__simple_alpha_unweight_2ch, stbir__simple_alpha_unweight_2ch};
+
+            // initialize info fields
+            info->alloced_mem   = alloced;
+            info->alloced_total = alloced_total;
+
+            info->channels           = channels;
+            info->effective_channels = effective_channels;
+
+            info->offset_x                      = new_x;
+            info->offset_y                      = new_y;
+            info->alloc_ring_buffer_num_entries = alloc_ring_buffer_num_entries;
+            info->ring_buffer_num_entries       = 0;
+            info->ring_buffer_length_bytes      = ring_buffer_length_bytes;
+            info->splits                        = splits;
+            info->vertical_first                = vertical_first;
+
+            info->input_pixel_layout_internal  = input_pixel_layout;
+            info->output_pixel_layout_internal = output_pixel_layout;
+
+            // setup alpha weight functions
+            info->alpha_weight   = 0;
+            info->alpha_unweight = 0;
+
+            // handle alpha weighting functions and overrides
+            if (alpha_weighting_type == 2) {
+                // high quality alpha multiplying on the way in, dividing on the way out
+                info->alpha_weight   = fancy_alpha_weights[input_pixel_layout - STBIRI_RGBA];
+                info->alpha_unweight = fancy_alpha_unweights[output_pixel_layout - STBIRI_RGBA];
+            } else if (alpha_weighting_type == 4) {
+                // fast alpha multiplying on the way in, dividing on the way out
+                info->alpha_weight   = simple_alpha_weights[input_pixel_layout - STBIRI_RGBA];
+                info->alpha_unweight = simple_alpha_unweights[output_pixel_layout - STBIRI_RGBA];
+            } else if (alpha_weighting_type == 1) {
+                // fast alpha on the way in, leave in premultiplied form on way out
+                info->alpha_weight = simple_alpha_weights[input_pixel_layout - STBIRI_RGBA];
+            } else if (alpha_weighting_type == 3) {
+                // incoming is premultiplied, fast alpha dividing on the way out - non-premultiplied
+                // output
+                info->alpha_unweight = simple_alpha_unweights[output_pixel_layout - STBIRI_RGBA];
+            }
+
+            // handle 3-chan color flipping, using the alpha weight path
+            if (((input_pixel_layout == STBIRI_RGB) && (output_pixel_layout == STBIRI_BGR)) ||
+                ((input_pixel_layout == STBIRI_BGR) && (output_pixel_layout == STBIRI_RGB))) {
+                // do the flipping on the smaller of the two ends
+                if (horizontal->scale_info.scale < 1.0f)
+                    info->alpha_unweight = stbir__simple_flip_3ch;
+                else
+                    info->alpha_weight = stbir__simple_flip_3ch;
+            }
+        }
+
+        // get all the per-split buffers
+        for (i = 0; i < splits; i++) {
+            STBIR__NEXT_PTR(info->split_info[i].decode_buffer, decode_buffer_size, float);
+
+#ifdef STBIR__SEPARATE_ALLOCATIONS
+
+#ifdef STBIR_SIMD8
+            if ((info) && (effective_channels == 3))
+                ++info->split_info[i].decode_buffer;  // avx in 3 channel mode needs one float at
+                                                      // the start of the buffer
+#endif
+
+            STBIR__NEXT_PTR(info->split_info[i].ring_buffers,
+                            alloc_ring_buffer_num_entries * sizeof(float *), float *);
+            {
+                int j;
+                for (j = 0; j < alloc_ring_buffer_num_entries; j++) {
+                    STBIR__NEXT_PTR(info->split_info[i].ring_buffers[j], ring_buffer_length_bytes,
+                                    float);
+#ifdef STBIR_SIMD8
+                    if ((info) && (effective_channels == 3))
+                        ++info->split_info[i].ring_buffers[j];  // avx in 3 channel mode needs one
+                                                                // float at the start of the buffer
+#endif
+                }
+            }
+#else
+            STBIR__NEXT_PTR(info->split_info[i].ring_buffer, ring_buffer_size, float);
+#endif
+            STBIR__NEXT_PTR(info->split_info[i].vertical_buffer, vertical_buffer_size, float);
+        }
+
+        // alloc memory for to-be-pivoted coeffs (if necessary)
+        if (vertical->is_gather == 0) {
+            int both;
+            int temp_mem_amt;
+
+            // when in vertical scatter mode, we first build the coefficients in gather mode, and
+            // then pivot after,
+            //   that means we need two buffers, so we try to use the decode buffer and ring buffer
+            //   for this. if that is too small, we just allocate extra memory to use as this temp.
+
+            both = vertical->gather_prescatter_contributors_size +
+                   vertical->gather_prescatter_coefficients_size;
+
+#ifdef STBIR__SEPARATE_ALLOCATIONS
+            temp_mem_amt = decode_buffer_size;
+
+#ifdef STBIR_SIMD8
+            if (effective_channels == 3)
+                --temp_mem_amt;  // avx in 3 channel mode needs one float at the start of the buffer
+#endif
+#else
+            temp_mem_amt = (decode_buffer_size + ring_buffer_size + vertical_buffer_size) * splits;
+#endif
+            if (temp_mem_amt >= both) {
+                if (info) {
+                    vertical->gather_prescatter_contributors =
+                        (stbir__contributors *)info->split_info[0].decode_buffer;
+                    vertical->gather_prescatter_coefficients =
+                        (float *)(((char *)info->split_info[0].decode_buffer) +
+                                  vertical->gather_prescatter_contributors_size);
+                }
+            } else {
+                // ring+decode memory is too small, so allocate temp memory
+                STBIR__NEXT_PTR(vertical->gather_prescatter_contributors,
+                                vertical->gather_prescatter_contributors_size, stbir__contributors);
+                STBIR__NEXT_PTR(vertical->gather_prescatter_coefficients,
+                                vertical->gather_prescatter_coefficients_size, float);
+            }
+        }
+
+        STBIR__NEXT_PTR(horizontal->contributors, horizontal->contributors_size,
+                        stbir__contributors);
+        STBIR__NEXT_PTR(horizontal->coefficients, horizontal->coefficients_size, float);
+
+        // are the two filters identical?? (happens a lot with mipmap generation)
+        if ((horizontal->filter_kernel == vertical->filter_kernel) &&
+            (horizontal->filter_support == vertical->filter_support) &&
+            (horizontal->edge == vertical->edge) &&
+            (horizontal->scale_info.output_sub_size == vertical->scale_info.output_sub_size)) {
+            float diff_scale = horizontal->scale_info.scale - vertical->scale_info.scale;
+            float diff_shift =
+                horizontal->scale_info.pixel_shift - vertical->scale_info.pixel_shift;
+            if (diff_scale < 0.0f)
+                diff_scale = -diff_scale;
+            if (diff_shift < 0.0f)
+                diff_shift = -diff_shift;
+            if ((diff_scale <= stbir__small_float) && (diff_shift <= stbir__small_float)) {
+                if (horizontal->is_gather == vertical->is_gather) {
+                    copy_horizontal = 1;
+                    goto no_vert_alloc;
+                }
+                // everything matches, but vertical is scatter, horizontal is gather, use horizontal
+                // coeffs for vertical pivot coeffs
+                possibly_use_horizontal_for_pivot = horizontal;
+            }
+        }
+
+        STBIR__NEXT_PTR(vertical->contributors, vertical->contributors_size, stbir__contributors);
+        STBIR__NEXT_PTR(vertical->coefficients, vertical->coefficients_size, float);
+
+    no_vert_alloc:
+
+        if (info) {
+            STBIR_PROFILE_BUILD_START(horizontal);
+
+            stbir__calculate_filters(horizontal, 0, user_data STBIR_ONLY_PROFILE_BUILD_SET_INFO);
+
+            // setup the horizontal gather functions
+            // start with defaulting to the n_coeffs functions (specialized on channels and remnant
+            // leftover)
+            info->horizontal_gather_channels =
+                stbir__horizontal_gather_n_coeffs_funcs[effective_channels]
+                                                       [horizontal->extent_info.widest & 3];
+            // but if the number of coeffs <= 12, use another set of special cases. <=12 coeffs is
+            // any enlarging resize, or shrinking resize down to about 1/3 size
+            if (horizontal->extent_info.widest <= 12)
+                info->horizontal_gather_channels =
+                    stbir__horizontal_gather_channels_funcs[effective_channels]
+                                                           [horizontal->extent_info.widest - 1];
+
+            info->scanline_extents.conservative.n0 = conservative->n0;
+            info->scanline_extents.conservative.n1 = conservative->n1;
+
+            // get exact extents
+            stbir__get_extents(horizontal, &info->scanline_extents);
+
+            // pack the horizontal coeffs
+            horizontal->coefficient_width = stbir__pack_coefficients(
+                horizontal->num_contributors, horizontal->contributors, horizontal->coefficients,
+                horizontal->coefficient_width, horizontal->extent_info.widest,
+                info->scanline_extents.conservative.n0, info->scanline_extents.conservative.n1);
+
+            STBIR_MEMCPY(&info->horizontal, horizontal, sizeof(stbir__sampler));
+
+            STBIR_PROFILE_BUILD_END(horizontal);
+
+            if (copy_horizontal) {
+                STBIR_MEMCPY(&info->vertical, horizontal, sizeof(stbir__sampler));
+            } else {
+                STBIR_PROFILE_BUILD_START(vertical);
+
+                stbir__calculate_filters(vertical, possibly_use_horizontal_for_pivot,
+                                         user_data STBIR_ONLY_PROFILE_BUILD_SET_INFO);
+                STBIR_MEMCPY(&info->vertical, vertical, sizeof(stbir__sampler));
+
+                STBIR_PROFILE_BUILD_END(vertical);
+            }
+
+            // setup the vertical split ranges
+            stbir__get_split_info(
+                info->split_info, info->splits, info->vertical.scale_info.output_sub_size,
+                info->vertical.filter_pixel_margin, info->vertical.scale_info.input_full_size);
+
+            // now we know precisely how many entries we need
+            info->ring_buffer_num_entries = info->vertical.extent_info.widest;
+
+            // we never need more ring buffer entries than the scanlines we're outputting
+            if ((!info->vertical.is_gather) &&
+                (info->ring_buffer_num_entries > conservative_split_output_size))
+                info->ring_buffer_num_entries = conservative_split_output_size;
+            STBIR_ASSERT(info->ring_buffer_num_entries <= info->alloc_ring_buffer_num_entries);
+
+            // a few of the horizontal gather functions read past the end of the decode (but mask it
+            // out),
+            //   so put in normal values so no snans or denormals accidentally sneak in (also, in
+            //   the ring buffer for vertical first)
+            for (i = 0; i < splits; i++) {
+                int t, ofs, start;
+
+                ofs = decode_buffer_size / 4;
+
+#if defined(STBIR__SEPARATE_ALLOCATIONS) && defined(STBIR_SIMD8)
+                if (effective_channels == 3)
+                    --ofs;  // avx in 3 channel mode needs one float at the start of the buffer, so
+                            // we snap back for clearing
+#endif
+
+                start = ofs - 4;
+                if (start < 0)
+                    start = 0;
+
+                for (t = start; t < ofs; t++)
+                    info->split_info[i].decode_buffer[t] = 9999.0f;
+
+                if (vertical_first) {
+                    int j;
+                    for (j = 0; j < info->ring_buffer_num_entries; j++) {
+                        for (t = start; t < ofs; t++)
+                            stbir__get_ring_buffer_entry(info, info->split_info + i, j)[t] =
+                                9999.0f;
+                    }
+                }
+            }
+        }
+
+#undef STBIR__NEXT_PTR
+
+        // is this the first time through loop?
+        if (info == 0) {
+            alloced_total = (15 + (size_t)advance_mem);
+            alloced       = STBIR_MALLOC(alloced_total, user_data);
+            if (alloced == 0)
+                return 0;
+        } else
+            return info;  // success
+    }
+}
+
+static int stbir__perform_resize(stbir__info const *info, int split_start, int split_count) {
+    stbir__per_split_info *split_info = info->split_info + split_start;
+
+    STBIR_PROFILE_CLEAR_EXTRAS();
+
+    STBIR_PROFILE_FIRST_START(looping);
+    if (info->vertical.is_gather)
+        stbir__vertical_gather_loop(info, split_info, split_count);
+    else
+        stbir__vertical_scatter_loop(info, split_info, split_count);
+    STBIR_PROFILE_END(looping);
+
+    return 1;
+}
+
+static void stbir__update_info_from_resize(stbir__info *info, STBIR_RESIZE *resize) {
+    static stbir__decode_pixels_func
+        *decode_simple[STBIR_TYPE_HALF_FLOAT - STBIR_TYPE_UINT8_SRGB + 1] = {
+            /* 1ch-4ch */ stbir__decode_uint8_srgb,
+            stbir__decode_uint8_srgb,
+            0,
+            stbir__decode_float_linear,
+            stbir__decode_half_float_linear,
+        };
+
+    static stbir__decode_pixels_func
+        *decode_alphas[STBIRI_AR - STBIRI_RGBA + 1][STBIR_TYPE_HALF_FLOAT - STBIR_TYPE_UINT8_SRGB +
+                                                    1] = {
+            {/* RGBA */ stbir__decode_uint8_srgb4_linearalpha,      stbir__decode_uint8_srgb,      0,
+             stbir__decode_float_linear,                                                                                               stbir__decode_half_float_linear     },
+            {/* BGRA */ stbir__decode_uint8_srgb4_linearalpha_BGRA, stbir__decode_uint8_srgb_BGRA,
+             0,                                                                                       stbir__decode_float_linear_BGRA, stbir__decode_half_float_linear_BGRA},
+            {/* ARGB */ stbir__decode_uint8_srgb4_linearalpha_ARGB, stbir__decode_uint8_srgb_ARGB,
+             0,                                                                                       stbir__decode_float_linear_ARGB, stbir__decode_half_float_linear_ARGB},
+            {/* ABGR */ stbir__decode_uint8_srgb4_linearalpha_ABGR, stbir__decode_uint8_srgb_ABGR,
+             0,                                                                                       stbir__decode_float_linear_ABGR, stbir__decode_half_float_linear_ABGR},
+            {/* RA   */ stbir__decode_uint8_srgb2_linearalpha,      stbir__decode_uint8_srgb,      0,
+             stbir__decode_float_linear,                                                                                               stbir__decode_half_float_linear     },
+            {/* AR   */ stbir__decode_uint8_srgb2_linearalpha_AR,   stbir__decode_uint8_srgb_AR,   0,
+             stbir__decode_float_linear_AR,                                                                                            stbir__decode_half_float_linear_AR  },
+    };
+
+    static stbir__decode_pixels_func *decode_simple_scaled_or_not[2][2] = {
+        {stbir__decode_uint8_linear_scaled,  stbir__decode_uint8_linear },
+        {stbir__decode_uint16_linear_scaled, stbir__decode_uint16_linear},
+    };
+
+    static stbir__decode_pixels_func
+        *decode_alphas_scaled_or_not[STBIRI_AR - STBIRI_RGBA + 1][2][2] = {
+            {/* RGBA */ {stbir__decode_uint8_linear_scaled, stbir__decode_uint8_linear},
+             {stbir__decode_uint16_linear_scaled, stbir__decode_uint16_linear}          },
+            {/* BGRA */ {stbir__decode_uint8_linear_scaled_BGRA, stbir__decode_uint8_linear_BGRA},
+             {stbir__decode_uint16_linear_scaled_BGRA, stbir__decode_uint16_linear_BGRA}},
+            {/* ARGB */ {stbir__decode_uint8_linear_scaled_ARGB, stbir__decode_uint8_linear_ARGB},
+             {stbir__decode_uint16_linear_scaled_ARGB, stbir__decode_uint16_linear_ARGB}},
+            {/* ABGR */ {stbir__decode_uint8_linear_scaled_ABGR, stbir__decode_uint8_linear_ABGR},
+             {stbir__decode_uint16_linear_scaled_ABGR, stbir__decode_uint16_linear_ABGR}},
+            {/* RA   */ {stbir__decode_uint8_linear_scaled, stbir__decode_uint8_linear},
+             {stbir__decode_uint16_linear_scaled, stbir__decode_uint16_linear}          },
+            {/* AR   */ {stbir__decode_uint8_linear_scaled_AR, stbir__decode_uint8_linear_AR},
+             {stbir__decode_uint16_linear_scaled_AR, stbir__decode_uint16_linear_AR}    }
+    };
+
+    static stbir__encode_pixels_func
+        *encode_simple[STBIR_TYPE_HALF_FLOAT - STBIR_TYPE_UINT8_SRGB + 1] = {
+            /* 1ch-4ch */ stbir__encode_uint8_srgb,
+            stbir__encode_uint8_srgb,
+            0,
+            stbir__encode_float_linear,
+            stbir__encode_half_float_linear,
+        };
+
+    static stbir__encode_pixels_func
+        *encode_alphas[STBIRI_AR - STBIRI_RGBA + 1][STBIR_TYPE_HALF_FLOAT - STBIR_TYPE_UINT8_SRGB +
+                                                    1] = {
+            {/* RGBA */ stbir__encode_uint8_srgb4_linearalpha,      stbir__encode_uint8_srgb,      0,
+             stbir__encode_float_linear,                                                                                               stbir__encode_half_float_linear     },
+            {/* BGRA */ stbir__encode_uint8_srgb4_linearalpha_BGRA, stbir__encode_uint8_srgb_BGRA,
+             0,                                                                                       stbir__encode_float_linear_BGRA, stbir__encode_half_float_linear_BGRA},
+            {/* ARGB */ stbir__encode_uint8_srgb4_linearalpha_ARGB, stbir__encode_uint8_srgb_ARGB,
+             0,                                                                                       stbir__encode_float_linear_ARGB, stbir__encode_half_float_linear_ARGB},
+            {/* ABGR */ stbir__encode_uint8_srgb4_linearalpha_ABGR, stbir__encode_uint8_srgb_ABGR,
+             0,                                                                                       stbir__encode_float_linear_ABGR, stbir__encode_half_float_linear_ABGR},
+            {/* RA   */ stbir__encode_uint8_srgb2_linearalpha,      stbir__encode_uint8_srgb,      0,
+             stbir__encode_float_linear,                                                                                               stbir__encode_half_float_linear     },
+            {/* AR   */ stbir__encode_uint8_srgb2_linearalpha_AR,   stbir__encode_uint8_srgb_AR,   0,
+             stbir__encode_float_linear_AR,                                                                                            stbir__encode_half_float_linear_AR  }
+    };
+
+    static stbir__encode_pixels_func *encode_simple_scaled_or_not[2][2] = {
+        {stbir__encode_uint8_linear_scaled,  stbir__encode_uint8_linear },
+        {stbir__encode_uint16_linear_scaled, stbir__encode_uint16_linear},
+    };
+
+    static stbir__encode_pixels_func
+        *encode_alphas_scaled_or_not[STBIRI_AR - STBIRI_RGBA + 1][2][2] = {
+            {/* RGBA */ {stbir__encode_uint8_linear_scaled, stbir__encode_uint8_linear},
+             {stbir__encode_uint16_linear_scaled, stbir__encode_uint16_linear}          },
+            {/* BGRA */ {stbir__encode_uint8_linear_scaled_BGRA, stbir__encode_uint8_linear_BGRA},
+             {stbir__encode_uint16_linear_scaled_BGRA, stbir__encode_uint16_linear_BGRA}},
+            {/* ARGB */ {stbir__encode_uint8_linear_scaled_ARGB, stbir__encode_uint8_linear_ARGB},
+             {stbir__encode_uint16_linear_scaled_ARGB, stbir__encode_uint16_linear_ARGB}},
+            {/* ABGR */ {stbir__encode_uint8_linear_scaled_ABGR, stbir__encode_uint8_linear_ABGR},
+             {stbir__encode_uint16_linear_scaled_ABGR, stbir__encode_uint16_linear_ABGR}},
+            {/* RA   */ {stbir__encode_uint8_linear_scaled, stbir__encode_uint8_linear},
+             {stbir__encode_uint16_linear_scaled, stbir__encode_uint16_linear}          },
+            {/* AR   */ {stbir__encode_uint8_linear_scaled_AR, stbir__encode_uint8_linear_AR},
+             {stbir__encode_uint16_linear_scaled_AR, stbir__encode_uint16_linear_AR}    }
+    };
+
+    stbir__decode_pixels_func *decode_pixels = 0;
+    stbir__encode_pixels_func *encode_pixels = 0;
+    stbir_datatype input_type, output_type;
+
+    input_type                = resize->input_data_type;
+    output_type               = resize->output_data_type;
+    info->input_data          = resize->input_pixels;
+    info->input_stride_bytes  = resize->input_stride_in_bytes;
+    info->output_stride_bytes = resize->output_stride_in_bytes;
+
+    // if we're completely point sampling, then we can turn off SRGB
+    if ((info->horizontal.filter_enum == STBIR_FILTER_POINT_SAMPLE) &&
+        (info->vertical.filter_enum == STBIR_FILTER_POINT_SAMPLE)) {
+        if (((input_type == STBIR_TYPE_UINT8_SRGB) ||
+             (input_type == STBIR_TYPE_UINT8_SRGB_ALPHA)) &&
+            ((output_type == STBIR_TYPE_UINT8_SRGB) ||
+             (output_type == STBIR_TYPE_UINT8_SRGB_ALPHA))) {
+            input_type  = STBIR_TYPE_UINT8;
+            output_type = STBIR_TYPE_UINT8;
+        }
+    }
+
+    // recalc the output and input strides
+    if (info->input_stride_bytes == 0)
+        info->input_stride_bytes = info->channels * info->horizontal.scale_info.input_full_size *
+                                   stbir__type_size[input_type];
+
+    if (info->output_stride_bytes == 0)
+        info->output_stride_bytes = info->channels * info->horizontal.scale_info.output_sub_size *
+                                    stbir__type_size[output_type];
+
+    // calc offset
+    info->output_data = ((char *)resize->output_pixels) +
+                        ((size_t)info->offset_y * (size_t)resize->output_stride_in_bytes) +
+                        (info->offset_x * info->channels * stbir__type_size[output_type]);
+
+    info->in_pixels_cb  = resize->input_cb;
+    info->user_data     = resize->user_data;
+    info->out_pixels_cb = resize->output_cb;
+
+    // setup the input format converters
+    if ((input_type == STBIR_TYPE_UINT8) || (input_type == STBIR_TYPE_UINT16)) {
+        int non_scaled = 0;
+
+        // check if we can run unscaled - 0-255.0/0-65535.0 instead of 0-1.0 (which is a tiny bit
+        // faster when doing linear 8->8 or 16->16)
+        if ((!info->alpha_weight) &&
+            (!info->alpha_unweight))  // don't short circuit when alpha weighting (get everything to
+                                      // 0-1.0 as usual)
+            if (((input_type == STBIR_TYPE_UINT8) && (output_type == STBIR_TYPE_UINT8)) ||
+                ((input_type == STBIR_TYPE_UINT16) && (output_type == STBIR_TYPE_UINT16)))
+                non_scaled = 1;
+
+        if (info->input_pixel_layout_internal <= STBIRI_4CHANNEL)
+            decode_pixels =
+                decode_simple_scaled_or_not[input_type == STBIR_TYPE_UINT16][non_scaled];
+        else
+            decode_pixels =
+                decode_alphas_scaled_or_not[(info->input_pixel_layout_internal - STBIRI_RGBA) %
+                                            (STBIRI_AR - STBIRI_RGBA + 1)]
+                                           [input_type == STBIR_TYPE_UINT16][non_scaled];
+    } else {
+        if (info->input_pixel_layout_internal <= STBIRI_4CHANNEL)
+            decode_pixels = decode_simple[input_type - STBIR_TYPE_UINT8_SRGB];
+        else
+            decode_pixels =
+                decode_alphas[(info->input_pixel_layout_internal - STBIRI_RGBA) %
+                              (STBIRI_AR - STBIRI_RGBA + 1)][input_type - STBIR_TYPE_UINT8_SRGB];
+    }
+
+    // setup the output format converters
+    if ((output_type == STBIR_TYPE_UINT8) || (output_type == STBIR_TYPE_UINT16)) {
+        int non_scaled = 0;
+
+        // check if we can run unscaled - 0-255.0/0-65535.0 instead of 0-1.0 (which is a tiny bit
+        // faster when doing linear 8->8 or 16->16)
+        if ((!info->alpha_weight) &&
+            (!info->alpha_unweight))  // don't short circuit when alpha weighting (get everything to
+                                      // 0-1.0 as usual)
+            if (((input_type == STBIR_TYPE_UINT8) && (output_type == STBIR_TYPE_UINT8)) ||
+                ((input_type == STBIR_TYPE_UINT16) && (output_type == STBIR_TYPE_UINT16)))
+                non_scaled = 1;
+
+        if (info->output_pixel_layout_internal <= STBIRI_4CHANNEL)
+            encode_pixels =
+                encode_simple_scaled_or_not[output_type == STBIR_TYPE_UINT16][non_scaled];
+        else
+            encode_pixels =
+                encode_alphas_scaled_or_not[(info->output_pixel_layout_internal - STBIRI_RGBA) %
+                                            (STBIRI_AR - STBIRI_RGBA + 1)]
+                                           [output_type == STBIR_TYPE_UINT16][non_scaled];
+    } else {
+        if (info->output_pixel_layout_internal <= STBIRI_4CHANNEL)
+            encode_pixels = encode_simple[output_type - STBIR_TYPE_UINT8_SRGB];
+        else
+            encode_pixels =
+                encode_alphas[(info->output_pixel_layout_internal - STBIRI_RGBA) %
+                              (STBIRI_AR - STBIRI_RGBA + 1)][output_type - STBIR_TYPE_UINT8_SRGB];
+    }
+
+    info->input_type    = input_type;
+    info->output_type   = output_type;
+    info->decode_pixels = decode_pixels;
+    info->encode_pixels = encode_pixels;
+}
+
+static void stbir__clip(int *outx, int *outsubw, int outw, double *u0, double *u1) {
+    double per, adj;
+    int over;
+
+    // do left/top edge
+    if (*outx < 0) {
+        per = ((double)*outx) / ((double)*outsubw);  // is negative
+        adj = per * (*u1 - *u0);
+        *u0 -= adj;  // increases u0
+        *outx = 0;
+    }
+
+    // do right/bot edge
+    over = outw - (*outx + *outsubw);
+    if (over < 0) {
+        per = ((double)over) / ((double)*outsubw);  // is negative
+        adj = per * (*u1 - *u0);
+        *u1 += adj;  // decrease u1
+        *outsubw = outw - *outx;
+    }
+}
+
+// converts a double to a rational that has less than one float bit of error (returns 0 if unable to
+// do so)
+static int stbir__double_to_rational(double f, stbir_uint32 limit, stbir_uint32 *numer,
+                                     stbir_uint32 *denom,
+                                     int limit_denom)  // limit_denom (1) or limit numer (0)
+{
+    double err;
+    stbir_uint64 top, bot;
+    stbir_uint64 numer_last     = 0;
+    stbir_uint64 denom_last     = 1;
+    stbir_uint64 numer_estimate = 1;
+    stbir_uint64 denom_estimate = 0;
+
+    // scale to past float error range
+    top = (stbir_uint64)(f * (double)(1 << 25));
+    bot = 1 << 25;
+
+    // keep refining, but usually stops in a few loops - usually 5 for bad cases
+    for (;;) {
+        stbir_uint64 est, temp;
+
+        // hit limit, break out and do best full range estimate
+        if (((limit_denom) ? denom_estimate : numer_estimate) >= limit)
+            break;
+
+        // is the current error less than 1 bit of a float? if so, we're done
+        if (denom_estimate) {
+            err = ((double)numer_estimate / (double)denom_estimate) - f;
+            if (err < 0.0)
+                err = -err;
+            if (err < (1.0 / (double)(1 << 24))) {
+                // yup, found it
+                *numer = (stbir_uint32)numer_estimate;
+                *denom = (stbir_uint32)denom_estimate;
+                return 1;
+            }
+        }
+
+        // no more refinement bits left? break out and do full range estimate
+        if (bot == 0)
+            break;
+
+        // gcd the estimate bits
+        est  = top / bot;
+        temp = top % bot;
+        top  = bot;
+        bot  = temp;
+
+        // move remainders
+        temp           = est * denom_estimate + denom_last;
+        denom_last     = denom_estimate;
+        denom_estimate = temp;
+
+        // move remainders
+        temp           = est * numer_estimate + numer_last;
+        numer_last     = numer_estimate;
+        numer_estimate = temp;
+    }
+
+    // we didn't fine anything good enough for float, use a full range estimate
+    if (limit_denom) {
+        numer_estimate = (stbir_uint64)(f * (double)limit + 0.5);
+        denom_estimate = limit;
+    } else {
+        numer_estimate = limit;
+        denom_estimate = (stbir_uint64)(((double)limit / f) + 0.5);
+    }
+
+    *numer = (stbir_uint32)numer_estimate;
+    *denom = (stbir_uint32)denom_estimate;
+
+    err = (denom_estimate)
+              ? (((double)(stbir_uint32)numer_estimate / (double)(stbir_uint32)denom_estimate) - f)
+              : 1.0;
+    if (err < 0.0)
+        err = -err;
+    return (err < (1.0 / (double)(1 << 24))) ? 1 : 0;
+}
+
+static int stbir__calculate_region_transform(stbir__scale_info *scale_info, int output_full_range,
+                                             int *output_offset, int output_sub_range,
+                                             int input_full_range, double input_s0,
+                                             double input_s1) {
+    double output_range, input_range, output_s, input_s, ratio, scale;
+
+    input_s = input_s1 - input_s0;
+
+    // null area
+    if ((output_full_range == 0) || (input_full_range == 0) || (output_sub_range == 0) ||
+        (input_s <= stbir__small_float))
+        return 0;
+
+    // are either of the ranges completely out of bounds?
+    if ((*output_offset >= output_full_range) || ((*output_offset + output_sub_range) <= 0) ||
+        (input_s0 >= (1.0f - stbir__small_float)) || (input_s1 <= stbir__small_float))
+        return 0;
+
+    output_range = (double)output_full_range;
+    input_range  = (double)input_full_range;
+
+    output_s = ((double)output_sub_range) / output_range;
+
+    // figure out the scaling to use
+    ratio = output_s / input_s;
+
+    // save scale before clipping
+    scale                 = (output_range / input_range) * ratio;
+    scale_info->scale     = (float)scale;
+    scale_info->inv_scale = (float)(1.0 / scale);
+
+    // clip output area to left/right output edges (and adjust input area)
+    stbir__clip(output_offset, &output_sub_range, output_full_range, &input_s0, &input_s1);
+
+    // recalc input area
+    input_s = input_s1 - input_s0;
+
+    // after clipping do we have zero input area?
+    if (input_s <= stbir__small_float)
+        return 0;
+
+    // calculate and store the starting source offsets in output pixel space
+    scale_info->pixel_shift = (float)(input_s0 * ratio * output_range);
+
+    scale_info->scale_is_rational = stbir__double_to_rational(
+        scale, (scale <= 1.0) ? output_full_range : input_full_range, &scale_info->scale_numerator,
+        &scale_info->scale_denominator, (scale >= 1.0));
+
+    scale_info->input_full_size = input_full_range;
+    scale_info->output_sub_size = output_sub_range;
+
+    return 1;
+}
+
+static void stbir__init_and_set_layout(STBIR_RESIZE *resize, stbir_pixel_layout pixel_layout,
+                                       stbir_datatype data_type) {
+    resize->input_cb                   = 0;
+    resize->output_cb                  = 0;
+    resize->user_data                  = resize;
+    resize->samplers                   = 0;
+    resize->called_alloc               = 0;
+    resize->horizontal_filter          = STBIR_FILTER_DEFAULT;
+    resize->horizontal_filter_kernel   = 0;
+    resize->horizontal_filter_support  = 0;
+    resize->vertical_filter            = STBIR_FILTER_DEFAULT;
+    resize->vertical_filter_kernel     = 0;
+    resize->vertical_filter_support    = 0;
+    resize->horizontal_edge            = STBIR_EDGE_CLAMP;
+    resize->vertical_edge              = STBIR_EDGE_CLAMP;
+    resize->input_s0                   = 0;
+    resize->input_t0                   = 0;
+    resize->input_s1                   = 1;
+    resize->input_t1                   = 1;
+    resize->output_subx                = 0;
+    resize->output_suby                = 0;
+    resize->output_subw                = resize->output_w;
+    resize->output_subh                = resize->output_h;
+    resize->input_data_type            = data_type;
+    resize->output_data_type           = data_type;
+    resize->input_pixel_layout_public  = pixel_layout;
+    resize->output_pixel_layout_public = pixel_layout;
+    resize->needs_rebuild              = 1;
+}
+
+STBIRDEF void stbir_resize_init(STBIR_RESIZE *resize, const void *input_pixels, int input_w,
+                                int input_h, int input_stride_in_bytes,  // stride can be zero
+                                void *output_pixels, int output_w, int output_h,
+                                int output_stride_in_bytes,  // stride can be zero
+                                stbir_pixel_layout pixel_layout, stbir_datatype data_type) {
+    resize->input_pixels           = input_pixels;
+    resize->input_w                = input_w;
+    resize->input_h                = input_h;
+    resize->input_stride_in_bytes  = input_stride_in_bytes;
+    resize->output_pixels          = output_pixels;
+    resize->output_w               = output_w;
+    resize->output_h               = output_h;
+    resize->output_stride_in_bytes = output_stride_in_bytes;
+    resize->fast_alpha             = 0;
+
+    stbir__init_and_set_layout(resize, pixel_layout, data_type);
+}
+
+// You can update parameters any time after resize_init
+STBIRDEF void
+stbir_set_datatypes(STBIR_RESIZE *resize, stbir_datatype input_type,
+                    stbir_datatype output_type)  // by default, datatype from resize_init
+{
+    resize->input_data_type  = input_type;
+    resize->output_data_type = output_type;
+    if ((resize->samplers) && (!resize->needs_rebuild))
+        stbir__update_info_from_resize(resize->samplers, resize);
+}
+
+STBIRDEF void
+stbir_set_pixel_callbacks(STBIR_RESIZE *resize, stbir_input_callback *input_cb,
+                          stbir_output_callback *output_cb)  // no callbacks by default
+{
+    resize->input_cb  = input_cb;
+    resize->output_cb = output_cb;
+
+    if ((resize->samplers) && (!resize->needs_rebuild)) {
+        resize->samplers->in_pixels_cb  = input_cb;
+        resize->samplers->out_pixels_cb = output_cb;
+    }
+}
+
+STBIRDEF void stbir_set_user_data(STBIR_RESIZE *resize,
+                                  void *user_data)  // pass back STBIR_RESIZE* by default
+{
+    resize->user_data = user_data;
+    if ((resize->samplers) && (!resize->needs_rebuild))
+        resize->samplers->user_data = user_data;
+}
+
+STBIRDEF void stbir_set_buffer_ptrs(STBIR_RESIZE *resize, const void *input_pixels,
+                                    int input_stride_in_bytes, void *output_pixels,
+                                    int output_stride_in_bytes) {
+    resize->input_pixels           = input_pixels;
+    resize->input_stride_in_bytes  = input_stride_in_bytes;
+    resize->output_pixels          = output_pixels;
+    resize->output_stride_in_bytes = output_stride_in_bytes;
+    if ((resize->samplers) && (!resize->needs_rebuild))
+        stbir__update_info_from_resize(resize->samplers, resize);
+}
+
+STBIRDEF int stbir_set_edgemodes(STBIR_RESIZE *resize, stbir_edge horizontal_edge,
+                                 stbir_edge vertical_edge)  // CLAMP by default
+{
+    resize->horizontal_edge = horizontal_edge;
+    resize->vertical_edge   = vertical_edge;
+    resize->needs_rebuild   = 1;
+    return 1;
+}
+
+STBIRDEF int stbir_set_filters(
+    STBIR_RESIZE *resize, stbir_filter horizontal_filter,
+    stbir_filter vertical_filter)  // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default
+{
+    resize->horizontal_filter = horizontal_filter;
+    resize->vertical_filter   = vertical_filter;
+    resize->needs_rebuild     = 1;
+    return 1;
+}
+
+STBIRDEF int stbir_set_filter_callbacks(STBIR_RESIZE *resize,
+                                        stbir__kernel_callback *horizontal_filter,
+                                        stbir__support_callback *horizontal_support,
+                                        stbir__kernel_callback *vertical_filter,
+                                        stbir__support_callback *vertical_support) {
+    resize->horizontal_filter_kernel  = horizontal_filter;
+    resize->horizontal_filter_support = horizontal_support;
+    resize->vertical_filter_kernel    = vertical_filter;
+    resize->vertical_filter_support   = vertical_support;
+    resize->needs_rebuild             = 1;
+    return 1;
+}
+
+STBIRDEF int
+stbir_set_pixel_layouts(STBIR_RESIZE *resize, stbir_pixel_layout input_pixel_layout,
+                        stbir_pixel_layout output_pixel_layout)  // sets new pixel layouts
+{
+    resize->input_pixel_layout_public  = input_pixel_layout;
+    resize->output_pixel_layout_public = output_pixel_layout;
+    resize->needs_rebuild              = 1;
+    return 1;
+}
+
+STBIRDEF int
+stbir_set_non_pm_alpha_speed_over_quality(STBIR_RESIZE *resize,
+                                          int non_pma_alpha_speed_over_quality)  // sets alpha speed
+{
+    resize->fast_alpha    = non_pma_alpha_speed_over_quality;
+    resize->needs_rebuild = 1;
+    return 1;
+}
+
+STBIRDEF int stbir_set_input_subrect(STBIR_RESIZE *resize, double s0, double t0, double s1,
+                                     double t1)  // sets input region (full region by default)
+{
+    resize->input_s0      = s0;
+    resize->input_t0      = t0;
+    resize->input_s1      = s1;
+    resize->input_t1      = t1;
+    resize->needs_rebuild = 1;
+
+    // are we inbounds?
+    if ((s1 < stbir__small_float) || ((s1 - s0) < stbir__small_float) ||
+        (t1 < stbir__small_float) || ((t1 - t0) < stbir__small_float) ||
+        (s0 > (1.0f - stbir__small_float)) || (t0 > (1.0f - stbir__small_float)))
+        return 0;
+
+    return 1;
+}
+
+STBIRDEF int stbir_set_output_pixel_subrect(STBIR_RESIZE *resize, int subx, int suby, int subw,
+                                            int subh)  // sets input region (full region by default)
+{
+    resize->output_subx   = subx;
+    resize->output_suby   = suby;
+    resize->output_subw   = subw;
+    resize->output_subh   = subh;
+    resize->needs_rebuild = 1;
+
+    // are we inbounds?
+    if ((subx >= resize->output_w) || ((subx + subw) <= 0) || (suby >= resize->output_h) ||
+        ((suby + subh) <= 0) || (subw == 0) || (subh == 0))
+        return 0;
+
+    return 1;
+}
+
+STBIRDEF int stbir_set_pixel_subrect(STBIR_RESIZE *resize, int subx, int suby, int subw,
+                                     int subh)  // sets both regions (full regions by default)
+{
+    double s0, t0, s1, t1;
+
+    s0 = ((double)subx) / ((double)resize->output_w);
+    t0 = ((double)suby) / ((double)resize->output_h);
+    s1 = ((double)(subx + subw)) / ((double)resize->output_w);
+    t1 = ((double)(suby + subh)) / ((double)resize->output_h);
+
+    resize->input_s0      = s0;
+    resize->input_t0      = t0;
+    resize->input_s1      = s1;
+    resize->input_t1      = t1;
+    resize->output_subx   = subx;
+    resize->output_suby   = suby;
+    resize->output_subw   = subw;
+    resize->output_subh   = subh;
+    resize->needs_rebuild = 1;
+
+    // are we inbounds?
+    if ((subx >= resize->output_w) || ((subx + subw) <= 0) || (suby >= resize->output_h) ||
+        ((suby + subh) <= 0) || (subw == 0) || (subh == 0))
+        return 0;
+
+    return 1;
+}
+
+static int stbir__perform_build(STBIR_RESIZE *resize, int splits) {
+    stbir__contributors conservative = {0, 0};
+    stbir__sampler horizontal, vertical;
+    int new_output_subx, new_output_suby;
+    stbir__info *out_info;
+#ifdef STBIR_PROFILE
+    stbir__info
+        profile_infod;  // used to contain building profile info before everything is allocated
+    stbir__info *profile_info = &profile_infod;
+#endif
+
+    // have we already built the samplers?
+    if (resize->samplers)
+        return 0;
+
+#define STBIR_RETURN_ERROR_AND_ASSERT(exp)                                                         \
+    STBIR_ASSERT(!(exp));                                                                          \
+    if (exp)                                                                                       \
+        return 0;
+    STBIR_RETURN_ERROR_AND_ASSERT((unsigned)resize->horizontal_filter >= STBIR_FILTER_OTHER)
+    STBIR_RETURN_ERROR_AND_ASSERT((unsigned)resize->vertical_filter >= STBIR_FILTER_OTHER)
+#undef STBIR_RETURN_ERROR_AND_ASSERT
+
+    if (splits <= 0)
+        return 0;
+
+    STBIR_PROFILE_BUILD_FIRST_START(build);
+
+    new_output_subx = resize->output_subx;
+    new_output_suby = resize->output_suby;
+
+    // do horizontal clip and scale calcs
+    if (!stbir__calculate_region_transform(&horizontal.scale_info, resize->output_w,
+                                           &new_output_subx, resize->output_subw, resize->input_w,
+                                           resize->input_s0, resize->input_s1))
+        return 0;
+
+    // do vertical clip and scale calcs
+    if (!stbir__calculate_region_transform(&vertical.scale_info, resize->output_h, &new_output_suby,
+                                           resize->output_subh, resize->input_h, resize->input_t0,
+                                           resize->input_t1))
+        return 0;
+
+    // if nothing to do, just return
+    if ((horizontal.scale_info.output_sub_size == 0) || (vertical.scale_info.output_sub_size == 0))
+        return 0;
+
+    stbir__set_sampler(&horizontal, resize->horizontal_filter, resize->horizontal_filter_kernel,
+                       resize->horizontal_filter_support, resize->horizontal_edge,
+                       &horizontal.scale_info, 1, resize->user_data);
+    stbir__get_conservative_extents(&horizontal, &conservative, resize->user_data);
+    stbir__set_sampler(&vertical, resize->vertical_filter, resize->horizontal_filter_kernel,
+                       resize->vertical_filter_support, resize->vertical_edge, &vertical.scale_info,
+                       0, resize->user_data);
+
+    if ((vertical.scale_info.output_sub_size / splits) <
+        STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS)  // each split should be a minimum of 4 scanlines
+                                                   // (handwavey choice)
+    {
+        splits = vertical.scale_info.output_sub_size / STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS;
+        if (splits == 0)
+            splits = 1;
+    }
+
+    STBIR_PROFILE_BUILD_START(alloc);
+    out_info = stbir__alloc_internal_mem_and_build_samplers(
+        &horizontal, &vertical, &conservative, resize->input_pixel_layout_public,
+        resize->output_pixel_layout_public, splits, new_output_subx, new_output_suby,
+        resize->fast_alpha, resize->user_data STBIR_ONLY_PROFILE_BUILD_SET_INFO);
+    STBIR_PROFILE_BUILD_END(alloc);
+    STBIR_PROFILE_BUILD_END(build);
+
+    if (out_info) {
+        resize->splits        = splits;
+        resize->samplers      = out_info;
+        resize->needs_rebuild = 0;
+#ifdef STBIR_PROFILE
+        STBIR_MEMCPY(&out_info->profile, &profile_infod.profile, sizeof(out_info->profile));
+#endif
+
+        // update anything that can be changed without recalcing samplers
+        stbir__update_info_from_resize(out_info, resize);
+
+        return splits;
+    }
+
+    return 0;
+}
+
+void stbir_free_samplers(STBIR_RESIZE *resize) {
+    if (resize->samplers) {
+        stbir__free_internal_mem(resize->samplers);
+        resize->samplers     = 0;
+        resize->called_alloc = 0;
+    }
+}
+
+STBIRDEF int stbir_build_samplers_with_splits(STBIR_RESIZE *resize, int splits) {
+    if ((resize->samplers == 0) || (resize->needs_rebuild)) {
+        if (resize->samplers)
+            stbir_free_samplers(resize);
+
+        resize->called_alloc = 1;
+        return stbir__perform_build(resize, splits);
+    }
+
+    STBIR_PROFILE_BUILD_CLEAR(resize->samplers);
+
+    return 1;
+}
+
+STBIRDEF int stbir_build_samplers(STBIR_RESIZE *resize) {
+    return stbir_build_samplers_with_splits(resize, 1);
+}
+
+STBIRDEF int stbir_resize_extended(STBIR_RESIZE *resize) {
+    int result;
+
+    if ((resize->samplers == 0) || (resize->needs_rebuild)) {
+        int alloc_state = resize->called_alloc;  // remember allocated state
+
+        if (resize->samplers) {
+            stbir__free_internal_mem(resize->samplers);
+            resize->samplers = 0;
+        }
+
+        if (!stbir_build_samplers(resize))
+            return 0;
+
+        resize->called_alloc = alloc_state;
+
+        // if build_samplers succeeded (above), but there are no samplers set, then
+        //   the area to stretch into was zero pixels, so don't do anything and return
+        //   success
+        if (resize->samplers == 0)
+            return 1;
+    } else {
+        // didn't build anything - clear it
+        STBIR_PROFILE_BUILD_CLEAR(resize->samplers);
+    }
+
+    // do resize
+    result = stbir__perform_resize(resize->samplers, 0, resize->splits);
+
+    // if we alloced, then free
+    if (!resize->called_alloc) {
+        stbir_free_samplers(resize);
+        resize->samplers = 0;
+    }
+
+    return result;
+}
+
+STBIRDEF int stbir_resize_extended_split(STBIR_RESIZE *resize, int split_start, int split_count) {
+    STBIR_ASSERT(resize->samplers);
+
+    // if we're just doing the whole thing, call full
+    if ((split_start == -1) || ((split_start == 0) && (split_count == resize->splits)))
+        return stbir_resize_extended(resize);
+
+    // you **must** build samplers first when using split resize
+    if ((resize->samplers == 0) || (resize->needs_rebuild))
+        return 0;
+
+    if ((split_start >= resize->splits) || (split_start < 0) ||
+        ((split_start + split_count) > resize->splits) || (split_count <= 0))
+        return 0;
+
+    // do resize
+    return stbir__perform_resize(resize->samplers, split_start, split_count);
+}
+
+static int stbir__check_output_stuff(void **ret_ptr, int *ret_pitch, void *output_pixels,
+                                     int type_size, int output_w, int output_h,
+                                     int output_stride_in_bytes,
+                                     stbir_internal_pixel_layout pixel_layout) {
+    size_t size;
+    int pitch;
+    void *ptr;
+
+    pitch = output_w * type_size * stbir__pixel_channels[pixel_layout];
+    if (pitch == 0)
+        return 0;
+
+    if (output_stride_in_bytes == 0)
+        output_stride_in_bytes = pitch;
+
+    if (output_stride_in_bytes < pitch)
+        return 0;
+
+    size = (size_t)output_stride_in_bytes * (size_t)output_h;
+    if (size == 0)
+        return 0;
+
+    *ret_ptr   = 0;
+    *ret_pitch = output_stride_in_bytes;
+
+    if (output_pixels == 0) {
+        ptr = STBIR_MALLOC(size, 0);
+        if (ptr == 0)
+            return 0;
+
+        *ret_ptr   = ptr;
+        *ret_pitch = pitch;
+    }
+
+    return 1;
+}
+
+STBIRDEF unsigned char *stbir_resize_uint8_linear(const unsigned char *input_pixels, int input_w,
+                                                  int input_h, int input_stride_in_bytes,
+                                                  unsigned char *output_pixels, int output_w,
+                                                  int output_h, int output_stride_in_bytes,
+                                                  stbir_pixel_layout pixel_layout) {
+    STBIR_RESIZE resize;
+    unsigned char *optr;
+    int opitch;
+
+    if (!stbir__check_output_stuff((void **)&optr, &opitch, output_pixels, sizeof(unsigned char),
+                                   output_w, output_h, output_stride_in_bytes,
+                                   stbir__pixel_layout_convert_public_to_internal[pixel_layout]))
+        return 0;
+
+    stbir_resize_init(&resize, input_pixels, input_w, input_h, input_stride_in_bytes,
+                      (optr) ? optr : output_pixels, output_w, output_h, opitch, pixel_layout,
+                      STBIR_TYPE_UINT8);
+
+    if (!stbir_resize_extended(&resize)) {
+        if (optr)
+            STBIR_FREE(optr, 0);
+        return 0;
+    }
+
+    return (optr) ? optr : output_pixels;
+}
+
+STBIRDEF unsigned char *stbir_resize_uint8_srgb(const unsigned char *input_pixels, int input_w,
+                                                int input_h, int input_stride_in_bytes,
+                                                unsigned char *output_pixels, int output_w,
+                                                int output_h, int output_stride_in_bytes,
+                                                stbir_pixel_layout pixel_layout) {
+    STBIR_RESIZE resize;
+    unsigned char *optr;
+    int opitch;
+
+    if (!stbir__check_output_stuff((void **)&optr, &opitch, output_pixels, sizeof(unsigned char),
+                                   output_w, output_h, output_stride_in_bytes,
+                                   stbir__pixel_layout_convert_public_to_internal[pixel_layout]))
+        return 0;
+
+    stbir_resize_init(&resize, input_pixels, input_w, input_h, input_stride_in_bytes,
+                      (optr) ? optr : output_pixels, output_w, output_h, opitch, pixel_layout,
+                      STBIR_TYPE_UINT8_SRGB);
+
+    if (!stbir_resize_extended(&resize)) {
+        if (optr)
+            STBIR_FREE(optr, 0);
+        return 0;
+    }
+
+    return (optr) ? optr : output_pixels;
+}
+
+STBIRDEF float *stbir_resize_float_linear(const float *input_pixels, int input_w, int input_h,
+                                          int input_stride_in_bytes, float *output_pixels,
+                                          int output_w, int output_h, int output_stride_in_bytes,
+                                          stbir_pixel_layout pixel_layout) {
+    STBIR_RESIZE resize;
+    float *optr;
+    int opitch;
+
+    if (!stbir__check_output_stuff((void **)&optr, &opitch, output_pixels, sizeof(float), output_w,
+                                   output_h, output_stride_in_bytes,
+                                   stbir__pixel_layout_convert_public_to_internal[pixel_layout]))
+        return 0;
+
+    stbir_resize_init(&resize, input_pixels, input_w, input_h, input_stride_in_bytes,
+                      (optr) ? optr : output_pixels, output_w, output_h, opitch, pixel_layout,
+                      STBIR_TYPE_FLOAT);
+
+    if (!stbir_resize_extended(&resize)) {
+        if (optr)
+            STBIR_FREE(optr, 0);
+        return 0;
+    }
+
+    return (optr) ? optr : output_pixels;
+}
+
+STBIRDEF void *stbir_resize(const void *input_pixels, int input_w, int input_h,
+                            int input_stride_in_bytes, void *output_pixels, int output_w,
+                            int output_h, int output_stride_in_bytes,
+                            stbir_pixel_layout pixel_layout, stbir_datatype data_type,
+                            stbir_edge edge, stbir_filter filter) {
+    STBIR_RESIZE resize;
+    float *optr;
+    int opitch;
+
+    if (!stbir__check_output_stuff(
+            (void **)&optr, &opitch, output_pixels, stbir__type_size[data_type], output_w, output_h,
+            output_stride_in_bytes, stbir__pixel_layout_convert_public_to_internal[pixel_layout]))
+        return 0;
+
+    stbir_resize_init(&resize, input_pixels, input_w, input_h, input_stride_in_bytes,
+                      (optr) ? optr : output_pixels, output_w, output_h, output_stride_in_bytes,
+                      pixel_layout, data_type);
+
+    resize.horizontal_edge   = edge;
+    resize.vertical_edge     = edge;
+    resize.horizontal_filter = filter;
+    resize.vertical_filter   = filter;
+
+    if (!stbir_resize_extended(&resize)) {
+        if (optr)
+            STBIR_FREE(optr, 0);
+        return 0;
+    }
+
+    return (optr) ? optr : output_pixels;
+}
+
+#ifdef STBIR_PROFILE
+
+STBIRDEF void stbir_resize_build_profile_info(STBIR_PROFILE_INFO *info,
+                                              STBIR_RESIZE const *resize) {
+    static char const *bdescriptions[6] = {
+        "Building",         "Allocating",          "Horizontal sampler",
+        "Vertical sampler", "Coefficient cleanup", "Coefficient piovot"};
+    stbir__info *samp = resize->samplers;
+    int i;
+
+    typedef int
+        testa[(STBIR__ARRAY_SIZE(bdescriptions) == (STBIR__ARRAY_SIZE(samp->profile.array) - 1))
+                  ? 1
+                  : -1];
+    typedef int testb[(sizeof(samp->profile.array) == (sizeof(samp->profile.named))) ? 1 : -1];
+    typedef int testc[(sizeof(info->clocks) >= (sizeof(samp->profile.named))) ? 1 : -1];
+
+    for (i = 0; i < STBIR__ARRAY_SIZE(bdescriptions); i++)
+        info->clocks[i] = samp->profile.array[i + 1];
+
+    info->total_clocks = samp->profile.named.total;
+    info->descriptions = bdescriptions;
+    info->count        = STBIR__ARRAY_SIZE(bdescriptions);
+}
+
+STBIRDEF void stbir_resize_split_profile_info(STBIR_PROFILE_INFO *info, STBIR_RESIZE const *resize,
+                                              int split_start, int split_count) {
+    static char const *descriptions[7] = {
+        "Looping",         "Vertical sampling", "Horizontal sampling", "Scanline input",
+        "Scanline output", "Alpha weighting",   "Alpha unweighting"};
+    stbir__per_split_info *split_info;
+    int s, i;
+
+    typedef int testa[(STBIR__ARRAY_SIZE(descriptions) ==
+                       (STBIR__ARRAY_SIZE(split_info->profile.array) - 1))
+                          ? 1
+                          : -1];
+    typedef int
+        testb[(sizeof(split_info->profile.array) == (sizeof(split_info->profile.named))) ? 1 : -1];
+    typedef int testc[(sizeof(info->clocks) >= (sizeof(split_info->profile.named))) ? 1 : -1];
+
+    if (split_start == -1) {
+        split_start = 0;
+        split_count = resize->samplers->splits;
+    }
+
+    if ((split_start >= resize->splits) || (split_start < 0) ||
+        ((split_start + split_count) > resize->splits) || (split_count <= 0)) {
+        info->total_clocks = 0;
+        info->descriptions = 0;
+        info->count        = 0;
+        return;
+    }
+
+    split_info = resize->samplers->split_info + split_start;
+
+    // sum up the profile from all the splits
+    for (i = 0; i < STBIR__ARRAY_SIZE(descriptions); i++) {
+        stbir_uint64 sum = 0;
+        for (s = 0; s < split_count; s++)
+            sum += split_info[s].profile.array[i + 1];
+        info->clocks[i] = sum;
+    }
+
+    info->total_clocks = split_info->profile.named.total;
+    info->descriptions = descriptions;
+    info->count        = STBIR__ARRAY_SIZE(descriptions);
+}
+
+STBIRDEF void stbir_resize_extended_profile_info(STBIR_PROFILE_INFO *info,
+                                                 STBIR_RESIZE const *resize) {
+    stbir_resize_split_profile_info(info, resize, -1, 0);
+}
+
+#endif  // STBIR_PROFILE
+
+#undef STBIR_BGR
+#undef STBIR_1CHANNEL
+#undef STBIR_2CHANNEL
+#undef STBIR_RGB
+#undef STBIR_RGBA
+#undef STBIR_4CHANNEL
+#undef STBIR_BGRA
+#undef STBIR_ARGB
+#undef STBIR_ABGR
+#undef STBIR_RA
+#undef STBIR_AR
+#undef STBIR_RGBA_PM
+#undef STBIR_BGRA_PM
+#undef STBIR_ARGB_PM
+#undef STBIR_ABGR_PM
+#undef STBIR_RA_PM
+#undef STBIR_AR_PM
+
+#endif  // STB_IMAGE_RESIZE_IMPLEMENTATION
+
+#else  // STB_IMAGE_RESIZE_HORIZONTALS&STB_IMAGE_RESIZE_DO_VERTICALS
+
+// we reinclude the header file to define all the horizontal functions
+//   specializing each function for the number of coeffs is 20-40% faster *OVERALL*
+
+// by including the header file again this way, we can still debug the functions
+
+#define STBIR_strs_join2(start, mid, end) start##mid##end
+#define STBIR_strs_join1(start, mid, end) STBIR_strs_join2(start, mid, end)
+
+#define STBIR_strs_join24(start, mid1, mid2, end) start##mid1##mid2##end
+#define STBIR_strs_join14(start, mid1, mid2, end) STBIR_strs_join24(start, mid1, mid2, end)
+
+#ifdef STB_IMAGE_RESIZE_DO_CODERS
+
+#ifdef stbir__decode_suffix
+#define STBIR__CODER_NAME(name) STBIR_strs_join1(name, _, stbir__decode_suffix)
+#else
+#define STBIR__CODER_NAME(name) name
+#endif
+
+#ifdef stbir__decode_swizzle
+#define stbir__decode_simdf8_flip(reg)                                                             \
+    STBIR_strs_join1(                                                                              \
+        STBIR_strs_join1(                                                                          \
+            STBIR_strs_join1(STBIR_strs_join1(stbir__simdf8_0123to, stbir__decode_order0,          \
+                                              stbir__decode_order1),                               \
+                             stbir__decode_order2, stbir__decode_order3),                          \
+            stbir__decode_order0, stbir__decode_order1),                                           \
+        stbir__decode_order2, stbir__decode_order3)(reg, reg)
+#define stbir__decode_simdf4_flip(reg)                                                             \
+    STBIR_strs_join1(                                                                              \
+        STBIR_strs_join1(stbir__simdf_0123to, stbir__decode_order0, stbir__decode_order1),         \
+        stbir__decode_order2, stbir__decode_order3)(reg, reg)
+#define stbir__encode_simdf8_unflip(reg)                                                           \
+    STBIR_strs_join1(                                                                              \
+        STBIR_strs_join1(                                                                          \
+            STBIR_strs_join1(STBIR_strs_join1(stbir__simdf8_0123to, stbir__encode_order0,          \
+                                              stbir__encode_order1),                               \
+                             stbir__encode_order2, stbir__encode_order3),                          \
+            stbir__encode_order0, stbir__encode_order1),                                           \
+        stbir__encode_order2, stbir__encode_order3)(reg, reg)
+#define stbir__encode_simdf4_unflip(reg)                                                           \
+    STBIR_strs_join1(                                                                              \
+        STBIR_strs_join1(stbir__simdf_0123to, stbir__encode_order0, stbir__encode_order1),         \
+        stbir__encode_order2, stbir__encode_order3)(reg, reg)
+#else
+#define stbir__decode_order0 0
+#define stbir__decode_order1 1
+#define stbir__decode_order2 2
+#define stbir__decode_order3 3
+#define stbir__encode_order0 0
+#define stbir__encode_order1 1
+#define stbir__encode_order2 2
+#define stbir__encode_order3 3
+#define stbir__decode_simdf8_flip(reg)
+#define stbir__decode_simdf4_flip(reg)
+#define stbir__encode_simdf8_unflip(reg)
+#define stbir__encode_simdf4_unflip(reg)
+#endif
+
+#ifdef STBIR_SIMD8
+#define stbir__encode_simdfX_unflip stbir__encode_simdf8_unflip
+#else
+#define stbir__encode_simdfX_unflip stbir__encode_simdf4_unflip
+#endif
+
+static void STBIR__CODER_NAME(stbir__decode_uint8_linear_scaled)(float *decodep,
+                                                                 int width_times_channels,
+                                                                 void const *inputp) {
+    float STBIR_STREAMOUT_PTR(*) decode = decodep;
+    float *decode_end                   = (float *)decode + width_times_channels;
+    unsigned char const *input          = (unsigned char const *)inputp;
+
+#ifdef STBIR_SIMD
+    unsigned char const *end_input_m16 = input + width_times_channels - 16;
+    if (width_times_channels >= 16) {
+        decode_end -= 16;
+        STBIR_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+#ifdef STBIR_SIMD8
+            stbir__simdi i;
+            stbir__simdi8 o0, o1;
+            stbir__simdf8 of0, of1;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdi_load(i, input);
+            stbir__simdi8_expand_u8_to_u32(o0, o1, i);
+            stbir__simdi8_convert_i32_to_float(of0, o0);
+            stbir__simdi8_convert_i32_to_float(of1, o1);
+            stbir__simdf8_mult(of0, of0, STBIR_max_uint8_as_float_inverted8);
+            stbir__simdf8_mult(of1, of1, STBIR_max_uint8_as_float_inverted8);
+            stbir__decode_simdf8_flip(of0);
+            stbir__decode_simdf8_flip(of1);
+            stbir__simdf8_store(decode + 0, of0);
+            stbir__simdf8_store(decode + 8, of1);
+#else
+            stbir__simdi i, o0, o1, o2, o3;
+            stbir__simdf of0, of1, of2, of3;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdi_load(i, input);
+            stbir__simdi_expand_u8_to_u32(o0, o1, o2, o3, i);
+            stbir__simdi_convert_i32_to_float(of0, o0);
+            stbir__simdi_convert_i32_to_float(of1, o1);
+            stbir__simdi_convert_i32_to_float(of2, o2);
+            stbir__simdi_convert_i32_to_float(of3, o3);
+            stbir__simdf_mult(of0, of0, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted));
+            stbir__simdf_mult(of1, of1, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted));
+            stbir__simdf_mult(of2, of2, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted));
+            stbir__simdf_mult(of3, of3, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted));
+            stbir__decode_simdf4_flip(of0);
+            stbir__decode_simdf4_flip(of1);
+            stbir__decode_simdf4_flip(of2);
+            stbir__decode_simdf4_flip(of3);
+            stbir__simdf_store(decode + 0, of0);
+            stbir__simdf_store(decode + 4, of1);
+            stbir__simdf_store(decode + 8, of2);
+            stbir__simdf_store(decode + 12, of3);
+#endif
+            decode += 16;
+            input += 16;
+            if (decode <= decode_end)
+                continue;
+            if (decode == (decode_end + 16))
+                break;
+            decode = decode_end;  // backup and do last couple
+            input  = end_input_m16;
+        }
+        return;
+    }
+#endif
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    decode += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (decode <= decode_end) {
+        STBIR_SIMD_NO_UNROLL(decode);
+        decode[0 - 4] = ((float)(input[stbir__decode_order0])) * stbir__max_uint8_as_float_inverted;
+        decode[1 - 4] = ((float)(input[stbir__decode_order1])) * stbir__max_uint8_as_float_inverted;
+        decode[2 - 4] = ((float)(input[stbir__decode_order2])) * stbir__max_uint8_as_float_inverted;
+        decode[3 - 4] = ((float)(input[stbir__decode_order3])) * stbir__max_uint8_as_float_inverted;
+        decode += 4;
+        input += 4;
+    }
+    decode -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode < decode_end) {
+        STBIR_NO_UNROLL(decode);
+        decode[0] = ((float)(input[stbir__decode_order0])) * stbir__max_uint8_as_float_inverted;
+#if stbir__coder_min_num >= 2
+        decode[1] = ((float)(input[stbir__decode_order1])) * stbir__max_uint8_as_float_inverted;
+#endif
+#if stbir__coder_min_num >= 3
+        decode[2] = ((float)(input[stbir__decode_order2])) * stbir__max_uint8_as_float_inverted;
+#endif
+        decode += stbir__coder_min_num;
+        input += stbir__coder_min_num;
+    }
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__encode_uint8_linear_scaled)(void *outputp,
+                                                                 int width_times_channels,
+                                                                 float const *encode) {
+    unsigned char STBIR_SIMD_STREAMOUT_PTR(*) output = (unsigned char *)outputp;
+    unsigned char *end_output = ((unsigned char *)output) + width_times_channels;
+
+#ifdef STBIR_SIMD
+    if (width_times_channels >= stbir__simdfX_float_count * 2) {
+        float const *end_encode_m8 = encode + width_times_channels - stbir__simdfX_float_count * 2;
+        end_output -= stbir__simdfX_float_count * 2;
+        STBIR_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+            stbir__simdfX e0, e1;
+            stbir__simdi i;
+            STBIR_SIMD_NO_UNROLL(encode);
+            stbir__simdfX_madd_mem(e0, STBIR_simd_point5X, STBIR_max_uint8_as_floatX, encode);
+            stbir__simdfX_madd_mem(e1, STBIR_simd_point5X, STBIR_max_uint8_as_floatX,
+                                   encode + stbir__simdfX_float_count);
+            stbir__encode_simdfX_unflip(e0);
+            stbir__encode_simdfX_unflip(e1);
+#ifdef STBIR_SIMD8
+            stbir__simdf8_pack_to_16bytes(i, e0, e1);
+            stbir__simdi_store(output, i);
+#else
+            stbir__simdf_pack_to_8bytes(i, e0, e1);
+            stbir__simdi_store2(output, i);
+#endif
+            encode += stbir__simdfX_float_count * 2;
+            output += stbir__simdfX_float_count * 2;
+            if (output <= end_output)
+                continue;
+            if (output == (end_output + stbir__simdfX_float_count * 2))
+                break;
+            output = end_output;  // backup and do last couple
+            encode = end_encode_m8;
+        }
+        return;
+    }
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    STBIR_NO_UNROLL_LOOP_START
+    while (output <= end_output) {
+        stbir__simdf e0;
+        stbir__simdi i0;
+        STBIR_NO_UNROLL(encode);
+        stbir__simdf_load(e0, encode);
+        stbir__simdf_madd(e0, STBIR__CONSTF(STBIR_simd_point5),
+                          STBIR__CONSTF(STBIR_max_uint8_as_float), e0);
+        stbir__encode_simdf4_unflip(e0);
+        stbir__simdf_pack_to_8bytes(i0, e0, e0);  // only use first 4
+        *(int *)(output - 4) = stbir__simdi_to_int(i0);
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (output < end_output) {
+        stbir__simdf e0;
+        STBIR_NO_UNROLL(encode);
+        stbir__simdf_madd1_mem(e0, STBIR__CONSTF(STBIR_simd_point5),
+                               STBIR__CONSTF(STBIR_max_uint8_as_float),
+                               encode + stbir__encode_order0);
+        output[0] = stbir__simdf_convert_float_to_uint8(e0);
+#if stbir__coder_min_num >= 2
+        stbir__simdf_madd1_mem(e0, STBIR__CONSTF(STBIR_simd_point5),
+                               STBIR__CONSTF(STBIR_max_uint8_as_float),
+                               encode + stbir__encode_order1);
+        output[1] = stbir__simdf_convert_float_to_uint8(e0);
+#endif
+#if stbir__coder_min_num >= 3
+        stbir__simdf_madd1_mem(e0, STBIR__CONSTF(STBIR_simd_point5),
+                               STBIR__CONSTF(STBIR_max_uint8_as_float),
+                               encode + stbir__encode_order2);
+        output[2] = stbir__simdf_convert_float_to_uint8(e0);
+#endif
+        output += stbir__coder_min_num;
+        encode += stbir__coder_min_num;
+    }
+#endif
+
+#else
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    while (output <= end_output) {
+        float f;
+        f = encode[stbir__encode_order0] * stbir__max_uint8_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[0 - 4] = (unsigned char)f;
+        f             = encode[stbir__encode_order1] * stbir__max_uint8_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[1 - 4] = (unsigned char)f;
+        f             = encode[stbir__encode_order2] * stbir__max_uint8_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[2 - 4] = (unsigned char)f;
+        f             = encode[stbir__encode_order3] * stbir__max_uint8_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[3 - 4] = (unsigned char)f;
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (output < end_output) {
+        float f;
+        STBIR_NO_UNROLL(encode);
+        f = encode[stbir__encode_order0] * stbir__max_uint8_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[0] = (unsigned char)f;
+#if stbir__coder_min_num >= 2
+        f = encode[stbir__encode_order1] * stbir__max_uint8_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[1] = (unsigned char)f;
+#endif
+#if stbir__coder_min_num >= 3
+        f = encode[stbir__encode_order2] * stbir__max_uint8_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[2] = (unsigned char)f;
+#endif
+        output += stbir__coder_min_num;
+        encode += stbir__coder_min_num;
+    }
+#endif
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__decode_uint8_linear)(float *decodep, int width_times_channels,
+                                                          void const *inputp) {
+    float STBIR_STREAMOUT_PTR(*) decode = decodep;
+    float *decode_end                   = (float *)decode + width_times_channels;
+    unsigned char const *input          = (unsigned char const *)inputp;
+
+#ifdef STBIR_SIMD
+    unsigned char const *end_input_m16 = input + width_times_channels - 16;
+    if (width_times_channels >= 16) {
+        decode_end -= 16;
+        STBIR_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+#ifdef STBIR_SIMD8
+            stbir__simdi i;
+            stbir__simdi8 o0, o1;
+            stbir__simdf8 of0, of1;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdi_load(i, input);
+            stbir__simdi8_expand_u8_to_u32(o0, o1, i);
+            stbir__simdi8_convert_i32_to_float(of0, o0);
+            stbir__simdi8_convert_i32_to_float(of1, o1);
+            stbir__decode_simdf8_flip(of0);
+            stbir__decode_simdf8_flip(of1);
+            stbir__simdf8_store(decode + 0, of0);
+            stbir__simdf8_store(decode + 8, of1);
+#else
+            stbir__simdi i, o0, o1, o2, o3;
+            stbir__simdf of0, of1, of2, of3;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdi_load(i, input);
+            stbir__simdi_expand_u8_to_u32(o0, o1, o2, o3, i);
+            stbir__simdi_convert_i32_to_float(of0, o0);
+            stbir__simdi_convert_i32_to_float(of1, o1);
+            stbir__simdi_convert_i32_to_float(of2, o2);
+            stbir__simdi_convert_i32_to_float(of3, o3);
+            stbir__decode_simdf4_flip(of0);
+            stbir__decode_simdf4_flip(of1);
+            stbir__decode_simdf4_flip(of2);
+            stbir__decode_simdf4_flip(of3);
+            stbir__simdf_store(decode + 0, of0);
+            stbir__simdf_store(decode + 4, of1);
+            stbir__simdf_store(decode + 8, of2);
+            stbir__simdf_store(decode + 12, of3);
+#endif
+            decode += 16;
+            input += 16;
+            if (decode <= decode_end)
+                continue;
+            if (decode == (decode_end + 16))
+                break;
+            decode = decode_end;  // backup and do last couple
+            input  = end_input_m16;
+        }
+        return;
+    }
+#endif
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    decode += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (decode <= decode_end) {
+        STBIR_SIMD_NO_UNROLL(decode);
+        decode[0 - 4] = ((float)(input[stbir__decode_order0]));
+        decode[1 - 4] = ((float)(input[stbir__decode_order1]));
+        decode[2 - 4] = ((float)(input[stbir__decode_order2]));
+        decode[3 - 4] = ((float)(input[stbir__decode_order3]));
+        decode += 4;
+        input += 4;
+    }
+    decode -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode < decode_end) {
+        STBIR_NO_UNROLL(decode);
+        decode[0] = ((float)(input[stbir__decode_order0]));
+#if stbir__coder_min_num >= 2
+        decode[1] = ((float)(input[stbir__decode_order1]));
+#endif
+#if stbir__coder_min_num >= 3
+        decode[2] = ((float)(input[stbir__decode_order2]));
+#endif
+        decode += stbir__coder_min_num;
+        input += stbir__coder_min_num;
+    }
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__encode_uint8_linear)(void *outputp, int width_times_channels,
+                                                          float const *encode) {
+    unsigned char STBIR_SIMD_STREAMOUT_PTR(*) output = (unsigned char *)outputp;
+    unsigned char *end_output = ((unsigned char *)output) + width_times_channels;
+
+#ifdef STBIR_SIMD
+    if (width_times_channels >= stbir__simdfX_float_count * 2) {
+        float const *end_encode_m8 = encode + width_times_channels - stbir__simdfX_float_count * 2;
+        end_output -= stbir__simdfX_float_count * 2;
+        STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+            stbir__simdfX e0, e1;
+            stbir__simdi i;
+            STBIR_SIMD_NO_UNROLL(encode);
+            stbir__simdfX_add_mem(e0, STBIR_simd_point5X, encode);
+            stbir__simdfX_add_mem(e1, STBIR_simd_point5X, encode + stbir__simdfX_float_count);
+            stbir__encode_simdfX_unflip(e0);
+            stbir__encode_simdfX_unflip(e1);
+#ifdef STBIR_SIMD8
+            stbir__simdf8_pack_to_16bytes(i, e0, e1);
+            stbir__simdi_store(output, i);
+#else
+            stbir__simdf_pack_to_8bytes(i, e0, e1);
+            stbir__simdi_store2(output, i);
+#endif
+            encode += stbir__simdfX_float_count * 2;
+            output += stbir__simdfX_float_count * 2;
+            if (output <= end_output)
+                continue;
+            if (output == (end_output + stbir__simdfX_float_count * 2))
+                break;
+            output = end_output;  // backup and do last couple
+            encode = end_encode_m8;
+        }
+        return;
+    }
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    STBIR_NO_UNROLL_LOOP_START
+    while (output <= end_output) {
+        stbir__simdf e0;
+        stbir__simdi i0;
+        STBIR_NO_UNROLL(encode);
+        stbir__simdf_load(e0, encode);
+        stbir__simdf_add(e0, STBIR__CONSTF(STBIR_simd_point5), e0);
+        stbir__encode_simdf4_unflip(e0);
+        stbir__simdf_pack_to_8bytes(i0, e0, e0);  // only use first 4
+        *(int *)(output - 4) = stbir__simdi_to_int(i0);
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+#else
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    while (output <= end_output) {
+        float f;
+        f = encode[stbir__encode_order0] + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[0 - 4] = (unsigned char)f;
+        f             = encode[stbir__encode_order1] + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[1 - 4] = (unsigned char)f;
+        f             = encode[stbir__encode_order2] + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[2 - 4] = (unsigned char)f;
+        f             = encode[stbir__encode_order3] + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[3 - 4] = (unsigned char)f;
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (output < end_output) {
+        float f;
+        STBIR_NO_UNROLL(encode);
+        f = encode[stbir__encode_order0] + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[0] = (unsigned char)f;
+#if stbir__coder_min_num >= 2
+        f = encode[stbir__encode_order1] + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[1] = (unsigned char)f;
+#endif
+#if stbir__coder_min_num >= 3
+        f = encode[stbir__encode_order2] + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[2] = (unsigned char)f;
+#endif
+        output += stbir__coder_min_num;
+        encode += stbir__coder_min_num;
+    }
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__decode_uint8_srgb)(float *decodep, int width_times_channels,
+                                                        void const *inputp) {
+    float STBIR_STREAMOUT_PTR(*) decode = decodep;
+    float const *decode_end             = (float *)decode + width_times_channels;
+    unsigned char const *input          = (unsigned char const *)inputp;
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    decode += 4;
+    while (decode <= decode_end) {
+        decode[0 - 4] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order0]];
+        decode[1 - 4] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order1]];
+        decode[2 - 4] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order2]];
+        decode[3 - 4] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order3]];
+        decode += 4;
+        input += 4;
+    }
+    decode -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode < decode_end) {
+        STBIR_NO_UNROLL(decode);
+        decode[0] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order0]];
+#if stbir__coder_min_num >= 2
+        decode[1] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order1]];
+#endif
+#if stbir__coder_min_num >= 3
+        decode[2] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order2]];
+#endif
+        decode += stbir__coder_min_num;
+        input += stbir__coder_min_num;
+    }
+#endif
+}
+
+#define stbir__min_max_shift20(i, f)                                                               \
+    stbir__simdf_max(f, f, stbir_simdf_casti(STBIR__CONSTI(STBIR_almost_zero)));                   \
+    stbir__simdf_min(f, f, stbir_simdf_casti(STBIR__CONSTI(STBIR_almost_one)));                    \
+    stbir__simdi_32shr(i, stbir_simdi_castf(f), 20);
+
+#define stbir__scale_and_convert(i, f)                                                             \
+    stbir__simdf_madd(f, STBIR__CONSTF(STBIR_simd_point5),                                         \
+                      STBIR__CONSTF(STBIR_max_uint8_as_float), f);                                 \
+    stbir__simdf_max(f, f, stbir__simdf_zeroP());                                                  \
+    stbir__simdf_min(f, f, STBIR__CONSTF(STBIR_max_uint8_as_float));                               \
+    stbir__simdf_convert_float_to_i32(i, f);
+
+#define stbir__linear_to_srgb_finish(i, f)                                                         \
+    {                                                                                              \
+        stbir__simdi temp;                                                                         \
+        stbir__simdi_32shr(temp, stbir_simdi_castf(f), 12);                                        \
+        stbir__simdi_and(temp, temp, STBIR__CONSTI(STBIR_mastissa_mask));                          \
+        stbir__simdi_or(temp, temp, STBIR__CONSTI(STBIR_topscale));                                \
+        stbir__simdi_16madd(i, i, temp);                                                           \
+        stbir__simdi_32shr(i, i, 16);                                                              \
+    }
+
+#define stbir__simdi_table_lookup2(v0, v1, table)                                                  \
+    {                                                                                              \
+        stbir__simdi_u32 temp0, temp1;                                                             \
+        temp0.m128i_i128   = v0;                                                                   \
+        temp1.m128i_i128   = v1;                                                                   \
+        temp0.m128i_u32[0] = table[temp0.m128i_i32[0]];                                            \
+        temp0.m128i_u32[1] = table[temp0.m128i_i32[1]];                                            \
+        temp0.m128i_u32[2] = table[temp0.m128i_i32[2]];                                            \
+        temp0.m128i_u32[3] = table[temp0.m128i_i32[3]];                                            \
+        temp1.m128i_u32[0] = table[temp1.m128i_i32[0]];                                            \
+        temp1.m128i_u32[1] = table[temp1.m128i_i32[1]];                                            \
+        temp1.m128i_u32[2] = table[temp1.m128i_i32[2]];                                            \
+        temp1.m128i_u32[3] = table[temp1.m128i_i32[3]];                                            \
+        v0                 = temp0.m128i_i128;                                                     \
+        v1                 = temp1.m128i_i128;                                                     \
+    }
+
+#define stbir__simdi_table_lookup3(v0, v1, v2, table)                                              \
+    {                                                                                              \
+        stbir__simdi_u32 temp0, temp1, temp2;                                                      \
+        temp0.m128i_i128   = v0;                                                                   \
+        temp1.m128i_i128   = v1;                                                                   \
+        temp2.m128i_i128   = v2;                                                                   \
+        temp0.m128i_u32[0] = table[temp0.m128i_i32[0]];                                            \
+        temp0.m128i_u32[1] = table[temp0.m128i_i32[1]];                                            \
+        temp0.m128i_u32[2] = table[temp0.m128i_i32[2]];                                            \
+        temp0.m128i_u32[3] = table[temp0.m128i_i32[3]];                                            \
+        temp1.m128i_u32[0] = table[temp1.m128i_i32[0]];                                            \
+        temp1.m128i_u32[1] = table[temp1.m128i_i32[1]];                                            \
+        temp1.m128i_u32[2] = table[temp1.m128i_i32[2]];                                            \
+        temp1.m128i_u32[3] = table[temp1.m128i_i32[3]];                                            \
+        temp2.m128i_u32[0] = table[temp2.m128i_i32[0]];                                            \
+        temp2.m128i_u32[1] = table[temp2.m128i_i32[1]];                                            \
+        temp2.m128i_u32[2] = table[temp2.m128i_i32[2]];                                            \
+        temp2.m128i_u32[3] = table[temp2.m128i_i32[3]];                                            \
+        v0                 = temp0.m128i_i128;                                                     \
+        v1                 = temp1.m128i_i128;                                                     \
+        v2                 = temp2.m128i_i128;                                                     \
+    }
+
+#define stbir__simdi_table_lookup4(v0, v1, v2, v3, table)                                          \
+    {                                                                                              \
+        stbir__simdi_u32 temp0, temp1, temp2, temp3;                                               \
+        temp0.m128i_i128   = v0;                                                                   \
+        temp1.m128i_i128   = v1;                                                                   \
+        temp2.m128i_i128   = v2;                                                                   \
+        temp3.m128i_i128   = v3;                                                                   \
+        temp0.m128i_u32[0] = table[temp0.m128i_i32[0]];                                            \
+        temp0.m128i_u32[1] = table[temp0.m128i_i32[1]];                                            \
+        temp0.m128i_u32[2] = table[temp0.m128i_i32[2]];                                            \
+        temp0.m128i_u32[3] = table[temp0.m128i_i32[3]];                                            \
+        temp1.m128i_u32[0] = table[temp1.m128i_i32[0]];                                            \
+        temp1.m128i_u32[1] = table[temp1.m128i_i32[1]];                                            \
+        temp1.m128i_u32[2] = table[temp1.m128i_i32[2]];                                            \
+        temp1.m128i_u32[3] = table[temp1.m128i_i32[3]];                                            \
+        temp2.m128i_u32[0] = table[temp2.m128i_i32[0]];                                            \
+        temp2.m128i_u32[1] = table[temp2.m128i_i32[1]];                                            \
+        temp2.m128i_u32[2] = table[temp2.m128i_i32[2]];                                            \
+        temp2.m128i_u32[3] = table[temp2.m128i_i32[3]];                                            \
+        temp3.m128i_u32[0] = table[temp3.m128i_i32[0]];                                            \
+        temp3.m128i_u32[1] = table[temp3.m128i_i32[1]];                                            \
+        temp3.m128i_u32[2] = table[temp3.m128i_i32[2]];                                            \
+        temp3.m128i_u32[3] = table[temp3.m128i_i32[3]];                                            \
+        v0                 = temp0.m128i_i128;                                                     \
+        v1                 = temp1.m128i_i128;                                                     \
+        v2                 = temp2.m128i_i128;                                                     \
+        v3                 = temp3.m128i_i128;                                                     \
+    }
+
+static void STBIR__CODER_NAME(stbir__encode_uint8_srgb)(void *outputp, int width_times_channels,
+                                                        float const *encode) {
+    unsigned char STBIR_SIMD_STREAMOUT_PTR(*) output = (unsigned char *)outputp;
+    unsigned char *end_output = ((unsigned char *)output) + width_times_channels;
+
+#ifdef STBIR_SIMD
+
+    if (width_times_channels >= 16) {
+        float const *end_encode_m16 = encode + width_times_channels - 16;
+        end_output -= 16;
+        STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+            stbir__simdf f0, f1, f2, f3;
+            stbir__simdi i0, i1, i2, i3;
+            STBIR_SIMD_NO_UNROLL(encode);
+
+            stbir__simdf_load4_transposed(f0, f1, f2, f3, encode);
+
+            stbir__min_max_shift20(i0, f0);
+            stbir__min_max_shift20(i1, f1);
+            stbir__min_max_shift20(i2, f2);
+            stbir__min_max_shift20(i3, f3);
+
+            stbir__simdi_table_lookup4(i0, i1, i2, i3, (fp32_to_srgb8_tab4 - (127 - 13) * 8));
+
+            stbir__linear_to_srgb_finish(i0, f0);
+            stbir__linear_to_srgb_finish(i1, f1);
+            stbir__linear_to_srgb_finish(i2, f2);
+            stbir__linear_to_srgb_finish(i3, f3);
+
+            stbir__interleave_pack_and_store_16_u8(output,
+                                                   STBIR_strs_join1(i, , stbir__encode_order0),
+                                                   STBIR_strs_join1(i, , stbir__encode_order1),
+                                                   STBIR_strs_join1(i, , stbir__encode_order2),
+                                                   STBIR_strs_join1(i, , stbir__encode_order3));
+
+            encode += 16;
+            output += 16;
+            if (output <= end_output)
+                continue;
+            if (output == (end_output + 16))
+                break;
+            output = end_output;  // backup and do last couple
+            encode = end_encode_m16;
+        }
+        return;
+    }
+#endif
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (output <= end_output) {
+        STBIR_SIMD_NO_UNROLL(encode);
+
+        output[0 - 4] = stbir__linear_to_srgb_uchar(encode[stbir__encode_order0]);
+        output[1 - 4] = stbir__linear_to_srgb_uchar(encode[stbir__encode_order1]);
+        output[2 - 4] = stbir__linear_to_srgb_uchar(encode[stbir__encode_order2]);
+        output[3 - 4] = stbir__linear_to_srgb_uchar(encode[stbir__encode_order3]);
+
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (output < end_output) {
+        STBIR_NO_UNROLL(encode);
+        output[0] = stbir__linear_to_srgb_uchar(encode[stbir__encode_order0]);
+#if stbir__coder_min_num >= 2
+        output[1] = stbir__linear_to_srgb_uchar(encode[stbir__encode_order1]);
+#endif
+#if stbir__coder_min_num >= 3
+        output[2] = stbir__linear_to_srgb_uchar(encode[stbir__encode_order2]);
+#endif
+        output += stbir__coder_min_num;
+        encode += stbir__coder_min_num;
+    }
+#endif
+}
+
+#if (stbir__coder_min_num == 4) ||                                                                 \
+    ((stbir__coder_min_num == 1) && (!defined(stbir__decode_swizzle)))
+
+static void STBIR__CODER_NAME(stbir__decode_uint8_srgb4_linearalpha)(float *decodep,
+                                                                     int width_times_channels,
+                                                                     void const *inputp) {
+    float STBIR_STREAMOUT_PTR(*) decode = decodep;
+    float const *decode_end             = (float *)decode + width_times_channels;
+    unsigned char const *input          = (unsigned char const *)inputp;
+    do {
+        decode[0] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order0]];
+        decode[1] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order1]];
+        decode[2] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order2]];
+        decode[3] = ((float)input[stbir__decode_order3]) * stbir__max_uint8_as_float_inverted;
+        input += 4;
+        decode += 4;
+    } while (decode < decode_end);
+}
+
+static void STBIR__CODER_NAME(stbir__encode_uint8_srgb4_linearalpha)(void *outputp,
+                                                                     int width_times_channels,
+                                                                     float const *encode) {
+    unsigned char STBIR_SIMD_STREAMOUT_PTR(*) output = (unsigned char *)outputp;
+    unsigned char *end_output = ((unsigned char *)output) + width_times_channels;
+
+#ifdef STBIR_SIMD
+
+    if (width_times_channels >= 16) {
+        float const *end_encode_m16 = encode + width_times_channels - 16;
+        end_output -= 16;
+        STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+            stbir__simdf f0, f1, f2, f3;
+            stbir__simdi i0, i1, i2, i3;
+
+            STBIR_SIMD_NO_UNROLL(encode);
+            stbir__simdf_load4_transposed(f0, f1, f2, f3, encode);
+
+            stbir__min_max_shift20(i0, f0);
+            stbir__min_max_shift20(i1, f1);
+            stbir__min_max_shift20(i2, f2);
+            stbir__scale_and_convert(i3, f3);
+
+            stbir__simdi_table_lookup3(i0, i1, i2, (fp32_to_srgb8_tab4 - (127 - 13) * 8));
+
+            stbir__linear_to_srgb_finish(i0, f0);
+            stbir__linear_to_srgb_finish(i1, f1);
+            stbir__linear_to_srgb_finish(i2, f2);
+
+            stbir__interleave_pack_and_store_16_u8(output,
+                                                   STBIR_strs_join1(i, , stbir__encode_order0),
+                                                   STBIR_strs_join1(i, , stbir__encode_order1),
+                                                   STBIR_strs_join1(i, , stbir__encode_order2),
+                                                   STBIR_strs_join1(i, , stbir__encode_order3));
+
+            output += 16;
+            encode += 16;
+
+            if (output <= end_output)
+                continue;
+            if (output == (end_output + 16))
+                break;
+            output = end_output;  // backup and do last couple
+            encode = end_encode_m16;
+        }
+        return;
+    }
+#endif
+
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float f;
+        STBIR_SIMD_NO_UNROLL(encode);
+
+        output[stbir__decode_order0] = stbir__linear_to_srgb_uchar(encode[0]);
+        output[stbir__decode_order1] = stbir__linear_to_srgb_uchar(encode[1]);
+        output[stbir__decode_order2] = stbir__linear_to_srgb_uchar(encode[2]);
+
+        f = encode[3] * stbir__max_uint8_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[stbir__decode_order3] = (unsigned char)f;
+
+        output += 4;
+        encode += 4;
+    } while (output < end_output);
+}
+
+#endif
+
+#if (stbir__coder_min_num == 2) ||                                                                 \
+    ((stbir__coder_min_num == 1) && (!defined(stbir__decode_swizzle)))
+
+static void STBIR__CODER_NAME(stbir__decode_uint8_srgb2_linearalpha)(float *decodep,
+                                                                     int width_times_channels,
+                                                                     void const *inputp) {
+    float STBIR_STREAMOUT_PTR(*) decode = decodep;
+    float const *decode_end             = (float *)decode + width_times_channels;
+    unsigned char const *input          = (unsigned char const *)inputp;
+    decode += 4;
+    while (decode <= decode_end) {
+        decode[0 - 4] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order0]];
+        decode[1 - 4] = ((float)input[stbir__decode_order1]) * stbir__max_uint8_as_float_inverted;
+        decode[2 - 4] = stbir__srgb_uchar_to_linear_float[input[stbir__decode_order0 + 2]];
+        decode[3 - 4] =
+            ((float)input[stbir__decode_order1 + 2]) * stbir__max_uint8_as_float_inverted;
+        input += 4;
+        decode += 4;
+    }
+    decode -= 4;
+    if (decode < decode_end) {
+        decode[0] = stbir__srgb_uchar_to_linear_float[stbir__decode_order0];
+        decode[1] = ((float)input[stbir__decode_order1]) * stbir__max_uint8_as_float_inverted;
+    }
+}
+
+static void STBIR__CODER_NAME(stbir__encode_uint8_srgb2_linearalpha)(void *outputp,
+                                                                     int width_times_channels,
+                                                                     float const *encode) {
+    unsigned char STBIR_SIMD_STREAMOUT_PTR(*) output = (unsigned char *)outputp;
+    unsigned char *end_output = ((unsigned char *)output) + width_times_channels;
+
+#ifdef STBIR_SIMD
+
+    if (width_times_channels >= 16) {
+        float const *end_encode_m16 = encode + width_times_channels - 16;
+        end_output -= 16;
+        STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+            stbir__simdf f0, f1, f2, f3;
+            stbir__simdi i0, i1, i2, i3;
+
+            STBIR_SIMD_NO_UNROLL(encode);
+            stbir__simdf_load4_transposed(f0, f1, f2, f3, encode);
+
+            stbir__min_max_shift20(i0, f0);
+            stbir__scale_and_convert(i1, f1);
+            stbir__min_max_shift20(i2, f2);
+            stbir__scale_and_convert(i3, f3);
+
+            stbir__simdi_table_lookup2(i0, i2, (fp32_to_srgb8_tab4 - (127 - 13) * 8));
+
+            stbir__linear_to_srgb_finish(i0, f0);
+            stbir__linear_to_srgb_finish(i2, f2);
+
+            stbir__interleave_pack_and_store_16_u8(output,
+                                                   STBIR_strs_join1(i, , stbir__encode_order0),
+                                                   STBIR_strs_join1(i, , stbir__encode_order1),
+                                                   STBIR_strs_join1(i, , stbir__encode_order2),
+                                                   STBIR_strs_join1(i, , stbir__encode_order3));
+
+            output += 16;
+            encode += 16;
+            if (output <= end_output)
+                continue;
+            if (output == (end_output + 16))
+                break;
+            output = end_output;  // backup and do last couple
+            encode = end_encode_m16;
+        }
+        return;
+    }
+#endif
+
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float f;
+        STBIR_SIMD_NO_UNROLL(encode);
+
+        output[stbir__decode_order0] = stbir__linear_to_srgb_uchar(encode[0]);
+
+        f = encode[1] * stbir__max_uint8_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 255);
+        output[stbir__decode_order1] = (unsigned char)f;
+
+        output += 2;
+        encode += 2;
+    } while (output < end_output);
+}
+
+#endif
+
+static void STBIR__CODER_NAME(stbir__decode_uint16_linear_scaled)(float *decodep,
+                                                                  int width_times_channels,
+                                                                  void const *inputp) {
+    float STBIR_STREAMOUT_PTR(*) decode = decodep;
+    float *decode_end                   = (float *)decode + width_times_channels;
+    unsigned short const *input         = (unsigned short const *)inputp;
+
+#ifdef STBIR_SIMD
+    unsigned short const *end_input_m8 = input + width_times_channels - 8;
+    if (width_times_channels >= 8) {
+        decode_end -= 8;
+        STBIR_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+#ifdef STBIR_SIMD8
+            stbir__simdi i;
+            stbir__simdi8 o;
+            stbir__simdf8 of;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdi_load(i, input);
+            stbir__simdi8_expand_u16_to_u32(o, i);
+            stbir__simdi8_convert_i32_to_float(of, o);
+            stbir__simdf8_mult(of, of, STBIR_max_uint16_as_float_inverted8);
+            stbir__decode_simdf8_flip(of);
+            stbir__simdf8_store(decode + 0, of);
+#else
+            stbir__simdi i, o0, o1;
+            stbir__simdf of0, of1;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdi_load(i, input);
+            stbir__simdi_expand_u16_to_u32(o0, o1, i);
+            stbir__simdi_convert_i32_to_float(of0, o0);
+            stbir__simdi_convert_i32_to_float(of1, o1);
+            stbir__simdf_mult(of0, of0, STBIR__CONSTF(STBIR_max_uint16_as_float_inverted));
+            stbir__simdf_mult(of1, of1, STBIR__CONSTF(STBIR_max_uint16_as_float_inverted));
+            stbir__decode_simdf4_flip(of0);
+            stbir__decode_simdf4_flip(of1);
+            stbir__simdf_store(decode + 0, of0);
+            stbir__simdf_store(decode + 4, of1);
+#endif
+            decode += 8;
+            input += 8;
+            if (decode <= decode_end)
+                continue;
+            if (decode == (decode_end + 8))
+                break;
+            decode = decode_end;  // backup and do last couple
+            input  = end_input_m8;
+        }
+        return;
+    }
+#endif
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    decode += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (decode <= decode_end) {
+        STBIR_SIMD_NO_UNROLL(decode);
+        decode[0 - 4] =
+            ((float)(input[stbir__decode_order0])) * stbir__max_uint16_as_float_inverted;
+        decode[1 - 4] =
+            ((float)(input[stbir__decode_order1])) * stbir__max_uint16_as_float_inverted;
+        decode[2 - 4] =
+            ((float)(input[stbir__decode_order2])) * stbir__max_uint16_as_float_inverted;
+        decode[3 - 4] =
+            ((float)(input[stbir__decode_order3])) * stbir__max_uint16_as_float_inverted;
+        decode += 4;
+        input += 4;
+    }
+    decode -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode < decode_end) {
+        STBIR_NO_UNROLL(decode);
+        decode[0] = ((float)(input[stbir__decode_order0])) * stbir__max_uint16_as_float_inverted;
+#if stbir__coder_min_num >= 2
+        decode[1] = ((float)(input[stbir__decode_order1])) * stbir__max_uint16_as_float_inverted;
+#endif
+#if stbir__coder_min_num >= 3
+        decode[2] = ((float)(input[stbir__decode_order2])) * stbir__max_uint16_as_float_inverted;
+#endif
+        decode += stbir__coder_min_num;
+        input += stbir__coder_min_num;
+    }
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__encode_uint16_linear_scaled)(void *outputp,
+                                                                  int width_times_channels,
+                                                                  float const *encode) {
+    unsigned short STBIR_SIMD_STREAMOUT_PTR(*) output = (unsigned short *)outputp;
+    unsigned short *end_output = ((unsigned short *)output) + width_times_channels;
+
+#ifdef STBIR_SIMD
+    {
+        if (width_times_channels >= stbir__simdfX_float_count * 2) {
+            float const *end_encode_m8 =
+                encode + width_times_channels - stbir__simdfX_float_count * 2;
+            end_output -= stbir__simdfX_float_count * 2;
+            STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+            for (;;) {
+                stbir__simdfX e0, e1;
+                stbir__simdiX i;
+                STBIR_SIMD_NO_UNROLL(encode);
+                stbir__simdfX_madd_mem(e0, STBIR_simd_point5X, STBIR_max_uint16_as_floatX, encode);
+                stbir__simdfX_madd_mem(e1, STBIR_simd_point5X, STBIR_max_uint16_as_floatX,
+                                       encode + stbir__simdfX_float_count);
+                stbir__encode_simdfX_unflip(e0);
+                stbir__encode_simdfX_unflip(e1);
+                stbir__simdfX_pack_to_words(i, e0, e1);
+                stbir__simdiX_store(output, i);
+                encode += stbir__simdfX_float_count * 2;
+                output += stbir__simdfX_float_count * 2;
+                if (output <= end_output)
+                    continue;
+                if (output == (end_output + stbir__simdfX_float_count * 2))
+                    break;
+                output = end_output;  // backup and do last couple
+                encode = end_encode_m8;
+            }
+            return;
+        }
+    }
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    STBIR_NO_UNROLL_LOOP_START
+    while (output <= end_output) {
+        stbir__simdf e;
+        stbir__simdi i;
+        STBIR_NO_UNROLL(encode);
+        stbir__simdf_load(e, encode);
+        stbir__simdf_madd(e, STBIR__CONSTF(STBIR_simd_point5),
+                          STBIR__CONSTF(STBIR_max_uint16_as_float), e);
+        stbir__encode_simdf4_unflip(e);
+        stbir__simdf_pack_to_8words(i, e, e);  // only use first 4
+        stbir__simdi_store2(output - 4, i);
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (output < end_output) {
+        stbir__simdf e;
+        STBIR_NO_UNROLL(encode);
+        stbir__simdf_madd1_mem(e, STBIR__CONSTF(STBIR_simd_point5),
+                               STBIR__CONSTF(STBIR_max_uint16_as_float),
+                               encode + stbir__encode_order0);
+        output[0] = stbir__simdf_convert_float_to_short(e);
+#if stbir__coder_min_num >= 2
+        stbir__simdf_madd1_mem(e, STBIR__CONSTF(STBIR_simd_point5),
+                               STBIR__CONSTF(STBIR_max_uint16_as_float),
+                               encode + stbir__encode_order1);
+        output[1] = stbir__simdf_convert_float_to_short(e);
+#endif
+#if stbir__coder_min_num >= 3
+        stbir__simdf_madd1_mem(e, STBIR__CONSTF(STBIR_simd_point5),
+                               STBIR__CONSTF(STBIR_max_uint16_as_float),
+                               encode + stbir__encode_order2);
+        output[2] = stbir__simdf_convert_float_to_short(e);
+#endif
+        output += stbir__coder_min_num;
+        encode += stbir__coder_min_num;
+    }
+#endif
+
+#else
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (output <= end_output) {
+        float f;
+        STBIR_SIMD_NO_UNROLL(encode);
+        f = encode[stbir__encode_order0] * stbir__max_uint16_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[0 - 4] = (unsigned short)f;
+        f             = encode[stbir__encode_order1] * stbir__max_uint16_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[1 - 4] = (unsigned short)f;
+        f             = encode[stbir__encode_order2] * stbir__max_uint16_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[2 - 4] = (unsigned short)f;
+        f             = encode[stbir__encode_order3] * stbir__max_uint16_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[3 - 4] = (unsigned short)f;
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (output < end_output) {
+        float f;
+        STBIR_NO_UNROLL(encode);
+        f = encode[stbir__encode_order0] * stbir__max_uint16_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[0] = (unsigned short)f;
+#if stbir__coder_min_num >= 2
+        f = encode[stbir__encode_order1] * stbir__max_uint16_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[1] = (unsigned short)f;
+#endif
+#if stbir__coder_min_num >= 3
+        f = encode[stbir__encode_order2] * stbir__max_uint16_as_float + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[2] = (unsigned short)f;
+#endif
+        output += stbir__coder_min_num;
+        encode += stbir__coder_min_num;
+    }
+#endif
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__decode_uint16_linear)(float *decodep, int width_times_channels,
+                                                           void const *inputp) {
+    float STBIR_STREAMOUT_PTR(*) decode = decodep;
+    float *decode_end                   = (float *)decode + width_times_channels;
+    unsigned short const *input         = (unsigned short const *)inputp;
+
+#ifdef STBIR_SIMD
+    unsigned short const *end_input_m8 = input + width_times_channels - 8;
+    if (width_times_channels >= 8) {
+        decode_end -= 8;
+        STBIR_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+#ifdef STBIR_SIMD8
+            stbir__simdi i;
+            stbir__simdi8 o;
+            stbir__simdf8 of;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdi_load(i, input);
+            stbir__simdi8_expand_u16_to_u32(o, i);
+            stbir__simdi8_convert_i32_to_float(of, o);
+            stbir__decode_simdf8_flip(of);
+            stbir__simdf8_store(decode + 0, of);
+#else
+            stbir__simdi i, o0, o1;
+            stbir__simdf of0, of1;
+            STBIR_NO_UNROLL(decode);
+            stbir__simdi_load(i, input);
+            stbir__simdi_expand_u16_to_u32(o0, o1, i);
+            stbir__simdi_convert_i32_to_float(of0, o0);
+            stbir__simdi_convert_i32_to_float(of1, o1);
+            stbir__decode_simdf4_flip(of0);
+            stbir__decode_simdf4_flip(of1);
+            stbir__simdf_store(decode + 0, of0);
+            stbir__simdf_store(decode + 4, of1);
+#endif
+            decode += 8;
+            input += 8;
+            if (decode <= decode_end)
+                continue;
+            if (decode == (decode_end + 8))
+                break;
+            decode = decode_end;  // backup and do last couple
+            input  = end_input_m8;
+        }
+        return;
+    }
+#endif
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    decode += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (decode <= decode_end) {
+        STBIR_SIMD_NO_UNROLL(decode);
+        decode[0 - 4] = ((float)(input[stbir__decode_order0]));
+        decode[1 - 4] = ((float)(input[stbir__decode_order1]));
+        decode[2 - 4] = ((float)(input[stbir__decode_order2]));
+        decode[3 - 4] = ((float)(input[stbir__decode_order3]));
+        decode += 4;
+        input += 4;
+    }
+    decode -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode < decode_end) {
+        STBIR_NO_UNROLL(decode);
+        decode[0] = ((float)(input[stbir__decode_order0]));
+#if stbir__coder_min_num >= 2
+        decode[1] = ((float)(input[stbir__decode_order1]));
+#endif
+#if stbir__coder_min_num >= 3
+        decode[2] = ((float)(input[stbir__decode_order2]));
+#endif
+        decode += stbir__coder_min_num;
+        input += stbir__coder_min_num;
+    }
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__encode_uint16_linear)(void *outputp, int width_times_channels,
+                                                           float const *encode) {
+    unsigned short STBIR_SIMD_STREAMOUT_PTR(*) output = (unsigned short *)outputp;
+    unsigned short *end_output = ((unsigned short *)output) + width_times_channels;
+
+#ifdef STBIR_SIMD
+    {
+        if (width_times_channels >= stbir__simdfX_float_count * 2) {
+            float const *end_encode_m8 =
+                encode + width_times_channels - stbir__simdfX_float_count * 2;
+            end_output -= stbir__simdfX_float_count * 2;
+            STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+            for (;;) {
+                stbir__simdfX e0, e1;
+                stbir__simdiX i;
+                STBIR_SIMD_NO_UNROLL(encode);
+                stbir__simdfX_add_mem(e0, STBIR_simd_point5X, encode);
+                stbir__simdfX_add_mem(e1, STBIR_simd_point5X, encode + stbir__simdfX_float_count);
+                stbir__encode_simdfX_unflip(e0);
+                stbir__encode_simdfX_unflip(e1);
+                stbir__simdfX_pack_to_words(i, e0, e1);
+                stbir__simdiX_store(output, i);
+                encode += stbir__simdfX_float_count * 2;
+                output += stbir__simdfX_float_count * 2;
+                if (output <= end_output)
+                    continue;
+                if (output == (end_output + stbir__simdfX_float_count * 2))
+                    break;
+                output = end_output;  // backup and do last couple
+                encode = end_encode_m8;
+            }
+            return;
+        }
+    }
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    STBIR_NO_UNROLL_LOOP_START
+    while (output <= end_output) {
+        stbir__simdf e;
+        stbir__simdi i;
+        STBIR_NO_UNROLL(encode);
+        stbir__simdf_load(e, encode);
+        stbir__simdf_add(e, STBIR__CONSTF(STBIR_simd_point5), e);
+        stbir__encode_simdf4_unflip(e);
+        stbir__simdf_pack_to_8words(i, e, e);  // only use first 4
+        stbir__simdi_store2(output - 4, i);
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+#else
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (output <= end_output) {
+        float f;
+        STBIR_SIMD_NO_UNROLL(encode);
+        f = encode[stbir__encode_order0] + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[0 - 4] = (unsigned short)f;
+        f             = encode[stbir__encode_order1] + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[1 - 4] = (unsigned short)f;
+        f             = encode[stbir__encode_order2] + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[2 - 4] = (unsigned short)f;
+        f             = encode[stbir__encode_order3] + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[3 - 4] = (unsigned short)f;
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (output < end_output) {
+        float f;
+        STBIR_NO_UNROLL(encode);
+        f = encode[stbir__encode_order0] + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[0] = (unsigned short)f;
+#if stbir__coder_min_num >= 2
+        f = encode[stbir__encode_order1] + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[1] = (unsigned short)f;
+#endif
+#if stbir__coder_min_num >= 3
+        f = encode[stbir__encode_order2] + 0.5f;
+        STBIR_CLAMP(f, 0, 65535);
+        output[2] = (unsigned short)f;
+#endif
+        output += stbir__coder_min_num;
+        encode += stbir__coder_min_num;
+    }
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__decode_half_float_linear)(float *decodep,
+                                                               int width_times_channels,
+                                                               void const *inputp) {
+    float STBIR_STREAMOUT_PTR(*) decode = decodep;
+    float *decode_end                   = (float *)decode + width_times_channels;
+    stbir__FP16 const *input            = (stbir__FP16 const *)inputp;
+
+#ifdef STBIR_SIMD
+    if (width_times_channels >= 8) {
+        stbir__FP16 const *end_input_m8 = input + width_times_channels - 8;
+        decode_end -= 8;
+        STBIR_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+            STBIR_NO_UNROLL(decode);
+
+            stbir__half_to_float_SIMD(decode, input);
+#ifdef stbir__decode_swizzle
+#ifdef STBIR_SIMD8
+            {
+                stbir__simdf8 of;
+                stbir__simdf8_load(of, decode);
+                stbir__decode_simdf8_flip(of);
+                stbir__simdf8_store(decode, of);
+            }
+#else
+            {
+                stbir__simdf of0, of1;
+                stbir__simdf_load(of0, decode);
+                stbir__simdf_load(of1, decode + 4);
+                stbir__decode_simdf4_flip(of0);
+                stbir__decode_simdf4_flip(of1);
+                stbir__simdf_store(decode, of0);
+                stbir__simdf_store(decode + 4, of1);
+            }
+#endif
+#endif
+            decode += 8;
+            input += 8;
+            if (decode <= decode_end)
+                continue;
+            if (decode == (decode_end + 8))
+                break;
+            decode = decode_end;  // backup and do last couple
+            input  = end_input_m8;
+        }
+        return;
+    }
+#endif
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    decode += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (decode <= decode_end) {
+        STBIR_SIMD_NO_UNROLL(decode);
+        decode[0 - 4] = stbir__half_to_float(input[stbir__decode_order0]);
+        decode[1 - 4] = stbir__half_to_float(input[stbir__decode_order1]);
+        decode[2 - 4] = stbir__half_to_float(input[stbir__decode_order2]);
+        decode[3 - 4] = stbir__half_to_float(input[stbir__decode_order3]);
+        decode += 4;
+        input += 4;
+    }
+    decode -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode < decode_end) {
+        STBIR_NO_UNROLL(decode);
+        decode[0] = stbir__half_to_float(input[stbir__decode_order0]);
+#if stbir__coder_min_num >= 2
+        decode[1] = stbir__half_to_float(input[stbir__decode_order1]);
+#endif
+#if stbir__coder_min_num >= 3
+        decode[2] = stbir__half_to_float(input[stbir__decode_order2]);
+#endif
+        decode += stbir__coder_min_num;
+        input += stbir__coder_min_num;
+    }
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__encode_half_float_linear)(void *outputp,
+                                                               int width_times_channels,
+                                                               float const *encode) {
+    stbir__FP16 STBIR_SIMD_STREAMOUT_PTR(*) output = (stbir__FP16 *)outputp;
+    stbir__FP16 *end_output                        = ((stbir__FP16 *)output) + width_times_channels;
+
+#ifdef STBIR_SIMD
+    if (width_times_channels >= 8) {
+        float const *end_encode_m8 = encode + width_times_channels - 8;
+        end_output -= 8;
+        STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+            STBIR_SIMD_NO_UNROLL(encode);
+#ifdef stbir__decode_swizzle
+#ifdef STBIR_SIMD8
+            {
+                stbir__simdf8 of;
+                stbir__simdf8_load(of, encode);
+                stbir__encode_simdf8_unflip(of);
+                stbir__float_to_half_SIMD(output, (float *)&of);
+            }
+#else
+            {
+                stbir__simdf of[2];
+                stbir__simdf_load(of[0], encode);
+                stbir__simdf_load(of[1], encode + 4);
+                stbir__encode_simdf4_unflip(of[0]);
+                stbir__encode_simdf4_unflip(of[1]);
+                stbir__float_to_half_SIMD(output, (float *)of);
+            }
+#endif
+#else
+            stbir__float_to_half_SIMD(output, encode);
+#endif
+            encode += 8;
+            output += 8;
+            if (output <= end_output)
+                continue;
+            if (output == (end_output + 8))
+                break;
+            output = end_output;  // backup and do last couple
+            encode = end_encode_m8;
+        }
+        return;
+    }
+#endif
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (output <= end_output) {
+        STBIR_SIMD_NO_UNROLL(output);
+        output[0 - 4] = stbir__float_to_half(encode[stbir__encode_order0]);
+        output[1 - 4] = stbir__float_to_half(encode[stbir__encode_order1]);
+        output[2 - 4] = stbir__float_to_half(encode[stbir__encode_order2]);
+        output[3 - 4] = stbir__float_to_half(encode[stbir__encode_order3]);
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (output < end_output) {
+        STBIR_NO_UNROLL(output);
+        output[0] = stbir__float_to_half(encode[stbir__encode_order0]);
+#if stbir__coder_min_num >= 2
+        output[1] = stbir__float_to_half(encode[stbir__encode_order1]);
+#endif
+#if stbir__coder_min_num >= 3
+        output[2] = stbir__float_to_half(encode[stbir__encode_order2]);
+#endif
+        output += stbir__coder_min_num;
+        encode += stbir__coder_min_num;
+    }
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__decode_float_linear)(float *decodep, int width_times_channels,
+                                                          void const *inputp) {
+#ifdef stbir__decode_swizzle
+    float STBIR_STREAMOUT_PTR(*) decode = decodep;
+    float *decode_end                   = (float *)decode + width_times_channels;
+    float const *input                  = (float const *)inputp;
+
+#ifdef STBIR_SIMD
+    if (width_times_channels >= 16) {
+        float const *end_input_m16 = input + width_times_channels - 16;
+        decode_end -= 16;
+        STBIR_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+            STBIR_NO_UNROLL(decode);
+#ifdef stbir__decode_swizzle
+#ifdef STBIR_SIMD8
+            {
+                stbir__simdf8 of0, of1;
+                stbir__simdf8_load(of0, input);
+                stbir__simdf8_load(of1, input + 8);
+                stbir__decode_simdf8_flip(of0);
+                stbir__decode_simdf8_flip(of1);
+                stbir__simdf8_store(decode, of0);
+                stbir__simdf8_store(decode + 8, of1);
+            }
+#else
+            {
+                stbir__simdf of0, of1, of2, of3;
+                stbir__simdf_load(of0, input);
+                stbir__simdf_load(of1, input + 4);
+                stbir__simdf_load(of2, input + 8);
+                stbir__simdf_load(of3, input + 12);
+                stbir__decode_simdf4_flip(of0);
+                stbir__decode_simdf4_flip(of1);
+                stbir__decode_simdf4_flip(of2);
+                stbir__decode_simdf4_flip(of3);
+                stbir__simdf_store(decode, of0);
+                stbir__simdf_store(decode + 4, of1);
+                stbir__simdf_store(decode + 8, of2);
+                stbir__simdf_store(decode + 12, of3);
+            }
+#endif
+#endif
+            decode += 16;
+            input += 16;
+            if (decode <= decode_end)
+                continue;
+            if (decode == (decode_end + 16))
+                break;
+            decode = decode_end;  // backup and do last couple
+            input  = end_input_m16;
+        }
+        return;
+    }
+#endif
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    decode += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (decode <= decode_end) {
+        STBIR_SIMD_NO_UNROLL(decode);
+        decode[0 - 4] = input[stbir__decode_order0];
+        decode[1 - 4] = input[stbir__decode_order1];
+        decode[2 - 4] = input[stbir__decode_order2];
+        decode[3 - 4] = input[stbir__decode_order3];
+        decode += 4;
+        input += 4;
+    }
+    decode -= 4;
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (decode < decode_end) {
+        STBIR_NO_UNROLL(decode);
+        decode[0] = input[stbir__decode_order0];
+#if stbir__coder_min_num >= 2
+        decode[1] = input[stbir__decode_order1];
+#endif
+#if stbir__coder_min_num >= 3
+        decode[2] = input[stbir__decode_order2];
+#endif
+        decode += stbir__coder_min_num;
+        input += stbir__coder_min_num;
+    }
+#endif
+
+#else
+
+    if ((void *)decodep != inputp)
+        STBIR_MEMCPY(decodep, inputp, width_times_channels * sizeof(float));
+
+#endif
+}
+
+static void STBIR__CODER_NAME(stbir__encode_float_linear)(void *outputp, int width_times_channels,
+                                                          float const *encode) {
+#if !defined(STBIR_FLOAT_HIGH_CLAMP) && !defined(STBIR_FLOAT_LO_CLAMP) &&                          \
+    !defined(stbir__decode_swizzle)
+
+    if ((void *)outputp != (void *)encode)
+        STBIR_MEMCPY(outputp, encode, width_times_channels * sizeof(float));
+
+#else
+
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = (float *)outputp;
+    float *end_output                        = ((float *)output) + width_times_channels;
+
+#ifdef STBIR_FLOAT_HIGH_CLAMP
+#define stbir_scalar_hi_clamp(v)                                                                   \
+    if (v > STBIR_FLOAT_HIGH_CLAMP)                                                                \
+        v = STBIR_FLOAT_HIGH_CLAMP;
+#else
+#define stbir_scalar_hi_clamp(v)
+#endif
+#ifdef STBIR_FLOAT_LOW_CLAMP
+#define stbir_scalar_lo_clamp(v)                                                                   \
+    if (v < STBIR_FLOAT_LOW_CLAMP)                                                                 \
+        v = STBIR_FLOAT_LOW_CLAMP;
+#else
+#define stbir_scalar_lo_clamp(v)
+#endif
+
+#ifdef STBIR_SIMD
+
+#ifdef STBIR_FLOAT_HIGH_CLAMP
+    const stbir__simdfX high_clamp = stbir__simdf_frepX(STBIR_FLOAT_HIGH_CLAMP);
+#endif
+#ifdef STBIR_FLOAT_LOW_CLAMP
+    const stbir__simdfX low_clamp = stbir__simdf_frepX(STBIR_FLOAT_LOW_CLAMP);
+#endif
+
+    if (width_times_channels >= (stbir__simdfX_float_count * 2)) {
+        float const *end_encode_m8 =
+            encode + width_times_channels - (stbir__simdfX_float_count * 2);
+        end_output -= (stbir__simdfX_float_count * 2);
+        STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+        for (;;) {
+            stbir__simdfX e0, e1;
+            STBIR_SIMD_NO_UNROLL(encode);
+            stbir__simdfX_load(e0, encode);
+            stbir__simdfX_load(e1, encode + stbir__simdfX_float_count);
+#ifdef STBIR_FLOAT_HIGH_CLAMP
+            stbir__simdfX_min(e0, e0, high_clamp);
+            stbir__simdfX_min(e1, e1, high_clamp);
+#endif
+#ifdef STBIR_FLOAT_LOW_CLAMP
+            stbir__simdfX_max(e0, e0, low_clamp);
+            stbir__simdfX_max(e1, e1, low_clamp);
+#endif
+            stbir__encode_simdfX_unflip(e0);
+            stbir__encode_simdfX_unflip(e1);
+            stbir__simdfX_store(output, e0);
+            stbir__simdfX_store(output + stbir__simdfX_float_count, e1);
+            encode += stbir__simdfX_float_count * 2;
+            output += stbir__simdfX_float_count * 2;
+            if (output < end_output)
+                continue;
+            if (output == (end_output + (stbir__simdfX_float_count * 2)))
+                break;
+            output = end_output;  // backup and do last couple
+            encode = end_encode_m8;
+        }
+        return;
+    }
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    STBIR_NO_UNROLL_LOOP_START
+    while (output <= end_output) {
+        stbir__simdf e0;
+        STBIR_NO_UNROLL(encode);
+        stbir__simdf_load(e0, encode);
+#ifdef STBIR_FLOAT_HIGH_CLAMP
+        stbir__simdf_min(e0, e0, high_clamp);
+#endif
+#ifdef STBIR_FLOAT_LOW_CLAMP
+        stbir__simdf_max(e0, e0, low_clamp);
+#endif
+        stbir__encode_simdf4_unflip(e0);
+        stbir__simdf_store(output - 4, e0);
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+#endif
+
+#else
+
+// try to do blocks of 4 when you can
+#if stbir__coder_min_num != 3  // doesn't divide cleanly by four
+    output += 4;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while (output <= end_output) {
+        float e;
+        STBIR_SIMD_NO_UNROLL(encode);
+        e = encode[stbir__encode_order0];
+        stbir_scalar_hi_clamp(e);
+        stbir_scalar_lo_clamp(e);
+        output[0 - 4] = e;
+        e             = encode[stbir__encode_order1];
+        stbir_scalar_hi_clamp(e);
+        stbir_scalar_lo_clamp(e);
+        output[1 - 4] = e;
+        e             = encode[stbir__encode_order2];
+        stbir_scalar_hi_clamp(e);
+        stbir_scalar_lo_clamp(e);
+        output[2 - 4] = e;
+        e             = encode[stbir__encode_order3];
+        stbir_scalar_hi_clamp(e);
+        stbir_scalar_lo_clamp(e);
+        output[3 - 4] = e;
+        output += 4;
+        encode += 4;
+    }
+    output -= 4;
+
+#endif
+
+#endif
+
+// do the remnants
+#if stbir__coder_min_num < 4
+    STBIR_NO_UNROLL_LOOP_START
+    while (output < end_output) {
+        float e;
+        STBIR_NO_UNROLL(encode);
+        e = encode[stbir__encode_order0];
+        stbir_scalar_hi_clamp(e);
+        stbir_scalar_lo_clamp(e);
+        output[0] = e;
+#if stbir__coder_min_num >= 2
+        e = encode[stbir__encode_order1];
+        stbir_scalar_hi_clamp(e);
+        stbir_scalar_lo_clamp(e);
+        output[1] = e;
+#endif
+#if stbir__coder_min_num >= 3
+        e = encode[stbir__encode_order2];
+        stbir_scalar_hi_clamp(e);
+        stbir_scalar_lo_clamp(e);
+        output[2] = e;
+#endif
+        output += stbir__coder_min_num;
+        encode += stbir__coder_min_num;
+    }
+#endif
+
+#endif
+}
+
+#undef stbir__decode_suffix
+#undef stbir__decode_simdf8_flip
+#undef stbir__decode_simdf4_flip
+#undef stbir__decode_order0
+#undef stbir__decode_order1
+#undef stbir__decode_order2
+#undef stbir__decode_order3
+#undef stbir__encode_order0
+#undef stbir__encode_order1
+#undef stbir__encode_order2
+#undef stbir__encode_order3
+#undef stbir__encode_simdf8_unflip
+#undef stbir__encode_simdf4_unflip
+#undef stbir__encode_simdfX_unflip
+#undef STBIR__CODER_NAME
+#undef stbir__coder_min_num
+#undef stbir__decode_swizzle
+#undef stbir_scalar_hi_clamp
+#undef stbir_scalar_lo_clamp
+#undef STB_IMAGE_RESIZE_DO_CODERS
+
+#elif defined(STB_IMAGE_RESIZE_DO_VERTICALS)
+
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#define STBIR_chans(start, end) STBIR_strs_join14(start, STBIR__vertical_channels, end, _cont)
+#else
+#define STBIR_chans(start, end) STBIR_strs_join1(start, STBIR__vertical_channels, end)
+#endif
+
+#if STBIR__vertical_channels >= 1
+#define stbIF0(code) code
+#else
+#define stbIF0(code)
+#endif
+#if STBIR__vertical_channels >= 2
+#define stbIF1(code) code
+#else
+#define stbIF1(code)
+#endif
+#if STBIR__vertical_channels >= 3
+#define stbIF2(code) code
+#else
+#define stbIF2(code)
+#endif
+#if STBIR__vertical_channels >= 4
+#define stbIF3(code) code
+#else
+#define stbIF3(code)
+#endif
+#if STBIR__vertical_channels >= 5
+#define stbIF4(code) code
+#else
+#define stbIF4(code)
+#endif
+#if STBIR__vertical_channels >= 6
+#define stbIF5(code) code
+#else
+#define stbIF5(code)
+#endif
+#if STBIR__vertical_channels >= 7
+#define stbIF6(code) code
+#else
+#define stbIF6(code)
+#endif
+#if STBIR__vertical_channels >= 8
+#define stbIF7(code) code
+#else
+#define stbIF7(code)
+#endif
+
+static void STBIR_chans(stbir__vertical_scatter_with_,
+                        _coeffs)(float **outputs, float const *vertical_coefficients,
+                                 float const *input, float const *input_end) {
+    stbIF0(float STBIR_SIMD_STREAMOUT_PTR(*) output0 = outputs[0];
+           float c0s                                 = vertical_coefficients[0];)
+        stbIF1(float STBIR_SIMD_STREAMOUT_PTR(*) output1 = outputs[1];
+               float c1s                                 = vertical_coefficients[1];)
+            stbIF2(float STBIR_SIMD_STREAMOUT_PTR(*) output2 = outputs[2];
+                   float c2s                                 = vertical_coefficients[2];)
+                stbIF3(float STBIR_SIMD_STREAMOUT_PTR(*) output3 = outputs[3];
+                       float c3s                                 = vertical_coefficients[3];)
+                    stbIF4(float STBIR_SIMD_STREAMOUT_PTR(*) output4 = outputs[4];
+                           float c4s                                 = vertical_coefficients[4];)
+                        stbIF5(float STBIR_SIMD_STREAMOUT_PTR(*) output5 = outputs[5];
+                               float c5s = vertical_coefficients[5];)
+                            stbIF6(float STBIR_SIMD_STREAMOUT_PTR(*) output6 = outputs[6];
+                                   float c6s = vertical_coefficients[6];)
+                                stbIF7(float STBIR_SIMD_STREAMOUT_PTR(*) output7 = outputs[7];
+                                       float c7s = vertical_coefficients[7];)
+
+#ifdef STBIR_SIMD
+    {
+        stbIF0(stbir__simdfX c0 = stbir__simdf_frepX(c0s);)
+            stbIF1(stbir__simdfX c1 = stbir__simdf_frepX(c1s);)
+                stbIF2(stbir__simdfX c2 = stbir__simdf_frepX(c2s);)
+                    stbIF3(stbir__simdfX c3 = stbir__simdf_frepX(c3s);)
+                        stbIF4(stbir__simdfX c4 = stbir__simdf_frepX(c4s);)
+                            stbIF5(stbir__simdfX c5 = stbir__simdf_frepX(c5s);)
+                                stbIF6(stbir__simdfX c6 = stbir__simdf_frepX(c6s);)
+                                    stbIF7(stbir__simdfX c7 = stbir__simdf_frepX(c7s);)
+                                        STBIR_SIMD_NO_UNROLL_LOOP_START while (
+                                            ((char *)input_end - (char *)input) >=
+                                            (16 * stbir__simdfX_float_count)) {
+            stbir__simdfX o0, o1, o2, o3, r0, r1, r2, r3;
+            STBIR_SIMD_NO_UNROLL(output0);
+
+            stbir__simdfX_load(r0, input);
+            stbir__simdfX_load(r1, input + stbir__simdfX_float_count);
+            stbir__simdfX_load(r2, input + (2 * stbir__simdfX_float_count));
+            stbir__simdfX_load(r3, input + (3 * stbir__simdfX_float_count));
+
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+            stbIF0(
+                stbir__simdfX_load(o0, output0);
+                stbir__simdfX_load(o1, output0 + stbir__simdfX_float_count);
+                stbir__simdfX_load(o2, output0 + (2 * stbir__simdfX_float_count));
+                stbir__simdfX_load(o3, output0 + (3 * stbir__simdfX_float_count));
+                stbir__simdfX_madd(o0, o0, r0, c0); stbir__simdfX_madd(o1, o1, r1, c0);
+                stbir__simdfX_madd(o2, o2, r2, c0); stbir__simdfX_madd(o3, o3, r3, c0);
+                stbir__simdfX_store(output0, o0);
+                stbir__simdfX_store(output0 + stbir__simdfX_float_count, o1);
+                stbir__simdfX_store(output0 + (2 * stbir__simdfX_float_count), o2);
+                stbir__simdfX_store(
+                    output0 + (3 * stbir__simdfX_float_count),
+                    o3);) stbIF1(stbir__simdfX_load(o0, output1);
+                                 stbir__simdfX_load(o1, output1 + stbir__simdfX_float_count);
+                                 stbir__simdfX_load(o2, output1 + (2 * stbir__simdfX_float_count));
+                                 stbir__simdfX_load(o3, output1 + (3 * stbir__simdfX_float_count));
+                                 stbir__simdfX_madd(o0, o0, r0, c1);
+                                 stbir__simdfX_madd(o1, o1, r1, c1);
+                                 stbir__simdfX_madd(o2, o2, r2, c1);
+                                 stbir__simdfX_madd(o3, o3, r3, c1);
+                                 stbir__simdfX_store(output1, o0);
+                                 stbir__simdfX_store(output1 + stbir__simdfX_float_count, o1);
+                                 stbir__simdfX_store(output1 + (2 * stbir__simdfX_float_count), o2);
+                                 stbir__simdfX_store(output1 + (3 * stbir__simdfX_float_count),
+                                                     o3);)
+                stbIF2(stbir__simdfX_load(o0, output2);
+                       stbir__simdfX_load(o1, output2 + stbir__simdfX_float_count);
+                       stbir__simdfX_load(o2, output2 + (2 * stbir__simdfX_float_count));
+                       stbir__simdfX_load(o3, output2 + (3 * stbir__simdfX_float_count));
+                       stbir__simdfX_madd(o0, o0, r0, c2); stbir__simdfX_madd(o1, o1, r1, c2);
+                       stbir__simdfX_madd(o2, o2, r2, c2); stbir__simdfX_madd(o3, o3, r3, c2);
+                       stbir__simdfX_store(output2, o0);
+                       stbir__simdfX_store(output2 + stbir__simdfX_float_count, o1);
+                       stbir__simdfX_store(output2 + (2 * stbir__simdfX_float_count), o2);
+                       stbir__simdfX_store(output2 + (3 * stbir__simdfX_float_count), o3);)
+                    stbIF3(stbir__simdfX_load(o0, output3);
+                           stbir__simdfX_load(o1, output3 + stbir__simdfX_float_count);
+                           stbir__simdfX_load(o2, output3 + (2 * stbir__simdfX_float_count));
+                           stbir__simdfX_load(o3, output3 + (3 * stbir__simdfX_float_count));
+                           stbir__simdfX_madd(o0, o0, r0, c3); stbir__simdfX_madd(o1, o1, r1, c3);
+                           stbir__simdfX_madd(o2, o2, r2, c3); stbir__simdfX_madd(o3, o3, r3, c3);
+                           stbir__simdfX_store(output3, o0);
+                           stbir__simdfX_store(output3 + stbir__simdfX_float_count, o1);
+                           stbir__simdfX_store(output3 + (2 * stbir__simdfX_float_count), o2);
+                           stbir__simdfX_store(output3 + (3 * stbir__simdfX_float_count), o3);)
+                        stbIF4(stbir__simdfX_load(o0, output4);
+                               stbir__simdfX_load(o1, output4 + stbir__simdfX_float_count);
+                               stbir__simdfX_load(o2, output4 + (2 * stbir__simdfX_float_count));
+                               stbir__simdfX_load(o3, output4 + (3 * stbir__simdfX_float_count));
+                               stbir__simdfX_madd(o0, o0, r0, c4);
+                               stbir__simdfX_madd(o1, o1, r1, c4);
+                               stbir__simdfX_madd(o2, o2, r2, c4);
+                               stbir__simdfX_madd(o3, o3, r3, c4); stbir__simdfX_store(output4, o0);
+                               stbir__simdfX_store(output4 + stbir__simdfX_float_count, o1);
+                               stbir__simdfX_store(output4 + (2 * stbir__simdfX_float_count), o2);
+                               stbir__simdfX_store(output4 + (3 * stbir__simdfX_float_count), o3);)
+                            stbIF5(
+                                stbir__simdfX_load(o0, output5);
+                                stbir__simdfX_load(o1, output5 + stbir__simdfX_float_count);
+                                stbir__simdfX_load(o2, output5 + (2 * stbir__simdfX_float_count));
+                                stbir__simdfX_load(o3, output5 + (3 * stbir__simdfX_float_count));
+                                stbir__simdfX_madd(o0, o0, r0, c5);
+                                stbir__simdfX_madd(o1, o1, r1, c5);
+                                stbir__simdfX_madd(o2, o2, r2, c5);
+                                stbir__simdfX_madd(o3, o3, r3, c5);
+                                stbir__simdfX_store(output5, o0);
+                                stbir__simdfX_store(output5 + stbir__simdfX_float_count, o1);
+                                stbir__simdfX_store(output5 + (2 * stbir__simdfX_float_count), o2);
+                                stbir__simdfX_store(output5 + (3 * stbir__simdfX_float_count), o3);)
+                                stbIF6(stbir__simdfX_load(o0, output6);
+                                       stbir__simdfX_load(o1, output6 + stbir__simdfX_float_count);
+                                       stbir__simdfX_load(o2, output6 +
+                                                                  (2 * stbir__simdfX_float_count));
+                                       stbir__simdfX_load(o3, output6 +
+                                                                  (3 * stbir__simdfX_float_count));
+                                       stbir__simdfX_madd(o0, o0, r0, c6);
+                                       stbir__simdfX_madd(o1, o1, r1, c6);
+                                       stbir__simdfX_madd(o2, o2, r2, c6);
+                                       stbir__simdfX_madd(o3, o3, r3, c6);
+                                       stbir__simdfX_store(output6, o0);
+                                       stbir__simdfX_store(output6 + stbir__simdfX_float_count, o1);
+                                       stbir__simdfX_store(
+                                           output6 + (2 * stbir__simdfX_float_count), o2);
+                                       stbir__simdfX_store(
+                                           output6 + (3 * stbir__simdfX_float_count), o3);)
+                                    stbIF7(stbir__simdfX_load(o0, output7); stbir__simdfX_load(
+                                               o1, output7 + stbir__simdfX_float_count);
+                                           stbir__simdfX_load(
+                                               o2, output7 + (2 * stbir__simdfX_float_count));
+                                           stbir__simdfX_load(
+                                               o3, output7 + (3 * stbir__simdfX_float_count));
+                                           stbir__simdfX_madd(o0, o0, r0, c7);
+                                           stbir__simdfX_madd(o1, o1, r1, c7);
+                                           stbir__simdfX_madd(o2, o2, r2, c7);
+                                           stbir__simdfX_madd(o3, o3, r3, c7);
+                                           stbir__simdfX_store(output7, o0); stbir__simdfX_store(
+                                               output7 + stbir__simdfX_float_count, o1);
+                                           stbir__simdfX_store(
+                                               output7 + (2 * stbir__simdfX_float_count), o2);
+                                           stbir__simdfX_store(
+                                               output7 + (3 * stbir__simdfX_float_count), o3);)
+#else
+            stbIF0(
+                stbir__simdfX_mult(o0, r0, c0); stbir__simdfX_mult(o1, r1, c0);
+                stbir__simdfX_mult(o2, r2, c0); stbir__simdfX_mult(o3, r3, c0);
+                stbir__simdfX_store(output0, o0);
+                stbir__simdfX_store(output0 + stbir__simdfX_float_count, o1);
+                stbir__simdfX_store(output0 + (2 * stbir__simdfX_float_count), o2);
+                stbir__simdfX_store(
+                    output0 + (3 * stbir__simdfX_float_count),
+                    o3);) stbIF1(stbir__simdfX_mult(o0, r0, c1); stbir__simdfX_mult(o1, r1, c1);
+                                 stbir__simdfX_mult(o2, r2, c1); stbir__simdfX_mult(o3, r3, c1);
+                                 stbir__simdfX_store(output1, o0);
+                                 stbir__simdfX_store(output1 + stbir__simdfX_float_count, o1);
+                                 stbir__simdfX_store(output1 + (2 * stbir__simdfX_float_count), o2);
+                                 stbir__simdfX_store(output1 + (3 * stbir__simdfX_float_count),
+                                                     o3);)
+                stbIF2(stbir__simdfX_mult(o0, r0, c2); stbir__simdfX_mult(o1, r1, c2);
+                       stbir__simdfX_mult(o2, r2, c2); stbir__simdfX_mult(o3, r3, c2);
+                       stbir__simdfX_store(output2, o0);
+                       stbir__simdfX_store(output2 + stbir__simdfX_float_count, o1);
+                       stbir__simdfX_store(output2 + (2 * stbir__simdfX_float_count), o2);
+                       stbir__simdfX_store(output2 + (3 * stbir__simdfX_float_count), o3);)
+                    stbIF3(stbir__simdfX_mult(o0, r0, c3); stbir__simdfX_mult(o1, r1, c3);
+                           stbir__simdfX_mult(o2, r2, c3); stbir__simdfX_mult(o3, r3, c3);
+                           stbir__simdfX_store(output3, o0);
+                           stbir__simdfX_store(output3 + stbir__simdfX_float_count, o1);
+                           stbir__simdfX_store(output3 + (2 * stbir__simdfX_float_count), o2);
+                           stbir__simdfX_store(output3 + (3 * stbir__simdfX_float_count), o3);)
+                        stbIF4(stbir__simdfX_mult(o0, r0, c4); stbir__simdfX_mult(o1, r1, c4);
+                               stbir__simdfX_mult(o2, r2, c4); stbir__simdfX_mult(o3, r3, c4);
+                               stbir__simdfX_store(output4, o0);
+                               stbir__simdfX_store(output4 + stbir__simdfX_float_count, o1);
+                               stbir__simdfX_store(output4 + (2 * stbir__simdfX_float_count), o2);
+                               stbir__simdfX_store(output4 + (3 * stbir__simdfX_float_count), o3);)
+                            stbIF5(
+                                stbir__simdfX_mult(o0, r0, c5); stbir__simdfX_mult(o1, r1, c5);
+                                stbir__simdfX_mult(o2, r2, c5); stbir__simdfX_mult(o3, r3, c5);
+                                stbir__simdfX_store(output5, o0);
+                                stbir__simdfX_store(output5 + stbir__simdfX_float_count, o1);
+                                stbir__simdfX_store(output5 + (2 * stbir__simdfX_float_count), o2);
+                                stbir__simdfX_store(output5 + (3 * stbir__simdfX_float_count), o3);)
+                                stbIF6(
+                                    stbir__simdfX_mult(o0, r0, c6); stbir__simdfX_mult(o1, r1, c6);
+                                    stbir__simdfX_mult(o2, r2, c6); stbir__simdfX_mult(o3, r3, c6);
+                                    stbir__simdfX_store(output6, o0);
+                                    stbir__simdfX_store(output6 + stbir__simdfX_float_count, o1);
+                                    stbir__simdfX_store(output6 + (2 * stbir__simdfX_float_count),
+                                                        o2);
+                                    stbir__simdfX_store(output6 + (3 * stbir__simdfX_float_count),
+                                                        o3);)
+                                    stbIF7(stbir__simdfX_mult(o0, r0, c7);
+                                           stbir__simdfX_mult(o1, r1, c7);
+                                           stbir__simdfX_mult(o2, r2, c7);
+                                           stbir__simdfX_mult(o3, r3, c7);
+                                           stbir__simdfX_store(output7, o0); stbir__simdfX_store(
+                                               output7 + stbir__simdfX_float_count, o1);
+                                           stbir__simdfX_store(
+                                               output7 + (2 * stbir__simdfX_float_count), o2);
+                                           stbir__simdfX_store(
+                                               output7 + (3 * stbir__simdfX_float_count), o3);)
+#endif
+
+                                        input += (4 * stbir__simdfX_float_count);
+            stbIF0(output0 += (4 * stbir__simdfX_float_count);)
+                stbIF1(output1 += (4 * stbir__simdfX_float_count);)
+                    stbIF2(output2 += (4 * stbir__simdfX_float_count);)
+                        stbIF3(output3 += (4 * stbir__simdfX_float_count);)
+                            stbIF4(output4 += (4 * stbir__simdfX_float_count);)
+                                stbIF5(output5 += (4 * stbir__simdfX_float_count);)
+                                    stbIF6(output6 += (4 * stbir__simdfX_float_count);)
+                                        stbIF7(output7 += (4 * stbir__simdfX_float_count);)
+        }
+        STBIR_SIMD_NO_UNROLL_LOOP_START
+        while (((char *)input_end - (char *)input) >= 16) {
+            stbir__simdf o0, r0;
+            STBIR_SIMD_NO_UNROLL(output0);
+
+            stbir__simdf_load(r0, input);
+
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+            stbIF0(stbir__simdf_load(o0, output0);
+                   stbir__simdf_madd(o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c0));
+                   stbir__simdf_store(output0, o0);)
+                stbIF1(stbir__simdf_load(o0, output1);
+                       stbir__simdf_madd(o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c1));
+                       stbir__simdf_store(output1, o0);)
+                    stbIF2(stbir__simdf_load(o0, output2);
+                           stbir__simdf_madd(o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c2));
+                           stbir__simdf_store(output2, o0);)
+                        stbIF3(stbir__simdf_load(o0, output3);
+                               stbir__simdf_madd(o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c3));
+                               stbir__simdf_store(output3, o0);)
+                            stbIF4(stbir__simdf_load(o0, output4); stbir__simdf_madd(
+                                       o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c4));
+                                   stbir__simdf_store(output4, o0);)
+                                stbIF5(stbir__simdf_load(o0, output5); stbir__simdf_madd(
+                                           o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c5));
+                                       stbir__simdf_store(output5, o0);)
+                                    stbIF6(stbir__simdf_load(o0, output6); stbir__simdf_madd(
+                                               o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c6));
+                                           stbir__simdf_store(output6, o0);)
+                                        stbIF7(stbir__simdf_load(o0, output7); stbir__simdf_madd(
+                                                   o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c7));
+                                               stbir__simdf_store(output7, o0);)
+#else
+            stbIF0(stbir__simdf_mult(o0, r0, stbir__if_simdf8_cast_to_simdf4(c0));
+                   stbir__simdf_store(output0, o0);)
+                stbIF1(stbir__simdf_mult(o0, r0, stbir__if_simdf8_cast_to_simdf4(c1));
+                       stbir__simdf_store(output1, o0);)
+                    stbIF2(stbir__simdf_mult(o0, r0, stbir__if_simdf8_cast_to_simdf4(c2));
+                           stbir__simdf_store(output2, o0);)
+                        stbIF3(stbir__simdf_mult(o0, r0, stbir__if_simdf8_cast_to_simdf4(c3));
+                               stbir__simdf_store(output3, o0);)
+                            stbIF4(stbir__simdf_mult(o0, r0, stbir__if_simdf8_cast_to_simdf4(c4));
+                                   stbir__simdf_store(output4, o0);)
+                                stbIF5(
+                                    stbir__simdf_mult(o0, r0, stbir__if_simdf8_cast_to_simdf4(c5));
+                                    stbir__simdf_store(output5, o0);)
+                                    stbIF6(stbir__simdf_mult(o0, r0,
+                                                             stbir__if_simdf8_cast_to_simdf4(c6));
+                                           stbir__simdf_store(output6, o0);)
+                                        stbIF7(stbir__simdf_mult(
+                                                   o0, r0, stbir__if_simdf8_cast_to_simdf4(c7));
+                                               stbir__simdf_store(output7, o0);)
+#endif
+
+                                            input += 4;
+            stbIF0(output0 += 4;) stbIF1(output1 += 4;) stbIF2(output2 += 4;) stbIF3(output3 += 4;)
+                stbIF4(output4 += 4;) stbIF5(output5 += 4;) stbIF6(output6 += 4;)
+                    stbIF7(output7 += 4;)
+        }
+    }
+#else
+                                    STBIR_NO_UNROLL_LOOP_START while (
+                                        ((char *)input_end - (char *)input) >= 16) {
+        float r0, r1, r2, r3;
+        STBIR_NO_UNROLL(input);
+
+        r0 = input[0], r1 = input[1], r2 = input[2], r3 = input[3];
+
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+        stbIF0(output0[0] += (r0 * c0s); output0[1] += (r1 * c0s); output0[2] += (r2 * c0s);
+               output0[3] += (r3 * c0s);)
+            stbIF1(output1[0] += (r0 * c1s); output1[1] += (r1 * c1s); output1[2] += (r2 * c1s);
+                   output1[3] += (r3 * c1s);)
+                stbIF2(output2[0] += (r0 * c2s); output2[1] += (r1 * c2s); output2[2] += (r2 * c2s);
+                       output2[3] += (r3 * c2s);)
+                    stbIF3(output3[0] += (r0 * c3s); output3[1] += (r1 * c3s);
+                           output3[2] += (r2 * c3s); output3[3] += (r3 * c3s);)
+                        stbIF4(output4[0] += (r0 * c4s); output4[1] += (r1 * c4s);
+                               output4[2] += (r2 * c4s); output4[3] += (r3 * c4s);)
+                            stbIF5(output5[0] += (r0 * c5s); output5[1] += (r1 * c5s);
+                                   output5[2] += (r2 * c5s); output5[3] += (r3 * c5s);)
+                                stbIF6(output6[0] += (r0 * c6s); output6[1] += (r1 * c6s);
+                                       output6[2] += (r2 * c6s); output6[3] += (r3 * c6s);)
+                                    stbIF7(output7[0] += (r0 * c7s); output7[1] += (r1 * c7s);
+                                           output7[2] += (r2 * c7s); output7[3] += (r3 * c7s);)
+#else
+        stbIF0(output0[0] = (r0 * c0s); output0[1] = (r1 * c0s); output0[2] = (r2 * c0s);
+               output0[3] = (r3 * c0s);) stbIF1(output1[0] = (r0 * c1s); output1[1] = (r1 * c1s);
+                                                output1[2] = (r2 * c1s); output1[3] = (r3 * c1s);)
+            stbIF2(output2[0] = (r0 * c2s); output2[1] = (r1 * c2s); output2[2] = (r2 * c2s);
+                   output2[3]                                                   = (r3 * c2s);)
+                stbIF3(output3[0] = (r0 * c3s); output3[1] = (r1 * c3s); output3[2] = (r2 * c3s);
+                       output3[3]                                                   = (r3 * c3s);)
+                    stbIF4(output4[0] = (r0 * c4s); output4[1] = (r1 * c4s);
+                           output4[2] = (r2 * c4s); output4[3] = (r3 * c4s);)
+                        stbIF5(output5[0] = (r0 * c5s); output5[1] = (r1 * c5s);
+                               output5[2] = (r2 * c5s); output5[3] = (r3 * c5s);)
+                            stbIF6(output6[0] = (r0 * c6s); output6[1] = (r1 * c6s);
+                                   output6[2] = (r2 * c6s); output6[3] = (r3 * c6s);)
+                                stbIF7(output7[0] = (r0 * c7s); output7[1] = (r1 * c7s);
+                                       output7[2] = (r2 * c7s); output7[3] = (r3 * c7s);)
+#endif
+
+                                        input += 4;
+        stbIF0(output0 += 4;) stbIF1(output1 += 4;) stbIF2(output2 += 4;) stbIF3(output3 += 4;)
+            stbIF4(output4 += 4;) stbIF5(output5 += 4;) stbIF6(output6 += 4;) stbIF7(output7 += 4;)
+    }
+#endif
+    STBIR_NO_UNROLL_LOOP_START
+    while (input < input_end) {
+        float r = input[0];
+        STBIR_NO_UNROLL(output0);
+
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+        stbIF0(output0[0] += (r * c0s);) stbIF1(output1[0] += (r * c1s);)
+            stbIF2(output2[0] += (r * c2s);) stbIF3(output3[0] += (r * c3s);)
+                stbIF4(output4[0] += (r * c4s);) stbIF5(output5[0] += (r * c5s);)
+                    stbIF6(output6[0] += (r * c6s);) stbIF7(output7[0] += (r * c7s);)
+#else
+        stbIF0(output0[0] = (r * c0s);) stbIF1(output1[0] = (r * c1s);)
+            stbIF2(output2[0] = (r * c2s);) stbIF3(output3[0] = (r * c3s);)
+                stbIF4(output4[0] = (r * c4s);) stbIF5(output5[0] = (r * c5s);)
+                    stbIF6(output6[0] = (r * c6s);) stbIF7(output7[0] = (r * c7s);)
+#endif
+
+                        ++ input;
+        stbIF0(++output0;) stbIF1(++output1;) stbIF2(++output2;) stbIF3(++output3;)
+            stbIF4(++output4;) stbIF5(++output5;) stbIF6(++output6;) stbIF7(++output7;)
+    }
+}
+
+static void STBIR_chans(stbir__vertical_gather_with_,
+                        _coeffs)(float *outputp, float const *vertical_coefficients,
+                                 float const **inputs, float const *input0_end) {
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = outputp;
+
+    stbIF0(float const *input0 = inputs[0]; float c0s = vertical_coefficients[0];) stbIF1(
+        float const *input1 = inputs[1]; float c1s = vertical_coefficients[1];)
+        stbIF2(float const *input2 = inputs[2]; float c2s = vertical_coefficients[2];) stbIF3(
+            float const *input3 = inputs[3]; float c3s = vertical_coefficients[3];)
+            stbIF4(float const *input4 = inputs[4]; float c4s = vertical_coefficients[4];) stbIF5(
+                float const *input5 = inputs[5]; float c5s = vertical_coefficients[5];)
+                stbIF6(float const *input6 = inputs[6]; float c6s = vertical_coefficients[6];)
+                    stbIF7(float const *input7 = inputs[7]; float c7s = vertical_coefficients[7];)
+
+#if (STBIR__vertical_channels == 1) && !defined(STB_IMAGE_RESIZE_VERTICAL_CONTINUE)
+        // check single channel one weight
+        if ((c0s >= (1.0f - 0.000001f)) && (c0s <= (1.0f + 0.000001f))) {
+        STBIR_MEMCPY(output, input0, (char *)input0_end - (char *)input0);
+        return;
+    }
+#endif
+
+#ifdef STBIR_SIMD
+    {
+        stbIF0(stbir__simdfX c0 = stbir__simdf_frepX(c0s);)
+            stbIF1(stbir__simdfX c1 = stbir__simdf_frepX(c1s);)
+                stbIF2(stbir__simdfX c2 = stbir__simdf_frepX(c2s);)
+                    stbIF3(stbir__simdfX c3 = stbir__simdf_frepX(c3s);)
+                        stbIF4(stbir__simdfX c4 = stbir__simdf_frepX(c4s);)
+                            stbIF5(stbir__simdfX c5 = stbir__simdf_frepX(c5s);)
+                                stbIF6(stbir__simdfX c6 = stbir__simdf_frepX(c6s);)
+                                    stbIF7(stbir__simdfX c7 = stbir__simdf_frepX(c7s);)
+
+                                        STBIR_SIMD_NO_UNROLL_LOOP_START while (
+                                            ((char *)input0_end - (char *)input0) >=
+                                            (16 * stbir__simdfX_float_count)) {
+            stbir__simdfX o0, o1, o2, o3, r0, r1, r2, r3;
+            STBIR_SIMD_NO_UNROLL(output);
+
+            // prefetch four loop iterations ahead (doesn't affect much for small resizes, but helps
+            // with big ones)
+            stbIF0(stbir__prefetch(input0 + (16 * stbir__simdfX_float_count));) stbIF1(
+                stbir__prefetch(input1 + (16 * stbir__simdfX_float_count));)
+                stbIF2(stbir__prefetch(input2 + (16 * stbir__simdfX_float_count));) stbIF3(
+                    stbir__prefetch(input3 + (16 * stbir__simdfX_float_count));)
+                    stbIF4(stbir__prefetch(input4 + (16 * stbir__simdfX_float_count));) stbIF5(
+                        stbir__prefetch(input5 + (16 * stbir__simdfX_float_count));)
+                        stbIF6(stbir__prefetch(input6 + (16 * stbir__simdfX_float_count));) stbIF7(
+                            stbir__prefetch(input7 + (16 * stbir__simdfX_float_count));)
+
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+                            stbIF0(stbir__simdfX_load(o0, output);
+                                   stbir__simdfX_load(o1, output + stbir__simdfX_float_count);
+                                   stbir__simdfX_load(o2, output + (2 * stbir__simdfX_float_count));
+                                   stbir__simdfX_load(o3, output + (3 * stbir__simdfX_float_count));
+                                   stbir__simdfX_load(r0, input0);
+                                   stbir__simdfX_load(r1, input0 + stbir__simdfX_float_count);
+                                   stbir__simdfX_load(r2, input0 + (2 * stbir__simdfX_float_count));
+                                   stbir__simdfX_load(r3, input0 + (3 * stbir__simdfX_float_count));
+                                   stbir__simdfX_madd(o0, o0, r0, c0);
+                                   stbir__simdfX_madd(o1, o1, r1, c0);
+                                   stbir__simdfX_madd(o2, o2, r2, c0);
+                                   stbir__simdfX_madd(o3, o3, r3, c0);)
+#else
+                            stbIF0(stbir__simdfX_load(r0, input0);
+                                   stbir__simdfX_load(r1, input0 + stbir__simdfX_float_count);
+                                   stbir__simdfX_load(r2, input0 + (2 * stbir__simdfX_float_count));
+                                   stbir__simdfX_load(r3, input0 + (3 * stbir__simdfX_float_count));
+                                   stbir__simdfX_mult(o0, r0, c0); stbir__simdfX_mult(o1, r1, c0);
+                                   stbir__simdfX_mult(o2, r2, c0); stbir__simdfX_mult(o3, r3, c0);)
+#endif
+
+                                stbIF1(
+                                    stbir__simdfX_load(r0, input1);
+                                    stbir__simdfX_load(r1, input1 + stbir__simdfX_float_count);
+                                    stbir__simdfX_load(r2,
+                                                       input1 + (2 * stbir__simdfX_float_count));
+                                    stbir__simdfX_load(r3,
+                                                       input1 + (3 * stbir__simdfX_float_count));
+                                    stbir__simdfX_madd(o0, o0, r0, c1);
+                                    stbir__simdfX_madd(o1, o1, r1, c1);
+                                    stbir__simdfX_madd(o2, o2, r2, c1); stbir__simdfX_madd(
+                                        o3, o3, r3,
+                                        c1);) stbIF2(stbir__simdfX_load(r0, input2);
+                                                     stbir__simdfX_load(
+                                                         r1, input2 + stbir__simdfX_float_count);
+                                                     stbir__simdfX_load(
+                                                         r2,
+                                                         input2 + (2 * stbir__simdfX_float_count));
+                                                     stbir__simdfX_load(
+                                                         r3,
+                                                         input2 + (3 * stbir__simdfX_float_count));
+                                                     stbir__simdfX_madd(o0, o0, r0, c2);
+                                                     stbir__simdfX_madd(o1, o1, r1, c2);
+                                                     stbir__simdfX_madd(o2, o2, r2, c2);
+                                                     stbir__simdfX_madd(o3, o3, r3, c2);)
+                                    stbIF3(stbir__simdfX_load(r0, input3); stbir__simdfX_load(
+                                               r1, input3 + stbir__simdfX_float_count);
+                                           stbir__simdfX_load(
+                                               r2, input3 + (2 * stbir__simdfX_float_count));
+                                           stbir__simdfX_load(
+                                               r3, input3 + (3 * stbir__simdfX_float_count));
+                                           stbir__simdfX_madd(o0, o0, r0, c3);
+                                           stbir__simdfX_madd(o1, o1, r1, c3);
+                                           stbir__simdfX_madd(o2, o2, r2, c3);
+                                           stbir__simdfX_madd(o3, o3, r3, c3);)
+                                        stbIF4(stbir__simdfX_load(r0, input4); stbir__simdfX_load(
+                                                   r1, input4 + stbir__simdfX_float_count);
+                                               stbir__simdfX_load(
+                                                   r2, input4 + (2 * stbir__simdfX_float_count));
+                                               stbir__simdfX_load(
+                                                   r3, input4 + (3 * stbir__simdfX_float_count));
+                                               stbir__simdfX_madd(o0, o0, r0, c4);
+                                               stbir__simdfX_madd(o1, o1, r1, c4);
+                                               stbir__simdfX_madd(o2, o2, r2, c4);
+                                               stbir__simdfX_madd(o3, o3, r3, c4);)
+                                            stbIF5(
+                                                stbir__simdfX_load(r0, input5); stbir__simdfX_load(
+                                                    r1, input5 + stbir__simdfX_float_count);
+                                                stbir__simdfX_load(
+                                                    r2, input5 + (2 * stbir__simdfX_float_count));
+                                                stbir__simdfX_load(
+                                                    r3, input5 + (3 * stbir__simdfX_float_count));
+                                                stbir__simdfX_madd(o0, o0, r0, c5);
+                                                stbir__simdfX_madd(o1, o1, r1, c5);
+                                                stbir__simdfX_madd(o2, o2, r2, c5);
+                                                stbir__simdfX_madd(o3, o3, r3, c5);)
+                                                stbIF6(
+                                                    stbir__simdfX_load(r0, input6);
+                                                    stbir__simdfX_load(
+                                                        r1, input6 + stbir__simdfX_float_count);
+                                                    stbir__simdfX_load(
+                                                        r2,
+                                                        input6 + (2 * stbir__simdfX_float_count));
+                                                    stbir__simdfX_load(
+                                                        r3,
+                                                        input6 + (3 * stbir__simdfX_float_count));
+                                                    stbir__simdfX_madd(o0, o0, r0, c6);
+                                                    stbir__simdfX_madd(o1, o1, r1, c6);
+                                                    stbir__simdfX_madd(o2, o2, r2, c6);
+                                                    stbir__simdfX_madd(o3, o3, r3, c6);)
+                                                    stbIF7(
+                                                        stbir__simdfX_load(r0, input7);
+                                                        stbir__simdfX_load(
+                                                            r1, input7 + stbir__simdfX_float_count);
+                                                        stbir__simdfX_load(
+                                                            r2,
+                                                            input7 +
+                                                                (2 * stbir__simdfX_float_count));
+                                                        stbir__simdfX_load(
+                                                            r3,
+                                                            input7 +
+                                                                (3 * stbir__simdfX_float_count));
+                                                        stbir__simdfX_madd(o0, o0, r0, c7);
+                                                        stbir__simdfX_madd(o1, o1, r1, c7);
+                                                        stbir__simdfX_madd(o2, o2, r2, c7);
+                                                        stbir__simdfX_madd(o3, o3, r3, c7);)
+
+                                                        stbir__simdfX_store(output, o0);
+            stbir__simdfX_store(output + stbir__simdfX_float_count, o1);
+            stbir__simdfX_store(output + (2 * stbir__simdfX_float_count), o2);
+            stbir__simdfX_store(output + (3 * stbir__simdfX_float_count), o3);
+            output += (4 * stbir__simdfX_float_count);
+            stbIF0(input0 += (4 * stbir__simdfX_float_count);)
+                stbIF1(input1 += (4 * stbir__simdfX_float_count);)
+                    stbIF2(input2 += (4 * stbir__simdfX_float_count);)
+                        stbIF3(input3 += (4 * stbir__simdfX_float_count);)
+                            stbIF4(input4 += (4 * stbir__simdfX_float_count);)
+                                stbIF5(input5 += (4 * stbir__simdfX_float_count);)
+                                    stbIF6(input6 += (4 * stbir__simdfX_float_count);)
+                                        stbIF7(input7 += (4 * stbir__simdfX_float_count);)
+        }
+
+        STBIR_SIMD_NO_UNROLL_LOOP_START
+        while (((char *)input0_end - (char *)input0) >= 16) {
+            stbir__simdf o0, r0;
+            STBIR_SIMD_NO_UNROLL(output);
+
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+            stbIF0(stbir__simdf_load(o0, output); stbir__simdf_load(r0, input0);
+                   stbir__simdf_madd(o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c0));)
+#else
+            stbIF0(stbir__simdf_load(r0, input0);
+                   stbir__simdf_mult(o0, r0, stbir__if_simdf8_cast_to_simdf4(c0));)
+#endif
+                stbIF1(stbir__simdf_load(r0, input1);
+                       stbir__simdf_madd(o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c1));)
+                    stbIF2(stbir__simdf_load(r0, input2);
+                           stbir__simdf_madd(o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c2));)
+                        stbIF3(stbir__simdf_load(r0, input3);
+                               stbir__simdf_madd(o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c3));)
+                            stbIF4(stbir__simdf_load(r0, input4); stbir__simdf_madd(
+                                       o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c4));)
+                                stbIF5(stbir__simdf_load(r0, input5); stbir__simdf_madd(
+                                           o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c5));)
+                                    stbIF6(stbir__simdf_load(r0, input6); stbir__simdf_madd(
+                                               o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c6));)
+                                        stbIF7(
+                                            stbir__simdf_load(r0, input7); stbir__simdf_madd(
+                                                o0, o0, r0, stbir__if_simdf8_cast_to_simdf4(c7));)
+
+                                            stbir__simdf_store(output, o0);
+            output += 4;
+            stbIF0(input0 += 4;) stbIF1(input1 += 4;) stbIF2(input2 += 4;) stbIF3(input3 += 4;)
+                stbIF4(input4 += 4;) stbIF5(input5 += 4;) stbIF6(input6 += 4;) stbIF7(input7 += 4;)
+        }
+    }
+#else
+                        STBIR_NO_UNROLL_LOOP_START while (((char *)input0_end - (char *)input0) >=
+                                                          16) {
+        float o0, o1, o2, o3;
+        STBIR_NO_UNROLL(output);
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+        stbIF0(o0 = output[0] + input0[0] * c0s; o1 = output[1] + input0[1] * c0s;
+               o2 = output[2] + input0[2] * c0s; o3 = output[3] + input0[3] * c0s;)
+#else
+        stbIF0(o0 = input0[0] * c0s; o1 = input0[1] * c0s; o2 = input0[2] * c0s;
+               o3                                             = input0[3] * c0s;)
+#endif
+            stbIF1(o0 += input1[0] * c1s; o1 += input1[1] * c1s; o2 += input1[2] * c1s;
+                   o3 += input1[3] * c1s;) stbIF2(o0 += input2[0] * c2s; o1 += input2[1] * c2s;
+                                                  o2 += input2[2] * c2s; o3 += input2[3] * c2s;)
+                stbIF3(o0 += input3[0] * c3s; o1 += input3[1] * c3s; o2 += input3[2] * c3s;
+                       o3 += input3[3] * c3s;) stbIF4(o0 += input4[0] * c4s; o1 += input4[1] * c4s;
+                                                      o2 += input4[2] * c4s; o3 += input4[3] * c4s;)
+                    stbIF5(o0 += input5[0] * c5s; o1 += input5[1] * c5s; o2 += input5[2] * c5s;
+                           o3 += input5[3] * c5s;)
+                        stbIF6(o0 += input6[0] * c6s; o1 += input6[1] * c6s; o2 += input6[2] * c6s;
+                               o3 += input6[3] * c6s;)
+                            stbIF7(o0 += input7[0] * c7s; o1 += input7[1] * c7s;
+                                   o2 += input7[2] * c7s; o3 += input7[3] * c7s;) output[0] = o0;
+        output[1]                                                                           = o1;
+        output[2]                                                                           = o2;
+        output[3]                                                                           = o3;
+        output += 4;
+        stbIF0(input0 += 4;) stbIF1(input1 += 4;) stbIF2(input2 += 4;) stbIF3(input3 += 4;)
+            stbIF4(input4 += 4;) stbIF5(input5 += 4;) stbIF6(input6 += 4;) stbIF7(input7 += 4;)
+    }
+#endif
+    STBIR_NO_UNROLL_LOOP_START
+    while (input0 < input0_end) {
+        float o0;
+        STBIR_NO_UNROLL(output);
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+        stbIF0(o0 = output[0] + input0[0] * c0s;)
+#else
+        stbIF0(o0 = input0[0] * c0s;)
+#endif
+            stbIF1(o0 += input1[0] * c1s;) stbIF2(o0 += input2[0] * c2s;)
+                stbIF3(o0 += input3[0] * c3s;) stbIF4(o0 += input4[0] * c4s;)
+                    stbIF5(o0 += input5[0] * c5s;) stbIF6(o0 += input6[0] * c6s;)
+                        stbIF7(o0 += input7[0] * c7s;) output[0] = o0;
+        ++output;
+        stbIF0(++input0;) stbIF1(++input1;) stbIF2(++input2;) stbIF3(++input3;) stbIF4(++input4;)
+            stbIF5(++input5;) stbIF6(++input6;) stbIF7(++input7;)
+    }
+}
+
+#undef stbIF0
+#undef stbIF1
+#undef stbIF2
+#undef stbIF3
+#undef stbIF4
+#undef stbIF5
+#undef stbIF6
+#undef stbIF7
+#undef STB_IMAGE_RESIZE_DO_VERTICALS
+#undef STBIR__vertical_channels
+#undef STB_IMAGE_RESIZE_DO_HORIZONTALS
+#undef STBIR_strs_join24
+#undef STBIR_strs_join14
+#undef STBIR_chans
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#undef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#endif
+
+#else  // !STB_IMAGE_RESIZE_DO_VERTICALS
+
+#define STBIR_chans(start, end) STBIR_strs_join1(start, STBIR__horizontal_channels, end)
+
+#ifndef stbir__2_coeff_only
+#define stbir__2_coeff_only()                                                                      \
+    stbir__1_coeff_only();                                                                         \
+    stbir__1_coeff_remnant(1);
+#endif
+
+#ifndef stbir__2_coeff_remnant
+#define stbir__2_coeff_remnant(ofs)                                                                \
+    stbir__1_coeff_remnant(ofs);                                                                   \
+    stbir__1_coeff_remnant((ofs) + 1);
+#endif
+
+#ifndef stbir__3_coeff_only
+#define stbir__3_coeff_only()                                                                      \
+    stbir__2_coeff_only();                                                                         \
+    stbir__1_coeff_remnant(2);
+#endif
+
+#ifndef stbir__3_coeff_remnant
+#define stbir__3_coeff_remnant(ofs)                                                                \
+    stbir__2_coeff_remnant(ofs);                                                                   \
+    stbir__1_coeff_remnant((ofs) + 2);
+#endif
+
+#ifndef stbir__3_coeff_setup
+#define stbir__3_coeff_setup()
+#endif
+
+#ifndef stbir__4_coeff_start
+#define stbir__4_coeff_start()                                                                     \
+    stbir__2_coeff_only();                                                                         \
+    stbir__2_coeff_remnant(2);
+#endif
+
+#ifndef stbir__4_coeff_continue_from_4
+#define stbir__4_coeff_continue_from_4(ofs)                                                        \
+    stbir__2_coeff_remnant(ofs);                                                                   \
+    stbir__2_coeff_remnant((ofs) + 2);
+#endif
+
+#ifndef stbir__store_output_tiny
+#define stbir__store_output_tiny stbir__store_output
+#endif
+
+static void STBIR_chans(stbir__horizontal_gather_,
+                        _channels_with_1_coeff)(float *output_buffer, unsigned int output_sub_size,
+                                                float const *decode_buffer,
+                                                stbir__contributors const *horizontal_contributors,
+                                                float const *horizontal_coefficients,
+                                                int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__1_coeff_only();
+        stbir__store_output_tiny();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_,
+                        _channels_with_2_coeffs)(float *output_buffer, unsigned int output_sub_size,
+                                                 float const *decode_buffer,
+                                                 stbir__contributors const *horizontal_contributors,
+                                                 float const *horizontal_coefficients,
+                                                 int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__2_coeff_only();
+        stbir__store_output_tiny();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_,
+                        _channels_with_3_coeffs)(float *output_buffer, unsigned int output_sub_size,
+                                                 float const *decode_buffer,
+                                                 stbir__contributors const *horizontal_contributors,
+                                                 float const *horizontal_coefficients,
+                                                 int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__3_coeff_only();
+        stbir__store_output_tiny();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_,
+                        _channels_with_4_coeffs)(float *output_buffer, unsigned int output_sub_size,
+                                                 float const *decode_buffer,
+                                                 stbir__contributors const *horizontal_contributors,
+                                                 float const *horizontal_coefficients,
+                                                 int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__4_coeff_start();
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_,
+                        _channels_with_5_coeffs)(float *output_buffer, unsigned int output_sub_size,
+                                                 float const *decode_buffer,
+                                                 stbir__contributors const *horizontal_contributors,
+                                                 float const *horizontal_coefficients,
+                                                 int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__4_coeff_start();
+        stbir__1_coeff_remnant(4);
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_,
+                        _channels_with_6_coeffs)(float *output_buffer, unsigned int output_sub_size,
+                                                 float const *decode_buffer,
+                                                 stbir__contributors const *horizontal_contributors,
+                                                 float const *horizontal_coefficients,
+                                                 int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__4_coeff_start();
+        stbir__2_coeff_remnant(4);
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_,
+                        _channels_with_7_coeffs)(float *output_buffer, unsigned int output_sub_size,
+                                                 float const *decode_buffer,
+                                                 stbir__contributors const *horizontal_contributors,
+                                                 float const *horizontal_coefficients,
+                                                 int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    stbir__3_coeff_setup();
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+
+        stbir__4_coeff_start();
+        stbir__3_coeff_remnant(4);
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_,
+                        _channels_with_8_coeffs)(float *output_buffer, unsigned int output_sub_size,
+                                                 float const *decode_buffer,
+                                                 stbir__contributors const *horizontal_contributors,
+                                                 float const *horizontal_coefficients,
+                                                 int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__4_coeff_start();
+        stbir__4_coeff_continue_from_4(4);
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_,
+                        _channels_with_9_coeffs)(float *output_buffer, unsigned int output_sub_size,
+                                                 float const *decode_buffer,
+                                                 stbir__contributors const *horizontal_contributors,
+                                                 float const *horizontal_coefficients,
+                                                 int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__4_coeff_start();
+        stbir__4_coeff_continue_from_4(4);
+        stbir__1_coeff_remnant(8);
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_, _channels_with_10_coeffs)(
+    float *output_buffer, unsigned int output_sub_size, float const *decode_buffer,
+    stbir__contributors const *horizontal_contributors, float const *horizontal_coefficients,
+    int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__4_coeff_start();
+        stbir__4_coeff_continue_from_4(4);
+        stbir__2_coeff_remnant(8);
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_, _channels_with_11_coeffs)(
+    float *output_buffer, unsigned int output_sub_size, float const *decode_buffer,
+    stbir__contributors const *horizontal_contributors, float const *horizontal_coefficients,
+    int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    stbir__3_coeff_setup();
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__4_coeff_start();
+        stbir__4_coeff_continue_from_4(4);
+        stbir__3_coeff_remnant(8);
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_, _channels_with_12_coeffs)(
+    float *output_buffer, unsigned int output_sub_size, float const *decode_buffer,
+    stbir__contributors const *horizontal_contributors, float const *horizontal_coefficients,
+    int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        float const *hc = horizontal_coefficients;
+        stbir__4_coeff_start();
+        stbir__4_coeff_continue_from_4(4);
+        stbir__4_coeff_continue_from_4(8);
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_, _channels_with_n_coeffs_mod0)(
+    float *output_buffer, unsigned int output_sub_size, float const *decode_buffer,
+    stbir__contributors const *horizontal_contributors, float const *horizontal_coefficients,
+    int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        int n = ((horizontal_contributors->n1 - horizontal_contributors->n0 + 1) - 4 + 3) >> 2;
+        float const *hc = horizontal_coefficients;
+
+        stbir__4_coeff_start();
+        STBIR_SIMD_NO_UNROLL_LOOP_START
+        do {
+            hc += 4;
+            decode += STBIR__horizontal_channels * 4;
+            stbir__4_coeff_continue_from_4(0);
+            --n;
+        } while (n > 0);
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_, _channels_with_n_coeffs_mod1)(
+    float *output_buffer, unsigned int output_sub_size, float const *decode_buffer,
+    stbir__contributors const *horizontal_contributors, float const *horizontal_coefficients,
+    int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        int n = ((horizontal_contributors->n1 - horizontal_contributors->n0 + 1) - 5 + 3) >> 2;
+        float const *hc = horizontal_coefficients;
+
+        stbir__4_coeff_start();
+        STBIR_SIMD_NO_UNROLL_LOOP_START
+        do {
+            hc += 4;
+            decode += STBIR__horizontal_channels * 4;
+            stbir__4_coeff_continue_from_4(0);
+            --n;
+        } while (n > 0);
+        stbir__1_coeff_remnant(4);
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_, _channels_with_n_coeffs_mod2)(
+    float *output_buffer, unsigned int output_sub_size, float const *decode_buffer,
+    stbir__contributors const *horizontal_contributors, float const *horizontal_coefficients,
+    int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        int n = ((horizontal_contributors->n1 - horizontal_contributors->n0 + 1) - 6 + 3) >> 2;
+        float const *hc = horizontal_coefficients;
+
+        stbir__4_coeff_start();
+        STBIR_SIMD_NO_UNROLL_LOOP_START
+        do {
+            hc += 4;
+            decode += STBIR__horizontal_channels * 4;
+            stbir__4_coeff_continue_from_4(0);
+            --n;
+        } while (n > 0);
+        stbir__2_coeff_remnant(4);
+
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static void STBIR_chans(stbir__horizontal_gather_, _channels_with_n_coeffs_mod3)(
+    float *output_buffer, unsigned int output_sub_size, float const *decode_buffer,
+    stbir__contributors const *horizontal_contributors, float const *horizontal_coefficients,
+    int coefficient_width) {
+    float const *output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+    float STBIR_SIMD_STREAMOUT_PTR(*) output = output_buffer;
+    stbir__3_coeff_setup();
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+        float const *decode =
+            decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+        int n = ((horizontal_contributors->n1 - horizontal_contributors->n0 + 1) - 7 + 3) >> 2;
+        float const *hc = horizontal_coefficients;
+
+        stbir__4_coeff_start();
+        STBIR_SIMD_NO_UNROLL_LOOP_START
+        do {
+            hc += 4;
+            decode += STBIR__horizontal_channels * 4;
+            stbir__4_coeff_continue_from_4(0);
+            --n;
+        } while (n > 0);
+        stbir__3_coeff_remnant(4);
+
+        stbir__store_output();
+    } while (output < output_end);
+}
+
+static stbir__horizontal_gather_channels_func *STBIR_chans(stbir__horizontal_gather_,
+                                                           _channels_with_n_coeffs_funcs)[4] = {
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_n_coeffs_mod0),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_n_coeffs_mod1),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_n_coeffs_mod2),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_n_coeffs_mod3),
+};
+
+static stbir__horizontal_gather_channels_func *STBIR_chans(stbir__horizontal_gather_,
+                                                           _channels_funcs)[12] = {
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_1_coeff),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_2_coeffs),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_3_coeffs),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_4_coeffs),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_5_coeffs),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_6_coeffs),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_7_coeffs),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_8_coeffs),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_9_coeffs),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_10_coeffs),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_11_coeffs),
+    STBIR_chans(stbir__horizontal_gather_, _channels_with_12_coeffs),
+};
+
+#undef STBIR__horizontal_channels
+#undef STB_IMAGE_RESIZE_DO_HORIZONTALS
+#undef stbir__1_coeff_only
+#undef stbir__1_coeff_remnant
+#undef stbir__2_coeff_only
+#undef stbir__2_coeff_remnant
+#undef stbir__3_coeff_only
+#undef stbir__3_coeff_remnant
+#undef stbir__3_coeff_setup
+#undef stbir__4_coeff_start
+#undef stbir__4_coeff_continue_from_4
+#undef stbir__store_output
+#undef stbir__store_output_tiny
+#undef STBIR_chans
+
+#endif  // HORIZONALS
+
+#undef STBIR_strs_join2
+#undef STBIR_strs_join1
+
+#endif  // STB_IMAGE_RESIZE_DO_HORIZONTALS/VERTICALS/CODERS
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
\ No newline at end of file
diff --git a/lib/stb/stb_image_write.h b/lib/stb/stb_image_write.h
new file mode 100644
index 00000000..f9d7865e
--- /dev/null
+++ b/lib/stb/stb_image_write.h
@@ -0,0 +1,2398 @@
+/* stb_image_write - v1.16 - public domain - http://nothings.org/stb
+   writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015
+                                     no warranty implied; use at your own risk
+
+   Before #including,
+
+       #define STB_IMAGE_WRITE_IMPLEMENTATION
+
+   in the file that you want to have the implementation.
+
+   Will probably not work correctly with strict-aliasing optimizations.
+
+ABOUT:
+
+   This header file is a library for writing images to C stdio or a callback.
+
+   The PNG output is not optimal; it is 20-50% larger than the file
+   written by a decent optimizing implementation; though providing a custom
+   zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that.
+   This library is designed for source code compactness and simplicity,
+   not optimal image file size or run-time performance.
+
+BUILDING:
+
+   You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h.
+   You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace
+   malloc,realloc,free.
+   You can #define STBIW_MEMMOVE() to replace memmove()
+   You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function
+   for PNG compression (instead of the builtin one), it must have the following signature:
+   unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality);
+   The returned data will be freed with STBIW_FREE() (free() by default),
+   so it must be heap allocated with STBIW_MALLOC() (malloc() by default),
+
+UNICODE:
+
+   If compiling for Windows and you wish to use Unicode filenames, compile
+   with
+       #define STBIW_WINDOWS_UTF8
+   and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert
+   Windows wchar_t filenames to utf8.
+
+USAGE:
+
+   There are five functions, one for each image file format:
+
+     int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int
+stride_in_bytes); int stbi_write_bmp(char const *filename, int w, int h, int comp, const void
+*data); int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); int
+stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality); int
+stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
+
+     void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically
+
+   There are also five equivalent functions that use an arbitrary write function. You are
+   expected to open/close your file-equivalent before and after calling these:
+
+     int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const
+void  *data, int stride_in_bytes); int stbi_write_bmp_to_func(stbi_write_func *func, void *context,
+int w, int h, int comp, const void  *data); int stbi_write_tga_to_func(stbi_write_func *func, void
+*context, int w, int h, int comp, const void  *data); int stbi_write_hdr_to_func(stbi_write_func
+*func, void *context, int w, int h, int comp, const float *data); int
+stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void
+*data, int quality);
+
+   where the callback is:
+      void stbi_write_func(void *context, void *data, int size);
+
+   You can configure it with these global variables:
+      int stbi_write_tga_with_rle;             // defaults to true; set to 0 to disable RLE
+      int stbi_write_png_compression_level;    // defaults to 8; set to higher for more compression
+      int stbi_write_force_png_filter;         // defaults to -1; set to 0..5 to force a filter mode
+
+
+   You can define STBI_WRITE_NO_STDIO to disable the file variant of these
+   functions, so the library will not use stdio.h at all. However, this will
+   also disable HDR writing, because it requires stdio for formatted output.
+
+   Each function returns 0 on failure and non-0 on success.
+
+   The functions create an image file defined by the parameters. The image
+   is a rectangle of pixels stored from left-to-right, top-to-bottom.
+   Each pixel contains 'comp' channels of data stored interleaved with 8-bits
+   per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
+   monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
+   The *data pointer points to the first byte of the top-left-most pixel.
+   For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
+   a row of pixels to the first byte of the next row of pixels.
+
+   PNG creates output files with the same number of components as the input.
+   The BMP format expands Y to RGB in the file format and does not
+   output alpha.
+
+   PNG supports writing rectangles of data even when the bytes storing rows of
+   data are not consecutive in memory (e.g. sub-rectangles of a larger image),
+   by supplying the stride between the beginning of adjacent rows. The other
+   formats do not. (Thus you cannot write a native-format BMP through the BMP
+   writer, both because it is in BGR order and because it may have padding
+   at the end of the line.)
+
+   PNG allows you to set the deflate compression level by setting the global
+   variable 'stbi_write_png_compression_level' (it defaults to 8).
+
+   HDR expects linear float data. Since the format is always 32-bit rgb(e)
+   data, alpha (if provided) is discarded, and for monochrome data it is
+   replicated across all three channels.
+
+   TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed
+   data, set the global variable 'stbi_write_tga_with_rle' to 0.
+
+   JPEG does ignore alpha channels in input data; quality is between 1 and 100.
+   Higher quality looks better but results in a bigger image.
+   JPEG baseline (no JPEG progressive).
+
+CREDITS:
+
+
+   Sean Barrett           -    PNG/BMP/TGA
+   Baldur Karlsson        -    HDR
+   Jean-Sebastien Guay    -    TGA monochrome
+   Tim Kelsey             -    misc enhancements
+   Alan Hickman           -    TGA RLE
+   Emmanuel Julien        -    initial file IO callback implementation
+   Jon Olick              -    original jo_jpeg.cpp code
+   Daniel Gibson          -    integrate JPEG, allow external zlib
+   Aarni Koskela          -    allow choosing PNG filter
+
+   bugfixes:
+      github:Chribba
+      Guillaume Chereau
+      github:jry2
+      github:romigrou
+      Sergio Gonzalez
+      Jonas Karlsson
+      Filip Wasil
+      Thatcher Ulrich
+      github:poppolopoppo
+      Patrick Boettcher
+      github:xeekworx
+      Cap Petschulat
+      Simon Rodriguez
+      Ivan Tikhonov
+      github:ignotion
+      Adam Schackart
+      Andrew Kensler
+
+LICENSE
+
+  See end of file for license information.
+
+*/
+
+#ifndef INCLUDE_STB_IMAGE_WRITE_H
+#define INCLUDE_STB_IMAGE_WRITE_H
+
+#include <stdlib.h>
+
+// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline'
+#ifndef STBIWDEF
+#ifdef STB_IMAGE_WRITE_STATIC
+#define STBIWDEF static
+#else
+#ifdef __cplusplus
+#define STBIWDEF extern "C"
+#else
+#define STBIWDEF extern
+#endif
+#endif
+#endif
+
+#ifndef STB_IMAGE_WRITE_STATIC  // C++ forbids static forward declarations
+STBIWDEF int stbi_write_tga_with_rle;
+STBIWDEF int stbi_write_png_compression_level;
+STBIWDEF int stbi_write_force_png_filter;
+#endif
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data,
+                            int stride_in_bytes);
+STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
+STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data,
+                            int quality);
+
+#ifdef STBIW_WINDOWS_UTF8
+STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t *input);
+#endif
+#endif
+
+typedef void stbi_write_func(void *context, void *data, int size);
+
+STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp,
+                                    const void *data, int stride_in_bytes);
+STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp,
+                                    const void *data);
+STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp,
+                                    const void *data);
+STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp,
+                                    const float *data);
+STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp,
+                                    const void *data, int quality);
+
+STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
+
+#endif  // INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef STB_IMAGE_WRITE_IMPLEMENTATION
+
+#ifdef _WIN32
+#ifndef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+#ifndef _CRT_NONSTDC_NO_DEPRECATE
+#define _CRT_NONSTDC_NO_DEPRECATE
+#endif
+#endif
+
+#ifndef STBI_WRITE_NO_STDIO
+#include <stdio.h>
+#endif  // STBI_WRITE_NO_STDIO
+
+#include <math.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(STBIW_MALLOC) && defined(STBIW_FREE) &&                                                \
+    (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED))
+// ok
+#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) &&                 \
+    !defined(STBIW_REALLOC_SIZED)
+// ok
+#else
+#error                                                                                             \
+    "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)."
+#endif
+
+#ifndef STBIW_MALLOC
+#define STBIW_MALLOC(sz)        malloc(sz)
+#define STBIW_REALLOC(p, newsz) realloc(p, newsz)
+#define STBIW_FREE(p)           free(p)
+#endif
+
+#ifndef STBIW_REALLOC_SIZED
+#define STBIW_REALLOC_SIZED(p, oldsz, newsz) STBIW_REALLOC(p, newsz)
+#endif
+
+#ifndef STBIW_MEMMOVE
+#define STBIW_MEMMOVE(a, b, sz) memmove(a, b, sz)
+#endif
+
+#ifndef STBIW_ASSERT
+#include <assert.h>
+#define STBIW_ASSERT(x) assert(x)
+#endif
+
+#define STBIW_UCHAR(x) (unsigned char)((x) & 0xff)
+
+#ifdef STB_IMAGE_WRITE_STATIC
+static int stbi_write_png_compression_level = 8;
+static int stbi_write_tga_with_rle          = 1;
+static int stbi_write_force_png_filter      = -1;
+#else
+int stbi_write_png_compression_level = 8;
+int stbi_write_tga_with_rle          = 1;
+int stbi_write_force_png_filter      = -1;
+#endif
+
+static int stbi__flip_vertically_on_write = 0;
+
+STBIWDEF void stbi_flip_vertically_on_write(int flag) { stbi__flip_vertically_on_write = flag; }
+
+typedef struct {
+    stbi_write_func *func;
+    void *context;
+    unsigned char buffer[64];
+    int buf_used;
+} stbi__write_context;
+
+// initialize a callback-based context
+static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context) {
+    s->func    = c;
+    s->context = context;
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+
+static void stbi__stdio_write(void *context, void *data, int size) {
+    fwrite(data, 1, size, (FILE *)context);
+}
+
+#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)
+#ifdef __cplusplus
+#define STBIW_EXTERN extern "C"
+#else
+#define STBIW_EXTERN extern
+#endif
+STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp,
+                                                                     unsigned long flags,
+                                                                     const char *str, int cbmb,
+                                                                     wchar_t *widestr, int cchwide);
+STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(
+    unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb,
+    const char *defchar, int *used_default);
+
+STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t *input) {
+    return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int)bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbiw__fopen(char const *filename, char const *mode) {
+    FILE *f;
+#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)
+    wchar_t wMode[64];
+    wchar_t wFilename[1024];
+    if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename,
+                                 sizeof(wFilename) / sizeof(*wFilename)))
+        return 0;
+
+    if (0 ==
+        MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode) / sizeof(*wMode)))
+        return 0;
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    if (0 != _wfopen_s(&f, wFilename, wMode))
+        f = 0;
+#else
+    f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+    if (0 != fopen_s(&f, filename, mode))
+        f = 0;
+#else
+    f = fopen(filename, mode);
+#endif
+    return f;
+}
+
+static int stbi__start_write_file(stbi__write_context *s, const char *filename) {
+    FILE *f = stbiw__fopen(filename, "wb");
+    stbi__start_write_callbacks(s, stbi__stdio_write, (void *)f);
+    return f != NULL;
+}
+
+static void stbi__end_write_file(stbi__write_context *s) { fclose((FILE *)s->context); }
+
+#endif  // !STBI_WRITE_NO_STDIO
+
+typedef unsigned int stbiw_uint32;
+typedef int stb_image_write_test[sizeof(stbiw_uint32) == 4 ? 1 : -1];
+
+static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v) {
+    while (*fmt) {
+        switch (*fmt++) {
+        case ' ':
+            break;
+        case '1': {
+            unsigned char x = STBIW_UCHAR(va_arg(v, int));
+            s->func(s->context, &x, 1);
+            break;
+        }
+        case '2': {
+            int x = va_arg(v, int);
+            unsigned char b[2];
+            b[0] = STBIW_UCHAR(x);
+            b[1] = STBIW_UCHAR(x >> 8);
+            s->func(s->context, b, 2);
+            break;
+        }
+        case '4': {
+            stbiw_uint32 x = va_arg(v, int);
+            unsigned char b[4];
+            b[0] = STBIW_UCHAR(x);
+            b[1] = STBIW_UCHAR(x >> 8);
+            b[2] = STBIW_UCHAR(x >> 16);
+            b[3] = STBIW_UCHAR(x >> 24);
+            s->func(s->context, b, 4);
+            break;
+        }
+        default:
+            STBIW_ASSERT(0);
+            return;
+        }
+    }
+}
+
+static void stbiw__writef(stbi__write_context *s, const char *fmt, ...) {
+    va_list v;
+    va_start(v, fmt);
+    stbiw__writefv(s, fmt, v);
+    va_end(v);
+}
+
+static void stbiw__write_flush(stbi__write_context *s) {
+    if (s->buf_used) {
+        s->func(s->context, &s->buffer, s->buf_used);
+        s->buf_used = 0;
+    }
+}
+
+static void stbiw__putc(stbi__write_context *s, unsigned char c) { s->func(s->context, &c, 1); }
+
+static void stbiw__write1(stbi__write_context *s, unsigned char a) {
+    if ((size_t)s->buf_used + 1 > sizeof(s->buffer))
+        stbiw__write_flush(s);
+    s->buffer[s->buf_used++] = a;
+}
+
+static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b,
+                          unsigned char c) {
+    int n;
+    if ((size_t)s->buf_used + 3 > sizeof(s->buffer))
+        stbiw__write_flush(s);
+    n                = s->buf_used;
+    s->buf_used      = n + 3;
+    s->buffer[n + 0] = a;
+    s->buffer[n + 1] = b;
+    s->buffer[n + 2] = c;
+}
+
+static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha,
+                               int expand_mono, unsigned char *d) {
+    unsigned char bg[3] = {255, 0, 255}, px[3];
+    int k;
+
+    if (write_alpha < 0)
+        stbiw__write1(s, d[comp - 1]);
+
+    switch (comp) {
+    case 2:  // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case
+    case 1:
+        if (expand_mono)
+            stbiw__write3(s, d[0], d[0], d[0]);  // monochrome bmp
+        else
+            stbiw__write1(s, d[0]);  // monochrome TGA
+        break;
+    case 4:
+        if (!write_alpha) {
+            // composite against pink background
+            for (k = 0; k < 3; ++k)
+                px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;
+            stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);
+            break;
+        }
+        /* FALLTHROUGH */
+    case 3:
+        stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);
+        break;
+    }
+    if (write_alpha > 0)
+        stbiw__write1(s, d[comp - 1]);
+}
+
+static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y,
+                                int comp, void *data, int write_alpha, int scanline_pad,
+                                int expand_mono) {
+    stbiw_uint32 zero = 0;
+    int i, j, j_end;
+
+    if (y <= 0)
+        return;
+
+    if (stbi__flip_vertically_on_write)
+        vdir *= -1;
+
+    if (vdir < 0) {
+        j_end = -1;
+        j     = y - 1;
+    } else {
+        j_end = y;
+        j     = 0;
+    }
+
+    for (; j != j_end; j += vdir) {
+        for (i = 0; i < x; ++i) {
+            unsigned char *d = (unsigned char *)data + (j * x + i) * comp;
+            stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d);
+        }
+        stbiw__write_flush(s);
+        s->func(s->context, &zero, scanline_pad);
+    }
+}
+
+static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp,
+                          int expand_mono, void *data, int alpha, int pad, const char *fmt, ...) {
+    if (y < 0 || x < 0) {
+        return 0;
+    } else {
+        va_list v;
+        va_start(v, fmt);
+        stbiw__writefv(s, fmt, v);
+        va_end(v);
+        stbiw__write_pixels(s, rgb_dir, vdir, x, y, comp, data, alpha, pad, expand_mono);
+        return 1;
+    }
+}
+
+static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data) {
+    if (comp != 4) {
+        // write RGB bitmap
+        int pad = (-x * 3) & 3;
+        return stbiw__outfile(s, -1, -1, x, y, comp, 1, (void *)data, 0, pad,
+                              "11 4 22 4"
+                              "4 44 22 444444",
+                              'B', 'M', 14 + 40 + (x * 3 + pad) * y, 0, 0, 14 + 40,  // file header
+                              40, x, y, 1, 24, 0, 0, 0, 0, 0, 0);  // bitmap header
+    } else {
+        // RGBA bitmaps need a v4 header
+        // use BI_BITFIELDS mode with 32bpp and alpha mask
+        // (straight BI_RGB with alpha mask doesn't work in most readers)
+        return stbiw__outfile(s, -1, -1, x, y, comp, 1, (void *)data, 1, 0,
+                              "11 4 22 4"
+                              "4 44 22 444444 4444 4 444 444 444 444",
+                              'B', 'M', 14 + 108 + x * y * 4, 0, 0, 14 + 108,  // file header
+                              108, x, y, 1, 32, 3, 0, 0, 0, 0, 0, 0xff0000, 0xff00, 0xff,
+                              0xff000000u, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                              0);  // bitmap V4 header
+    }
+}
+
+STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp,
+                                    const void *data) {
+    stbi__write_context s = {0};
+    stbi__start_write_callbacks(&s, func, context);
+    return stbi_write_bmp_core(&s, x, y, comp, data);
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data) {
+    stbi__write_context s = {0};
+    if (stbi__start_write_file(&s, filename)) {
+        int r = stbi_write_bmp_core(&s, x, y, comp, data);
+        stbi__end_write_file(&s);
+        return r;
+    } else
+        return 0;
+}
+#endif  //! STBI_WRITE_NO_STDIO
+
+static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data) {
+    int has_alpha  = (comp == 2 || comp == 4);
+    int colorbytes = has_alpha ? comp - 1 : comp;
+    int format     = colorbytes < 2 ? 3
+                                    : 2;  // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3
+
+    if (y < 0 || x < 0)
+        return 0;
+
+    if (!stbi_write_tga_with_rle) {
+        return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *)data, has_alpha, 0,
+                              "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y,
+                              (colorbytes + has_alpha) * 8, has_alpha * 8);
+    } else {
+        int i, j, k;
+        int jend, jdir;
+
+        stbiw__writef(s, "111 221 2222 11", 0, 0, format + 8, 0, 0, 0, 0, 0, x, y,
+                      (colorbytes + has_alpha) * 8, has_alpha * 8);
+
+        if (stbi__flip_vertically_on_write) {
+            j    = 0;
+            jend = y;
+            jdir = 1;
+        } else {
+            j    = y - 1;
+            jend = -1;
+            jdir = -1;
+        }
+        for (; j != jend; j += jdir) {
+            unsigned char *row = (unsigned char *)data + j * x * comp;
+            int len;
+
+            for (i = 0; i < x; i += len) {
+                unsigned char *begin = row + i * comp;
+                int diff             = 1;
+                len                  = 1;
+
+                if (i < x - 1) {
+                    ++len;
+                    diff = memcmp(begin, row + (i + 1) * comp, comp);
+                    if (diff) {
+                        const unsigned char *prev = begin;
+                        for (k = i + 2; k < x && len < 128; ++k) {
+                            if (memcmp(prev, row + k * comp, comp)) {
+                                prev += comp;
+                                ++len;
+                            } else {
+                                --len;
+                                break;
+                            }
+                        }
+                    } else {
+                        for (k = i + 2; k < x && len < 128; ++k) {
+                            if (!memcmp(begin, row + k * comp, comp)) {
+                                ++len;
+                            } else {
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                if (diff) {
+                    unsigned char header = STBIW_UCHAR(len - 1);
+                    stbiw__write1(s, header);
+                    for (k = 0; k < len; ++k) {
+                        stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp);
+                    }
+                } else {
+                    unsigned char header = STBIW_UCHAR(len - 129);
+                    stbiw__write1(s, header);
+                    stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin);
+                }
+            }
+        }
+        stbiw__write_flush(s);
+    }
+    return 1;
+}
+
+STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp,
+                                    const void *data) {
+    stbi__write_context s = {0};
+    stbi__start_write_callbacks(&s, func, context);
+    return stbi_write_tga_core(&s, x, y, comp, (void *)data);
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data) {
+    stbi__write_context s = {0};
+    if (stbi__start_write_file(&s, filename)) {
+        int r = stbi_write_tga_core(&s, x, y, comp, (void *)data);
+        stbi__end_write_file(&s);
+        return r;
+    } else
+        return 0;
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR writer
+// by Baldur Karlsson
+
+#define stbiw__max(a, b) ((a) > (b) ? (a) : (b))
+
+#ifndef STBI_WRITE_NO_STDIO
+
+static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear) {
+    int exponent;
+    float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));
+
+    if (maxcomp < 1e-32f) {
+        rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
+    } else {
+        float normalize = (float)frexp(maxcomp, &exponent) * 256.0f / maxcomp;
+
+        rgbe[0] = (unsigned char)(linear[0] * normalize);
+        rgbe[1] = (unsigned char)(linear[1] * normalize);
+        rgbe[2] = (unsigned char)(linear[2] * normalize);
+        rgbe[3] = (unsigned char)(exponent + 128);
+    }
+}
+
+static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte) {
+    unsigned char lengthbyte = STBIW_UCHAR(length + 128);
+    STBIW_ASSERT(length + 128 <= 255);
+    s->func(s->context, &lengthbyte, 1);
+    s->func(s->context, &databyte, 1);
+}
+
+static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data) {
+    unsigned char lengthbyte = STBIW_UCHAR(length);
+    STBIW_ASSERT(length <= 128);  // inconsistent with spec but consistent with official code
+    s->func(s->context, &lengthbyte, 1);
+    s->func(s->context, data, length);
+}
+
+static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp,
+                                      unsigned char *scratch, float *scanline) {
+    unsigned char scanlineheader[4] = {2, 2, 0, 0};
+    unsigned char rgbe[4];
+    float linear[3];
+    int x;
+
+    scanlineheader[2] = (width & 0xff00) >> 8;
+    scanlineheader[3] = (width & 0x00ff);
+
+    /* skip RLE for images too small or large */
+    if (width < 8 || width >= 32768) {
+        for (x = 0; x < width; x++) {
+            switch (ncomp) {
+            case 4: /* fallthrough */
+            case 3:
+                linear[2] = scanline[x * ncomp + 2];
+                linear[1] = scanline[x * ncomp + 1];
+                linear[0] = scanline[x * ncomp + 0];
+                break;
+            default:
+                linear[0] = linear[1] = linear[2] = scanline[x * ncomp + 0];
+                break;
+            }
+            stbiw__linear_to_rgbe(rgbe, linear);
+            s->func(s->context, rgbe, 4);
+        }
+    } else {
+        int c, r;
+        /* encode into scratch buffer */
+        for (x = 0; x < width; x++) {
+            switch (ncomp) {
+            case 4: /* fallthrough */
+            case 3:
+                linear[2] = scanline[x * ncomp + 2];
+                linear[1] = scanline[x * ncomp + 1];
+                linear[0] = scanline[x * ncomp + 0];
+                break;
+            default:
+                linear[0] = linear[1] = linear[2] = scanline[x * ncomp + 0];
+                break;
+            }
+            stbiw__linear_to_rgbe(rgbe, linear);
+            scratch[x + width * 0] = rgbe[0];
+            scratch[x + width * 1] = rgbe[1];
+            scratch[x + width * 2] = rgbe[2];
+            scratch[x + width * 3] = rgbe[3];
+        }
+
+        s->func(s->context, scanlineheader, 4);
+
+        /* RLE each component separately */
+        for (c = 0; c < 4; c++) {
+            unsigned char *comp = &scratch[width * c];
+
+            x = 0;
+            while (x < width) {
+                // find first run
+                r = x;
+                while (r + 2 < width) {
+                    if (comp[r] == comp[r + 1] && comp[r] == comp[r + 2])
+                        break;
+                    ++r;
+                }
+                if (r + 2 >= width)
+                    r = width;
+                // dump up to first run
+                while (x < r) {
+                    int len = r - x;
+                    if (len > 128)
+                        len = 128;
+                    stbiw__write_dump_data(s, len, &comp[x]);
+                    x += len;
+                }
+                // if there's a run, output it
+                if (r + 2 < width) {  // same test as what we break out of in search loop, so only
+                                      // true if we break'd
+                    // find next byte after run
+                    while (r < width && comp[r] == comp[x])
+                        ++r;
+                    // output run up to r
+                    while (x < r) {
+                        int len = r - x;
+                        if (len > 127)
+                            len = 127;
+                        stbiw__write_run_data(s, len, comp[x]);
+                        x += len;
+                    }
+                }
+            }
+        }
+    }
+}
+
+static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data) {
+    if (y <= 0 || x <= 0 || data == NULL)
+        return 0;
+    else {
+        // Each component is stored separately. Allocate scratch space for full output scanline.
+        unsigned char *scratch = (unsigned char *)STBIW_MALLOC(x * 4);
+        int i, len;
+        char buffer[128];
+        char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
+        s->func(s->context, header, sizeof(header) - 1);
+
+#ifdef __STDC_LIB_EXT1__
+        len = sprintf_s(buffer, sizeof(buffer),
+                        "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
+#else
+        len = sprintf(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
+#endif
+        s->func(s->context, buffer, len);
+
+        for (i = 0; i < y; i++)
+            stbiw__write_hdr_scanline(s, x, comp, scratch,
+                                      data + comp * x *
+                                                 (stbi__flip_vertically_on_write ? y - 1 - i : i));
+        STBIW_FREE(scratch);
+        return 1;
+    }
+}
+
+STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp,
+                                    const float *data) {
+    stbi__write_context s = {0};
+    stbi__start_write_callbacks(&s, func, context);
+    return stbi_write_hdr_core(&s, x, y, comp, (float *)data);
+}
+
+STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data) {
+    stbi__write_context s = {0};
+    if (stbi__start_write_file(&s, filename)) {
+        int r = stbi_write_hdr_core(&s, x, y, comp, (float *)data);
+        stbi__end_write_file(&s);
+        return r;
+    } else
+        return 0;
+}
+#endif  // STBI_WRITE_NO_STDIO
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PNG writer
+//
+
+#ifndef STBIW_ZLIB_COMPRESS
+// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size()
+#define stbiw__sbraw(a) ((int *)(void *)(a)-2)
+#define stbiw__sbm(a)   stbiw__sbraw(a)[0]
+#define stbiw__sbn(a)   stbiw__sbraw(a)[1]
+
+#define stbiw__sbneedgrow(a, n)  ((a) == 0 || stbiw__sbn(a) + n >= stbiw__sbm(a))
+#define stbiw__sbmaybegrow(a, n) (stbiw__sbneedgrow(a, (n)) ? stbiw__sbgrow(a, n) : 0)
+#define stbiw__sbgrow(a, n)      stbiw__sbgrowf((void **)&(a), (n), sizeof(*(a)))
+
+#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a, 1), (a)[stbiw__sbn(a)++] = (v))
+#define stbiw__sbcount(a)   ((a) ? stbiw__sbn(a) : 0)
+#define stbiw__sbfree(a)    ((a) ? STBIW_FREE(stbiw__sbraw(a)), 0 : 0)
+
+static void *stbiw__sbgrowf(void **arr, int increment, int itemsize) {
+    int m   = *arr ? 2 * stbiw__sbm(*arr) + increment : increment + 1;
+    void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0,
+                                  *arr ? (stbiw__sbm(*arr) * itemsize + sizeof(int) * 2) : 0,
+                                  itemsize * m + sizeof(int) * 2);
+    STBIW_ASSERT(p);
+    if (p) {
+        if (!*arr)
+            ((int *)p)[1] = 0;
+        *arr             = (void *)((int *)p + 2);
+        stbiw__sbm(*arr) = m;
+    }
+    return *arr;
+}
+
+static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer,
+                                         int *bitcount) {
+    while (*bitcount >= 8) {
+        stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));
+        *bitbuffer >>= 8;
+        *bitcount -= 8;
+    }
+    return data;
+}
+
+static int stbiw__zlib_bitrev(int code, int codebits) {
+    int res = 0;
+    while (codebits--) {
+        res = (res << 1) | (code & 1);
+        code >>= 1;
+    }
+    return res;
+}
+
+static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit) {
+    int i;
+    for (i = 0; i < limit && i < 258; ++i)
+        if (a[i] != b[i])
+            break;
+    return i;
+}
+
+static unsigned int stbiw__zhash(unsigned char *data) {
+    stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
+    hash ^= hash << 3;
+    hash += hash >> 5;
+    hash ^= hash << 4;
+    hash += hash >> 17;
+    hash ^= hash << 25;
+    hash += hash >> 6;
+    return hash;
+}
+
+#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))
+#define stbiw__zlib_add(code, codebits)                                                            \
+    (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush())
+#define stbiw__zlib_huffa(b, c) stbiw__zlib_add(stbiw__zlib_bitrev(b, c), c)
+// default huffman tables
+#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8)
+#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9)
+#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256, 7)
+#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280, 8)
+#define stbiw__zlib_huff(n)                                                                        \
+    ((n) <= 143   ? stbiw__zlib_huff1(n)                                                           \
+     : (n) <= 255 ? stbiw__zlib_huff2(n)                                                           \
+     : (n) <= 279 ? stbiw__zlib_huff3(n)                                                           \
+                  : stbiw__zlib_huff4(n))
+#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))
+
+#define stbiw__ZHASH 16384
+
+#endif  // STBIW_ZLIB_COMPRESS
+
+STBIWDEF unsigned char *stbi_zlib_compress(unsigned char *data, int data_len, int *out_len,
+                                           int quality) {
+#ifdef STBIW_ZLIB_COMPRESS
+    // user provided a zlib compress implementation, use that
+    return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
+#else   // use builtin
+    static unsigned short lengthc[] = {3,  4,  5,  6,   7,   8,   9,   10,  11,  13,
+                                       15, 17, 19, 23,  27,  31,  35,  43,  51,  59,
+                                       67, 83, 99, 115, 131, 163, 195, 227, 258, 259};
+    static unsigned char lengtheb[] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2,
+                                       2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0};
+    static unsigned short distc[]   = {1,    2,    3,    4,     5,     7,     9,    13,
+                                       17,   25,   33,   49,    65,    97,    129,  193,
+                                       257,  385,  513,  769,   1025,  1537,  2049, 3073,
+                                       4097, 6145, 8193, 12289, 16385, 24577, 32768};
+    static unsigned char disteb[]   = {0, 0, 0, 0, 1, 1, 2, 2,  3,  3,  4,  4,  5,  5,  6,
+                                       6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
+    unsigned int bitbuf             = 0;
+    int i, j, bitcount = 0;
+    unsigned char *out = NULL;
+    unsigned char ***hash_table =
+        (unsigned char ***)STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char **));
+    if (hash_table == NULL)
+        return NULL;
+    if (quality < 5)
+        quality = 5;
+
+    stbiw__sbpush(out, 0x78);  // DEFLATE 32K window
+    stbiw__sbpush(out, 0x5e);  // FLEVEL = 1
+    stbiw__zlib_add(1, 1);     // BFINAL = 1
+    stbiw__zlib_add(1, 2);     // BTYPE = 1 -- fixed huffman
+
+    for (i = 0; i < stbiw__ZHASH; ++i)
+        hash_table[i] = NULL;
+
+    i = 0;
+    while (i < data_len - 3) {
+        // hash next 3 bytes of data to be compressed
+        int h = stbiw__zhash(data + i) & (stbiw__ZHASH - 1), best = 3;
+        unsigned char *bestloc = 0;
+        unsigned char **hlist  = hash_table[h];
+        int n                  = stbiw__sbcount(hlist);
+        for (j = 0; j < n; ++j) {
+            if (hlist[j] - data > i - 32768) {  // if entry lies within window
+                int d = stbiw__zlib_countm(hlist[j], data + i, data_len - i);
+                if (d >= best) {
+                    best    = d;
+                    bestloc = hlist[j];
+                }
+            }
+        }
+        // when hash table entry is too long, delete half the entries
+        if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2 * quality) {
+            STBIW_MEMMOVE(hash_table[h], hash_table[h] + quality,
+                          sizeof(hash_table[h][0]) * quality);
+            stbiw__sbn(hash_table[h]) = quality;
+        }
+        stbiw__sbpush(hash_table[h], data + i);
+
+        if (bestloc) {
+            // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as
+            // literal
+            h     = stbiw__zhash(data + i + 1) & (stbiw__ZHASH - 1);
+            hlist = hash_table[h];
+            n     = stbiw__sbcount(hlist);
+            for (j = 0; j < n; ++j) {
+                if (hlist[j] - data > i - 32767) {
+                    int e = stbiw__zlib_countm(hlist[j], data + i + 1, data_len - i - 1);
+                    if (e > best) {  // if next match is better, bail on current match
+                        bestloc = NULL;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (bestloc) {
+            int d = (int)(data + i - bestloc);  // distance back
+            STBIW_ASSERT(d <= 32767 && best <= 258);
+            for (j = 0; best > lengthc[j + 1] - 1; ++j)
+                ;
+            stbiw__zlib_huff(j + 257);
+            if (lengtheb[j])
+                stbiw__zlib_add(best - lengthc[j], lengtheb[j]);
+            for (j = 0; d > distc[j + 1] - 1; ++j)
+                ;
+            stbiw__zlib_add(stbiw__zlib_bitrev(j, 5), 5);
+            if (disteb[j])
+                stbiw__zlib_add(d - distc[j], disteb[j]);
+            i += best;
+        } else {
+            stbiw__zlib_huffb(data[i]);
+            ++i;
+        }
+    }
+    // write out final bytes
+    for (; i < data_len; ++i)
+        stbiw__zlib_huffb(data[i]);
+    stbiw__zlib_huff(256);  // end of block
+    // pad with 0 bits to byte boundary
+    while (bitcount)
+        stbiw__zlib_add(0, 1);
+
+    for (i = 0; i < stbiw__ZHASH; ++i)
+        (void)stbiw__sbfree(hash_table[i]);
+    STBIW_FREE(hash_table);
+
+    // store uncompressed instead if compression was worse
+    if (stbiw__sbn(out) > data_len + 2 + ((data_len + 32766) / 32767) * 5) {
+        stbiw__sbn(out) = 2;  // truncate to DEFLATE 32K window and FLEVEL = 1
+        for (j = 0; j < data_len;) {
+            int blocklen = data_len - j;
+            if (blocklen > 32767)
+                blocklen = 32767;
+            stbiw__sbpush(out,
+                          data_len - j == blocklen);    // BFINAL = ?, BTYPE = 0 -- no compression
+            stbiw__sbpush(out, STBIW_UCHAR(blocklen));  // LEN
+            stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8));
+            stbiw__sbpush(out, STBIW_UCHAR(~blocklen));  // NLEN
+            stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8));
+            memcpy(out + stbiw__sbn(out), data + j, blocklen);
+            stbiw__sbn(out) += blocklen;
+            j += blocklen;
+        }
+    }
+
+    {
+        // compute adler32 on input
+        unsigned int s1 = 1, s2 = 0;
+        int blocklen = (int)(data_len % 5552);
+        j            = 0;
+        while (j < data_len) {
+            for (i = 0; i < blocklen; ++i) {
+                s1 += data[j + i];
+                s2 += s1;
+            }
+            s1 %= 65521;
+            s2 %= 65521;
+            j += blocklen;
+            blocklen = 5552;
+        }
+        stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8));
+        stbiw__sbpush(out, STBIW_UCHAR(s2));
+        stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8));
+        stbiw__sbpush(out, STBIW_UCHAR(s1));
+    }
+    *out_len = stbiw__sbn(out);
+    // make returned pointer freeable
+    STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len);
+    return (unsigned char *)stbiw__sbraw(out);
+#endif  // STBIW_ZLIB_COMPRESS
+}
+
+static unsigned int stbiw__crc32(unsigned char *buffer, int len) {
+#ifdef STBIW_CRC32
+    return STBIW_CRC32(buffer, len);
+#else
+    static unsigned int crc_table[256] = {
+        0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,
+        0x9E6495A3, 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
+        0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D,
+        0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
+        0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
+        0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
+        0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC,
+        0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+        0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB,
+        0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
+        0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB,
+        0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+        0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA,
+        0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE,
+        0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
+        0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+        0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409,
+        0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
+        0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739,
+        0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
+        0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268,
+        0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0,
+        0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8,
+        0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+        0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
+        0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
+        0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7,
+        0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
+        0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE,
+        0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
+        0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6,
+        0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+        0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D,
+        0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
+        0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
+        0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+        0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D};
+
+    unsigned int crc = ~0u;
+    int i;
+    for (i = 0; i < len; ++i)
+        crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
+    return ~crc;
+#endif
+}
+
+#define stbiw__wpng4(o, a, b, c, d)                                                                \
+    ((o)[0] = STBIW_UCHAR(a), (o)[1] = STBIW_UCHAR(b), (o)[2] = STBIW_UCHAR(c),                    \
+     (o)[3] = STBIW_UCHAR(d), (o) += 4)
+#define stbiw__wp32(data, v)  stbiw__wpng4(data, (v) >> 24, (v) >> 16, (v) >> 8, (v));
+#define stbiw__wptag(data, s) stbiw__wpng4(data, s[0], s[1], s[2], s[3])
+
+static void stbiw__wpcrc(unsigned char **data, int len) {
+    unsigned int crc = stbiw__crc32(*data - len - 4, len + 4);
+    stbiw__wp32(*data, crc);
+}
+
+static unsigned char stbiw__paeth(int a, int b, int c) {
+    int p = a + b - c, pa = abs(p - a), pb = abs(p - b), pc = abs(p - c);
+    if (pa <= pb && pa <= pc)
+        return STBIW_UCHAR(a);
+    if (pb <= pc)
+        return STBIW_UCHAR(b);
+    return STBIW_UCHAR(c);
+}
+
+// @OPTIMIZE: provide an option that always forces left-predict or paeth predict
+static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height,
+                                   int y, int n, int filter_type, signed char *line_buffer) {
+    static int mapping[]  = {0, 1, 2, 3, 4};
+    static int firstmap[] = {0, 1, 0, 5, 6};
+    int *mymap            = (y != 0) ? mapping : firstmap;
+    int i;
+    int type = mymap[filter_type];
+    unsigned char *z =
+        pixels + stride_bytes * (stbi__flip_vertically_on_write ? height - 1 - y : y);
+    int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes;
+
+    if (type == 0) {
+        memcpy(line_buffer, z, width * n);
+        return;
+    }
+
+    // first loop isn't optimized since it's just one pixel
+    for (i = 0; i < n; ++i) {
+        switch (type) {
+        case 1:
+            line_buffer[i] = z[i];
+            break;
+        case 2:
+            line_buffer[i] = z[i] - z[i - signed_stride];
+            break;
+        case 3:
+            line_buffer[i] = z[i] - (z[i - signed_stride] >> 1);
+            break;
+        case 4:
+            line_buffer[i] = (signed char)(z[i] - stbiw__paeth(0, z[i - signed_stride], 0));
+            break;
+        case 5:
+            line_buffer[i] = z[i];
+            break;
+        case 6:
+            line_buffer[i] = z[i];
+            break;
+        }
+    }
+    switch (type) {
+    case 1:
+        for (i = n; i < width * n; ++i)
+            line_buffer[i] = z[i] - z[i - n];
+        break;
+    case 2:
+        for (i = n; i < width * n; ++i)
+            line_buffer[i] = z[i] - z[i - signed_stride];
+        break;
+    case 3:
+        for (i = n; i < width * n; ++i)
+            line_buffer[i] = z[i] - ((z[i - n] + z[i - signed_stride]) >> 1);
+        break;
+    case 4:
+        for (i = n; i < width * n; ++i)
+            line_buffer[i] =
+                z[i] - stbiw__paeth(z[i - n], z[i - signed_stride], z[i - signed_stride - n]);
+        break;
+    case 5:
+        for (i = n; i < width * n; ++i)
+            line_buffer[i] = z[i] - (z[i - n] >> 1);
+        break;
+    case 6:
+        for (i = n; i < width * n; ++i)
+            line_buffer[i] = z[i] - stbiw__paeth(z[i - n], 0, 0);
+        break;
+    }
+}
+
+STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x,
+                                              int y, int n, int *out_len) {
+    int force_filter     = stbi_write_force_png_filter;
+    int ctype[5]         = {-1, 0, 4, 2, 6};
+    unsigned char sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+    unsigned char *out, *o, *filt, *zlib;
+    signed char *line_buffer;
+    int j, zlen;
+
+    if (stride_bytes == 0)
+        stride_bytes = x * n;
+
+    if (force_filter >= 5) {
+        force_filter = -1;
+    }
+
+    filt = (unsigned char *)STBIW_MALLOC((x * n + 1) * y);
+    if (!filt)
+        return 0;
+    line_buffer = (signed char *)STBIW_MALLOC(x * n);
+    if (!line_buffer) {
+        STBIW_FREE(filt);
+        return 0;
+    }
+    for (j = 0; j < y; ++j) {
+        int filter_type;
+        if (force_filter > -1) {
+            filter_type = force_filter;
+            stbiw__encode_png_line((unsigned char *)(pixels), stride_bytes, x, y, j, n,
+                                   force_filter, line_buffer);
+        } else {  // Estimate the best filter by running through all of them:
+            int best_filter = 0, best_filter_val = 0x7fffffff, est, i;
+            for (filter_type = 0; filter_type < 5; filter_type++) {
+                stbiw__encode_png_line((unsigned char *)(pixels), stride_bytes, x, y, j, n,
+                                       filter_type, line_buffer);
+
+                // Estimate the entropy of the line using this filter; the less, the better.
+                est = 0;
+                for (i = 0; i < x * n; ++i) {
+                    est += abs((signed char)line_buffer[i]);
+                }
+                if (est < best_filter_val) {
+                    best_filter_val = est;
+                    best_filter     = filter_type;
+                }
+            }
+            if (filter_type != best_filter) {  // If the last iteration already got us the best
+                                               // filter, don't redo it
+                stbiw__encode_png_line((unsigned char *)(pixels), stride_bytes, x, y, j, n,
+                                       best_filter, line_buffer);
+                filter_type = best_filter;
+            }
+        }
+        // when we get here, filter_type contains the filter type, and line_buffer contains the data
+        filt[j * (x * n + 1)] = (unsigned char)filter_type;
+        STBIW_MEMMOVE(filt + j * (x * n + 1) + 1, line_buffer, x * n);
+    }
+    STBIW_FREE(line_buffer);
+    zlib = stbi_zlib_compress(filt, y * (x * n + 1), &zlen, stbi_write_png_compression_level);
+    STBIW_FREE(filt);
+    if (!zlib)
+        return 0;
+
+    // each tag requires 12 bytes of overhead
+    out = (unsigned char *)STBIW_MALLOC(8 + 12 + 13 + 12 + zlen + 12);
+    if (!out)
+        return 0;
+    *out_len = 8 + 12 + 13 + 12 + zlen + 12;
+
+    o = out;
+    STBIW_MEMMOVE(o, sig, 8);
+    o += 8;
+    stbiw__wp32(o, 13);  // header length
+    stbiw__wptag(o, "IHDR");
+    stbiw__wp32(o, x);
+    stbiw__wp32(o, y);
+    *o++ = 8;
+    *o++ = STBIW_UCHAR(ctype[n]);
+    *o++ = 0;
+    *o++ = 0;
+    *o++ = 0;
+    stbiw__wpcrc(&o, 13);
+
+    stbiw__wp32(o, zlen);
+    stbiw__wptag(o, "IDAT");
+    STBIW_MEMMOVE(o, zlib, zlen);
+    o += zlen;
+    STBIW_FREE(zlib);
+    stbiw__wpcrc(&o, zlen);
+
+    stbiw__wp32(o, 0);
+    stbiw__wptag(o, "IEND");
+    stbiw__wpcrc(&o, 0);
+
+    STBIW_ASSERT(o == out + *out_len);
+
+    return out;
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data,
+                            int stride_bytes) {
+    FILE *f;
+    int len;
+    unsigned char *png =
+        stbi_write_png_to_mem((const unsigned char *)data, stride_bytes, x, y, comp, &len);
+    if (png == NULL)
+        return 0;
+
+    f = stbiw__fopen(filename, "wb");
+    if (!f) {
+        STBIW_FREE(png);
+        return 0;
+    }
+    fwrite(png, 1, len, f);
+    fclose(f);
+    STBIW_FREE(png);
+    return 1;
+}
+#endif
+
+STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp,
+                                    const void *data, int stride_bytes) {
+    int len;
+    unsigned char *png =
+        stbi_write_png_to_mem((const unsigned char *)data, stride_bytes, x, y, comp, &len);
+    if (png == NULL)
+        return 0;
+    func(context, png, len);
+    STBIW_FREE(png);
+    return 1;
+}
+
+/* ***************************************************************************
+ *
+ * JPEG writer
+ *
+ * This is based on Jon Olick's jo_jpeg.cpp:
+ * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html
+ */
+
+static const unsigned char stbiw__jpg_ZigZag[] = {
+    0,  1,  5,  6,  14, 15, 27, 28, 2,  4,  7,  13, 16, 26, 29, 42, 3,  8,  12, 17, 25, 30,
+    41, 43, 9,  11, 18, 24, 31, 40, 44, 53, 10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38,
+    46, 51, 55, 60, 21, 34, 37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63};
+
+static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP,
+                                 const unsigned short *bs) {
+    int bitBuf = *bitBufP, bitCnt = *bitCntP;
+    bitCnt += bs[1];
+    bitBuf |= bs[0] << (24 - bitCnt);
+    while (bitCnt >= 8) {
+        unsigned char c = (bitBuf >> 16) & 255;
+        stbiw__putc(s, c);
+        if (c == 255) {
+            stbiw__putc(s, 0);
+        }
+        bitBuf <<= 8;
+        bitCnt -= 8;
+    }
+    *bitBufP = bitBuf;
+    *bitCntP = bitCnt;
+}
+
+static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p,
+                           float *d6p, float *d7p) {
+    float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p;
+    float z1, z2, z3, z4, z5, z11, z13;
+
+    float tmp0 = d0 + d7;
+    float tmp7 = d0 - d7;
+    float tmp1 = d1 + d6;
+    float tmp6 = d1 - d6;
+    float tmp2 = d2 + d5;
+    float tmp5 = d2 - d5;
+    float tmp3 = d3 + d4;
+    float tmp4 = d3 - d4;
+
+    // Even part
+    float tmp10 = tmp0 + tmp3;  // phase 2
+    float tmp13 = tmp0 - tmp3;
+    float tmp11 = tmp1 + tmp2;
+    float tmp12 = tmp1 - tmp2;
+
+    d0 = tmp10 + tmp11;  // phase 3
+    d4 = tmp10 - tmp11;
+
+    z1 = (tmp12 + tmp13) * 0.707106781f;  // c4
+    d2 = tmp13 + z1;                      // phase 5
+    d6 = tmp13 - z1;
+
+    // Odd part
+    tmp10 = tmp4 + tmp5;  // phase 2
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    // The rotator is modified from fig 4-8 to avoid extra negations.
+    z5 = (tmp10 - tmp12) * 0.382683433f;  // c6
+    z2 = tmp10 * 0.541196100f + z5;       // c2-c6
+    z4 = tmp12 * 1.306562965f + z5;       // c2+c6
+    z3 = tmp11 * 0.707106781f;            // c4
+
+    z11 = tmp7 + z3;  // phase 5
+    z13 = tmp7 - z3;
+
+    *d5p = z13 + z2;  // phase 6
+    *d3p = z13 - z2;
+    *d1p = z11 + z4;
+    *d7p = z11 - z4;
+
+    *d0p = d0;
+    *d2p = d2;
+    *d4p = d4;
+    *d6p = d6;
+}
+
+static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
+    int tmp1 = val < 0 ? -val : val;
+    val      = val < 0 ? val - 1 : val;
+    bits[1]  = 1;
+    while (tmp1 >>= 1) {
+        ++bits[1];
+    }
+    bits[0] = val & ((1 << bits[1]) - 1);
+}
+
+static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU,
+                                int du_stride, float *fdtbl, int DC,
+                                const unsigned short HTDC[256][2],
+                                const unsigned short HTAC[256][2]) {
+    const unsigned short EOB[2]       = {HTAC[0x00][0], HTAC[0x00][1]};
+    const unsigned short M16zeroes[2] = {HTAC[0xF0][0], HTAC[0xF0][1]};
+    int dataOff, i, j, n, diff, end0pos, x, y;
+    int DU[64];
+
+    // DCT rows
+    for (dataOff = 0, n = du_stride * 8; dataOff < n; dataOff += du_stride) {
+        stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff + 1], &CDU[dataOff + 2], &CDU[dataOff + 3],
+                       &CDU[dataOff + 4], &CDU[dataOff + 5], &CDU[dataOff + 6], &CDU[dataOff + 7]);
+    }
+    // DCT columns
+    for (dataOff = 0; dataOff < 8; ++dataOff) {
+        stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff + du_stride], &CDU[dataOff + du_stride * 2],
+                       &CDU[dataOff + du_stride * 3], &CDU[dataOff + du_stride * 4],
+                       &CDU[dataOff + du_stride * 5], &CDU[dataOff + du_stride * 6],
+                       &CDU[dataOff + du_stride * 7]);
+    }
+    // Quantize/descale/zigzag the coefficients
+    for (y = 0, j = 0; y < 8; ++y) {
+        for (x = 0; x < 8; ++x, ++j) {
+            float v;
+            i = y * du_stride + x;
+            v = CDU[i] * fdtbl[j];
+            // DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));
+            // ceilf() and floorf() are C99, not C89, but I /think/ they're not needed here anyway?
+            DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? v - 0.5f : v + 0.5f);
+        }
+    }
+
+    // Encode DC
+    diff = DU[0] - DC;
+    if (diff == 0) {
+        stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[0]);
+    } else {
+        unsigned short bits[2];
+        stbiw__jpg_calcBits(diff, bits);
+        stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[bits[1]]);
+        stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
+    }
+    // Encode ACs
+    end0pos = 63;
+    for (; (end0pos > 0) && (DU[end0pos] == 0); --end0pos) {
+    }
+    // end0pos = first element in reverse order !=0
+    if (end0pos == 0) {
+        stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
+        return DU[0];
+    }
+    for (i = 1; i <= end0pos; ++i) {
+        int startpos = i;
+        int nrzeroes;
+        unsigned short bits[2];
+        for (; DU[i] == 0 && i <= end0pos; ++i) {
+        }
+        nrzeroes = i - startpos;
+        if (nrzeroes >= 16) {
+            int lng = nrzeroes >> 4;
+            int nrmarker;
+            for (nrmarker = 1; nrmarker <= lng; ++nrmarker)
+                stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes);
+            nrzeroes &= 15;
+        }
+        stbiw__jpg_calcBits(DU[i], bits);
+        stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes << 4) + bits[1]]);
+        stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
+    }
+    if (end0pos != 63) {
+        stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
+    }
+    return DU[0];
+}
+
+static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp,
+                               const void *data, int quality) {
+    // Constants that don't pollute global namespace
+    static const unsigned char std_dc_luminance_nrcodes[] = {0, 0, 1, 5, 1, 1, 1, 1, 1,
+                                                             1, 0, 0, 0, 0, 0, 0, 0};
+    static const unsigned char std_dc_luminance_values[]  = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    static const unsigned char std_ac_luminance_nrcodes[] = {0, 0, 2, 1, 3, 3, 2, 4,   3,
+                                                             5, 5, 4, 4, 0, 0, 1, 0x7d};
+    static const unsigned char std_ac_luminance_values[]  = {
+        0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61,
+        0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52,
+        0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25,
+        0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45,
+        0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64,
+        0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83,
+        0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
+        0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+        0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3,
+        0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8,
+        0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa};
+    static const unsigned char std_dc_chrominance_nrcodes[] = {0, 0, 3, 1, 1, 1, 1, 1, 1,
+                                                               1, 1, 1, 0, 0, 0, 0, 0};
+    static const unsigned char std_dc_chrominance_values[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    static const unsigned char std_ac_chrominance_nrcodes[] = {0, 0, 2, 1, 2, 4, 4, 3,   4,
+                                                               7, 5, 4, 4, 0, 1, 2, 0x77};
+    static const unsigned char std_ac_chrominance_values[]  = {
+        0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61,
+        0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33,
+        0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18,
+        0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44,
+        0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63,
+        0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
+        0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+        0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+        0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca,
+        0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+        0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa};
+    // Huffman tables
+    static const unsigned short YDC_HT[256][2] = {
+        {0,   2},
+        {2,   3},
+        {3,   3},
+        {4,   3},
+        {5,   3},
+        {6,   3},
+        {14,  4},
+        {30,  5},
+        {62,  6},
+        {126, 7},
+        {254, 8},
+        {510, 9}
+    };
+    static const unsigned short UVDC_HT[256][2] = {
+        {0,    2 },
+        {1,    2 },
+        {2,    2 },
+        {6,    3 },
+        {14,   4 },
+        {30,   5 },
+        {62,   6 },
+        {126,  7 },
+        {254,  8 },
+        {510,  9 },
+        {1022, 10},
+        {2046, 11}
+    };
+    static const unsigned short YAC_HT[256][2] = {
+        {10,    4 },
+        {0,     2 },
+        {1,     2 },
+        {4,     3 },
+        {11,    4 },
+        {26,    5 },
+        {120,   7 },
+        {248,   8 },
+        {1014,  10},
+        {65410, 16},
+        {65411, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {12,    4 },
+        {27,    5 },
+        {121,   7 },
+        {502,   9 },
+        {2038,  11},
+        {65412, 16},
+        {65413, 16},
+        {65414, 16},
+        {65415, 16},
+        {65416, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {28,    5 },
+        {249,   8 },
+        {1015,  10},
+        {4084,  12},
+        {65417, 16},
+        {65418, 16},
+        {65419, 16},
+        {65420, 16},
+        {65421, 16},
+        {65422, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {58,    6 },
+        {503,   9 },
+        {4085,  12},
+        {65423, 16},
+        {65424, 16},
+        {65425, 16},
+        {65426, 16},
+        {65427, 16},
+        {65428, 16},
+        {65429, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {59,    6 },
+        {1016,  10},
+        {65430, 16},
+        {65431, 16},
+        {65432, 16},
+        {65433, 16},
+        {65434, 16},
+        {65435, 16},
+        {65436, 16},
+        {65437, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {122,   7 },
+        {2039,  11},
+        {65438, 16},
+        {65439, 16},
+        {65440, 16},
+        {65441, 16},
+        {65442, 16},
+        {65443, 16},
+        {65444, 16},
+        {65445, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {123,   7 },
+        {4086,  12},
+        {65446, 16},
+        {65447, 16},
+        {65448, 16},
+        {65449, 16},
+        {65450, 16},
+        {65451, 16},
+        {65452, 16},
+        {65453, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {250,   8 },
+        {4087,  12},
+        {65454, 16},
+        {65455, 16},
+        {65456, 16},
+        {65457, 16},
+        {65458, 16},
+        {65459, 16},
+        {65460, 16},
+        {65461, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {504,   9 },
+        {32704, 15},
+        {65462, 16},
+        {65463, 16},
+        {65464, 16},
+        {65465, 16},
+        {65466, 16},
+        {65467, 16},
+        {65468, 16},
+        {65469, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {505,   9 },
+        {65470, 16},
+        {65471, 16},
+        {65472, 16},
+        {65473, 16},
+        {65474, 16},
+        {65475, 16},
+        {65476, 16},
+        {65477, 16},
+        {65478, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {506,   9 },
+        {65479, 16},
+        {65480, 16},
+        {65481, 16},
+        {65482, 16},
+        {65483, 16},
+        {65484, 16},
+        {65485, 16},
+        {65486, 16},
+        {65487, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {1017,  10},
+        {65488, 16},
+        {65489, 16},
+        {65490, 16},
+        {65491, 16},
+        {65492, 16},
+        {65493, 16},
+        {65494, 16},
+        {65495, 16},
+        {65496, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {1018,  10},
+        {65497, 16},
+        {65498, 16},
+        {65499, 16},
+        {65500, 16},
+        {65501, 16},
+        {65502, 16},
+        {65503, 16},
+        {65504, 16},
+        {65505, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {2040,  11},
+        {65506, 16},
+        {65507, 16},
+        {65508, 16},
+        {65509, 16},
+        {65510, 16},
+        {65511, 16},
+        {65512, 16},
+        {65513, 16},
+        {65514, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {65515, 16},
+        {65516, 16},
+        {65517, 16},
+        {65518, 16},
+        {65519, 16},
+        {65520, 16},
+        {65521, 16},
+        {65522, 16},
+        {65523, 16},
+        {65524, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {2041,  11},
+        {65525, 16},
+        {65526, 16},
+        {65527, 16},
+        {65528, 16},
+        {65529, 16},
+        {65530, 16},
+        {65531, 16},
+        {65532, 16},
+        {65533, 16},
+        {65534, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 }
+    };
+    static const unsigned short UVAC_HT[256][2] = {
+        {0,     2 },
+        {1,     2 },
+        {4,     3 },
+        {10,    4 },
+        {24,    5 },
+        {25,    5 },
+        {56,    6 },
+        {120,   7 },
+        {500,   9 },
+        {1014,  10},
+        {4084,  12},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {11,    4 },
+        {57,    6 },
+        {246,   8 },
+        {501,   9 },
+        {2038,  11},
+        {4085,  12},
+        {65416, 16},
+        {65417, 16},
+        {65418, 16},
+        {65419, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {26,    5 },
+        {247,   8 },
+        {1015,  10},
+        {4086,  12},
+        {32706, 15},
+        {65420, 16},
+        {65421, 16},
+        {65422, 16},
+        {65423, 16},
+        {65424, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {27,    5 },
+        {248,   8 },
+        {1016,  10},
+        {4087,  12},
+        {65425, 16},
+        {65426, 16},
+        {65427, 16},
+        {65428, 16},
+        {65429, 16},
+        {65430, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {58,    6 },
+        {502,   9 },
+        {65431, 16},
+        {65432, 16},
+        {65433, 16},
+        {65434, 16},
+        {65435, 16},
+        {65436, 16},
+        {65437, 16},
+        {65438, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {59,    6 },
+        {1017,  10},
+        {65439, 16},
+        {65440, 16},
+        {65441, 16},
+        {65442, 16},
+        {65443, 16},
+        {65444, 16},
+        {65445, 16},
+        {65446, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {121,   7 },
+        {2039,  11},
+        {65447, 16},
+        {65448, 16},
+        {65449, 16},
+        {65450, 16},
+        {65451, 16},
+        {65452, 16},
+        {65453, 16},
+        {65454, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {122,   7 },
+        {2040,  11},
+        {65455, 16},
+        {65456, 16},
+        {65457, 16},
+        {65458, 16},
+        {65459, 16},
+        {65460, 16},
+        {65461, 16},
+        {65462, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {249,   8 },
+        {65463, 16},
+        {65464, 16},
+        {65465, 16},
+        {65466, 16},
+        {65467, 16},
+        {65468, 16},
+        {65469, 16},
+        {65470, 16},
+        {65471, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {503,   9 },
+        {65472, 16},
+        {65473, 16},
+        {65474, 16},
+        {65475, 16},
+        {65476, 16},
+        {65477, 16},
+        {65478, 16},
+        {65479, 16},
+        {65480, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {504,   9 },
+        {65481, 16},
+        {65482, 16},
+        {65483, 16},
+        {65484, 16},
+        {65485, 16},
+        {65486, 16},
+        {65487, 16},
+        {65488, 16},
+        {65489, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {505,   9 },
+        {65490, 16},
+        {65491, 16},
+        {65492, 16},
+        {65493, 16},
+        {65494, 16},
+        {65495, 16},
+        {65496, 16},
+        {65497, 16},
+        {65498, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {506,   9 },
+        {65499, 16},
+        {65500, 16},
+        {65501, 16},
+        {65502, 16},
+        {65503, 16},
+        {65504, 16},
+        {65505, 16},
+        {65506, 16},
+        {65507, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {2041,  11},
+        {65508, 16},
+        {65509, 16},
+        {65510, 16},
+        {65511, 16},
+        {65512, 16},
+        {65513, 16},
+        {65514, 16},
+        {65515, 16},
+        {65516, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {16352, 14},
+        {65517, 16},
+        {65518, 16},
+        {65519, 16},
+        {65520, 16},
+        {65521, 16},
+        {65522, 16},
+        {65523, 16},
+        {65524, 16},
+        {65525, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {1018,  10},
+        {32707, 15},
+        {65526, 16},
+        {65527, 16},
+        {65528, 16},
+        {65529, 16},
+        {65530, 16},
+        {65531, 16},
+        {65532, 16},
+        {65533, 16},
+        {65534, 16},
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 },
+        {0,     0 }
+    };
+    static const int YQT[]    = {16,  11,  10,  16,  24, 40, 51,  61,  12,  12,  14,  19,  26,
+                                 58,  60,  55,  14,  13, 16, 24,  40,  57,  69,  56,  14,  17,
+                                 22,  29,  51,  87,  80, 62, 18,  22,  37,  56,  68,  109, 103,
+                                 77,  24,  35,  55,  64, 81, 104, 113, 92,  49,  64,  78,  87,
+                                 103, 121, 120, 101, 72, 92, 95,  98,  112, 100, 103, 99};
+    static const int UVQT[]   = {17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66, 99, 99, 99, 99,
+                                 24, 26, 56, 99, 99, 99, 99, 99, 47, 66, 99, 99, 99, 99, 99, 99,
+                                 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+                                 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99};
+    static const float aasf[] = {1.0f * 2.828427125f,         1.387039845f * 2.828427125f,
+                                 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f,
+                                 1.0f * 2.828427125f,         0.785694958f * 2.828427125f,
+                                 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f};
+
+    int row, col, i, k, subsample;
+    float fdtbl_Y[64], fdtbl_UV[64];
+    unsigned char YTable[64], UVTable[64];
+
+    if (!data || !width || !height || comp > 4 || comp < 1) {
+        return 0;
+    }
+
+    quality   = quality ? quality : 90;
+    subsample = quality <= 90 ? 1 : 0;
+    quality   = quality < 1 ? 1 : quality > 100 ? 100 : quality;
+    quality   = quality < 50 ? 5000 / quality : 200 - quality * 2;
+
+    for (i = 0; i < 64; ++i) {
+        int uvti, yti = (YQT[i] * quality + 50) / 100;
+        YTable[stbiw__jpg_ZigZag[i]]  = (unsigned char)(yti < 1 ? 1 : yti > 255 ? 255 : yti);
+        uvti                          = (UVQT[i] * quality + 50) / 100;
+        UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char)(uvti < 1 ? 1 : uvti > 255 ? 255 : uvti);
+    }
+
+    for (row = 0, k = 0; row < 8; ++row) {
+        for (col = 0; col < 8; ++col, ++k) {
+            fdtbl_Y[k]  = 1 / (YTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
+            fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
+        }
+    }
+
+    // Write Headers
+    {
+        static const unsigned char head0[] = {0xFF, 0xD8, 0xFF, 0xE0, 0, 0x10, 'J', 'F', 'I',
+                                              'F',  0,    1,    1,    0, 0,    1,   0,   1,
+                                              0,    0,    0xFF, 0xDB, 0, 0x84, 0};
+        static const unsigned char head2[] = {0xFF, 0xDA, 0, 0xC,  3, 1,    0,
+                                              2,    0x11, 3, 0x11, 0, 0x3F, 0};
+        const unsigned char head1[]        = {0xFF,
+                                              0xC0,
+                                              0,
+                                              0x11,
+                                              8,
+                                              (unsigned char)(height >> 8),
+                                              STBIW_UCHAR(height),
+                                              (unsigned char)(width >> 8),
+                                              STBIW_UCHAR(width),
+                                              3,
+                                              1,
+                                              (unsigned char)(subsample ? 0x22 : 0x11),
+                                              0,
+                                              2,
+                                              0x11,
+                                              1,
+                                              3,
+                                              0x11,
+                                              1,
+                                              0xFF,
+                                              0xC4,
+                                              0x01,
+                                              0xA2,
+                                              0};
+        s->func(s->context, (void *)head0, sizeof(head0));
+        s->func(s->context, (void *)YTable, sizeof(YTable));
+        stbiw__putc(s, 1);
+        s->func(s->context, UVTable, sizeof(UVTable));
+        s->func(s->context, (void *)head1, sizeof(head1));
+        s->func(s->context, (void *)(std_dc_luminance_nrcodes + 1),
+                sizeof(std_dc_luminance_nrcodes) - 1);
+        s->func(s->context, (void *)std_dc_luminance_values, sizeof(std_dc_luminance_values));
+        stbiw__putc(s, 0x10);  // HTYACinfo
+        s->func(s->context, (void *)(std_ac_luminance_nrcodes + 1),
+                sizeof(std_ac_luminance_nrcodes) - 1);
+        s->func(s->context, (void *)std_ac_luminance_values, sizeof(std_ac_luminance_values));
+        stbiw__putc(s, 1);  // HTUDCinfo
+        s->func(s->context, (void *)(std_dc_chrominance_nrcodes + 1),
+                sizeof(std_dc_chrominance_nrcodes) - 1);
+        s->func(s->context, (void *)std_dc_chrominance_values, sizeof(std_dc_chrominance_values));
+        stbiw__putc(s, 0x11);  // HTUACinfo
+        s->func(s->context, (void *)(std_ac_chrominance_nrcodes + 1),
+                sizeof(std_ac_chrominance_nrcodes) - 1);
+        s->func(s->context, (void *)std_ac_chrominance_values, sizeof(std_ac_chrominance_values));
+        s->func(s->context, (void *)head2, sizeof(head2));
+    }
+
+    // Encode 8x8 macroblocks
+    {
+        static const unsigned short fillBits[] = {0x7F, 7};
+        int DCY = 0, DCU = 0, DCV = 0;
+        int bitBuf = 0, bitCnt = 0;
+        // comp == 2 is grey+alpha (alpha is ignored)
+        int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0;
+        const unsigned char *dataR = (const unsigned char *)data;
+        const unsigned char *dataG = dataR + ofsG;
+        const unsigned char *dataB = dataR + ofsB;
+        int x, y, pos;
+        if (subsample) {
+            for (y = 0; y < height; y += 16) {
+                for (x = 0; x < width; x += 16) {
+                    float Y[256], U[256], V[256];
+                    for (row = y, pos = 0; row < y + 16; ++row) {
+                        // row >= height => use last input row
+                        int clamped_row = (row < height) ? row : height - 1;
+                        int base_p = (stbi__flip_vertically_on_write ? (height - 1 - clamped_row)
+                                                                     : clamped_row) *
+                                     width * comp;
+                        for (col = x; col < x + 16; ++col, ++pos) {
+                            // if col >= width => use pixel from last input column
+                            int p   = base_p + ((col < width) ? col : (width - 1)) * comp;
+                            float r = dataR[p], g = dataG[p], b = dataB[p];
+                            Y[pos] = +0.29900f * r + 0.58700f * g + 0.11400f * b - 128;
+                            U[pos] = -0.16874f * r - 0.33126f * g + 0.50000f * b;
+                            V[pos] = +0.50000f * r - 0.41869f * g - 0.08131f * b;
+                        }
+                    }
+                    DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y + 0, 16, fdtbl_Y, DCY, YDC_HT,
+                                               YAC_HT);
+                    DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y + 8, 16, fdtbl_Y, DCY, YDC_HT,
+                                               YAC_HT);
+                    DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y + 128, 16, fdtbl_Y, DCY,
+                                               YDC_HT, YAC_HT);
+                    DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y + 136, 16, fdtbl_Y, DCY,
+                                               YDC_HT, YAC_HT);
+
+                    // subsample U,V
+                    {
+                        float subU[64], subV[64];
+                        int yy, xx;
+                        for (yy = 0, pos = 0; yy < 8; ++yy) {
+                            for (xx = 0; xx < 8; ++xx, ++pos) {
+                                int j     = yy * 32 + xx * 2;
+                                subU[pos] = (U[j + 0] + U[j + 1] + U[j + 16] + U[j + 17]) * 0.25f;
+                                subV[pos] = (V[j + 0] + V[j + 1] + V[j + 16] + V[j + 17]) * 0.25f;
+                            }
+                        }
+                        DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU,
+                                                   UVDC_HT, UVAC_HT);
+                        DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV,
+                                                   UVDC_HT, UVAC_HT);
+                    }
+                }
+            }
+        } else {
+            for (y = 0; y < height; y += 8) {
+                for (x = 0; x < width; x += 8) {
+                    float Y[64], U[64], V[64];
+                    for (row = y, pos = 0; row < y + 8; ++row) {
+                        // row >= height => use last input row
+                        int clamped_row = (row < height) ? row : height - 1;
+                        int base_p = (stbi__flip_vertically_on_write ? (height - 1 - clamped_row)
+                                                                     : clamped_row) *
+                                     width * comp;
+                        for (col = x; col < x + 8; ++col, ++pos) {
+                            // if col >= width => use pixel from last input column
+                            int p   = base_p + ((col < width) ? col : (width - 1)) * comp;
+                            float r = dataR[p], g = dataG[p], b = dataB[p];
+                            Y[pos] = +0.29900f * r + 0.58700f * g + 0.11400f * b - 128;
+                            U[pos] = -0.16874f * r - 0.33126f * g + 0.50000f * b;
+                            V[pos] = +0.50000f * r - 0.41869f * g - 0.08131f * b;
+                        }
+                    }
+
+                    DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT,
+                                               YAC_HT);
+                    DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT,
+                                               UVAC_HT);
+                    DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT,
+                                               UVAC_HT);
+                }
+            }
+        }
+
+        // Do the bit alignment of the EOI marker
+        stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits);
+    }
+
+    // EOI
+    stbiw__putc(s, 0xFF);
+    stbiw__putc(s, 0xD9);
+
+    return 1;
+}
+
+STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp,
+                                    const void *data, int quality) {
+    stbi__write_context s = {0};
+    stbi__start_write_callbacks(&s, func, context);
+    return stbi_write_jpg_core(&s, x, y, comp, (void *)data, quality);
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data,
+                            int quality) {
+    stbi__write_context s = {0};
+    if (stbi__start_write_file(&s, filename)) {
+        int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
+        stbi__end_write_file(&s);
+        return r;
+    } else
+        return 0;
+}
+#endif
+
+#endif  // STB_IMAGE_WRITE_IMPLEMENTATION
+
+/* Revision history
+      1.16  (2021-07-11)
+             make Deflate code emit uncompressed blocks when it would otherwise expand
+             support writing BMPs with alpha channel
+      1.15  (2020-07-13) unknown
+      1.14  (2020-02-02) updated JPEG writer to downsample chroma channels
+      1.13
+      1.12
+      1.11  (2019-08-11)
+
+      1.10  (2019-02-07)
+             support utf8 filenames in Windows; fix warnings and platform ifdefs
+      1.09  (2018-02-11)
+             fix typo in zlib quality API, improve STB_I_W_STATIC in C++
+      1.08  (2018-01-29)
+             add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter
+      1.07  (2017-07-24)
+             doc fix
+      1.06 (2017-07-23)
+             writing JPEG (using Jon Olick's code)
+      1.05   ???
+      1.04 (2017-03-03)
+             monochrome BMP expansion
+      1.03   ???
+      1.02 (2016-04-02)
+             avoid allocating large structures on the stack
+      1.01 (2016-01-16)
+             STBIW_REALLOC_SIZED: support allocators with no realloc support
+             avoid race-condition in crc initialization
+             minor compile issues
+      1.00 (2015-09-14)
+             installable file IO function
+      0.99 (2015-09-13)
+             warning fixes; TGA rle support
+      0.98 (2015-04-08)
+             added STBIW_MALLOC, STBIW_ASSERT etc
+      0.97 (2015-01-18)
+             fixed HDR asserts, rewrote HDR rle logic
+      0.96 (2015-01-17)
+             add HDR output
+             fix monochrome BMP
+      0.95 (2014-08-17)
+             add monochrome TGA output
+      0.94 (2014-05-31)
+             rename private functions to avoid conflicts with stb_image.h
+      0.93 (2014-05-27)
+             warning fixes
+      0.92 (2010-08-01)
+             casts to unsigned char to fix warnings
+      0.91 (2010-07-17)
+             first public release
+      0.90   first internal release
+*/
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
\ No newline at end of file
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 01e5ae84..96dc6d0f 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -16,6 +16,10 @@
 #include <imgui.h>
 #include <imgui_impl_glfw.h>
 #include <imgui_internal.h>
+
+#ifndef STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_IMPLEMENTATION
+#endif
 #include <stb/stb_image.h>
 
 #include "core/core.hpp"
@@ -473,7 +477,7 @@ namespace Toolbox {
                                          ImGuiWindowFlags_NoDecoration |
                                              ImGuiWindowFlags_NoInputs)) {
                             ImagePainter painter;
-                            painter.renderOverlay(*action->getImage(), pos, size);
+                            painter.render(*action->getImage(), pos, size);
 
                             if (ImGuiWindow *win = ImGui::GetCurrentWindow()) {
                                 if (win->Viewport != ImGui::GetMainViewport()) {
diff --git a/src/gui/dragdrop/target.cpp b/src/gui/dragdrop/target.cpp
index c8e943e1..45cc8246 100644
--- a/src/gui/dragdrop/target.cpp
+++ b/src/gui/dragdrop/target.cpp
@@ -5,6 +5,8 @@
 #include "gui/event/dropevent.hpp"
 #include "gui/window.hpp"
 
+#include "image/imagebuilder.hpp"
+
 namespace Toolbox::UI {
 
     static UUID64 searchDropTarget(const ImVec2 &mouse_pos) {
@@ -246,7 +248,7 @@ namespace Toolbox::UI {
             DragDropManager::instance().setSystemAction(false);
         }
 
-        action->setHotSpot(ImVec2(pt.x, pt.y));
+        action->setHotSpot(ImVec2((float)pt.x, (float)pt.y));
 
         DropTypes supported_drop_types = DropType::ACTION_NONE;
         if ((*pdwEffect & DROPEFFECT_COPY)) {
@@ -267,7 +269,7 @@ namespace Toolbox::UI {
     HRESULT __stdcall WindowsDragDropTarget::DragOver(DWORD grfKeyState, POINTL pt,
                                                       DWORD *pdwEffect) {
         RefPtr<DragAction> action = DragDropManager::instance().getCurrentDragAction();
-        action->setHotSpot(ImVec2(pt.x, pt.y));
+        action->setHotSpot(ImVec2((float)pt.x, (float)pt.y));
         m_delegate->onDragMove(action);
         return S_OK;
     }
@@ -286,7 +288,7 @@ namespace Toolbox::UI {
             action = DragDropManager::instance().createDragAction(0, std::move(mime_data));
         }
 
-        action->setHotSpot(ImVec2(pt.x, pt.y));
+        action->setHotSpot(ImVec2((float)pt.x, (float)pt.y));
 
         DropTypes supported_drop_types = DropType::ACTION_NONE;
         if ((*pdwEffect & DROPEFFECT_COPY)) {
@@ -309,13 +311,6 @@ namespace Toolbox::UI {
         UUID64 prev_uuid = action->getTargetUUID();
         UUID64 new_uuid  = searchDropTarget(mouse_pos);
 
-        ResourceManager &resource_manager = GUIApplication::instance().getResourceManager();
-        RefPtr<const ImageHandle> image =
-            resource_manager
-                .getImageHandle("toolbox.png", resource_manager.getResourcePathUUID("Images/Icons"))
-                .value_or(nullptr);
-        action->setImage(image);
-
         if (prev_uuid != new_uuid) {
             if (prev_uuid != 0) {
                 GUIApplication::instance().dispatchEvent<DragEvent, true>(
@@ -336,13 +331,6 @@ namespace Toolbox::UI {
         UUID64 prev_uuid = action->getTargetUUID();
         UUID64 new_uuid  = searchDropTarget(mouse_pos);
 
-        ResourceManager &resource_manager = GUIApplication::instance().getResourceManager();
-        RefPtr<const ImageHandle> image =
-            resource_manager
-                .getImageHandle("toolbox.png", resource_manager.getResourcePathUUID("Images/Icons"))
-                .value_or(nullptr);
-        action->setImage(image);
-
         if (prev_uuid != new_uuid && prev_uuid != 0) {
             GUIApplication::instance().dispatchEvent<DragEvent, true>(EVENT_DRAG_LEAVE, mouse_pos.x,
                                                                       mouse_pos.y, action);
@@ -356,13 +344,6 @@ namespace Toolbox::UI {
         UUID64 prev_uuid = action->getTargetUUID();
         UUID64 new_uuid  = searchDropTarget(mouse_pos);
 
-        ResourceManager &resource_manager = GUIApplication::instance().getResourceManager();
-        RefPtr<const ImageHandle> image =
-            resource_manager
-                .getImageHandle("toolbox.png", resource_manager.getResourcePathUUID("Images/Icons"))
-                .value_or(nullptr);
-        action->setImage(image);
-
         if (prev_uuid != new_uuid) {
             if (!m_block_implicit_drag_events && prev_uuid != 0) {
                 GUIApplication::instance().dispatchEvent<DragEvent, true>(
@@ -387,13 +368,6 @@ namespace Toolbox::UI {
     void WindowsDragDropTargetDelegate::onDrop(RefPtr<DragAction> action) {
         ImVec2 mouse_pos = action->getHotSpot();
 
-        ResourceManager &resource_manager = GUIApplication::instance().getResourceManager();
-        RefPtr<const ImageHandle> image =
-            resource_manager
-                .getImageHandle("toolbox.png", resource_manager.getResourcePathUUID("Images/Icons"))
-                .value_or(nullptr);
-        action->setImage(image);
-
         UUID64 new_uuid = searchDropTarget(mouse_pos);
         action->setTargetUUID(new_uuid);
 
diff --git a/src/gui/pad/window.cpp b/src/gui/pad/window.cpp
index 840e3472..084aac23 100644
--- a/src/gui/pad/window.cpp
+++ b/src/gui/pad/window.cpp
@@ -31,8 +31,8 @@
 #include "gui/window.hpp"
 
 #include "gui/logging/errors.hpp"
-#include "gui/stb_image.h"
 
+#include <stb/stb_image.h>
 #include <ImGuiFileDialog.h>
 #include <imgui.h>
 
diff --git a/src/gui/scene/billboard.cpp b/src/gui/scene/billboard.cpp
index 30f66169..f7131a40 100644
--- a/src/gui/scene/billboard.cpp
+++ b/src/gui/scene/billboard.cpp
@@ -1,7 +1,7 @@
 #include "gui/scene/billboard.hpp"
 #include <filesystem>
 #include <gui/scene/renderer.hpp>
-#include "gui/stb_image.h"
+#include <stb/stb_image.h>
 #include <glad/glad.h>
 
 namespace Toolbox::UI {
diff --git a/src/image/imagebuilder.cpp b/src/image/imagebuilder.cpp
new file mode 100644
index 00000000..d4b9fed9
--- /dev/null
+++ b/src/image/imagebuilder.cpp
@@ -0,0 +1,353 @@
+#include "image/imagebuilder.hpp"
+#include "image/imagehandle.hpp"
+
+#include <stb/stb_image.h>
+
+#ifndef STB_IMAGE_RESIZE_IMPLEMENTATION
+#define STB_IMAGE_RESIZE_IMPLEMENTATION
+#endif
+#include <stb/stb_image_resize2.h>
+
+#include <glad/glad.h>
+#include <imgui/imgui.h>
+
+namespace Toolbox::UI {
+
+    using pixel_pix_op_t   = std::function<u8(u8, u8)>;
+    using pixel_color_op_t = std::function<void(u8 *, const u8 *, const u8 *, int, int, int)>;
+
+    static ScopePtr<ImageData> _ImageApplyOperationPix(const ImageData &a, const ImageData &b,
+                                                       pixel_pix_op_t operation) {
+        const u8 *A = a.getData();
+        const u8 *B = b.getData();
+
+        int chan_a = a.getChannels();
+        int chan_b = b.getChannels();
+
+        int rows_a = a.getHeight();
+        int cols_a = a.getWidth();
+        int rows_b = b.getHeight();
+        int cols_b = b.getWidth();
+
+        // Determine the intersection size
+        int min_height = std::min(rows_a, rows_b);
+        int min_width  = std::min(cols_a, cols_b);
+
+        int max_height      = std::max(rows_a, rows_b);
+        int max_width       = std::max(cols_a, cols_b);
+        int result_channels = std::max(chan_a, chan_b);
+
+        Buffer result_buf;
+        result_buf.alloc(max_width * max_height * result_channels);
+
+        // Apply the operation to the overlapping region
+        for (int row = 0; row < min_height; ++row) {
+            for (int col = 0; col < min_width; ++col) {
+                // Process for channels in A and B
+                for (int ch = 0; ch < result_channels; ++ch) {
+                    int ind_a  = row * cols_a * chan_a + col * chan_a + ch;
+                    int ind_b  = row * cols_b * chan_b + col * chan_b + ch;
+                    u8 pixel_A = (ch < chan_a) ? A[ind_a] : 0;
+                    u8 pixel_B = (ch < chan_b) ? B[ind_b] : 0;
+
+                    // Store in the result image
+                    int ind_res = row * max_width * result_channels + col * result_channels + ch;
+                    result_buf[ind_res] = operation(pixel_A, pixel_B);
+                }
+            }
+        }
+
+        // Copy the rest of A if it's bigger than B
+        for (int row = min_height; row < rows_a; ++row) {
+            for (int col = min_width; col < cols_a; ++col) {
+                // Skip pixels that are already handled in the overlap region
+                if (row < min_height && col < min_width)
+                    continue;
+
+                for (int ch = 0; ch < result_channels; ++ch) {
+                    u8 pixel_A = (ch < chan_a) ? A[row * cols_a * chan_a + col * chan_a + ch] : 0;
+                    result_buf[row * max_width * result_channels + col * result_channels + ch] =
+                        pixel_A;
+                }
+            }
+        }
+
+        // Copy the rest of B if it's bigger than A
+        for (int row = min_height; row < rows_b; ++row) {
+            for (int col = min_width; col < cols_b; ++col) {
+                // Skip pixels that are already handled in the overlap region
+                if (row < min_height && col < min_width)
+                    continue;
+
+                for (int ch = 0; ch < result_channels; ++ch) {
+                    u8 pixel_B = (ch < chan_b) ? B[row * cols_b * chan_b + col * chan_b + ch] : 0;
+                    result_buf[row * max_width * result_channels + col * result_channels + ch] =
+                        pixel_B;
+                }
+            }
+        }
+
+        return make_scoped<ImageData>(std::move(result_buf), result_channels, max_width,
+                                      max_height);
+    }
+
+    static ScopePtr<ImageData> _ImageApplyOperationColor(const ImageData &a, const ImageData &b,
+                                                         pixel_color_op_t operation) {
+        const u8 *A = a.getData();
+        const u8 *B = b.getData();
+
+        int chan_a = a.getChannels();
+        int chan_b = b.getChannels();
+
+        int rows_a = a.getHeight();
+        int cols_a = a.getWidth();
+        int rows_b = b.getHeight();
+        int cols_b = b.getWidth();
+
+        // Determine the intersection size
+        int min_height = std::min(rows_a, rows_b);
+        int min_width  = std::min(cols_a, cols_b);
+
+        int max_height      = std::max(rows_a, rows_b);
+        int max_width       = std::max(cols_a, cols_b);
+        int result_channels = std::max(chan_a, chan_b);
+
+        Buffer result_buf;
+        result_buf.alloc(max_width * max_height * result_channels);
+
+        // Apply the operation to the overlapping region
+        for (int row = 0; row < min_height; ++row) {
+            for (int col = 0; col < min_width; ++col) {
+                // Process for channels in A and B
+                int ind_a   = row * cols_a * chan_a + col * chan_a;
+                int ind_b   = row * cols_b * chan_b + col * chan_b;
+                int ind_res = row * max_width * result_channels + col * result_channels;
+                operation(result_buf.buf<u8>() + ind_res, A + ind_a, B + ind_b, result_channels,
+                          chan_a, chan_b);
+            }
+        }
+
+        // Copy the rest of A if it's bigger than B
+        for (int row = min_height; row < rows_a; ++row) {
+            for (int col = min_width; col < cols_a; ++col) {
+                // Skip pixels that are already handled in the overlap region
+                if (row < min_height && col < min_width)
+                    continue;
+
+                for (int ch = 0; ch < result_channels; ++ch) {
+                    u8 pixel_A = (ch < chan_a) ? A[row * cols_a * chan_a + col * chan_a + ch] : 0;
+                    result_buf[row * max_width * result_channels + col * result_channels + ch] =
+                        pixel_A;
+                }
+            }
+        }
+
+        // Copy the rest of B if it's bigger than A
+        for (int row = min_height; row < rows_b; ++row) {
+            for (int col = min_width; col < cols_b; ++col) {
+                // Skip pixels that are already handled in the overlap region
+                if (row < min_height && col < min_width)
+                    continue;
+
+                for (int ch = 0; ch < result_channels; ++ch) {
+                    u8 pixel_B = (ch < chan_b) ? B[row * cols_b * chan_b + col * chan_b + ch] : 0;
+                    result_buf[row * max_width * result_channels + col * result_channels + ch] =
+                        pixel_B;
+                }
+            }
+        }
+
+        return make_scoped<ImageData>(std::move(result_buf), result_channels, max_width,
+                                      max_height);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageAdd(const ImageData &a, const ImageData &b, float scale,
+                                               float offset) {
+        // Function to add two pixels safely (with clamping)
+        auto add_pixel = [scale, offset](u8 px_a, u8 px_b) -> u8 {
+            int sum = (static_cast<int>(px_a) + static_cast<int>(px_b)) / scale + (offset * 255.0f);
+            return static_cast<u8>(std::min(255, sum));  // Clamp to 255
+        };
+
+        return _ImageApplyOperationPix(a, b, add_pixel);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageAddModulo(const ImageData &a, const ImageData &b) {
+        // Function to add two pixels safely (with clamping)
+        auto add_pixel = [](u8 px_a, u8 px_b) -> u8 {
+            int sum = (static_cast<int>(px_a) + static_cast<int>(px_b));
+            return static_cast<u8>(sum % 256);
+        };
+
+        return _ImageApplyOperationPix(a, b, add_pixel);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageBlend(const ImageData &a, const ImageData &b,
+                                                 float alpha) {
+        auto blend = [alpha](u8 px_a, u8 px_b) -> u8 {
+            return static_cast<u8>(
+                std::lerp(static_cast<float>(px_a), static_cast<float>(px_b), alpha));
+        };
+
+        return _ImageApplyOperationPix(a, b, blend);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageComposite(const ImageData &a, const ImageData &b) {
+        auto composite = [](u8 *dst, const u8 *a, const u8 *b, int ch_dst, int ch_a,
+                            int ch_b) -> void {
+            // Composite the two images
+            if (ch_b < 4) {
+                for (int i = 0; i < ch_dst; ++i) {
+                    dst[i] = (i < ch_b) ? b[i] : 0;
+                }
+                return;
+            }
+
+            float alpha = static_cast<float>(b[3]) / 255.0f;
+
+            for (int ch = 0; ch < ch_dst; ++ch) {
+                float pa = (ch < ch_a) ? static_cast<float>(a[ch]) : 0.0f;
+                float pb = (ch < ch_b) ? static_cast<float>(b[ch]) : 0.0f;
+                dst[ch]  = static_cast<u8>(std::lerp(pa, pb, alpha));
+            }
+        };
+
+        return _ImageApplyOperationColor(a, b, composite);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageDarker(const ImageData &a, const ImageData &b) {
+        auto darker = [](u8 px_a, u8 px_b) -> u8 { return std::min(px_a, px_b); };
+
+        return _ImageApplyOperationPix(a, b, darker);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageDifference(const ImageData &a, const ImageData &b) {
+        auto darker = [](u8 px_a, u8 px_b) -> u8 { return std::abs(px_a - px_b); };
+
+        return _ImageApplyOperationPix(a, b, darker);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageDivide(const ImageData &a, const ImageData &b) {
+        auto divide = [](u8 px_a, u8 px_b) -> u8 {
+            float a = static_cast<float>(px_a) / 255.0f;
+            float b = static_cast<float>(px_b) / 255.0f;
+            int div = static_cast<int>((static_cast<float>(a) / static_cast<float>(b) * 255.0f));
+            return static_cast<u8>(std::min(255, div));
+        };
+
+        return _ImageApplyOperationPix(a, b, divide);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageLighter(const ImageData &a, const ImageData &b) {
+        auto lighter = [](u8 px_a, u8 px_b) -> u8 { return std::max(px_a, px_b); };
+
+        return _ImageApplyOperationPix(a, b, lighter);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageMultiply(const ImageData &a, const ImageData &b) {
+        auto divide = [](u8 px_a, u8 px_b) -> u8 {
+            float a = static_cast<float>(px_a) / 255.0f;
+            float b = static_cast<float>(px_b) / 255.0f;
+            return static_cast<u8>((static_cast<float>(a) * static_cast<float>(b) * 255.0f));
+        };
+
+        return _ImageApplyOperationPix(a, b, divide);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageOffset(const ImageData &image, int d_x, int d_y) {
+        int width  = image.getWidth();
+        int height = image.getHeight();
+        int ch     = image.getChannels();
+
+        const u8 *A = image.getData();
+
+        Buffer result_buf;
+        result_buf.alloc(width * height * ch);
+        result_buf.initTo(0);
+
+        for (int y = 0; (y + d_y) < height; ++y) {
+            for (int x = 0; (x + d_x) < width; ++x) {
+                for (int c = 0; c < ch; ++ch) {
+                    int src_ind         = y * width * c + x * c + c;
+                    int dst_ind         = (y + d_y) * width * c + (x + d_x) * c + c;
+                    result_buf[dst_ind] = A[src_ind];
+                }
+            }
+        }
+
+        return make_scoped<ImageData>(std::move(result_buf), ch, width, height);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageOverlay(const ImageData &a, const ImageData &b) {
+        auto overlay = [](u8 px_a, u8 px_b) -> u8 {
+            float a = static_cast<float>(px_a) / 255.0f;
+            float b = static_cast<float>(px_b) / 255.0f;
+            if (px_b < 128)
+                return 2.0f * a * b * 255.0f;
+            return (1.0f - 2.0f * (1.0f - a) * (1.0f - b)) * 255.0f;
+        };
+
+        return _ImageApplyOperationPix(a, b, overlay);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageResize(const ImageData &image, int width, int height) {
+        Buffer result_buf;
+        result_buf.alloc(width * height * image.getChannels());
+
+        stbir_pixel_layout layouts[] = {STBIR_1CHANNEL, STBIR_2CHANNEL, STBIR_RGB, STBIR_RGBA};
+
+        stbir_resize_uint8_linear(image.getData(), image.getWidth(), image.getHeight(), 0,
+                                  result_buf.buf<u8>(), width, height, 0,
+                                  layouts[image.getChannels()]);
+
+        return make_scoped<ImageData>(std::move(result_buf), image.getChannels(), width, height);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageScreen(const ImageData &a, const ImageData &b) {
+        auto screen = [](u8 px_a, u8 px_b) -> u8 {
+            float a = static_cast<float>(px_a) / 255.0f;
+            float b = static_cast<float>(px_b) / 255.0f;
+            return (1.0f - (1.0f - a) * (1.0f - b)) * 255.0f;
+        };
+
+        return _ImageApplyOperationPix(a, b, screen);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageSubtract(const ImageData &a, const ImageData &b,
+                                                    float scale, float offset) {
+        auto sub_pixel = [scale, offset](u8 px_a, u8 px_b) -> u8 {
+            int sum = (static_cast<int>(px_a) - static_cast<int>(px_b)) / scale + (offset * 255.0f);
+            return static_cast<u8>(std::min(255, sum));  // Clamp to 255
+        };
+
+        return _ImageApplyOperationPix(a, b, sub_pixel);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageSubtractModulo(const ImageData &a, const ImageData &b) {
+        auto sub_pixel = [](u8 px_a, u8 px_b) -> u8 {
+            int diff = (static_cast<int>(px_a) - static_cast<int>(px_b));
+            return static_cast<u8>(((diff % 256) + 256) % 256);
+        };
+
+        return _ImageApplyOperationPix(a, b, sub_pixel);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageAND(const ImageData &a, const ImageData &b) {
+        auto sub_pixel = [](u8 px_a, u8 px_b) -> u8 { return px_a & px_b; };
+
+        return _ImageApplyOperationPix(a, b, sub_pixel);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageOR(const ImageData &a, const ImageData &b) {
+        auto sub_pixel = [](u8 px_a, u8 px_b) -> u8 { return px_a | px_b; };
+
+        return _ImageApplyOperationPix(a, b, sub_pixel);
+    }
+
+    ScopePtr<ImageData> ImageBuilder::ImageXOR(const ImageData &a, const ImageData &b) {
+        auto sub_pixel = [](u8 px_a, u8 px_b) -> u8 { return px_a ^ px_b; };
+
+        return _ImageApplyOperationPix(a, b, sub_pixel);
+    }
+
+}  // namespace Toolbox::UI
diff --git a/src/image/imagedata.cpp b/src/image/imagedata.cpp
new file mode 100644
index 00000000..8753d796
--- /dev/null
+++ b/src/image/imagedata.cpp
@@ -0,0 +1,52 @@
+#include "image/imagedata.hpp"
+
+#include <stb/stb_image.h>
+
+#ifndef STB_IMAGE_WRITE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#endif
+#include <stb/stb_image_write.h>
+
+namespace Toolbox {
+
+    ImageData::ImageData(const fs_path &res_path) {
+        stbi_uc *data = stbi_load(res_path.string().c_str(), &m_width, &m_height, &m_channels, 0);
+        m_data.setBuf(data, static_cast<size_t>(m_width * m_height * m_channels));
+    }
+
+    ImageData::ImageData(std::span<u8> data) {
+        stbi_uc *stbi_buf =
+            stbi_load_from_memory(data.data(), data.size(), &m_width, &m_height, &m_channels, 0);
+        m_data.setBuf(stbi_buf, static_cast<size_t>(m_width * m_height * m_channels));
+    }
+
+    ImageData::ImageData(std::span<u8> data, int channels, int dx, int dy)
+        : m_channels(channels), m_width(dx), m_height(dy) {
+        m_data.setBuf(data.data(), data.size());
+    }
+
+    ImageData::ImageData(const Buffer &data) {
+        stbi_uc *stbi_buf =
+            stbi_load_from_memory(data.buf<u8>(), data.size(), &m_width, &m_height, &m_channels, 0);
+        m_data.setBuf(stbi_buf, static_cast<size_t>(m_width * m_height * m_channels));
+    }
+
+    ImageData::ImageData(Buffer &&data, int channels, int dx, int dy)
+        : m_channels(channels), m_width(dx), m_height(dy) {
+        m_data = std::move(data);
+    }
+
+    ImageData::~ImageData() { 
+        if (m_data) {
+            //stbi_image_free(m_data.buf<u8>());
+            m_data.free();
+        }
+    }
+
+    bool ImageData::save(const fs_path &filename) const {
+        stbi_write_png(filename.string().c_str(), m_width, m_height, m_channels, m_data.buf<u8>(),
+                       0);
+        return true;
+    }
+
+}  // namespace Toolbox
diff --git a/src/image/imagehandle.cpp b/src/image/imagehandle.cpp
index b135d8d5..70d9e9f0 100644
--- a/src/image/imagehandle.cpp
+++ b/src/image/imagehandle.cpp
@@ -1,5 +1,3 @@
-#pragma once
-
 #include <fstream>
 
 #include "image/imagehandle.hpp"
@@ -7,13 +5,11 @@
 #include "core/memory.hpp"
 #include "fsystem.hpp"
 
-#define STB_IMAGE_IMPLEMENTATION
-#include "gui/stb_image.h"
-#include "stb/stb_image_resize.h"
-
 #include <glad/glad.h>
 #include <imgui/imgui.h>
 
+#include <stb/stb_image.h>
+
 namespace Toolbox {
 
     ImageHandle::ImageHandle(const ImageHandle &other) { copyGL(other); }
@@ -65,6 +61,10 @@ namespace Toolbox {
         stbi_image_free(stbi_buf);
     }
 
+    ImageHandle::ImageHandle(const ImageData &data) {
+        loadGL(data.m_data, data.getChannels(), data.getWidth(), data.getHeight());
+    }
+
     ImageHandle::ImageHandle(const Buffer &data, int channels, int dx, int dy) {
         loadGL(data, channels, dx, dy);
     }
diff --git a/src/resource/resource.cpp b/src/resource/resource.cpp
index 54e04756..13e602af 100644
--- a/src/resource/resource.cpp
+++ b/src/resource/resource.cpp
@@ -149,6 +149,72 @@ namespace Toolbox {
         return result;
     }
 
+    Result<RefPtr<const ImageData>, FSError>
+    ResourceManager::getImageData(const fs_path &path, const UUID64 &resource_path_uuid) const {
+        if (!hasDataPath(path, resource_path_uuid)) {
+            return make_fs_error<RefPtr<const ImageData>>(std::error_code(),
+                                                          {"Resource path not found"});
+        }
+
+        if (m_data_preload_cache.find(path) != m_data_preload_cache.end()) {
+            const ResourceData &data = m_data_preload_cache[path];
+
+            std::span<u8> data_span(static_cast<u8 *>(data.m_data_ptr), data.m_data_size);
+            RefPtr<const ImageData> handle = make_referable<const ImageData>(data_span);
+
+            if (!handle->isValid()) {
+                return make_fs_error<RefPtr<const ImageData>>(std::error_code(),
+                                                              {"Failed to load image"});
+            }
+
+            return handle;
+        }
+
+        fs_path resource_path = getResourcePath(resource_path_uuid).value_or(fs_path());
+        fs_path abs_path      = resource_path / path;
+
+        RefPtr<const ImageData> handle = make_referable<const ImageData>(abs_path);
+        if (!handle->isValid()) {
+            return make_fs_error<RefPtr<const ImageData>>(std::error_code(),
+                                                            {"Failed to load image"});
+        }
+
+        return handle;
+    }
+
+    Result<RefPtr<const ImageData>, FSError>
+    ResourceManager::getImageData(fs_path &&path, const UUID64 &resource_path_uuid) const {
+        if (!hasDataPath(path, resource_path_uuid)) {
+            return make_fs_error<RefPtr<const ImageData>>(std::error_code(),
+                                                          {"Resource path not found"});
+        }
+
+        if (m_data_preload_cache.find(path) != m_data_preload_cache.end()) {
+            const ResourceData &data = m_data_preload_cache[path];
+
+            std::span<u8> data_span(static_cast<u8 *>(data.m_data_ptr), data.m_data_size);
+            RefPtr<const ImageData> handle = make_referable<const ImageData>(data_span);
+
+            if (!handle->isValid()) {
+                return make_fs_error<RefPtr<const ImageData>>(std::error_code(),
+                                                              {"Failed to load image"});
+            }
+
+            return handle;
+        }
+
+        fs_path resource_path = getResourcePath(resource_path_uuid).value_or(fs_path());
+        fs_path abs_path      = resource_path / path;
+
+        RefPtr<const ImageData> handle = make_referable<const ImageData>(abs_path);
+        if (!handle->isValid()) {
+            return make_fs_error<RefPtr<const ImageData>>(std::error_code(),
+                                                          {"Failed to load image"});
+        }
+
+        return handle;
+    }
+
     Result<RefPtr<const ImageHandle>, FSError>
     ResourceManager::getImageHandle(const fs_path &path, const UUID64 &resource_path_uuid) const {
         if (m_image_handle_cache.find(path) != m_image_handle_cache.end()) {

From c7ca9a57e2dd13f81c5f8fba27fe99cda5830ea9 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Tue, 8 Oct 2024 23:56:54 -0500
Subject: [PATCH 085/129] Enhance drag icon rendering

---
 include/gui/dragdrop/dragaction.hpp | 23 ++++++----
 src/gui/application.cpp             | 67 +++++++++++++----------------
 src/gui/dragdrop/target.cpp         | 49 ++++++++++++++++++++-
 3 files changed, 94 insertions(+), 45 deletions(-)

diff --git a/include/gui/dragdrop/dragaction.hpp b/include/gui/dragdrop/dragaction.hpp
index a23fe281..7c7d1128 100644
--- a/include/gui/dragdrop/dragaction.hpp
+++ b/include/gui/dragdrop/dragaction.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
-#include <imgui/imgui.h>
-#include "unique.hpp"
 #include "core/mimedata/mimedata.hpp"
-#include "image/imagehandle.hpp"
 #include "gui/dragdrop/dropaction.hpp"
+#include "image/imagehandle.hpp"
+#include "unique.hpp"
+#include <imgui/imgui.h>
 
 namespace Toolbox::UI {
 
@@ -12,15 +12,22 @@ namespace Toolbox::UI {
         friend class DragDropManager;
 
     protected:
-        DragAction()                   = default;
+        DragAction() = default;
 
     public:
+        using render_fn = std::function<void(const ImVec2 &pos, const ImVec2 &size)>;
+
         DragAction(UUID64 source_uuid) : m_source_uuid(source_uuid) {}
         DragAction(const DragAction &) = default;
         DragAction(DragAction &&)      = default;
 
+        void render(const ImVec2 &size) const {
+            if (m_render) {
+                m_render(ImGui::GetWindowPos(), size);
+            }
+        }
+
         [[nodiscard]] const ImVec2 &getHotSpot() const { return m_hot_spot; }
-        [[nodiscard]] RefPtr<const ImageHandle> getImage() { return m_image_handle; }
 
         [[nodiscard]] const MimeData &getPayload() const { return m_mime_data; }
         [[nodiscard]] DropType getDefaultDropType() const { m_default_drop_type; }
@@ -30,17 +37,17 @@ namespace Toolbox::UI {
         [[nodiscard]] UUID64 getTargetUUID() const { return m_target_uuid; }
 
         void setHotSpot(const ImVec2 &absp) { m_hot_spot = absp; }
-        void setImage(RefPtr<const ImageHandle> image) { m_image_handle = image; }
+        void setRender(render_fn render) { m_render = render; }
         void setPayload(const MimeData &data) { m_mime_data = data; }
         void setTargetUUID(const UUID64 &uuid) { m_target_uuid = uuid; }
         void setSupportedDropTypes(DropTypes types) { m_supported_drop_types = types; }
 
     private:
         ImVec2 m_hot_spot;
-        RefPtr<const ImageHandle> m_image_handle;
+        render_fn m_render;
 
         MimeData m_mime_data;
-        DropType m_default_drop_type = DropType::ACTION_MOVE;
+        DropType m_default_drop_type     = DropType::ACTION_MOVE;
         DropTypes m_supported_drop_types = DropType::ACTION_COPY | DropType::ACTION_MOVE;
 
         UUID64 m_source_uuid = 0;
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 96dc6d0f..6183b41e 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -456,45 +456,40 @@ namespace Toolbox {
 
                 action->setHotSpot({(float)x, (float)y});
 
-                if (RefPtr<const ImageHandle> image = action->getImage()) {
-                    const ImVec2 &hotspot = action->getHotSpot();
-
-                    ImGuiViewportP *viewport =
-                        ImGui::FindHoveredViewportFromPlatformWindowStack(hotspot);
-                    if (viewport) {
-                        const ImVec2 size = {96, 96};
-                        const ImVec2 pos  = {hotspot.x - size.x / 2.0f, hotspot.y - size.y / 1.1f};
-
-                        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
-                        // ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 5.0f);
-                        ImGui::PushStyleColor(ImGuiCol_WindowBg,
-                                              ImGui::GetStyleColorVec4(ImGuiCol_HeaderHovered));
-
-                        ImGui::SetNextWindowBgAlpha(1.0f);
-                        ImGui::SetNextWindowPos(pos);
-                        ImGui::SetNextWindowSize(size);
-                        if (ImGui::Begin("###Drag Icon", nullptr,
-                                         ImGuiWindowFlags_NoDecoration |
-                                             ImGuiWindowFlags_NoInputs)) {
-                            ImagePainter painter;
-                            painter.render(*action->getImage(), pos, size);
-
-                            if (ImGuiWindow *win = ImGui::GetCurrentWindow()) {
-                                if (win->Viewport != ImGui::GetMainViewport()) {
-                                    Platform::SetWindowClickThrough(
-                                        (Platform::LowWindow)win->Viewport->PlatformHandleRaw,
-                                        true);
-                                    m_drag_drop_viewport = win->Viewport;
-                                } else {
-                                    m_drag_drop_viewport = nullptr;
-                                }
+                const ImVec2 &hotspot = action->getHotSpot();
+
+                ImGuiViewportP *viewport =
+                    ImGui::FindHoveredViewportFromPlatformWindowStack(hotspot);
+                if (viewport) {
+                    const ImVec2 size = {96, 96};
+                    const ImVec2 pos  = {hotspot.x - size.x / 2.0f, hotspot.y - size.y / 1.1f};
+
+                    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
+                    // ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 5.0f);
+                    ImGui::PushStyleColor(ImGuiCol_WindowBg,
+                                          ImGui::GetStyleColorVec4(ImGuiCol_Text));
+
+                    ImGui::SetNextWindowBgAlpha(1.0f);
+                    ImGui::SetNextWindowPos(pos);
+                    ImGui::SetNextWindowSize(size);
+                    if (ImGui::Begin("###Drag Icon", nullptr,
+                                     ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoInputs)) {
+                        action->render(size);
+
+                        if (ImGuiWindow *win = ImGui::GetCurrentWindow()) {
+                            if (win->Viewport != ImGui::GetMainViewport()) {
+                                Platform::SetWindowClickThrough(
+                                    (Platform::LowWindow)win->Viewport->PlatformHandleRaw, true);
+                                m_drag_drop_viewport = win->Viewport;
+                            } else {
+                                m_drag_drop_viewport = nullptr;
                             }
                         }
-                        ImGui::End();
-
-                        ImGui::PopStyleColor(1);
-                        ImGui::PopStyleVar(1);
                     }
+                    ImGui::End();
+
+                    ImGui::PopStyleColor(1);
+                    ImGui::PopStyleVar(1);
                 }
             }
         }
diff --git a/src/gui/dragdrop/target.cpp b/src/gui/dragdrop/target.cpp
index 45cc8246..f04736b4 100644
--- a/src/gui/dragdrop/target.cpp
+++ b/src/gui/dragdrop/target.cpp
@@ -7,6 +7,8 @@
 
 #include "image/imagebuilder.hpp"
 
+#include <imgui.h>
+
 namespace Toolbox::UI {
 
     static UUID64 searchDropTarget(const ImVec2 &mouse_pos) {
@@ -246,6 +248,29 @@ namespace Toolbox::UI {
             MimeData mime_data = createMimeDataFromDataObject(pDataObj);
             action = DragDropManager::instance().createDragAction(0, std::move(mime_data));
             DragDropManager::instance().setSystemAction(false);
+
+            action->setRender([action](const ImVec2 &pos, const ImVec2 &size) {
+                std::string urls = action->getPayload().get_urls().value_or("");
+                if (urls.empty()) {
+                    return;
+                }
+
+                ImGuiStyle &style = ImGui::GetStyle();
+
+                size_t num_files = std::count(urls.begin(), urls.end(), '\n');
+                std::string file_count = std::format("{}", num_files);
+                ImVec2 text_size       = ImGui::CalcTextSize(file_count.c_str());
+
+                ImDrawList *draw_list = ImGui::GetWindowDrawList();
+                ImVec2 center         = pos + (size / 2.0f);
+
+                ImGui::DrawSquare(
+                    (size / 2.0f), size.x / 5.0f, IM_COL32_WHITE,
+                    ImGui::ColorConvertFloat4ToU32(style.Colors[ImGuiCol_HeaderActive]), 1.0f);
+
+                draw_list->AddText(pos + (size / 2.0f) - (text_size / 2.0f), IM_COL32_WHITE,
+                                   file_count.c_str(), file_count.c_str() + file_count.size());
+            });
         }
 
         action->setHotSpot(ImVec2((float)pt.x, (float)pt.y));
@@ -286,6 +311,26 @@ namespace Toolbox::UI {
         if (!action) {
             MimeData mime_data = createMimeDataFromDataObject(pDataObj);
             action = DragDropManager::instance().createDragAction(0, std::move(mime_data));
+
+            action->setRender([action](const ImVec2 &pos, const ImVec2 &size) {
+                std::string urls = action->getPayload().get_urls().value_or("");
+                if (urls.empty()) {
+                    return;
+                }
+
+                size_t num_files = std::count(urls.begin(), urls.end(), '\n');
+
+                ImDrawList *draw_list = ImGui::GetBackgroundDrawList();
+                ImVec2 center         = pos + (size / 2.0f);
+
+                ImGui::DrawSquare(center, size.x / 6.0f, IM_COL32_BLACK, IM_COL32_WHITE, 2.0f);
+
+                std::string file_count = std::format("{}", num_files);
+                ImVec2 text_size       = ImGui::CalcTextSize(file_count.c_str());
+
+                draw_list->AddText(pos + (size / 2.0f) - (text_size / 2.0f), IM_COL32_WHITE,
+                                   file_count.c_str(), file_count.c_str() + file_count.size());
+            });
         }
 
         action->setHotSpot(ImVec2((float)pt.x, (float)pt.y));
@@ -424,7 +469,9 @@ namespace Toolbox::UI {
 
     void LinuxDragDropTargetDelegate::onDrop(RefPtr<DragAction> action) {}
 
-    bool LinuxDragDropTargetDelegate::initializeForWindow(Platform::LowWindow window) { return false; }
+    bool LinuxDragDropTargetDelegate::initializeForWindow(Platform::LowWindow window) {
+        return false;
+    }
 
     void LinuxDragDropTargetDelegate::shutdownForWindow(Platform::LowWindow window) {}
 

From 7f92715d4b57bffacd0bc1989d789cff16939f31 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Wed, 9 Oct 2024 19:29:09 -0500
Subject: [PATCH 086/129] Drag internal wip

---
 include/gui/dragdrop/dragdropmanager.hpp |  2 +-
 include/gui/project/window.hpp           |  3 ++
 src/gui/dragdrop/dragdropmanager.cpp     | 13 ++-----
 src/gui/dragdrop/target.cpp              |  2 +-
 src/gui/project/window.cpp               | 47 +++++++++++++++++++++++-
 5 files changed, 55 insertions(+), 12 deletions(-)

diff --git a/include/gui/dragdrop/dragdropmanager.hpp b/include/gui/dragdrop/dragdropmanager.hpp
index e698686d..1aa0a25e 100644
--- a/include/gui/dragdrop/dragdropmanager.hpp
+++ b/include/gui/dragdrop/dragdropmanager.hpp
@@ -27,7 +27,7 @@ namespace Toolbox::UI {
 
         void setSystemAction(bool is_system) { m_is_system_action = is_system; }
 
-        RefPtr<DragAction> createDragAction(UUID64 source_uuid, MimeData &&data);
+        RefPtr<DragAction> createDragAction(UUID64 source_uuid, MimeData &&data, bool system_level = true);
         RefPtr<DragAction> getCurrentDragAction() const { return m_current_drag_action; }
         void destroyDragAction(RefPtr<DragAction> action);
 
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 5c9f6f39..692aa123 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -91,6 +91,7 @@ namespace Toolbox::UI {
         void onDropEvent(RefPtr<DropEvent> ev) override;
 
         void buildContextMenu();
+        MimeData &&buildFolderViewMimeData();
 
         // Selection actions
         void actionDeleteIndexes(std::vector<ModelIndex> &indices);
@@ -132,6 +133,8 @@ namespace Toolbox::UI {
 
         bool m_delete_without_request = false;
         bool m_delete_requested       = false;
+
+        ImVec2 m_last_reg_mouse_pos;
     };
 
 }  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/gui/dragdrop/dragdropmanager.cpp b/src/gui/dragdrop/dragdropmanager.cpp
index 5b9a238d..049824dd 100644
--- a/src/gui/dragdrop/dragdropmanager.cpp
+++ b/src/gui/dragdrop/dragdropmanager.cpp
@@ -40,9 +40,12 @@ static std::vector<std::string_view> splitLines(std::string_view s) {
 
 namespace Toolbox::UI {
 
-    RefPtr<DragAction> DragDropManager::createDragAction(UUID64 source_uuid, MimeData &&data) {
+    RefPtr<DragAction> DragDropManager::createDragAction(UUID64 source_uuid, MimeData &&data, bool system_level) {
         m_current_drag_action = make_referable<DragAction>(source_uuid);
         m_current_drag_action->setPayload(data);
+        if (system_level) {
+            createSystemDragDropSource(std::move(data));
+        }
         return m_current_drag_action;
     }
 
@@ -56,14 +59,6 @@ namespace Toolbox::UI {
     void DragDropManager::shutdown() { OleUninitialize(); }
 
     Result<void, BaseError> DragDropManager::createSystemDragDropSource(MimeData &&data) {
-        std::vector<std::string> formats =
-            SystemClipboard::instance().getAvailableContentFormats().value_or(
-                std::vector<std::string>());
-
-        if (std::find(formats.begin(), formats.end(), "text/uri-list") == formats.end()) {
-            return make_error<void>("DRAG_DROP", "No paths available in mimedata");
-        }
-
         std::string paths = data.get_urls().value_or("");
 
         std::vector<PIDLIST_ABSOLUTE> pidls;
diff --git a/src/gui/dragdrop/target.cpp b/src/gui/dragdrop/target.cpp
index f04736b4..82b8c4d8 100644
--- a/src/gui/dragdrop/target.cpp
+++ b/src/gui/dragdrop/target.cpp
@@ -246,7 +246,7 @@ namespace Toolbox::UI {
         if (!action) {
             DragDropManager::instance().setSystemAction(true);
             MimeData mime_data = createMimeDataFromDataObject(pDataObj);
-            action = DragDropManager::instance().createDragAction(0, std::move(mime_data));
+            action = DragDropManager::instance().createDragAction(0, std::move(mime_data), false);
             DragDropManager::instance().setSystemAction(false);
 
             action->setRender([action](const ImVec2 &pos, const ImVec2 &size) {
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index e0e3db1f..ce700ea4 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -1,5 +1,6 @@
 #include "gui/project/window.hpp"
 #include "gui/application.hpp"
+#include "gui/dragdrop/dragdropmanager.hpp"
 #include "model/fsmodel.hpp"
 
 #include <cmath>
@@ -37,7 +38,21 @@ namespace Toolbox::UI {
 
         const ImGuiStyle &style = ImGui::GetStyle();
 
-        bool is_left_click        = Input::GetMouseButtonDown(MouseButton::BUTTON_LEFT);
+        ImVec2 mouse_pos;
+        {
+            double mouse_x, mouse_y;
+            Input::GetMousePosition(mouse_x, mouse_y);
+            mouse_pos.x = mouse_x;
+            mouse_pos.y = mouse_y;
+        }
+
+        bool is_left_click = Input::GetMouseButtonDown(MouseButton::BUTTON_LEFT);
+        bool is_left_drag  = Input::GetMouseButton(MouseButton::BUTTON_LEFT);
+
+        if (!is_left_drag) {
+            m_last_reg_mouse_pos = mouse_pos;
+        }
+
         bool is_double_left_click = ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left);
         bool is_right_click       = Input::GetMouseButtonDown(MouseButton::BUTTON_RIGHT);
 
@@ -84,6 +99,17 @@ namespace Toolbox::UI {
                         ImGui::PushStyleColor(ImGuiCol_ChildBg,
                                               ImGui::ColorConvertFloat4ToU32(
                                                   ImGui::GetStyleColorVec4(ImGuiCol_TabSelected)));
+
+                        if (is_left_drag && ImLengthSqr(mouse_pos - m_last_reg_mouse_pos) > 10.0f) {
+                            if (DragDropManager::instance().getCurrentDragAction() == nullptr) {
+                                RefPtr<DragAction> action = DragDropManager::instance().createDragAction(
+                                    getUUID(), buildFolderViewMimeData());
+                                if (action) {
+                                    // action->setHotspot()
+                                    // action->setImage()
+                                }
+                            }
+                        }
                     } else {
                         ImGui::PushStyleColor(ImGuiCol_ChildBg,
                                               ImGui::ColorConvertFloat4ToU32(
@@ -429,6 +455,23 @@ namespace Toolbox::UI {
             });
     }
 
+    MimeData &&ProjectViewWindow::buildFolderViewMimeData() {
+        MimeData &&result = MimeData();
+
+        std::string paths;
+        for (const ModelIndex &index : m_selected_indices_ctx) {
+            fs_path path = m_file_system_model->getPath(index);
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+            paths += std::format("file:///{}\n", path.string());
+#elif defined(TOOLBOX_PLATFORM_LINUX)
+            paths += std::format("file://{}\n", path.string());
+#endif
+        }
+
+        result.set_urls(paths);
+        return std::move(result);
+    }
+
     void ProjectViewWindow::actionDeleteIndexes(std::vector<ModelIndex> &indices) {
         for (auto &item_index : indices) {
             m_file_system_model->remove(item_index);
@@ -608,6 +651,8 @@ namespace Toolbox::UI {
 
             return true;
         }
+
+        return false;
     }
 
     bool ProjectViewWindow::actionOpenPad(const ModelIndex &index) {

From 581c3cacd1d1b14c5cb5c9ac0c42fd0c79d701f6 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Wed, 9 Oct 2024 19:29:18 -0500
Subject: [PATCH 087/129] UI drag stuff

---
 include/core/event/event.hpp        |   4 +-
 include/gui/dragdrop/dragaction.hpp |  12 +++
 include/gui/event/dragevent.hpp     |  10 +++
 include/gui/project/window.hpp      |   6 +-
 src/gui/application.cpp             |  15 ++++
 src/gui/project/window.cpp          | 114 +++++++++++++++++++++++-----
 6 files changed, 139 insertions(+), 22 deletions(-)

diff --git a/include/core/event/event.hpp b/include/core/event/event.hpp
index b1563199..8f390bab 100644
--- a/include/core/event/event.hpp
+++ b/include/core/event/event.hpp
@@ -59,8 +59,8 @@ namespace Toolbox {
 
         [[nodiscard]] bool isSystemEvent() const noexcept { return m_is_system_event; }
 
-        void accept();
-        void ignore();
+        virtual void accept();
+        virtual void ignore();
 
         ScopePtr<ISmartResource> clone(bool deep) const override;
 
diff --git a/include/gui/dragdrop/dragaction.hpp b/include/gui/dragdrop/dragaction.hpp
index 7c7d1128..78c881f5 100644
--- a/include/gui/dragdrop/dragaction.hpp
+++ b/include/gui/dragdrop/dragaction.hpp
@@ -10,6 +10,7 @@ namespace Toolbox::UI {
 
     class DragAction {
         friend class DragDropManager;
+        friend class DragEvent;
 
     protected:
         DragAction() = default;
@@ -27,6 +28,13 @@ namespace Toolbox::UI {
             }
         }
 
+        struct DropState {
+            bool m_valid_target;
+            DropType m_pending_action;
+        };
+
+        const DropState &getDropState() const { return m_drop_state; }
+
         [[nodiscard]] const ImVec2 &getHotSpot() const { return m_hot_spot; }
 
         [[nodiscard]] const MimeData &getPayload() const { return m_mime_data; }
@@ -42,9 +50,13 @@ namespace Toolbox::UI {
         void setTargetUUID(const UUID64 &uuid) { m_target_uuid = uuid; }
         void setSupportedDropTypes(DropTypes types) { m_supported_drop_types = types; }
 
+    protected:
+        void setDropState(DropState &&state) { m_drop_state = std::move(state); }
+
     private:
         ImVec2 m_hot_spot;
         render_fn m_render;
+        DropState m_drop_state;
 
         MimeData m_mime_data;
         DropType m_default_drop_type     = DropType::ACTION_MOVE;
diff --git a/include/gui/event/dragevent.hpp b/include/gui/event/dragevent.hpp
index 258036fd..6d6d5c51 100644
--- a/include/gui/event/dragevent.hpp
+++ b/include/gui/event/dragevent.hpp
@@ -23,6 +23,16 @@ namespace Toolbox::UI {
         [[nodiscard]] RefPtr<DragAction> getDragAction() const noexcept { return m_drag_action; }
         [[nodiscard]] UUID64 getSourceId() const noexcept { return m_drag_action->getSourceUUID(); }
 
+        void accept() override {
+            BaseEvent::accept();
+            m_drag_action->m_drop_state.m_valid_target = true;
+        }
+
+        void ignore() override {
+            BaseEvent::ignore();
+            m_drag_action->m_drop_state.m_valid_target = false;
+        }
+
         ScopePtr<ISmartResource> clone(bool deep) const override;
 
         DragEvent &operator=(const DragEvent &)     = default;
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 692aa123..6d58e920 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -91,7 +91,7 @@ namespace Toolbox::UI {
         void onDropEvent(RefPtr<DropEvent> ev) override;
 
         void buildContextMenu();
-        MimeData &&buildFolderViewMimeData();
+        MimeData buildFolderViewMimeData() const;
 
         // Selection actions
         void actionDeleteIndexes(std::vector<ModelIndex> &indices);
@@ -102,6 +102,8 @@ namespace Toolbox::UI {
 
         void actionLeftClickIndex(const ModelIndex &view_index, const ModelIndex &child_index,
                                   bool is_selected);
+        void actionClearRequestExcIndex(const ModelIndex &view_index,
+                                        const ModelIndex &child_index, bool is_left_button);
 
         bool actionOpenScene(const ModelIndex &index);
         bool actionOpenPad(const ModelIndex &index);
@@ -134,6 +136,8 @@ namespace Toolbox::UI {
         bool m_delete_without_request = false;
         bool m_delete_requested       = false;
 
+        bool m_did_drag_drop = false;
+
         ImVec2 m_last_reg_mouse_pos;
     };
 
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 6183b41e..7638a37e 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -464,6 +464,8 @@ namespace Toolbox {
                     const ImVec2 size = {96, 96};
                     const ImVec2 pos  = {hotspot.x - size.x / 2.0f, hotspot.y - size.y / 1.1f};
 
+                    ImGuiStyle &style = ImGui::GetStyle();
+
                     ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
                     // ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 5.0f);
                     ImGui::PushStyleColor(ImGuiCol_WindowBg,
@@ -476,6 +478,19 @@ namespace Toolbox {
                                      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoInputs)) {
                         action->render(size);
 
+                        ImVec2 status_size = {16, 16};
+                        ImGui::SetCursorScreenPos(pos + size - status_size);
+
+                        ImGui::DrawSquare(
+                            pos + size - (status_size / 2), status_size.x, IM_COL32_WHITE,
+                            ImGui::ColorConvertFloat4ToU32(style.Colors[ImGuiCol_HeaderActive]));
+
+                        const DragAction::DropState &state = action->getDropState();
+                        if (state.m_valid_target) {
+
+                        } else {
+                        }
+
                         if (ImGuiWindow *win = ImGui::GetCurrentWindow()) {
                             if (win->Viewport != ImGui::GetMainViewport()) {
                                 Platform::SetWindowClickThrough(
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index ce700ea4..eaad3363 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -20,6 +20,8 @@ namespace Toolbox::UI {
         renderProjectFolderView();
         renderProjectFolderButton();
         renderProjectFileButton();
+
+        m_did_drag_drop = DragDropManager::instance().getCurrentDragAction() != nullptr;
     }
 
     void ProjectViewWindow::renderProjectTreeView() {
@@ -46,8 +48,9 @@ namespace Toolbox::UI {
             mouse_pos.y = mouse_y;
         }
 
-        bool is_left_click = Input::GetMouseButtonDown(MouseButton::BUTTON_LEFT);
-        bool is_left_drag  = Input::GetMouseButton(MouseButton::BUTTON_LEFT);
+        bool is_left_click         = Input::GetMouseButtonDown(MouseButton::BUTTON_LEFT);
+        bool is_left_click_release = Input::GetMouseButtonUp(MouseButton::BUTTON_LEFT);
+        bool is_left_drag          = Input::GetMouseButton(MouseButton::BUTTON_LEFT);
 
         if (!is_left_drag) {
             m_last_reg_mouse_pos = mouse_pos;
@@ -55,6 +58,7 @@ namespace Toolbox::UI {
 
         bool is_double_left_click = ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left);
         bool is_right_click       = Input::GetMouseButtonDown(MouseButton::BUTTON_RIGHT);
+        bool is_right_click_release = Input::GetMouseButtonUp(MouseButton::BUTTON_RIGHT);
 
         if (ImGui::BeginChild("Folder View", {0, 0}, true,
                               ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoDecoration)) {
@@ -102,11 +106,39 @@ namespace Toolbox::UI {
 
                         if (is_left_drag && ImLengthSqr(mouse_pos - m_last_reg_mouse_pos) > 10.0f) {
                             if (DragDropManager::instance().getCurrentDragAction() == nullptr) {
-                                RefPtr<DragAction> action = DragDropManager::instance().createDragAction(
-                                    getUUID(), buildFolderViewMimeData());
+                                RefPtr<DragAction> action =
+                                    DragDropManager::instance().createDragAction(
+                                        getUUID(), std::move(buildFolderViewMimeData()));
                                 if (action) {
-                                    // action->setHotspot()
-                                    // action->setImage()
+                                    action->setHotSpot(mouse_pos);
+                                    action->setRender([action](const ImVec2 &pos,
+                                                               const ImVec2 &size) {
+                                        std::string urls =
+                                            action->getPayload().get_urls().value_or("");
+                                        if (urls.empty()) {
+                                            return;
+                                        }
+
+                                        ImGuiStyle &style = ImGui::GetStyle();
+
+                                        size_t num_files =
+                                            std::count(urls.begin(), urls.end(), '\n');
+                                        std::string file_count = std::format("{}", num_files);
+                                        ImVec2 text_size = ImGui::CalcTextSize(file_count.c_str());
+
+                                        ImDrawList *draw_list = ImGui::GetWindowDrawList();
+                                        ImVec2 center         = pos + (size / 2.0f);
+
+                                        ImGui::DrawSquare((size / 2.0f), size.x / 5.0f,
+                                                          IM_COL32_WHITE,
+                                                          ImGui::ColorConvertFloat4ToU32(
+                                                              style.Colors[ImGuiCol_HeaderActive]),
+                                                          1.0f);
+
+                                        draw_list->AddText(pos + (size / 2.0f) - (text_size / 2.0f),
+                                                           IM_COL32_WHITE, file_count.c_str(),
+                                                           file_count.c_str() + file_count.size());
+                                    });
                                 }
                             }
                         }
@@ -186,9 +218,14 @@ namespace Toolbox::UI {
                                         ImGui::PopStyleColor(1);
                                         break;
                                     }
-                                } else if (is_left_click) {
-                                    m_is_renaming = false;
-                                    actionLeftClickIndex(view_index, child_index, is_selected);
+                                } else {
+                                    if (is_left_click && !is_left_click_release) {
+                                        m_is_renaming = false;
+                                        actionLeftClickIndex(view_index, child_index, is_selected);
+                                    } else if (is_left_click_release || is_right_click_release) {
+                                        actionClearRequestExcIndex(view_index, child_index,
+                                                                   is_left_click_release);
+                                    }
                                 }
                             }
                         }
@@ -202,6 +239,11 @@ namespace Toolbox::UI {
                     }
                 }
 
+                if (!any_items_hovered && (is_left_click_release || is_right_click_release)) {
+                    actionClearRequestExcIndex(view_index, ModelIndex(), is_left_click_release);
+                    m_is_renaming = false;
+                }
+
                 ImVec2 center = ImGui::GetMainViewport()->GetCenter();
                 ImGui::SetNextWindowPos(center, ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
 
@@ -235,11 +277,6 @@ namespace Toolbox::UI {
                     }
                     ImGui::EndPopup();
                 } else {
-                    // Clearing the selection
-                    if (!any_items_hovered && ImGui::IsMouseClicked(0)) {
-                        m_selected_indices.clear();
-                        m_is_renaming = false;
-                    }
                     // Delete stuff
                     if (m_delete_requested) {
                         ImGui::OpenPopup("Delete?");
@@ -455,11 +492,11 @@ namespace Toolbox::UI {
             });
     }
 
-    MimeData &&ProjectViewWindow::buildFolderViewMimeData() {
-        MimeData &&result = MimeData();
+    MimeData ProjectViewWindow::buildFolderViewMimeData() const {
+        MimeData result;
 
         std::string paths;
-        for (const ModelIndex &index : m_selected_indices_ctx) {
+        for (const ModelIndex &index : m_selected_indices) {
             fs_path path = m_file_system_model->getPath(index);
 #ifdef TOOLBOX_PLATFORM_WINDOWS
             paths += std::format("file:///{}\n", path.string());
@@ -469,7 +506,7 @@ namespace Toolbox::UI {
         }
 
         result.set_urls(paths);
-        return std::move(result);
+        return result;
     }
 
     void ProjectViewWindow::actionDeleteIndexes(std::vector<ModelIndex> &indices) {
@@ -560,6 +597,10 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::actionLeftClickIndex(const ModelIndex &view_index,
                                                  const ModelIndex &child_index, bool is_selected) {
+        if (m_did_drag_drop) {
+            return;
+        }
+
         ModelIndex source_child_index = m_view_proxy.toSourceIndex(child_index);
         if (Input::GetKey(KeyCode::KEY_LEFTCONTROL) || Input::GetKey(KeyCode::KEY_RIGHTCONTROL)) {
             if (is_selected) {
@@ -571,8 +612,8 @@ namespace Toolbox::UI {
                 m_last_selected_index = source_child_index;
             }
         } else {
-            m_selected_indices.clear();
             if (Input::GetKey(KeyCode::KEY_LEFTSHIFT) || Input::GetKey(KeyCode::KEY_RIGHTSHIFT)) {
+                m_selected_indices.clear();
                 if (m_file_system_model->validateIndex(m_last_selected_index)) {
                     int64_t this_row = m_view_proxy.getRow(child_index);
                     int64_t last_row =
@@ -592,12 +633,47 @@ namespace Toolbox::UI {
                     m_selected_indices.push_back(source_child_index);
                 }
             } else {
+                if (m_selected_indices.size() < 2) {
+                    m_selected_indices.clear();
+                }
                 m_selected_indices.push_back(source_child_index);
                 m_last_selected_index = source_child_index;
             }
         }
     }
 
+    void ProjectViewWindow::actionClearRequestExcIndex(const ModelIndex &view_index,
+                                                       const ModelIndex &child_index,
+                                                       bool is_left_button) {
+        if (m_did_drag_drop) {
+            return;
+        }
+
+        if (Input::GetKey(KeyCode::KEY_LEFTCONTROL) || Input::GetKey(KeyCode::KEY_RIGHTCONTROL)) {
+            return;
+        }
+
+        if (Input::GetKey(KeyCode::KEY_LEFTSHIFT) || Input::GetKey(KeyCode::KEY_RIGHTSHIFT)) {
+            return;
+        }
+
+        if (is_left_button) {
+            m_selected_indices.clear();
+            m_last_selected_index = ModelIndex();
+            if (m_view_proxy.validateIndex(child_index)) {
+                ModelIndex source_index = m_view_proxy.toSourceIndex(child_index);
+                m_selected_indices.push_back(source_index);
+                m_last_selected_index = source_index;
+            }
+        } else {
+            if (!m_view_proxy.validateIndex(child_index)) {
+                m_selected_indices.clear();
+                m_last_selected_index = ModelIndex();
+            }
+            m_selected_indices_ctx = m_selected_indices;
+        }
+    }
+
     bool ProjectViewWindow::actionOpenScene(const ModelIndex &index) {
         if (!m_file_system_model->validateIndex(index)) {
             return false;

From 3f418e1093a99037c87e3ff5d29cddbe29b80662 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Wed, 9 Oct 2024 21:35:27 -0500
Subject: [PATCH 088/129] Further polish project interactions

---
 include/gui/project/window.hpp |   2 +-
 src/gui/project/window.cpp     | 141 +++++++++++++++++++--------------
 2 files changed, 84 insertions(+), 59 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 6d58e920..3a0cb492 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -100,7 +100,7 @@ namespace Toolbox::UI {
         void actionPasteIntoIndex(const ModelIndex &index, const MimeData &data);
         void actionCopyIndexes(const std::vector<ModelIndex> &indices);
 
-        void actionLeftClickIndex(const ModelIndex &view_index, const ModelIndex &child_index,
+        void actionSelectIndex(const ModelIndex &view_index, const ModelIndex &child_index,
                                   bool is_selected);
         void actionClearRequestExcIndex(const ModelIndex &view_index,
                                         const ModelIndex &child_index, bool is_left_button);
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index eaad3363..b661eb52 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -56,8 +56,8 @@ namespace Toolbox::UI {
             m_last_reg_mouse_pos = mouse_pos;
         }
 
-        bool is_double_left_click = ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left);
-        bool is_right_click       = Input::GetMouseButtonDown(MouseButton::BUTTON_RIGHT);
+        bool is_double_left_click   = ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left);
+        bool is_right_click         = Input::GetMouseButtonDown(MouseButton::BUTTON_RIGHT);
         bool is_right_click_release = Input::GetMouseButtonUp(MouseButton::BUTTON_RIGHT);
 
         if (ImGui::BeginChild("Folder View", {0, 0}, true,
@@ -74,6 +74,7 @@ namespace Toolbox::UI {
                 ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 3.0f);
 
                 const float box_width   = 76.0f;
+                const float box_height  = 100.0f;
                 const float label_width = box_width - style.WindowPadding.x * 4.0f;
 
                 ImVec2 size = ImGui::GetContentRegionAvail();
@@ -95,6 +96,9 @@ namespace Toolbox::UI {
 
                     ModelIndex source_child_index = m_view_proxy.toSourceIndex(child_index);
 
+                    ImVec2 win_min = ImGui::GetCursorScreenPos();
+                    ImVec2 win_max = win_min + ImVec2(box_width, box_height);
+
                     bool is_selected =
                         std::find(m_selected_indices.begin(), m_selected_indices.end(),
                                   source_child_index) != m_selected_indices.end();
@@ -103,50 +107,16 @@ namespace Toolbox::UI {
                         ImGui::PushStyleColor(ImGuiCol_ChildBg,
                                               ImGui::ColorConvertFloat4ToU32(
                                                   ImGui::GetStyleColorVec4(ImGuiCol_TabSelected)));
-
-                        if (is_left_drag && ImLengthSqr(mouse_pos - m_last_reg_mouse_pos) > 10.0f) {
-                            if (DragDropManager::instance().getCurrentDragAction() == nullptr) {
-                                RefPtr<DragAction> action =
-                                    DragDropManager::instance().createDragAction(
-                                        getUUID(), std::move(buildFolderViewMimeData()));
-                                if (action) {
-                                    action->setHotSpot(mouse_pos);
-                                    action->setRender([action](const ImVec2 &pos,
-                                                               const ImVec2 &size) {
-                                        std::string urls =
-                                            action->getPayload().get_urls().value_or("");
-                                        if (urls.empty()) {
-                                            return;
-                                        }
-
-                                        ImGuiStyle &style = ImGui::GetStyle();
-
-                                        size_t num_files =
-                                            std::count(urls.begin(), urls.end(), '\n');
-                                        std::string file_count = std::format("{}", num_files);
-                                        ImVec2 text_size = ImGui::CalcTextSize(file_count.c_str());
-
-                                        ImDrawList *draw_list = ImGui::GetWindowDrawList();
-                                        ImVec2 center         = pos + (size / 2.0f);
-
-                                        ImGui::DrawSquare((size / 2.0f), size.x / 5.0f,
-                                                          IM_COL32_WHITE,
-                                                          ImGui::ColorConvertFloat4ToU32(
-                                                              style.Colors[ImGuiCol_HeaderActive]),
-                                                          1.0f);
-
-                                        draw_list->AddText(pos + (size / 2.0f) - (text_size / 2.0f),
-                                                           IM_COL32_WHITE, file_count.c_str(),
-                                                           file_count.c_str() + file_count.size());
-                                    });
-                                }
-                            }
-                        }
+                    } else if (ImGui::IsMouseHoveringRect(win_min, win_max)) {
+                        ImGui::PushStyleColor(ImGuiCol_ChildBg,
+                                              ImGui::ColorConvertFloat4ToU32(
+                                                  ImGui::GetStyleColorVec4(ImGuiCol_TabHovered)));
                     } else {
                         ImGui::PushStyleColor(ImGuiCol_ChildBg,
                                               ImGui::ColorConvertFloat4ToU32(
                                                   ImGui::GetStyleColorVec4(ImGuiCol_ChildBg)));
                     }
+
                     const bool is_selected_rename = m_is_renaming && is_selected;
 
                     // Get the label and it's size
@@ -158,9 +128,20 @@ namespace Toolbox::UI {
                                                  ? std::min(rename_size.x, label_width)
                                                  : std::min(text_size.x, label_width);
 
+                    ImGuiWindowFlags window_flags = ImGuiWindowFlags_ChildWindow |
+                                                    ImGuiWindowFlags_NoDecoration |
+                                                    ImGuiWindowFlags_NoScrollWithMouse;
+
+                    if (source_child_index == m_last_selected_index) {
+                        ImGui::GetWindowDrawList()->AddRect(
+                            win_min - (style.FramePadding / 2.0f),
+                            win_max + (style.FramePadding / 2.0f),
+                            ImGui::ColorConvertFloat4ToU32(style.Colors[ImGuiCol_Text]), 3.0f,
+                            ImDrawFlags_RoundCornersAll, 2.0f);
+                    }
+
                     if (ImGui::BeginChild(child_index.getUUID(), {box_width, 100.0f}, true,
-                                          ImGuiWindowFlags_ChildWindow |
-                                              ImGuiWindowFlags_NoDecoration)) {
+                                          window_flags)) {
                         ImVec2 pos       = ImGui::GetCursorScreenPos() + style.WindowPadding;
                         ImVec2 icon_size = ImVec2(box_width - style.WindowPadding.x * 2.0f,
                                                   box_width - style.WindowPadding.x * 2.0f);
@@ -219,9 +200,10 @@ namespace Toolbox::UI {
                                         break;
                                     }
                                 } else {
-                                    if (is_left_click && !is_left_click_release) {
+                                    if ((is_left_click && !is_left_click_release) ||
+                                        (is_right_click && !is_right_click_release)) {
                                         m_is_renaming = false;
-                                        actionLeftClickIndex(view_index, child_index, is_selected);
+                                        actionSelectIndex(view_index, child_index, is_selected);
                                     } else if (is_left_click_release || is_right_click_release) {
                                         actionClearRequestExcIndex(view_index, child_index,
                                                                    is_left_click_release);
@@ -244,6 +226,41 @@ namespace Toolbox::UI {
                     m_is_renaming = false;
                 }
 
+                if (any_items_hovered && is_left_drag && m_selected_indices.size() > 0 &&
+                    ImLengthSqr(mouse_pos - m_last_reg_mouse_pos) > 10.0f) {
+                    if (DragDropManager::instance().getCurrentDragAction() == nullptr) {
+                        RefPtr<DragAction> action = DragDropManager::instance().createDragAction(
+                            getUUID(), std::move(buildFolderViewMimeData()));
+                        if (action) {
+                            action->setHotSpot(mouse_pos);
+                            action->setRender([action](const ImVec2 &pos, const ImVec2 &size) {
+                                std::string urls = action->getPayload().get_urls().value_or("");
+                                if (urls.empty()) {
+                                    return;
+                                }
+
+                                ImGuiStyle &style = ImGui::GetStyle();
+
+                                size_t num_files       = std::count(urls.begin(), urls.end(), '\n');
+                                std::string file_count = std::format("{}", num_files);
+                                ImVec2 text_size       = ImGui::CalcTextSize(file_count.c_str());
+
+                                ImDrawList *draw_list = ImGui::GetWindowDrawList();
+                                ImVec2 center         = pos + (size / 2.0f);
+
+                                ImGui::DrawSquare((size / 2.0f), size.x / 5.0f, IM_COL32_WHITE,
+                                                  ImGui::ColorConvertFloat4ToU32(
+                                                      style.Colors[ImGuiCol_HeaderActive]),
+                                                  1.0f);
+
+                                draw_list->AddText(pos + (size / 2.0f) - (text_size / 2.0f),
+                                                   IM_COL32_WHITE, file_count.c_str(),
+                                                   file_count.c_str() + file_count.size());
+                            });
+                        }
+                    }
+                }
+
                 ImVec2 center = ImGui::GetMainViewport()->GetCenter();
                 ImGui::SetNextWindowPos(center, ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
 
@@ -595,8 +612,8 @@ namespace Toolbox::UI {
         }
     }
 
-    void ProjectViewWindow::actionLeftClickIndex(const ModelIndex &view_index,
-                                                 const ModelIndex &child_index, bool is_selected) {
+    void ProjectViewWindow::actionSelectIndex(const ModelIndex &view_index,
+                                              const ModelIndex &child_index, bool is_selected) {
         if (m_did_drag_drop) {
             return;
         }
@@ -606,11 +623,10 @@ namespace Toolbox::UI {
             if (is_selected) {
                 m_selected_indices.erase(std::remove(m_selected_indices.begin(),
                                                      m_selected_indices.end(), source_child_index));
-                m_last_selected_index = ModelIndex();
             } else {
                 m_selected_indices.push_back(source_child_index);
-                m_last_selected_index = source_child_index;
             }
+            m_last_selected_index = source_child_index;
         } else {
             if (Input::GetKey(KeyCode::KEY_LEFTSHIFT) || Input::GetKey(KeyCode::KEY_RIGHTSHIFT)) {
                 m_selected_indices.clear();
@@ -633,11 +649,17 @@ namespace Toolbox::UI {
                     m_selected_indices.push_back(source_child_index);
                 }
             } else {
-                if (m_selected_indices.size() < 2) {
+                if (is_selected) {
+                    if (m_selected_indices.size() < 2) {
+                        m_selected_indices.clear();
+                        m_selected_indices.push_back(source_child_index);
+                    }
+                    m_last_selected_index = source_child_index;
+                } else {
                     m_selected_indices.clear();
+                    m_selected_indices.push_back(source_child_index);
+                    m_last_selected_index = source_child_index;
                 }
-                m_selected_indices.push_back(source_child_index);
-                m_last_selected_index = source_child_index;
             }
         }
     }
@@ -658,12 +680,14 @@ namespace Toolbox::UI {
         }
 
         if (is_left_button) {
-            m_selected_indices.clear();
-            m_last_selected_index = ModelIndex();
-            if (m_view_proxy.validateIndex(child_index)) {
-                ModelIndex source_index = m_view_proxy.toSourceIndex(child_index);
-                m_selected_indices.push_back(source_index);
-                m_last_selected_index = source_index;
+            if (m_selected_indices.size() > 1) {
+                m_selected_indices.clear();
+                m_last_selected_index = ModelIndex();
+                if (m_view_proxy.validateIndex(child_index)) {
+                    ModelIndex source_index = m_view_proxy.toSourceIndex(child_index);
+                    m_selected_indices.push_back(source_index);
+                    m_last_selected_index = source_index;
+                }
             }
         } else {
             if (!m_view_proxy.validateIndex(child_index)) {
@@ -671,6 +695,7 @@ namespace Toolbox::UI {
                 m_last_selected_index = ModelIndex();
             }
             m_selected_indices_ctx = m_selected_indices;
+            m_last_selected_index  = ModelIndex();
         }
     }
 

From 7ecd7c1d2b56ae43fe7d0f5459dcb5f98a4544c5 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 11 Oct 2024 14:28:54 -0700
Subject: [PATCH 089/129] Don't fight the window manager

This code assumed that the user had exclusive control over the
size and position of all windows. While this is generally true of most
window managers, for users with a tiling window manager, this meant
that the code was constantly fighting the window manager for control,
causing the window to flash back and forth between multiple places.

The fix is to not assume that m_is_resized == (window->size !=
m_prev_size), and instead only try to set the size once when
m_is_resized is set to true, and the same for m_is_repositioned and positions.
---
 src/gui/window.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/gui/window.cpp b/src/gui/window.cpp
index 5d8f8bbf..aefdd749 100644
--- a/src/gui/window.cpp
+++ b/src/gui/window.cpp
@@ -221,18 +221,20 @@ namespace Toolbox::UI {
 
         // Establish window constraints
         if (window) {
-            if (window->Size != m_prev_size) {
+            if (window->Size != m_prev_size && m_is_resized) {
                 if (m_next_size.x >= 0.0f && m_next_size.y >= 0.0f) {
                     GUIApplication::instance().dispatchEvent<WindowEvent, true>(
                         getUUID(), EVENT_WINDOW_RESIZE, window->Size);
                 }
                 ImGui::SetWindowSize(window, m_prev_size, ImGuiCond_Always);
+                m_is_resized = false;
             }
 
-            if (window->Pos != m_prev_pos) {
+            if (window->Pos != m_prev_pos && m_is_repositioned) {
                 GUIApplication::instance().dispatchEvent<WindowEvent, true>(
                     getUUID(), EVENT_WINDOW_MOVE, window->Pos);
                 ImGui::SetWindowPos(window, m_prev_pos, ImGuiCond_Always);
+                m_is_repositioned = false;
             }
         }
 

From 4dde55f3c21f011ce4b7bdc0fb23b0c77651fca0 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Fri, 11 Oct 2024 16:08:58 -0700
Subject: [PATCH 090/129] Reuse the GLFW display connection for everything

---
 src/core/input/input.cpp | 11 ++++-------
 src/platform/process.cpp | 10 ++++++----
 2 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/core/input/input.cpp b/src/core/input/input.cpp
index 2438cc70..7c2401e3 100644
--- a/src/core/input/input.cpp
+++ b/src/core/input/input.cpp
@@ -12,6 +12,8 @@
 #elif defined(TOOLBOX_PLATFORM_LINUX)
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
+#define GLFW_EXPOSE_NATIVE_X11
+#include <GLFW/glfw3native.h>
 #else
 #error "Unsupported OS"
 #endif
@@ -181,16 +183,13 @@ namespace Toolbox::Input {
 #ifdef TOOLBOX_PLATFORM_WINDOWS
         SetCursorPos((int)pos_x, (int)pos_y);
 #elif defined(TOOLBOX_PLATFORM_LINUX)
-        Display *display = XOpenDisplay(0);
-        if (display == nullptr)
-            return;
+        Display *display = getGLFWDisplay();
 
         float rel_pos_x = s_mouse_position_x - pos_x;
         float rel_pos_y = s_mouse_position_y - pos_y;
         XWarpPointer(display, 0, 0, 0, 0, 0, 0, rel_pos_x, rel_pos_y);
 
         XFlush(display);
-        XCloseDisplay(display);
 #else
 #error "Unsupported OS"
 #endif
@@ -213,9 +212,7 @@ namespace Toolbox::Input {
 #elif defined(TOOLBOX_PLATFORM_LINUX)
         // TODO: Check that this actually works
 
-        Display *display = XOpenDisplay(0);
-        if (display == nullptr)
-            return;
+        Display *display = getGLFWDisplay();
 
         Window root = DefaultRootWindow(display);
         Window child;
diff --git a/src/platform/process.cpp b/src/platform/process.cpp
index 7d17f783..93efa066 100644
--- a/src/platform/process.cpp
+++ b/src/platform/process.cpp
@@ -20,6 +20,8 @@
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 #include <X11/Xutil.h>
+#define GLFW_EXPOSE_NATIVE_X11
+#include <GLFW/glfw3native.h>
 #endif
 
 namespace Toolbox::Platform {
@@ -326,7 +328,7 @@ namespace Toolbox::Platform {
         return true;
     }
     std::string GetWindowTitle(LowWindow window) {
-        Display* display = XOpenDisplay(0);
+        Display* display = getGLFWDisplay();
         XTextProperty title;
         XGetWMName(display, (Window)window, &title);
         char** stringList;
@@ -345,7 +347,7 @@ namespace Toolbox::Platform {
         return false;
     }
     bool ForceWindowToFront(LowWindow window) {
-        Display* display = XOpenDisplay(0);
+        Display* display = getGLFWDisplay();
         return XRaiseWindow(display, (Window)window);
     }
     bool ForceWindowToFront(LowWindow window, LowWindow target) {
@@ -360,7 +362,7 @@ namespace Toolbox::Platform {
 
     bool GetWindowClientRect(LowWindow window, int &x, int &y, int &width, int &height) {
         XWindowAttributes attribs;
-        Display* display = XOpenDisplay(0);
+        Display* display = getGLFWDisplay();
         if (!XGetWindowAttributes(display, (Window)window, &attribs)) {
             return false;
         }
@@ -374,7 +376,7 @@ namespace Toolbox::Platform {
                                 const Atom PIDAtom, const int pid,
                                 std::vector<LowWindow> &result);
     std::vector<LowWindow> FindWindowsOfProcess(const ProcessInformation &process) {
-        Display* display = XOpenDisplay(0);
+        Display* display = getGLFWDisplay();
         Atom PIDAtom = XInternAtom(display, "_NET_WM_PID", True);
 
         if(PIDAtom == None)

From 5c771af12e46a6574ed7892e29ff3cf67f1bbe3b Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Sun, 13 Oct 2024 14:37:45 -0700
Subject: [PATCH 091/129] Oops fix the linux build

---
 src/platform/process.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/platform/process.cpp b/src/platform/process.cpp
index 93efa066..df980289 100644
--- a/src/platform/process.cpp
+++ b/src/platform/process.cpp
@@ -20,6 +20,7 @@
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 #include <X11/Xutil.h>
+#include <GLFW/glfw3.h>
 #define GLFW_EXPOSE_NATIVE_X11
 #include <GLFW/glfw3native.h>
 #endif

From 125bdf059be85b6c7acede4d6fbccc3b35feb586 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Sun, 13 Oct 2024 21:34:47 -0700
Subject: [PATCH 092/129] Set the variables that indicate whether size and pos
 have changed.

---
 src/gui/window.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/gui/window.cpp b/src/gui/window.cpp
index aefdd749..bcef87c9 100644
--- a/src/gui/window.cpp
+++ b/src/gui/window.cpp
@@ -33,6 +33,7 @@ namespace Toolbox::UI {
         if (size == getSize()) {
             return;
         }
+        m_is_resized = true;
         GUIApplication::instance().dispatchEvent<WindowEvent, true>(getUUID(), EVENT_WINDOW_RESIZE,
                                                                     size);
     }
@@ -40,6 +41,7 @@ namespace Toolbox::UI {
         if (pos == getPos()) {
             return;
         }
+        m_is_repositioned = true;
         GUIApplication::instance().dispatchEvent<WindowEvent, true>(getUUID(), EVENT_WINDOW_MOVE,
                                                                     pos);
     }

From 3ba83e3fe90557546b985476e48b3ddc5666392b Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 14 Oct 2024 10:33:44 -0700
Subject: [PATCH 093/129] Clipboard api refactor (#36)

* New clipboard api for linux

* Fix some formatting stuff

* Add a bunch of comments and refactor a bit

* Remove unused undeclared function

* Adhere windows implementaiton to new clipboard api

* Add getFiles to Windows

* Oops weird backslash

* Fix incorrect reservation of paths vector

* Use references in more places

* Simplify this weird conversion back and forth code
---
 include/core/clipboard.hpp         |   6 +-
 include/core/mimedata/mimedata.hpp |   9 +-
 include/gui/project/window.hpp     |   2 +-
 include/strutil.hpp                |  38 ++-
 src/core/mimedata/mimedata.cpp     |  20 +-
 src/gui/clipboard.cpp              | 373 +++++++++++++++++++----------
 src/gui/project/window.cpp         |  84 ++-----
 src/gui/window.cpp                 |   2 +-
 8 files changed, 339 insertions(+), 195 deletions(-)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index 468b1b1c..a3c7efa4 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -7,6 +7,7 @@
 #include "core/error.hpp"
 #include "core/mimedata/mimedata.hpp"
 #include "tristate.hpp"
+#include "fsystem.hpp"
 
 namespace Toolbox {
 
@@ -40,8 +41,9 @@ namespace Toolbox {
 
         Result<std::string, ClipboardError> getText() const;
         Result<void, ClipboardError> setText(const std::string &text);
-        Result<MimeData, ClipboardError> getContent(const std::string &type) const;
-        Result<void, ClipboardError> setContent(const std::string &type, const MimeData &mimedata);
+        Result<MimeData, ClipboardError> getContent() const;
+        Result<std::vector<fs_path>, ClipboardError> getFiles() const;
+        Result<void, ClipboardError> setContent(const MimeData &mimedata);
 
 
 #ifdef TOOLBOX_PLATFORM_WINDOWS
diff --git a/include/core/mimedata/mimedata.hpp b/include/core/mimedata/mimedata.hpp
index 74c22896..f0565fea 100644
--- a/include/core/mimedata/mimedata.hpp
+++ b/include/core/mimedata/mimedata.hpp
@@ -59,8 +59,8 @@ namespace Toolbox {
         [[nodiscard]] std::optional<std::string> get_text() const;
         void set_text(std::string_view data);
 
-        [[nodiscard]] std::optional<std::string> get_urls() const;
-        void set_urls(std::string_view data);
+        [[nodiscard]] std::optional<std::vector<std::string>> get_urls() const;
+        void set_urls(const std::vector<std::string> &data);
 
         void clear();
 
@@ -74,6 +74,11 @@ namespace Toolbox {
             return *this;
         }
 
+        static bool isMimeTarget(const std::string &target) {
+            return target.starts_with("image/") || target.starts_with("application/") ||
+                   target.starts_with("text/");
+        }
+
     private:
         mutable std::unordered_map<std::string, Buffer> m_data_map;
     };
diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index 3a0cb492..dc4a2013 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -97,7 +97,7 @@ namespace Toolbox::UI {
         void actionDeleteIndexes(std::vector<ModelIndex> &indices);
         void actionOpenIndexes(const std::vector<ModelIndex> &indices);
         void actionRenameIndex(const ModelIndex &index);
-        void actionPasteIntoIndex(const ModelIndex &index, const MimeData &data);
+        void actionPasteIntoIndex(const ModelIndex &index, const std::vector<fs_path> &data);
         void actionCopyIndexes(const std::vector<ModelIndex> &indices);
 
         void actionSelectIndex(const ModelIndex &view_index, const ModelIndex &child_index,
diff --git a/include/strutil.hpp b/include/strutil.hpp
index 770e439f..b2a3883d 100644
--- a/include/strutil.hpp
+++ b/include/strutil.hpp
@@ -6,6 +6,7 @@
 #include <iconv.h>
 #include <string>
 #include <string_view>
+#include <iterator>
 
 #include "core/error.hpp"
 
@@ -62,5 +63,40 @@ namespace Toolbox::String {
     inline Result<std::string, EncodingError> toGameEncoding(std::string_view value) {
         return asEncoding(value, IMGUI_ENCODING, GAME_ENCODING);
     }
+    inline std::vector<std::string_view> splitLines(std::string_view s) {
+        std::vector<std::string_view> result;
+        size_t last_pos         = 0;
+        size_t next_newline_pos = s.find('\n', 0);
+        while (next_newline_pos != std::string::npos) {
+            if (s[next_newline_pos - 1] == '\r') {
+                result.push_back(s.substr(last_pos, next_newline_pos - last_pos - 1));
+            } else {
+                result.push_back(s.substr(last_pos, next_newline_pos - last_pos));
+            }
+            last_pos         = next_newline_pos + 1;
+            next_newline_pos = s.find('\n', last_pos);
+        }
+        if (last_pos < s.size()) {
+            if (s[s.size() - 1] == '\r') {
+                result.push_back(s.substr(last_pos, s.size() - last_pos - 1));
+            } else {
+                result.push_back(s.substr(last_pos));
+            }
+        }
+        return result;
+    }
+    inline std::string joinStrings(std::vector<std::string> strings, const char *const delimiter) {
+        std::ostringstream os;
+        auto b = strings.begin(), e = strings.end();
 
-}  // namespace Toolbox::String
\ No newline at end of file
+        if (b != e) {
+            std::copy(b, prev(e), std::ostream_iterator<std::string>(os, delimiter));
+            b = prev(e);
+        }
+        if (b != e) {
+            os << *b;
+        }
+
+        return os.str();
+    }
+}  // namespace Toolbox::String
diff --git a/src/core/mimedata/mimedata.cpp b/src/core/mimedata/mimedata.cpp
index 4bef8d12..b56540e1 100644
--- a/src/core/mimedata/mimedata.cpp
+++ b/src/core/mimedata/mimedata.cpp
@@ -16,6 +16,8 @@
 
 #include "core/mimedata/mimedata.hpp"
 
+#include "strutil.hpp"
+
 namespace Toolbox {
 
     static std::vector<std::string> s_image_formats = {
@@ -114,19 +116,25 @@ namespace Toolbox {
         set_data("text/plain", std::move(_tmp));
     }
 
-    [[nodiscard]] std::optional<std::string> MimeData::get_urls() const {
+    [[nodiscard]] std::optional<std::vector<std::string>> MimeData::get_urls() const{
         if (!has_urls()) {
             return std::nullopt;
         }
         const Buffer &data_buf = m_data_map["text/uri-list"];
-        return std::string(data_buf.buf<char>(), data_buf.size() - 1);
+        std::string data_string(data_buf.buf<char>(), data_buf.size() - 1);
+        std::vector<std::string> result;
+        for (auto line : splitLines(data_string)) {
+            result.push_back(std::string(line));
+        }
+        return result;
     }
 
-    void MimeData::set_urls(std::string_view data) {
+    void MimeData::set_urls(const std::vector<std::string> &data){
+        std::string url_data = joinStrings(data, "\r\n");
         Buffer _tmp;
-        _tmp.alloc(data.size() + 1);
-        std::memcpy(_tmp.buf(), data.data(), data.size());
-        _tmp.get<char>(data.size()) = '\0';
+        _tmp.alloc(url_data.size() + 1);
+        std::memcpy(_tmp.buf(), url_data.data(), url_data.size());
+        _tmp.get<char>(url_data.size()) = '\0';
         set_data("text/uri-list", std::move(_tmp));
     }
 
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 12ee12de..4e23a7e9 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -9,6 +9,7 @@
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #define GLFW_EXPOSE_NATIVE_X11
+#include "strutil.hpp"
 #include <GLFW/glfw3native.h>
 #endif
 
@@ -81,6 +82,35 @@ namespace Toolbox {
 
         return result;
     }
+    // Assume the clipboard contains file paths and return them in a
+    // vector. Returns a clipboardError if the clipboard doesn't have
+    // files in it.
+    Result<std::vector<fs_path>, ClipboardError> SystemClipboard::getFiles() const {
+        // Get the file list target.
+        auto data = getContentType("text/uri-list");
+        // If the clipboard doesn't have a file list, propogate the
+        // error.
+        if (!data) {
+            return std::unexpected<ClipboardError>(data.error());
+        }
+        auto lines = data.value().get_urls();
+        // Allocate a vector of paths, and convert the vector of
+        // strings to it. When doing so, strip off the "file://"
+        // prefix.
+        std::vector<fs_path> result((int)lines.size());
+        for (int i = 0; i < lines.size(); ++i) {
+            if (line.starts_with("file:/")) {
+                if (src_path_str.starts_with("file:///")) {
+                    result[i] = src_path_str.substr(8);
+                } else {
+                    result[i] = src_path_str.substr(7);
+                }
+            } else {
+                return make_clipboard_error<std::vector<fs_path>>("Can't copy non file uri");
+            }
+        }
+        return result;
+    }
 
     Result<void, ClipboardError> SystemClipboard::setText(const std::string &text) {
         if (!OpenClipboard(nullptr)) {
@@ -115,20 +145,22 @@ namespace Toolbox {
         return {};
     }
 
-    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) const {
+    Result<MimeData, ClipboardError>
+    getContentType(std::unordered_map<std::string, UINT> &mime_to_format,
+                   const std::string &type) const {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<MimeData>("Failed to open the clipboard!");
         }
 
         UINT format = CF_NULL;
-        if (m_mime_to_format.find(type) == m_mime_to_format.end()) {
+        if (mime_to_format.find(type) == mime_to_format.end()) {
             format = FormatForMime(type);
             if (format == CF_NULL) {
-                m_mime_to_format[type] = RegisterClipboardFormat(type.c_str());
-                format                 = m_mime_to_format[type];
+                mime_to_format[type] = RegisterClipboardFormat(type.c_str());
+                format                 = mime_to_format[type];
             }
         } else {
-            format = m_mime_to_format[type];
+            format = mime_to_format[type];
         }
 
         if (format == CF_NULL) {
@@ -208,9 +240,27 @@ namespace Toolbox {
 
         return make_clipboard_error<MimeData>("Unimplemented MIME type!");
     }
+    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) const {
+        // Figure out all possible formats the content can be in.
+        auto formats = getAvailableContentFormats();
+        // If that didn't work, propogate the error.
+        if (!formats) {
+            return std::unexpected<ClipboardError>(formats.error());
+        }
+        // For each possible data type...
+        MimeData result;
+        for (std::string &target : formats.value()) {
+            // Get the target of each type.
+            auto data = getContenttype(target, m_mime_to_format);
+            if (!data) {
+                return std::unexpected<ClipboardError>(data.error());
+            }
+            result.set_data(target, std::move(data.value().get_data(target).value()));
+        }
+        return result;
+    }
 
-    Result<void, ClipboardError> SystemClipboard::setContent(const std::string &type,
-                                                             const MimeData &mimedata) {
+    Result<void, ClipboardError> SystemClipboard::setContent(const MimeData &mimedata) {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<void>("Failed to open the clipboard!");
         }
@@ -219,7 +269,13 @@ namespace Toolbox {
             return make_clipboard_error<void>("Failed to clear the clipboard!");
         }
 
-        std::optional<Buffer> result = mimedata.get_data(type);
+        std::vector<std::string> formats = mimedata.get_all_formats();
+        if (formats.size() > 1) {
+            return make_clipboard_error<void>("Can't set clipboard to mulitple types at once on Windows!");
+        }
+        TOOLBOX_ASSERT(formats.size() > 0);
+
+        std::optional<Buffer> result = mimedata.get_data(formats[0]);
         if (!result) {
             return make_clipboard_error<void>(
                 std::format("Failed to find MIME data type \"{}\"", type));
@@ -388,7 +444,7 @@ namespace Toolbox {
     void (*glfwSelectionRequestHandler)(XEvent *);
     // Sends a notification that we're done responding to a given
     // request.
-    void sendRequestNotify(Display* dpy, const XSelectionRequestEvent *request) {
+    void sendRequestNotify(Display *dpy, const XSelectionRequestEvent *request) {
         XSelectionEvent response;
         response.type      = SelectionNotify;
         response.requestor = request->requestor;
@@ -408,18 +464,18 @@ namespace Toolbox {
         // instance. This function can't be a method on that object
         // because we're going to be passing it as a function pointer
         // into GLFW, so we have to do everything externally.
-        MimeData clipboard_contents           = SystemClipboard::instance().m_clipboard_contents;
+        MimeData clipboard_contents = SystemClipboard::instance().m_clipboard_contents;
         // Get the display object from GLFW so we can intern our
         // strings in its namespace.
-        Display *dpy                          = getGLFWDisplay();
+        Display *dpy = getGLFWDisplay();
         // Pull out the specific event from the general one.
         const XSelectionRequestEvent *request = &event->xselectionrequest;
         // Start our targets array with just the "TARGET" target,
         // since we'll generate the rest in a loop.
-        Atom TARGETS                          = XInternAtom(dpy, "TARGETS", False);
-        // If they
+        Atom TARGETS = XInternAtom(dpy, "TARGETS", False);
         if (request->target == TARGETS) {
-            std::vector<Atom> targets             = {TARGETS};
+            // If they requested the targets...
+            std::vector<Atom> targets = {TARGETS};
             // For each format the selection data supports, intern it into
             // an atom and add it to the targets array.
             for (auto &string_format : clipboard_contents.get_all_formats()) {
@@ -447,7 +503,8 @@ namespace Toolbox {
                 // Then set the property, and notify of a response.
                 XChangeProperty(dpy, request->requestor, request->property, request->target,
                                 8 /* is this ever wrong? */, PropModeReplace,
-                                reinterpret_cast<const unsigned char *>(data.value().buf()), data.value().size());
+                                reinterpret_cast<const unsigned char *>(data.value().buf()),
+                                data.value().size());
                 sendRequestNotify(dpy, request);
             } else {
                 // If we don't recognize the data, or it's a legacy
@@ -469,136 +526,208 @@ namespace Toolbox {
         // Set our handler as the new handler.
         setSelectionRequestHandler(handleSelectionRequest);
     }
+    // Requests that the selection owner send us the data in the
+    // `target` format, by putting it on the `target_property`
+    // property of the `target_window` window.
+    void requestTarget(std::string target, Window target_window, Atom target_property) {
+        Display *dpy          = getGLFWDisplay();
+        Atom requested_target = XInternAtom(dpy, target.c_str(), False);
+        Atom sel              = XInternAtom(dpy, "CLIPBOARD", False);
+        XConvertSelection(dpy, sel, requested_target, target_property, target_window, CurrentTime);
+    }
+
     // Get all possible content types for the system clipboard.
     Result<std::vector<std::string>, ClipboardError>
     SystemClipboard::getAvailableContentFormats() const {
         Display *dpy         = getGLFWDisplay();
-        Atom sel             = XInternAtom(dpy, "CLIPBOARD", False);
-        Atom targets         = XInternAtom(dpy, "TARGETS", False);
-        Atom target_property = XInternAtom(dpy, "CLIP_TYPES", False);
         Window target_window = getGLFWHelperWindow();
-        XConvertSelection(dpy, sel, targets, target_property, target_window, CurrentTime);
+        Atom target_property = XInternAtom(dpy, "CLIP", False);
+        // Request that the "TARGETS" info be sent to the CLIP
+        // property on the glfw helper window.
+        requestTarget("TARGETS", target_window, target_property);
 
+        // Keep waiting for X events until we get a SelectionNotify
         XEvent ev;
-        XSelectionEvent *sev;
-        // This unconditional while loop looks pretty dangerous but
-        // this is how glfw does it, and how the examples online do
-        // it, so :shrug:
-        while (true) {
+        while (ev.type != SelectionNotify) {
             XNextEvent(dpy, &ev);
-            switch (ev.type) {
-            case SelectionNotify:
-                sev = (XSelectionEvent *)&ev.xselection;
-                if (sev->property == None) {
-                    return make_clipboard_error<std::vector<std::string>>(
-                        "Conversion could not be performed.\n");
-                } else {
-                    std::vector<std::string> types;
-                    unsigned long nitems;
-                    unsigned char *prop_ret = nullptr;
-                    // We won't use these.
-                    Atom _type;
-                    int _di;
-                    unsigned long _dul;
-                    XGetWindowProperty(dpy, target_window, target_property, 0, 1024 * sizeof(Atom),
-                                       False, XA_ATOM, &_type, &_di, &nitems, &_dul, &prop_ret);
-
-                    Atom *targets = (Atom *)prop_ret;
-                    for (int i = 0; i < nitems; ++i) {
-                        char *an = XGetAtomName(dpy, targets[i]);
-                        types.push_back(std::string(an));
-                        if (an)
-                            XFree(an);
-                    }
-                    XFree(prop_ret);
-                    XDeleteProperty(dpy, target_window, target_property);
-                    return types;
-                }
-                break;
-            }
         }
-        return {};
+        XSelectionEvent *sev = &ev.xselection;
+        // We can only copy from clients that give us a property to
+        // put the data on.
+        if (sev->property == None) {
+            return make_clipboard_error<std::vector<std::string>>(
+                "Conversion could not be performed.\n");
+        }
+        // Get the value on the property that the source told us.
+        std::vector<std::string> types;
+        unsigned long nitems;
+        unsigned char *prop_ret = nullptr;
+        // We won't use these.
+        Atom _type;
+        int _di;
+        unsigned long _dul;
+        XGetWindowProperty(dpy, target_window, target_property, 0, 1024 * sizeof(Atom), False,
+                           XA_ATOM, &_type, &_di, &nitems, &_dul, &prop_ret);
+
+        // Iterate through the returned atoms and convert them
+        // into strings to return.
+        Atom *targets = (Atom *)prop_ret;
+        for (int i = 0; i < nitems; ++i) {
+            char *an = XGetAtomName(dpy, targets[i]);
+            types.push_back(std::string(an));
+            if (an)
+                XFree(an);
+        }
+        // Free up the X11 resources we used.
+        XFree(prop_ret);
+        XDeleteProperty(dpy, target_window, target_property);
+        return types;
     }
-    Result<std::string, ClipboardError> SystemClipboard::getText() const {
-        auto data = getContent("text/plain");
-        if (!data || !data.value().has_text()) {
-            return make_clipboard_error<std::string>("No text in clipboard!");
+
+    // Get the bytes corresponding to a particular target. This is a
+    // higher-level function than requestTarget, which only sends the
+    // request and doesn't return anything.
+    Result<Buffer, ClipboardError> getTarget(std::string target) {
+        // Request the target from the clipboard owner.
+        Display *dpy         = getGLFWDisplay();
+        Window target_window = getGLFWHelperWindow();
+        Atom target_property = XInternAtom(dpy, "CLIP", False);
+        requestTarget(target, target_window, target_property);
+
+        // Keep waiting for X events until we get a SelectionNotify
+        XEvent ev;
+        while (ev.type != SelectionNotify) {
+            XNextEvent(dpy, &ev);
         }
-        return data.value().get_text().value();
+        XSelectionEvent *sev = &ev.xselection;
+        // Throw an error on old clients who don't tell you where they
+        // put stuff.
+        if (sev->property == None) {
+            return make_clipboard_error<Buffer>("Conversion could not be performed.");
+        }
+        Atom type_received;
+        unsigned long size;
+        unsigned char *prop_ret = nullptr;
+        // These are unused
+        int _di;
+        unsigned long _dul;
+        Atom _da;
+
+        // Use an initial X11 request to figure out how big the data is
+        // and whether it's requesting multiple batches.
+        XGetWindowProperty(dpy, target_window, target_property, 0, 0, False, AnyPropertyType,
+                           &type_received, &_di, &_dul, &size, &prop_ret);
+        // Don't use the return data, it's zero sized anyway.
+        XFree(prop_ret);
+
+        // If the data needs multiple batches, throw an error for now.
+        Atom incr = XInternAtom(dpy, "INCR", False);
+        if (type_received == incr) {
+            return make_clipboard_error<Buffer>("Data over 256kb, this isn't supported yet");
+        }
+        // Request that X11 copy the property data to an internal
+        // buffer and put a pointer to that buffer in prop_ret, using
+        // the size we got earlier.
+        XGetWindowProperty(dpy, target_window, target_property, 0, size, False, AnyPropertyType,
+                           &_da, &_di, &_dul, &_dul, &prop_ret);
+        // Allocate our own Buffer object and copy the data into
+        // it. Make sure to null-terminate the data in case it's a
+        // c string (which it often is).
+        Buffer data_buffer;
+        if (!data_buffer.alloc(size + 1)) {
+            return make_clipboard_error<Buffer>("Couldn't allocate buffer of big enough size");
+        }
+        std::memcpy(data_buffer.buf(), prop_ret, size);
+        data_buffer.buf<char>()[size] = '\0';
+        // Free the X11 data buffer
+        XFree(prop_ret);
+        // Free the window property
+        XDeleteProperty(dpy, target_window, target_property);
+        return data_buffer;
+    }
+    // Assume the clipboard has plain text and return it as a
+    // string. Returns a ClipboardError if the clipboard doesn't have
+    // plain text.
+    Result<std::string, ClipboardError> SystemClipboard::getText() const {
+        // Request the plain text target from the clipboard owner.
+        auto data = getTarget("text/plain");
+        // If the clipboard doesn't have plain text, propogate the
+        // error.
+        if (!data) {
+            return std::unexpected<ClipboardError>(data.error());
+        }
+        // Reinterpret the received buffer as a c-string, then wrap it
+        // in a c++ string to return.
+        return std::string(reinterpret_cast<char *>(data.value().buf()));
     }
 
+    // Set the contents of the cilpboard to the given string. This
+    // can't fail at this step on Linux, but we return Result to be
+    // consistent with the Windows code.
     Result<void, ClipboardError> SystemClipboard::setText(const std::string &text) {
         MimeData data;
         data.set_text(text);
-        return setContent("text/plain", data);
+        return setContent(data);
+    }
+    // Assume the clipboard contains file paths and return them in a
+    // vector. Returns a clipboardError if the clipboard doesn't have
+    // files in it.
+    Result<std::vector<fs_path>, ClipboardError> SystemClipboard::getFiles() const {
+        // Get the file list target.
+        auto data = getTarget("text/uri-list");
+        // If the clipboard doesn't have a file list, propogate the
+        // error.
+        if (!data) {
+            return std::unexpected<ClipboardError>(data.error());
+        }
+        // Reinterpret the received buffer as a c-string, then wrap it
+        // in a c++ string.
+        std::string data_string(data.value().buf<char>());
+        // Split the string into lines, one for each path.
+        auto lines = String::splitLines(data_string);
+        // Allocate a vector of paths, and convert the vector of
+        // strings to it. When doing so, strip off the "file://"
+        // prefix.
+        std::vector<fs_path> result((int)lines.size());
+        for (int i = 0; i < lines.size(); ++i) {
+            if (!lines[i].starts_with("file:///")) {
+                TOOLBOX_ERROR_V("Can't copy non-local uri \"{}\"", lines[i]);
+            }
+            result[i] = lines[i].substr(7);
+        }
+        return result;
     }
 
     // Get the contents of the system clipboard.
-    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) const {
-        Display *dpy           = getGLFWDisplay();
-        Atom requested_type    = XInternAtom(dpy, type.c_str(), False);
-        Atom sel               = XInternAtom(dpy, "CLIPBOARD", False);
-        Window clipboard_owner = XGetSelectionOwner(dpy, sel);
-        if (clipboard_owner == None) {
-            return make_clipboard_error<MimeData>("Clipboard isn't owned by anyone");
-        }
-        Window target_window = getGLFWHelperWindow();
-        Atom target_property = XInternAtom(dpy, "CLIP_CONTENTS", False);
-        XConvertSelection(dpy, sel, requested_type, target_property, target_window, CurrentTime);
-        XEvent ev;
-        XSelectionEvent *sev;
-        // This unconditional while loop looks pretty dangerous but
-        // this is how glfw does it, and how the examples online do
-        // it, so :shrug:
-        while (true) {
-            XNextEvent(dpy, &ev);
-            switch (ev.type) {
-            case SelectionNotify:
-                sev = (XSelectionEvent *)&ev.xselection;
-                if (sev->property == None) {
-                    return make_clipboard_error<MimeData>("Conversion could not be performed.");
-                } else {
-                    Atom type_received;
-                    unsigned long size;
-                    unsigned char *prop_ret = nullptr;
-                    // These are unused
-                    int _di;
-                    unsigned long _dul;
-                    Atom _da;
-
-                    XGetWindowProperty(dpy, target_window, target_property, 0, 0, False,
-                                       AnyPropertyType, &type_received, &_di, &_dul, &size,
-                                       &prop_ret);
-                    XFree(prop_ret);
-
-                    Atom incr = XInternAtom(dpy, "INCR", False);
-                    if (type_received == incr) {
-                        return make_clipboard_error<MimeData>(
-                            "Data over 256kb, this isn't supported yet");
-                    }
-                    XGetWindowProperty(dpy, target_window, target_property, 0, size, False,
-                                       AnyPropertyType, &_da, &_di, &_dul, &_dul, &prop_ret);
-                    Buffer data_buffer;
-                    if (!data_buffer.alloc(size)) {
-                        return make_clipboard_error<MimeData>(
-                            "Couldn't allocate buffer of big enough size");
-                    }
-                    std::memcpy(data_buffer.buf(), prop_ret, size);
-                    XFree(prop_ret);
-                    XDeleteProperty(dpy, target_window, target_property);
-
-                    MimeData result;
-                    result.set_data(type, std::move(data_buffer));
-                    return result;
-                }
+    Result<MimeData, ClipboardError> SystemClipboard::getContent() const {
+        // Figure out all possible formats the content can be in.
+        auto formats = getAvailableContentFormats();
+        // If that didn't work, propogate the error.
+        if (!formats) {
+            return std::unexpected<ClipboardError>(formats.error());
+        }
+        // For each possible data type...
+        MimeData result;
+        for (std::string &target : formats.value()) {
+            // Skip targets that aren't MIME types. These will pretty
+            // much always be redundant with a mime-type target
+            // (except TARGETS, which we don't want to do here anyway.
+            if (!MimeData::isMimeTarget(target))
+                continue;
+            // Get the target of each type.
+            auto data = getTarget(target);
+            if (!data) {
+                return std::unexpected<ClipboardError>(data.error());
             }
+            // Put that into the returned mime data indexed by the
+            // type.
+            result.set_data(target, std::move(data.value()));
         }
-        return {};
+        return result;
     }
 
     // Set the contents of the system clipboard.
-    Result<void, ClipboardError> SystemClipboard::setContent(const std::string &_type,
-                                                             const MimeData &content) {
+    Result<void, ClipboardError> SystemClipboard::setContent(const MimeData &content) {
         // Get the display and helper window from GLFW using our custom hooks.
         Display *dpy         = getGLFWDisplay();
         Window target_window = getGLFWHelperWindow();
@@ -607,7 +736,7 @@ namespace Toolbox {
         // Set ourselves as the owner of the clipboard. We'll do all
         // the actual data transfer once someone asks us for data, in
         // our event handling hook.
-        Atom CLIPBOARD       = XInternAtom(dpy, "CLIPBOARD", False);
+        Atom CLIPBOARD = XInternAtom(dpy, "CLIPBOARD", False);
         XSetSelectionOwner(dpy, CLIPBOARD, target_window, CurrentTime);
         return {};
     }
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index b661eb52..bc1a250c 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -356,31 +356,19 @@ namespace Toolbox::UI {
     }
 
     void ProjectViewWindow::onDropEvent(RefPtr<DropEvent> ev) {
-        actionPasteIntoIndex(m_view_index, ev->getMimeData());
-        ev->accept();
-    }
-
-    std::vector<std::string_view> splitLines(std::string_view s) {
-        std::vector<std::string_view> result;
-        size_t last_pos         = 0;
-        size_t next_newline_pos = s.find('\n', 0);
-        while (next_newline_pos != std::string::npos) {
-            if (s[next_newline_pos - 1] == '\r') {
-                result.push_back(s.substr(last_pos, next_newline_pos - last_pos - 1));
-            } else {
-                result.push_back(s.substr(last_pos, next_newline_pos - last_pos));
-            }
-            last_pos         = next_newline_pos + 1;
-            next_newline_pos = s.find('\n', last_pos);
+        MimeData data = ev->getMimeData();
+        auto urls     = data.get_urls();
+        if (!urls) {
+            TOOLBOX_ERROR("Passed mime data did not represent files!");
+            return;
         }
-        if (last_pos < s.size()) {
-            if (s[s.size() - 1] == '\r') {
-                result.push_back(s.substr(last_pos, s.size() - last_pos - 1));
-            } else {
-                result.push_back(s.substr(last_pos));
-            }
+        std::vector<fs_path> paths;
+        paths.reserve(urls.value().size());
+        for (auto &url : urls.value()) {
+            paths.push_back(url);
         }
-        return result;
+        actionPasteIntoIndex(m_view_index, paths);
+        ev->accept();
     }
 
     void ProjectViewWindow::buildContextMenu() {
@@ -492,9 +480,9 @@ namespace Toolbox::UI {
                               std::string("text/uri-list")) == content_types.value().end()) {
                     return;
                 }
+                auto maybe_data = SystemClipboard::instance().getFiles();
 
-                MimeData data =
-                    SystemClipboard::instance().getContent("text/uri-list").value_or(MimeData());
+                std::vector<fs_path> data = maybe_data.value();
 
                 actionPasteIntoIndex(m_view_index, data);
             });
@@ -559,54 +547,30 @@ namespace Toolbox::UI {
         std::strncpy(m_rename_buffer, file_name.c_str(), IM_ARRAYSIZE(m_rename_buffer));
     }
 
-    void ProjectViewWindow::actionPasteIntoIndex(const ModelIndex &index, const MimeData &data) {
-        std::optional<std::string> text = data.get_urls();
-        if (!text) {
-            TOOLBOX_ERROR("Mime data wouldn't return uri list");
-            return;
-        }
-
-        std::vector<std::string_view> urls = splitLines(text.value());
-        for (std::string_view src_path_str : urls) {
-            if (src_path_str.starts_with("file:/")) {
-#ifdef TOOLBOX_PLATFORM_LINUX
-                src_path_str = src_path_str.substr(7);
-#elif defined TOOLBOX_PLATFORM_WINDOWS
-                if (src_path_str.starts_with("file:///")) {
-                    src_path_str = src_path_str.substr(8);
-                } else {
-                    src_path_str = src_path_str.substr(7);
-                }
-#endif
-            } else {
-                TOOLBOX_ERROR_V("Can't copy non-local uri {}", src_path_str);
-                continue;
-            }
-
-            fs_path src_path = src_path_str;
-            m_file_system_model->copy(src_path, index, src_path.filename().string());
+    void ProjectViewWindow::actionPasteIntoIndex(const ModelIndex &index,
+                                                 const std::vector<fs_path> &paths) {
+        for (fs_path &src_path : paths) {
+            m_file_system_model->copy(src_path, index,
+                                      src_path.filename().string());
         }
     }
 
     void ProjectViewWindow::actionCopyIndexes(const std::vector<ModelIndex> &indices) {
-        std::string copied_paths;
+
+        std::vector<std::string> copied_paths;
         for (const ModelIndex &index : indices) {
 #ifdef TOOLBOX_PLATFORM_LINUX
-            copied_paths += "file://";
+            const char *prefix = "file://";
 #elif defined TOOLBOX_PLATFORM_WINDOWS
-            copied_paths += "file:///";
-#endif
-            copied_paths += m_file_system_model->getPath(index).string();
-#ifdef TOOLBOX_PLATFORM_LINUX
-            copied_paths += "\r";
+            const char *prefix = "file:///";
 #endif
-            copied_paths += "\n";
+            copied_paths.push_back(prefix + m_file_system_model->getPath(index).string());
         }
 
         MimeData data;
         data.set_urls(copied_paths);
 
-        auto result = SystemClipboard::instance().setContent("text/uri-list", data);
+        auto result = SystemClipboard::instance().setContent(data);
         if (!result) {
             TOOLBOX_ERROR("[PROJECT] Failed to set contents of clipboard");
         }
diff --git a/src/gui/window.cpp b/src/gui/window.cpp
index bcef87c9..53af641b 100644
--- a/src/gui/window.cpp
+++ b/src/gui/window.cpp
@@ -301,4 +301,4 @@ namespace Toolbox::UI {
         return t;
     }
 
-}  // namespace Toolbox::UI
\ No newline at end of file
+}  // namespace Toolbox::UI

From f722dd35536ff8f20b78d66e8ff9deb7cfc53a76 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 14 Oct 2024 13:14:37 -0700
Subject: [PATCH 094/129] Fix up project-system to use new clipboard api

---
 src/gui/project/window.cpp | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index bc1a250c..6a8a3c39 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -234,14 +234,15 @@ namespace Toolbox::UI {
                         if (action) {
                             action->setHotSpot(mouse_pos);
                             action->setRender([action](const ImVec2 &pos, const ImVec2 &size) {
-                                std::string urls = action->getPayload().get_urls().value_or("");
-                                if (urls.empty()) {
+                                auto urls_maybe = action->getPayload().get_urls();
+                                if (!urls_maybe) {
                                     return;
                                 }
+                                std::vector<std::string> urls = urls_maybe.value();
 
                                 ImGuiStyle &style = ImGui::GetStyle();
 
-                                size_t num_files       = std::count(urls.begin(), urls.end(), '\n');
+                                size_t num_files       = urls.size();
                                 std::string file_count = std::format("{}", num_files);
                                 ImVec2 text_size       = ImGui::CalcTextSize(file_count.c_str());
 
@@ -500,14 +501,9 @@ namespace Toolbox::UI {
     MimeData ProjectViewWindow::buildFolderViewMimeData() const {
         MimeData result;
 
-        std::string paths;
+        std::vector<std::string> paths;
         for (const ModelIndex &index : m_selected_indices) {
-            fs_path path = m_file_system_model->getPath(index);
-#ifdef TOOLBOX_PLATFORM_WINDOWS
-            paths += std::format("file:///{}\n", path.string());
-#elif defined(TOOLBOX_PLATFORM_LINUX)
-            paths += std::format("file://{}\n", path.string());
-#endif
+            paths.push_back(m_file_system_model->getPath(index));
         }
 
         result.set_urls(paths);
@@ -549,7 +545,7 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::actionPasteIntoIndex(const ModelIndex &index,
                                                  const std::vector<fs_path> &paths) {
-        for (fs_path &src_path : paths) {
+        for (const fs_path &src_path : paths) {
             m_file_system_model->copy(src_path, index,
                                       src_path.filename().string());
         }

From dd129ca00754b04312b55a8ff5e972b8b14240b4 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 14 Oct 2024 15:35:02 -0700
Subject: [PATCH 095/129] Fixes for the windows code in clipboard api

---
 src/gui/clipboard.cpp       | 193 ++++++++++++++++++------------------
 src/gui/dragdrop/target.cpp |  21 ++--
 src/gui/project/window.cpp  |   2 +-
 3 files changed, 108 insertions(+), 108 deletions(-)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 4e23a7e9..b751806e 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -54,96 +54,6 @@ namespace Toolbox {
         return types;
     }
 
-    Result<std::string, ClipboardError> SystemClipboard::getText() const {
-        if (!OpenClipboard(nullptr)) {
-            return make_clipboard_error<std::string>("Failed to open the clipboard!");
-        }
-
-        HANDLE clipboard_data = GetClipboardData(CF_TEXT);
-        if (!clipboard_data) {
-            return make_clipboard_error<std::string>("Failed to retrieve the data handle!");
-        }
-
-        const char *text_data = static_cast<const char *>(GlobalLock(clipboard_data));
-        if (!text_data) {
-            return make_clipboard_error<std::string>(
-                "Failed to retrieve the buffer from the handle!");
-        }
-
-        std::string result = text_data;
-
-        if (!GlobalUnlock(clipboard_data)) {
-            return make_clipboard_error<std::string>("Failed to unlock the data handle!");
-        }
-
-        if (!CloseClipboard()) {
-            return make_clipboard_error<std::string>("Failed to close the clipboard!");
-        }
-
-        return result;
-    }
-    // Assume the clipboard contains file paths and return them in a
-    // vector. Returns a clipboardError if the clipboard doesn't have
-    // files in it.
-    Result<std::vector<fs_path>, ClipboardError> SystemClipboard::getFiles() const {
-        // Get the file list target.
-        auto data = getContentType("text/uri-list");
-        // If the clipboard doesn't have a file list, propogate the
-        // error.
-        if (!data) {
-            return std::unexpected<ClipboardError>(data.error());
-        }
-        auto lines = data.value().get_urls();
-        // Allocate a vector of paths, and convert the vector of
-        // strings to it. When doing so, strip off the "file://"
-        // prefix.
-        std::vector<fs_path> result((int)lines.size());
-        for (int i = 0; i < lines.size(); ++i) {
-            if (line.starts_with("file:/")) {
-                if (src_path_str.starts_with("file:///")) {
-                    result[i] = src_path_str.substr(8);
-                } else {
-                    result[i] = src_path_str.substr(7);
-                }
-            } else {
-                return make_clipboard_error<std::vector<fs_path>>("Can't copy non file uri");
-            }
-        }
-        return result;
-    }
-
-    Result<void, ClipboardError> SystemClipboard::setText(const std::string &text) {
-        if (!OpenClipboard(nullptr)) {
-            return make_clipboard_error<void>("Failed to open the clipboard!");
-        }
-
-        if (!EmptyClipboard()) {
-            return make_clipboard_error<void>("Failed to clear the clipboard!");
-        }
-
-        HANDLE data_handle = GlobalAlloc(GMEM_DDESHARE, text.size() + 1);
-        if (!data_handle) {
-            return make_clipboard_error<void>("Failed to alloc new data handle!");
-        }
-
-        char *data_buffer = static_cast<char *>(GlobalLock(data_handle));
-        if (!data_buffer) {
-            return make_clipboard_error<void>("Failed to retrieve the buffer from the handle!");
-        }
-
-        strncpy_s(data_buffer, text.size() + 1, text.c_str(), text.size() + 1);
-
-        if (!GlobalUnlock(data_handle)) {
-            return make_clipboard_error<void>("Failed to unlock the data handle!");
-        }
-
-        SetClipboardData(CF_TEXT, data_handle);
-
-        if (!CloseClipboard()) {
-            return make_clipboard_error<void>("Failed to close the clipboard!");
-        }
-        return {};
-    }
 
     Result<MimeData, ClipboardError>
     getContentType(std::unordered_map<std::string, UINT> &mime_to_format,
@@ -197,15 +107,13 @@ namespace Toolbox {
         if (format == CF_HDROP) {
             HDROP hdrop    = static_cast<HDROP>(data_handle);
             UINT num_files = DragQueryFile(hdrop, 0xFFFFFFFF, nullptr, 0);
-            std::string uri_list;
+            std::vector<std::string> uri_list;
+            uri_list.reserve(num_files);
             for (UINT i = 0; i < num_files; ++i) {
                 UINT size = DragQueryFile(hdrop, i, nullptr, 0);
                 std::string file(size, '\0');
                 DragQueryFile(hdrop, i, file.data(), size + 1);
-                uri_list += std::format("file:///{}", file);
-                if (i != num_files - 1) {
-                    uri_list += "\r\n";
-                }
+                uri_list.push_back(file);
             }
 
             if (!GlobalUnlock(clipboard_data)) {
@@ -240,7 +148,98 @@ namespace Toolbox {
 
         return make_clipboard_error<MimeData>("Unimplemented MIME type!");
     }
-    Result<MimeData, ClipboardError> SystemClipboard::getContent(const std::string &type) const {
+    Result<std::string, ClipboardError> SystemClipboard::getText() const {
+        if (!OpenClipboard(nullptr)) {
+            return make_clipboard_error<std::string>("Failed to open the clipboard!");
+        }
+
+        HANDLE clipboard_data = GetClipboardData(CF_TEXT);
+        if (!clipboard_data) {
+            return make_clipboard_error<std::string>("Failed to retrieve the data handle!");
+        }
+
+        const char *text_data = static_cast<const char *>(GlobalLock(clipboard_data));
+        if (!text_data) {
+            return make_clipboard_error<std::string>(
+                "Failed to retrieve the buffer from the handle!");
+        }
+
+        std::string result = text_data;
+
+        if (!GlobalUnlock(clipboard_data)) {
+            return make_clipboard_error<std::string>("Failed to unlock the data handle!");
+        }
+
+        if (!CloseClipboard()) {
+            return make_clipboard_error<std::string>("Failed to close the clipboard!");
+        }
+
+        return result;
+    }
+    // Assume the clipboard contains file paths and return them in a
+    // vector. Returns a clipboardError if the clipboard doesn't have
+    // files in it.
+    Result<std::vector<fs_path>, ClipboardError> SystemClipboard::getFiles() const {
+        // Get the file list target.
+        auto data = getContentType(m_mime_to_format, "text/uri-list");
+        // If the clipboard doesn't have a file list, propogate the
+        // error.
+        if (!data) {
+            return std::unexpected<ClipboardError>(data.error());
+        }
+        auto lines = data.value().get_urls().value();
+        // Allocate a vector of paths, and convert the vector of
+        // strings to it. When doing so, strip off the "file://"
+        // prefix.
+        std::vector<fs_path> result;
+        result.reserve((int)lines.size());
+        for (auto &line : lines) {
+            if (line.starts_with("file:/")) {
+                if (line.starts_with("file:///")) {
+                    result.push_back(line.substr(8));
+                } else {
+                    result.push_back(line.substr(7));
+                }
+            } else {
+                return make_clipboard_error<std::vector<fs_path>>("Can't copy non file uri");
+            }
+        }
+        return result;
+    }
+
+    Result<void, ClipboardError> SystemClipboard::setText(const std::string &text) {
+        if (!OpenClipboard(nullptr)) {
+            return make_clipboard_error<void>("Failed to open the clipboard!");
+        }
+
+        if (!EmptyClipboard()) {
+            return make_clipboard_error<void>("Failed to clear the clipboard!");
+        }
+
+        HANDLE data_handle = GlobalAlloc(GMEM_DDESHARE, text.size() + 1);
+        if (!data_handle) {
+            return make_clipboard_error<void>("Failed to alloc new data handle!");
+        }
+
+        char *data_buffer = static_cast<char *>(GlobalLock(data_handle));
+        if (!data_buffer) {
+            return make_clipboard_error<void>("Failed to retrieve the buffer from the handle!");
+        }
+
+        strncpy_s(data_buffer, text.size() + 1, text.c_str(), text.size() + 1);
+
+        if (!GlobalUnlock(data_handle)) {
+            return make_clipboard_error<void>("Failed to unlock the data handle!");
+        }
+
+        SetClipboardData(CF_TEXT, data_handle);
+
+        if (!CloseClipboard()) {
+            return make_clipboard_error<void>("Failed to close the clipboard!");
+        }
+        return {};
+    }
+    Result<MimeData, ClipboardError> SystemClipboard::getContent() const {
         // Figure out all possible formats the content can be in.
         auto formats = getAvailableContentFormats();
         // If that didn't work, propogate the error.
@@ -251,7 +250,7 @@ namespace Toolbox {
         MimeData result;
         for (std::string &target : formats.value()) {
             // Get the target of each type.
-            auto data = getContenttype(target, m_mime_to_format);
+            auto data = getContentType(m_mime_to_format, target);
             if (!data) {
                 return std::unexpected<ClipboardError>(data.error());
             }
diff --git a/src/gui/dragdrop/target.cpp b/src/gui/dragdrop/target.cpp
index 82b8c4d8..d3619524 100644
--- a/src/gui/dragdrop/target.cpp
+++ b/src/gui/dragdrop/target.cpp
@@ -72,17 +72,17 @@ namespace Toolbox::UI {
                     }
                 }
 
-                std::string uri_paths;
+                std::vector<std::string> uri_paths;
 
                 HDROP hdrop = (HDROP)GlobalLock(stg_medium.hGlobal);
 
                 if (hdrop) {
                     UINT num_files = DragQueryFile(hdrop, 0xFFFFFFFF, nullptr, 0);
+                    uri_paths.reserve(num_files);
                     for (UINT i = 0; i < num_files; ++i) {
                         TCHAR file_path[MAX_PATH];
                         if (UINT length = DragQueryFile(hdrop, i, file_path, MAX_PATH)) {
-                            uri_paths +=
-                                std::format("file:///{}\n", std::string(file_path, length));
+                            uri_paths.push_back(std::string(file_path, length));
                         }
                     }
                 }
@@ -250,14 +250,15 @@ namespace Toolbox::UI {
             DragDropManager::instance().setSystemAction(false);
 
             action->setRender([action](const ImVec2 &pos, const ImVec2 &size) {
-                std::string urls = action->getPayload().get_urls().value_or("");
-                if (urls.empty()) {
+                auto maybe_urls = action->getPayload().get_urls();
+                if (!maybe_urls) {
                     return;
                 }
+                std::vector<std::string> urls = maybe_urls.value();
 
                 ImGuiStyle &style = ImGui::GetStyle();
 
-                size_t num_files = std::count(urls.begin(), urls.end(), '\n');
+                size_t num_files = urls.size();
                 std::string file_count = std::format("{}", num_files);
                 ImVec2 text_size       = ImGui::CalcTextSize(file_count.c_str());
 
@@ -313,12 +314,12 @@ namespace Toolbox::UI {
             action = DragDropManager::instance().createDragAction(0, std::move(mime_data));
 
             action->setRender([action](const ImVec2 &pos, const ImVec2 &size) {
-                std::string urls = action->getPayload().get_urls().value_or("");
-                if (urls.empty()) {
+                auto maybe_urls = action->getPayload().get_urls();
+                if (!maybe_urls) {
                     return;
                 }
 
-                size_t num_files = std::count(urls.begin(), urls.end(), '\n');
+                size_t num_files = maybe_urls.value().size();
 
                 ImDrawList *draw_list = ImGui::GetBackgroundDrawList();
                 ImVec2 center         = pos + (size / 2.0f);
@@ -477,4 +478,4 @@ namespace Toolbox::UI {
 
 #endif
 
-}  // namespace Toolbox::UI
\ No newline at end of file
+}  // namespace Toolbox::UI
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 6a8a3c39..e5e29dba 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -503,7 +503,7 @@ namespace Toolbox::UI {
 
         std::vector<std::string> paths;
         for (const ModelIndex &index : m_selected_indices) {
-            paths.push_back(m_file_system_model->getPath(index));
+            paths.push_back(m_file_system_model->getPath(index).string());
         }
 
         result.set_urls(paths);

From 675f576c4839b2d4c204dceb219151d8347e5e87 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 14 Oct 2024 18:09:16 -0700
Subject: [PATCH 096/129] Oops fix some more windows issues

I swear my VS in VM compiled fine before this, but these are
definitely problems.
---
 src/gui/clipboard.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index b751806e..96af5104 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -57,14 +57,14 @@ namespace Toolbox {
 
     Result<MimeData, ClipboardError>
     getContentType(std::unordered_map<std::string, UINT> &mime_to_format,
-                   const std::string &type) const {
+                   const std::string &type) {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<MimeData>("Failed to open the clipboard!");
         }
 
         UINT format = CF_NULL;
         if (mime_to_format.find(type) == mime_to_format.end()) {
-            format = FormatForMime(type);
+            format = SystemClipboard::FormatForMime(type);
             if (format == CF_NULL) {
                 mime_to_format[type] = RegisterClipboardFormat(type.c_str());
                 format                 = mime_to_format[type];
@@ -273,8 +273,9 @@ namespace Toolbox {
             return make_clipboard_error<void>("Can't set clipboard to mulitple types at once on Windows!");
         }
         TOOLBOX_ASSERT(formats.size() > 0);
+        auto type = formats[0];
 
-        std::optional<Buffer> result = mimedata.get_data(formats[0]);
+        std::optional<Buffer> result = mimedata.get_data(type);
         if (!result) {
             return make_clipboard_error<void>(
                 std::format("Failed to find MIME data type \"{}\"", type));
@@ -284,7 +285,7 @@ namespace Toolbox {
 
         UINT format = CF_NULL;
         if (m_mime_to_format.find(type) == m_mime_to_format.end()) {
-            format = FormatForMime(type);
+            format = SystemClipboard::FormatForMime(type);
             if (format == CF_NULL) {
                 m_mime_to_format[type] = RegisterClipboardFormat(type.c_str());
                 format                 = m_mime_to_format[type];

From c786d282e41a760441b5829dc72d11466fedf9d3 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 14 Oct 2024 18:16:00 -0700
Subject: [PATCH 097/129] Make getContentType a friend function

---
 include/core/clipboard.hpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index a3c7efa4..f4a3bc5b 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -45,8 +45,11 @@ namespace Toolbox {
         Result<std::vector<fs_path>, ClipboardError> getFiles() const;
         Result<void, ClipboardError> setContent(const MimeData &mimedata);
 
-
 #ifdef TOOLBOX_PLATFORM_WINDOWS
+        friend Result<MimeData, ClipboardError>
+        getContentType(std::unordered_map<std::string, UINT> &mime_to_format,
+                       const std::string &type);
+
     protected:
         static UINT FormatForMime(std::string_view mimetype);
         static std::string MimeForFormat(UINT format);
@@ -68,9 +71,10 @@ namespace Toolbox {
         // of names we like to use in other places.
         MimeData m_clipboard_contents;
 #endif
-
     };
-    void hookClipboardIntoGLFW(void) ;
+    Result<MimeData, ClipboardError>
+    getContentType(std::unordered_map<std::string, UINT> &mime_to_format, const std::string &type);
+    void hookClipboardIntoGLFW(void);
 
     class DataClipboard {
     public:

From d29053c529818a74cbb34bd6db2527cceeba6cf1 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 14 Oct 2024 18:16:19 -0700
Subject: [PATCH 098/129] Some clang-format stuff

---
 include/core/clipboard.hpp |  2 +-
 src/gui/clipboard.cpp      | 11 +++++------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index f4a3bc5b..bf679c85 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -6,8 +6,8 @@
 
 #include "core/error.hpp"
 #include "core/mimedata/mimedata.hpp"
-#include "tristate.hpp"
 #include "fsystem.hpp"
+#include "tristate.hpp"
 
 namespace Toolbox {
 
diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index 96af5104..e9a3523d 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -54,10 +54,8 @@ namespace Toolbox {
         return types;
     }
 
-
     Result<MimeData, ClipboardError>
-    getContentType(std::unordered_map<std::string, UINT> &mime_to_format,
-                   const std::string &type) {
+    getContentType(std::unordered_map<std::string, UINT> &mime_to_format, const std::string &type) {
         if (!OpenClipboard(nullptr)) {
             return make_clipboard_error<MimeData>("Failed to open the clipboard!");
         }
@@ -67,7 +65,7 @@ namespace Toolbox {
             format = SystemClipboard::FormatForMime(type);
             if (format == CF_NULL) {
                 mime_to_format[type] = RegisterClipboardFormat(type.c_str());
-                format                 = mime_to_format[type];
+                format               = mime_to_format[type];
             }
         } else {
             format = mime_to_format[type];
@@ -270,7 +268,8 @@ namespace Toolbox {
 
         std::vector<std::string> formats = mimedata.get_all_formats();
         if (formats.size() > 1) {
-            return make_clipboard_error<void>("Can't set clipboard to mulitple types at once on Windows!");
+            return make_clipboard_error<void>(
+                "Can't set clipboard to mulitple types at once on Windows!");
         }
         TOOLBOX_ASSERT(formats.size() > 0);
         auto type = formats[0];
@@ -331,7 +330,7 @@ namespace Toolbox {
                 }
             }
 
-            path_list_ptr[data_buf.size()] = L'\0';
+            path_list_ptr[data_buf.size()]     = L'\0';
             path_list_ptr[data_buf.size() + 1] = L'\0';
         } else if (format == CF_TEXT) {
             wchar_t *path_list_ptr = (wchar_t *)data_buffer;

From c5bd30d38b40de9a3404c37e2b54170257daf80c Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 14 Oct 2024 18:24:22 -0700
Subject: [PATCH 099/129] Oops don't declare windows-specific function on Linux

---
 include/core/clipboard.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/core/clipboard.hpp b/include/core/clipboard.hpp
index bf679c85..83e2d567 100644
--- a/include/core/clipboard.hpp
+++ b/include/core/clipboard.hpp
@@ -72,8 +72,10 @@ namespace Toolbox {
         MimeData m_clipboard_contents;
 #endif
     };
+#ifdef TOOLBOX_PLATFORM_WINDOWS
     Result<MimeData, ClipboardError>
     getContentType(std::unordered_map<std::string, UINT> &mime_to_format, const std::string &type);
+#endif
     void hookClipboardIntoGLFW(void);
 
     class DataClipboard {

From 8a06024bd2f8d64349689432f6ac308ca36f99f9 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 14 Oct 2024 19:29:43 -0700
Subject: [PATCH 100/129] Fix some more windows build errors

---
 src/gui/clipboard.cpp                |  4 ++-
 src/gui/dragdrop/dragdropmanager.cpp | 37 ++++++----------------------
 2 files changed, 10 insertions(+), 31 deletions(-)

diff --git a/src/gui/clipboard.cpp b/src/gui/clipboard.cpp
index e9a3523d..3bc6149a 100644
--- a/src/gui/clipboard.cpp
+++ b/src/gui/clipboard.cpp
@@ -271,7 +271,9 @@ namespace Toolbox {
             return make_clipboard_error<void>(
                 "Can't set clipboard to mulitple types at once on Windows!");
         }
-        TOOLBOX_ASSERT(formats.size() > 0);
+        if (formats.size() == 0) {
+            return make_clipboard_error<void>("The mimedata set on the clipboard has no formats!");
+        }
         auto type = formats[0];
 
         std::optional<Buffer> result = mimedata.get_data(type);
diff --git a/src/gui/dragdrop/dragdropmanager.cpp b/src/gui/dragdrop/dragdropmanager.cpp
index 049824dd..4172be0b 100644
--- a/src/gui/dragdrop/dragdropmanager.cpp
+++ b/src/gui/dragdrop/dragdropmanager.cpp
@@ -15,29 +15,6 @@
 #elif defined(TOOLBOX_PLATFORM_LINUX)
 #endif
 
-static std::vector<std::string_view> splitLines(std::string_view s) {
-    std::vector<std::string_view> result;
-    size_t last_pos         = 0;
-    size_t next_newline_pos = s.find('\n', 0);
-    while (next_newline_pos != std::string::npos) {
-        if (s[next_newline_pos - 1] == '\r') {
-            result.push_back(s.substr(last_pos, next_newline_pos - last_pos - 1));
-        } else {
-            result.push_back(s.substr(last_pos, next_newline_pos - last_pos));
-        }
-        last_pos         = next_newline_pos + 1;
-        next_newline_pos = s.find('\n', last_pos);
-    }
-    if (last_pos < s.size()) {
-        if (s[s.size() - 1] == '\r') {
-            result.push_back(s.substr(last_pos, s.size() - last_pos - 1));
-        } else {
-            result.push_back(s.substr(last_pos));
-        }
-    }
-    return result;
-}
-
 namespace Toolbox::UI {
 
     RefPtr<DragAction> DragDropManager::createDragAction(UUID64 source_uuid, MimeData &&data, bool system_level) {
@@ -59,18 +36,18 @@ namespace Toolbox::UI {
     void DragDropManager::shutdown() { OleUninitialize(); }
 
     Result<void, BaseError> DragDropManager::createSystemDragDropSource(MimeData &&data) {
-        std::string paths = data.get_urls().value_or("");
+        auto maybe_paths = data.get_urls();
+        if (!maybe_paths) {
+            return make_error<void>("DRAG_DROP", "Passed Mimedata did not include urls");
+        }
+        std::vector<std::string> paths = maybe_paths.value();
 
         std::vector<PIDLIST_ABSOLUTE> pidls;
-        std::vector<std::string_view> lines = splitLines(paths);
 
         size_t next_newline_pos = 0;
-        for (const std::string_view &line : lines) {
-            if (line.empty()) {
-                continue;
-            }
+        for (const std::string_view &path : paths) {
 
-            std::wstring wpath = std::wstring(line.begin(), line.end());
+            std::wstring wpath = std::wstring(path.begin(), path.end());
 
             PIDLIST_ABSOLUTE pidl = ILCreateFromPathW(wpath.c_str());
             if (pidl == NULL) {

From f54836ae0dfb7a9c720ffcc3b50056e5bc14c380 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Tue, 15 Oct 2024 17:43:37 -0500
Subject: [PATCH 101/129] Stuff

---
 include/gui/dragdrop/dragdropmanager.hpp |   1 +
 src/gui/dragdrop/dragdropmanager.cpp     | 214 ++++++++++++++++++-----
 2 files changed, 171 insertions(+), 44 deletions(-)

diff --git a/include/gui/dragdrop/dragdropmanager.hpp b/include/gui/dragdrop/dragdropmanager.hpp
index 1aa0a25e..4f922b8d 100644
--- a/include/gui/dragdrop/dragdropmanager.hpp
+++ b/include/gui/dragdrop/dragdropmanager.hpp
@@ -41,6 +41,7 @@ namespace Toolbox::UI {
 #ifdef TOOLBOX_PLATFORM_WINDOWS
         IDataObject *m_data_object = nullptr;
         IDropSource *m_drop_source = nullptr;
+        std::thread m_drag_thread;
 #elif defined(TOOLBOX_PLATFORM_LINUX)
 #endif
 
diff --git a/src/gui/dragdrop/dragdropmanager.cpp b/src/gui/dragdrop/dragdropmanager.cpp
index 049824dd..24ea771c 100644
--- a/src/gui/dragdrop/dragdropmanager.cpp
+++ b/src/gui/dragdrop/dragdropmanager.cpp
@@ -15,32 +15,10 @@
 #elif defined(TOOLBOX_PLATFORM_LINUX)
 #endif
 
-static std::vector<std::string_view> splitLines(std::string_view s) {
-    std::vector<std::string_view> result;
-    size_t last_pos         = 0;
-    size_t next_newline_pos = s.find('\n', 0);
-    while (next_newline_pos != std::string::npos) {
-        if (s[next_newline_pos - 1] == '\r') {
-            result.push_back(s.substr(last_pos, next_newline_pos - last_pos - 1));
-        } else {
-            result.push_back(s.substr(last_pos, next_newline_pos - last_pos));
-        }
-        last_pos         = next_newline_pos + 1;
-        next_newline_pos = s.find('\n', last_pos);
-    }
-    if (last_pos < s.size()) {
-        if (s[s.size() - 1] == '\r') {
-            result.push_back(s.substr(last_pos, s.size() - last_pos - 1));
-        } else {
-            result.push_back(s.substr(last_pos));
-        }
-    }
-    return result;
-}
-
 namespace Toolbox::UI {
 
-    RefPtr<DragAction> DragDropManager::createDragAction(UUID64 source_uuid, MimeData &&data, bool system_level) {
+    RefPtr<DragAction> DragDropManager::createDragAction(UUID64 source_uuid, MimeData &&data,
+                                                         bool system_level) {
         m_current_drag_action = make_referable<DragAction>(source_uuid);
         m_current_drag_action->setPayload(data);
         if (system_level) {
@@ -56,7 +34,165 @@ namespace Toolbox::UI {
 #ifdef TOOLBOX_PLATFORM_WINDOWS
     bool DragDropManager::initialize() { return OleInitialize(nullptr) >= 0; }
 
-    void DragDropManager::shutdown() { OleUninitialize(); }
+    void DragDropManager::shutdown() {
+        OleUninitialize();
+        m_drag_thread.join();
+    }
+
+    static std::vector<std::string_view> splitLines(std::string_view s) {
+        std::vector<std::string_view> result;
+        size_t last_pos         = 0;
+        size_t next_newline_pos = s.find('\n', 0);
+        while (next_newline_pos != std::string::npos) {
+            if (s[next_newline_pos - 1] == '\r') {
+                result.push_back(s.substr(last_pos, next_newline_pos - last_pos - 1));
+            } else {
+                result.push_back(s.substr(last_pos, next_newline_pos - last_pos));
+            }
+            last_pos         = next_newline_pos + 1;
+            next_newline_pos = s.find('\n', last_pos);
+        }
+        if (last_pos < s.size()) {
+            if (s[s.size() - 1] == '\r') {
+                result.push_back(s.substr(last_pos, s.size() - last_pos - 1));
+            } else {
+                result.push_back(s.substr(last_pos));
+            }
+        }
+        return result;
+    }
+
+    class DropSource : public IDropSource {
+    public:
+        STDMETHODIMP QueryInterface(REFIID riid, void **ppvObject) {
+            if (riid == IID_IUnknown || riid == IID_IDropSource) {
+                *ppvObject = static_cast<IDropSource *>(this);
+                AddRef();
+                return S_OK;
+            }
+            *ppvObject = nullptr;
+            return E_NOINTERFACE;
+        }
+
+        STDMETHODIMP_(ULONG) AddRef() { return ++m_refCount; }
+
+        STDMETHODIMP_(ULONG) Release() {
+            if (--m_refCount == 0) {
+                delete this;
+                return 0;
+            }
+            return m_refCount;
+        }
+
+        STDMETHODIMP QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState) {
+            if (fEscapePressed)
+                return DRAGDROP_S_CANCEL;
+            if (!(grfKeyState & MK_LBUTTON))
+                return DRAGDROP_S_DROP;
+            return S_OK;
+        }
+
+        STDMETHODIMP GiveFeedback(DWORD dwEffect) {
+            return DRAGDROP_S_USEDEFAULTCURSORS;  // Use default drag-and-drop cursors
+        }
+
+    private:
+        ULONG m_refCount = 1;
+    };
+
+    // Create an IDataObject with CF_HDROP for file drag-and-drop
+    class FileDropDataObject : public IDataObject {
+    public:
+        FileDropDataObject(LPCWSTR filePath) {
+            m_refCount = 1;
+            m_filePath = filePath;
+        }
+
+        STDMETHODIMP QueryInterface(REFIID riid, void **ppvObject) {
+            if (riid == IID_IUnknown || riid == IID_IDataObject) {
+                *ppvObject = static_cast<IDataObject *>(this);
+                AddRef();
+                return S_OK;
+            }
+            *ppvObject = nullptr;
+            return E_NOINTERFACE;
+        }
+
+        STDMETHODIMP_(ULONG) AddRef() { return ++m_refCount; }
+
+        STDMETHODIMP_(ULONG) Release() {
+            if (--m_refCount == 0) {
+                delete this;
+                return 0;
+            }
+            return m_refCount;
+        }
+
+        STDMETHODIMP GetData(FORMATETC *pFormatEtc, STGMEDIUM *pMedium) {
+            if (pFormatEtc->cfFormat == CF_HDROP && pFormatEtc->tymed & TYMED_HGLOBAL) {
+                // Allocate global memory for the file list
+                SIZE_T filePathSize = (wcslen(m_filePath) + 1) * sizeof(WCHAR);
+                SIZE_T totalSize    = sizeof(DROPFILES) + filePathSize;
+
+                HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, totalSize);
+                if (!hGlobal)
+                    return E_OUTOFMEMORY;
+
+                // Fill in the DROPFILES structure
+                DROPFILES *pDropFiles = (DROPFILES *)GlobalLock(hGlobal);
+                pDropFiles->pFiles    = sizeof(DROPFILES);  // Offset to the file list
+                pDropFiles->fWide     = TRUE;               // Using Unicode (WCHAR)
+
+                // Copy the file path to the memory block
+                WCHAR *pDst = (WCHAR *)((BYTE *)pDropFiles + sizeof(DROPFILES));
+                wcscpy(pDst, m_filePath);
+
+                GlobalUnlock(hGlobal);
+
+                // Set the STGMEDIUM
+                pMedium->tymed          = TYMED_HGLOBAL;
+                pMedium->hGlobal        = hGlobal;
+                pMedium->pUnkForRelease = nullptr;
+                return S_OK;
+            }
+
+            return DV_E_FORMATETC;  // Unsupported format
+        }
+
+        STDMETHODIMP GetDataHere(FORMATETC *pFormatEtc, STGMEDIUM *pMedium) { return E_NOTIMPL; }
+
+        STDMETHODIMP QueryGetData(FORMATETC *pFormatEtc) {
+            if (pFormatEtc->cfFormat == CF_HDROP && pFormatEtc->tymed & TYMED_HGLOBAL) {
+                return S_OK;
+            }
+            return DV_E_FORMATETC;
+        }
+
+        STDMETHODIMP GetCanonicalFormatEtc(FORMATETC *pFormatEtcIn, FORMATETC *pFormatEtcOut) {
+            return DATA_S_SAMEFORMATETC;
+        }
+
+        STDMETHODIMP SetData(FORMATETC *pFormatEtc, STGMEDIUM *pMedium, BOOL fRelease) {
+            return E_NOTIMPL;
+        }
+
+        STDMETHODIMP EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc) {
+            return E_NOTIMPL;
+        }
+
+        STDMETHODIMP DAdvise(FORMATETC *pFormatEtc, DWORD advf, IAdviseSink *pAdvSink,
+                             DWORD *pdwConnection) {
+            return E_NOTIMPL;
+        }
+
+        STDMETHODIMP DUnadvise(DWORD dwConnection) { return E_NOTIMPL; }
+
+        STDMETHODIMP EnumDAdvise(IEnumSTATDATA **ppEnumAdvise) { return E_NOTIMPL; }
+
+    private:
+        ULONG m_refCount;
+        LPCWSTR m_filePath;
+    };
 
     Result<void, BaseError> DragDropManager::createSystemDragDropSource(MimeData &&data) {
         std::string paths = data.get_urls().value_or("");
@@ -85,8 +221,9 @@ namespace Toolbox::UI {
 
         IDataObject *data_object = nullptr;
         {
-            HRESULT hr = SHCreateDataObject(NULL, static_cast<UINT>(pidls.size()), (PCIDLIST_ABSOLUTE *)pidls.data(),
-                                            nullptr, IID_IDataObject, (void **)&data_object);
+            HRESULT hr = SHCreateDataObject(NULL, static_cast<UINT>(pidls.size()),
+                                            (PCIDLIST_ABSOLUTE *)pidls.data(), nullptr,
+                                            IID_IDataObject, (void **)&data_object);
 
             for (PIDLIST_ABSOLUTE pidl : pidls) {
                 ILFree(pidl);
@@ -97,24 +234,15 @@ namespace Toolbox::UI {
             }
         }
 
-        IDropSource *drop_source = nullptr;
-        {
-            HRESULT hr = CoCreateInstance(CLSID_DragDropHelper, nullptr, CLSCTX_INPROC_SERVER,
-                                          IID_IDropSource, (void **)&drop_source);
-            if (FAILED(hr)) {
-                data_object->Release();
-                return make_error<void>("DRAG_DROP", "Failed to create drop source");
-            }
-        }
+        DropSource *drop_source = new DropSource();
 
-        DWORD effect;
         {
-            HRESULT hr = DoDragDrop(data_object, drop_source, DROPEFFECT_COPY, &effect);
-            if (FAILED(hr)) {
+            m_drag_thread = std::thread([data_object, drop_source]() {
+                DWORD effect;
+                DoDragDrop(data_object, drop_source, DROPEFFECT_MOVE, &effect);
                 drop_source->Release();
                 data_object->Release();
-                return make_error<void>("DRAG_DROP", "Failed to perform drag drop operation");
-            }
+            });
         }
 
         m_data_object = data_object;
@@ -142,9 +270,7 @@ namespace Toolbox::UI {
         return {};
     }
 
-    Result<void, BaseError> DragDropManager::destroySystemDragDropSource() {
-        return {};
-    }
+    Result<void, BaseError> DragDropManager::destroySystemDragDropSource() { return {}; }
 
 #endif
 

From 78f9158b01ad452f5ae9c699578db931cd127a7d Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Fri, 18 Oct 2024 00:45:38 -0500
Subject: [PATCH 102/129] Disable system drag from app for now

---
 include/gui/dragdrop/dragdropmanager.hpp |   1 +
 src/gui/dragdrop/dragdropmanager.cpp     | 159 ++++++++++++-----------
 2 files changed, 87 insertions(+), 73 deletions(-)

diff --git a/include/gui/dragdrop/dragdropmanager.hpp b/include/gui/dragdrop/dragdropmanager.hpp
index 4f922b8d..12c03e21 100644
--- a/include/gui/dragdrop/dragdropmanager.hpp
+++ b/include/gui/dragdrop/dragdropmanager.hpp
@@ -42,6 +42,7 @@ namespace Toolbox::UI {
         IDataObject *m_data_object = nullptr;
         IDropSource *m_drop_source = nullptr;
         std::thread m_drag_thread;
+        bool m_is_thread_running;
 #elif defined(TOOLBOX_PLATFORM_LINUX)
 #endif
 
diff --git a/src/gui/dragdrop/dragdropmanager.cpp b/src/gui/dragdrop/dragdropmanager.cpp
index bf3e9ef2..fbef7221 100644
--- a/src/gui/dragdrop/dragdropmanager.cpp
+++ b/src/gui/dragdrop/dragdropmanager.cpp
@@ -74,14 +74,14 @@ namespace Toolbox::UI {
             return E_NOINTERFACE;
         }
 
-        STDMETHODIMP_(ULONG) AddRef() { return ++m_refCount; }
+        STDMETHODIMP_(ULONG) AddRef() { return ++m_ref_count; }
 
         STDMETHODIMP_(ULONG) Release() {
-            if (--m_refCount == 0) {
+            if (--m_ref_count == 0) {
                 delete this;
                 return 0;
             }
-            return m_refCount;
+            return m_ref_count;
         }
 
         STDMETHODIMP QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState) {
@@ -97,18 +97,60 @@ namespace Toolbox::UI {
         }
 
     private:
-        ULONG m_refCount = 1;
+        ULONG m_ref_count = 1;
     };
 
     // Create an IDataObject with CF_HDROP for file drag-and-drop
     class FileDropDataObject : public IDataObject {
     public:
-        FileDropDataObject(LPCWSTR filePath) {
-            m_refCount = 1;
-            m_filePath = filePath;
+        FileDropDataObject(const std::vector<std::string> &file_paths) : m_ref_count(1) {
+            size_t total_path_size = 2;  // Double null-terminator
+            for (const std::string &path : file_paths) {
+                total_path_size += path.size() + 1;  // +1 for null-terminator
+            }
+
+            m_format_etc.cfFormat = CF_HDROP;
+            m_format_etc.ptd      = nullptr;
+            m_format_etc.dwAspect = DVASPECT_CONTENT;
+            m_format_etc.lindex   = -1;
+            m_format_etc.tymed    = TYMED_HGLOBAL;
+
+            m_stg_medium.tymed = TYMED_HGLOBAL;
+            m_stg_medium.hGlobal =
+                GlobalAlloc(GHND, sizeof(DROPFILES) + total_path_size * sizeof(WCHAR));
+            m_stg_medium.pUnkForRelease = nullptr;
+            
+            DROPFILES *drop_files = static_cast<DROPFILES *>(GlobalLock(m_stg_medium.hGlobal));
+            if (!drop_files) {
+                TOOLBOX_ERROR("Failed to lock global memory for DROPFILES structure");
+                return;
+            }
+
+            drop_files->pFiles    = sizeof(DROPFILES);
+            drop_files->fWide     = TRUE;
+
+            WCHAR *file_path_buffer =
+                reinterpret_cast<WCHAR *>((CHAR *)drop_files + drop_files->pFiles);
+            for (const std::string &file_path : file_paths) {
+                size_t path_size = file_path.size();
+                std::mbstowcs(file_path_buffer, file_path.c_str(), path_size);
+                file_path_buffer += path_size;
+                *file_path_buffer++ = L'\0';
+            }
+
+            *file_path_buffer = L'\0';
+
+            GlobalUnlock(m_stg_medium.hGlobal);
         }
 
-        STDMETHODIMP QueryInterface(REFIID riid, void **ppvObject) {
+        ~FileDropDataObject() {
+            if (m_stg_medium.hGlobal) {
+                GlobalFree(m_stg_medium.hGlobal);
+            }
+        }
+
+        STDMETHODIMP
+        QueryInterface(REFIID riid, void **ppvObject) {
             if (riid == IID_IUnknown || riid == IID_IDataObject) {
                 *ppvObject = static_cast<IDataObject *>(this);
                 AddRef();
@@ -118,40 +160,24 @@ namespace Toolbox::UI {
             return E_NOINTERFACE;
         }
 
-        STDMETHODIMP_(ULONG) AddRef() { return ++m_refCount; }
+        STDMETHODIMP_(ULONG) AddRef() { return ++m_ref_count; }
 
         STDMETHODIMP_(ULONG) Release() {
-            if (--m_refCount == 0) {
+            if (--m_ref_count == 0) {
                 delete this;
                 return 0;
             }
-            return m_refCount;
+            return m_ref_count;
         }
 
         STDMETHODIMP GetData(FORMATETC *pFormatEtc, STGMEDIUM *pMedium) {
-            if (pFormatEtc->cfFormat == CF_HDROP && pFormatEtc->tymed & TYMED_HGLOBAL) {
-                // Allocate global memory for the file list
-                SIZE_T filePathSize = (wcslen(m_filePath) + 1) * sizeof(WCHAR);
-                SIZE_T totalSize    = sizeof(DROPFILES) + filePathSize;
-
-                HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, totalSize);
-                if (!hGlobal)
-                    return E_OUTOFMEMORY;
-
-                // Fill in the DROPFILES structure
-                DROPFILES *pDropFiles = (DROPFILES *)GlobalLock(hGlobal);
-                pDropFiles->pFiles    = sizeof(DROPFILES);  // Offset to the file list
-                pDropFiles->fWide     = TRUE;               // Using Unicode (WCHAR)
-
-                // Copy the file path to the memory block
-                WCHAR *pDst = (WCHAR *)((BYTE *)pDropFiles + sizeof(DROPFILES));
-                wcscpy(pDst, m_filePath);
-
-                GlobalUnlock(hGlobal);
+            if ((pFormatEtc->tymed & TYMED_HGLOBAL) == 0) {
+                return DV_E_TYMED;  // Unsupported medium
+            }
 
-                // Set the STGMEDIUM
+            if (pFormatEtc->cfFormat == CF_HDROP) {
                 pMedium->tymed          = TYMED_HGLOBAL;
-                pMedium->hGlobal        = hGlobal;
+                pMedium->hGlobal         = m_stg_medium.hGlobal;
                 pMedium->pUnkForRelease = nullptr;
                 return S_OK;
             }
@@ -162,7 +188,12 @@ namespace Toolbox::UI {
         STDMETHODIMP GetDataHere(FORMATETC *pFormatEtc, STGMEDIUM *pMedium) { return E_NOTIMPL; }
 
         STDMETHODIMP QueryGetData(FORMATETC *pFormatEtc) {
-            if (pFormatEtc->cfFormat == CF_HDROP && pFormatEtc->tymed & TYMED_HGLOBAL) {
+            if ((pFormatEtc->tymed & TYMED_HGLOBAL) == 0) {
+                return DV_E_TYMED;
+            }
+            if (pFormatEtc->cfFormat == CF_HDROP ||
+                pFormatEtc->cfFormat == RegisterClipboardFormat(CFSTR_FILECONTENTS) ||
+                pFormatEtc->cfFormat == RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR)) {
                 return S_OK;
             }
             return DV_E_FORMATETC;
@@ -177,7 +208,7 @@ namespace Toolbox::UI {
         }
 
         STDMETHODIMP EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc) {
-            return E_NOTIMPL;
+            return OLE_S_USEREG;
         }
 
         STDMETHODIMP DAdvise(FORMATETC *pFormatEtc, DWORD advf, IAdviseSink *pAdvSink,
@@ -190,8 +221,9 @@ namespace Toolbox::UI {
         STDMETHODIMP EnumDAdvise(IEnumSTATDATA **ppEnumAdvise) { return E_NOTIMPL; }
 
     private:
-        ULONG m_refCount;
-        LPCWSTR m_filePath;
+        ULONG m_ref_count;
+        FORMATETC m_format_etc;
+        STGMEDIUM m_stg_medium;
     };
 
     Result<void, BaseError> DragDropManager::createSystemDragDropSource(MimeData &&data) {
@@ -199,54 +231,35 @@ namespace Toolbox::UI {
         if (!maybe_paths) {
             return make_error<void>("DRAG_DROP", "Passed Mimedata did not include urls");
         }
-        std::vector<std::string> paths = maybe_paths.value();
-
-        std::vector<PIDLIST_ABSOLUTE> pidls;
-
-        size_t next_newline_pos = 0;
-        for (const std::string_view &path : paths) {
 
-            std::wstring wpath = std::wstring(path.begin(), path.end());
-
-            PIDLIST_ABSOLUTE pidl = ILCreateFromPathW(wpath.c_str());
-            if (pidl == NULL) {
-                for (PIDLIST_ABSOLUTE pidl : pidls) {
-                    ILFree(pidl);
-                }
-                return make_error<void>("DRAG_DROP", "Failed to create PIDL from path");
-            }
+        IDataObject *data_object = new FileDropDataObject(std::move(maybe_paths.value()));
+        IDropSource *drop_source = new DropSource();
 
-            pidls.push_back(pidl);
-        }
-
-        IDataObject *data_object = nullptr;
+        #if 0
         {
-            HRESULT hr = SHCreateDataObject(NULL, static_cast<UINT>(pidls.size()),
-                                            (PCIDLIST_ABSOLUTE *)pidls.data(), nullptr,
-                                            IID_IDataObject, (void **)&data_object);
-
-            for (PIDLIST_ABSOLUTE pidl : pidls) {
-                ILFree(pidl);
+            if (m_is_thread_running) {
+                m_drag_thread.join();
             }
 
-            if (FAILED(hr)) {
-                return make_error<void>("DRAG_DROP", "Failed to create data object");
-            }
-        }
-
-        DropSource *drop_source = new DropSource();
-
-        {
             m_drag_thread = std::thread([data_object, drop_source]() {
                 DWORD effect;
-                DoDragDrop(data_object, drop_source, DROPEFFECT_MOVE, &effect);
+                DoDragDrop(data_object, drop_source, DROPEFFECT_COPY | DROPEFFECT_MOVE, &effect);
                 drop_source->Release();
                 data_object->Release();
             });
-        }
 
-        m_data_object = data_object;
-        m_drop_source = drop_source;
+            m_data_object = data_object;
+            m_drop_source = drop_source;
+        }
+        #elif 0
+        {
+            DWORD effect;
+            DoDragDrop(data_object, drop_source, DROPEFFECT_COPY | DROPEFFECT_MOVE, &effect);
+            drop_source->Release();
+            data_object->Release();
+        }
+        #else
+        #endif
         return {};
     }
 

From fa0b767ec2f4265fb2f46016e2e0809b2d36f698 Mon Sep 17 00:00:00 2001
From: JoshuaMK <60854312+JoshuaMKW@users.noreply.github.com>
Date: Sun, 20 Oct 2024 19:24:19 -0500
Subject: [PATCH 103/129] New dialog (#37)

* Outline new item window

* Fix wrong file modified

* Some things

* Idk more stuff

* Update gitignore

* Button behavior is underlaying?

* Fix rendering issues

* Add idea of context path for convenient saving

* Adjust code
---
 .gitignore                      |   1 +
 CMakeLists.txt                  |   2 +
 include/gui/new_item/window.hpp |  99 +++++++++++
 include/gui/scene/window.hpp    |   5 +
 src/gui/new_item/window.cpp     | 304 ++++++++++++++++++++++++++++++++
 src/gui/project/window.cpp      |  12 +-
 src/gui/scene/window.cpp        |  15 +-
 7 files changed, 429 insertions(+), 9 deletions(-)
 create mode 100644 include/gui/new_item/window.hpp
 create mode 100644 src/gui/new_item/window.cpp

diff --git a/.gitignore b/.gitignore
index 470633de..63a11346 100644
--- a/.gitignore
+++ b/.gitignore
@@ -35,3 +35,4 @@
 .vs/*
 out/*
 /enc_temp_folder
+/.idea
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 38a5c141..26fcad8e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -58,6 +58,8 @@ file(GLOB TOOLBOX_SRC
     "include/gui/image/*.hpp"
     "src/gui/layer/*.cpp"
     "include/gui/layer/*.hpp"
+    "src/gui/new_item/*.cpp"
+    "include/gui/new_item/*.hpp"
     "src/gui/pad/*.cpp"
     "include/gui/pad/*.hpp"
     "src/gui/project/*.cpp"
diff --git a/include/gui/new_item/window.hpp b/include/gui/new_item/window.hpp
new file mode 100644
index 00000000..17eda1d2
--- /dev/null
+++ b/include/gui/new_item/window.hpp
@@ -0,0 +1,99 @@
+#pragma once
+
+#include <filesystem>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "core/memory.hpp"
+#include "fsystem.hpp"
+#include "objlib/object.hpp"
+#include "objlib/template.hpp"
+#include "scene/scene.hpp"
+#include "smart_resource.hpp"
+
+#include "core/clipboard.hpp"
+#include "game/task.hpp"
+#include "gui/context_menu.hpp"
+#include "gui/event/event.hpp"
+#include "gui/image/imagepainter.hpp"
+#include "gui/project/asset.hpp"
+#include "gui/window.hpp"
+
+#include "model/fsmodel.hpp"
+
+#include <imgui.h>
+
+namespace Toolbox::UI {
+
+    class NewItemWindow final : public ImWindow {
+    public:
+        NewItemWindow(const std::string &name);
+        ~NewItemWindow() = default;
+
+        using window_constructor = std::function<RefPtr<ImWindow>(const fs_path &context_path)>;
+
+        struct ItemInfo {
+            std::string m_name;
+            std::string m_extension;
+            std::string m_description;
+            RefPtr<const ImageHandle> m_icon;
+            window_constructor m_win_factory;
+        };
+
+        void setContextPath(const fs_path &path) {
+            m_context_path = path;
+        }
+
+    protected:
+        void onRenderBody(TimeStep delta_time) override;
+
+        void renderItemRow(const ItemInfo &info, bool selected, bool pressed, bool hovered, const ImVec2 &pos, const ImVec2 &size);
+        void renderItemDescription(const ItemInfo &info, const ImVec2 &pos, const ImVec2 &size);
+        void renderControlPanel();
+
+    public:
+        ImGuiWindowFlags flags() const override { return ImWindow::flags(); }
+
+        const ImGuiWindowClass *windowClass() const override {
+            ImGuiWindow *currentWindow           = ImGui::GetCurrentWindow();
+            m_window_class.ClassId               = (ImGuiID)getUUID();
+            m_window_class.ParentViewportId      = currentWindow->ViewportId;
+            m_window_class.DockingAllowUnclassed = false;
+            m_window_class.DockingAlwaysTabBar   = false;
+            return nullptr;
+        }
+
+        std::optional<ImVec2> minSize() const override {
+            return {
+                {650, 400}
+            };
+        }
+
+        [[nodiscard]] std::string context() const override { return m_context_path.string(); }
+
+        [[nodiscard]] bool unsaved() const override { return false; }
+
+        // Returns the supported file types, empty string is designed for a folder.
+        [[nodiscard]] std::vector<std::string> extensions() const override { return {}; }
+
+        [[nodiscard]] bool onLoadData(const std::filesystem::path &path) override { return false; }
+
+        [[nodiscard]] bool onSaveData(std::optional<std::filesystem::path> path) override {
+            return false;
+        }
+
+        void onAttach() override;
+        void onDetach() override;
+        void onImGuiUpdate(TimeStep delta_time) override;
+
+    private:
+        fs_path m_context_path;
+        std::vector<ItemInfo> m_item_infos;
+        std::string m_search_buffer;
+        int m_selected_item_index;
+    };
+
+}  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/include/gui/scene/window.hpp b/include/gui/scene/window.hpp
index d2586b98..c11b8e51 100644
--- a/include/gui/scene/window.hpp
+++ b/include/gui/scene/window.hpp
@@ -80,6 +80,9 @@ namespace Toolbox::UI {
 
         void deregisterOverlay(const std::string &layer_name) { m_render_layers.erase(layer_name); }
 
+        void initToBasic() { m_current_scene = SceneInstance::BasicScene(); }
+        void setIOContextPath(const fs_path &path) { m_io_context_path = path; }
+
     protected:
         ImGuiID onBuildDockspace() override;
         void onRenderMenuBar() override;
@@ -191,6 +194,8 @@ namespace Toolbox::UI {
     private:
         ScopePtr<Toolbox::SceneInstance> m_current_scene;
 
+        fs_path m_io_context_path;
+
         // Hierarchy view
         ImGuiTextFilter m_hierarchy_filter;
         std::vector<SelectionNodeInfo<Object::ISceneObject>> m_hierarchy_selected_nodes = {};
diff --git a/src/gui/new_item/window.cpp b/src/gui/new_item/window.cpp
new file mode 100644
index 00000000..d445c798
--- /dev/null
+++ b/src/gui/new_item/window.cpp
@@ -0,0 +1,304 @@
+#include "gui/new_item/window.hpp"
+#include "gui/application.hpp"
+#include "gui/scene/window.hpp"
+
+#include "resource/resource.hpp"
+
+namespace Toolbox::UI {
+
+    struct _BuiltinItemInfo {
+        std::string m_name;
+        std::string m_extension;
+        std::string m_description;
+        std::string m_icon_name;
+        NewItemWindow::window_constructor m_win_factory;
+    };
+
+    static std::array<_BuiltinItemInfo, 10> s_default_items = {
+        _BuiltinItemInfo("Basic Scene", "", "A minimal scene that runs in game.", "toolbox.png",
+                         [](const fs_path &context_path) -> RefPtr<SceneWindow> {
+                             RefPtr<SceneWindow> window =
+                                 GUIApplication::instance().createWindow<SceneWindow>(
+                                     "Scene Editor");
+                             window->initToBasic();
+                             window->setIOContextPath(context_path);
+                             return window;
+                         }),
+        _BuiltinItemInfo("Message Data", ".bmg", "A message list with metadata descriptors.",
+            "FileSystem/fs_bmg.png",
+            [](const fs_path &context_path) -> RefPtr<SceneWindow> { return nullptr; }),
+        _BuiltinItemInfo(
+            "Parameter Data", ".prm", "A parameter sheet for tuning behaviors.",
+            "FileSystem/fs_prm.png",
+            [](const fs_path &context_path) -> RefPtr<SceneWindow> { return nullptr; }),
+        _BuiltinItemInfo(
+            "Sunscript", ".sb", "A script format for defining high-level scene behaviors.",
+            "FileSystem/fs_sb.png",
+            [](const fs_path &context_path) -> RefPtr<SceneWindow> { return nullptr; }),
+        _BuiltinItemInfo(
+            "DolphinOS Movie Data", ".thp",
+            "A video format that displays JPEGs and plays adpcm audio.", "FileSystem/fs_thp.png",
+            [](const fs_path &context_path) -> RefPtr<SceneWindow> { return nullptr; }),
+        _BuiltinItemInfo(
+            "J2D Texture Image", ".bti", "A texture resource for models and UI.",
+            "FileSystem/fs_bti.png",
+            [](const fs_path &context_path) -> RefPtr<SceneWindow> { return nullptr; }),
+        _BuiltinItemInfo(
+            "J2D Texture UV Anim", ".btk", "A texture coordinate animation for models and UI.",
+            "FileSystem/fs_btk.png",
+            [](const fs_path &context_path) -> RefPtr<SceneWindow> { return nullptr; }),
+        _BuiltinItemInfo(
+            "J2D Texture Pattern Anim", ".btp", "A texture pattern animation for models and UI.",
+            "FileSystem/fs_btp.png",
+            [](const fs_path &context_path) -> RefPtr<SceneWindow> { return nullptr; }),
+        _BuiltinItemInfo(
+            "J3D Model Data", ".bmd", "A 3D model format for Nintendo games.",
+            "FileSystem/fs_bmd.png",
+            [](const fs_path &context_path) -> RefPtr<SceneWindow> { return nullptr; }),
+        _BuiltinItemInfo(
+            "JParticle Data", ".jpa",
+            "A particle format defining texture resources, physics parameters, and more.",
+            "FileSystem/fs_jpa.png",
+            [](const fs_path &context_path) -> RefPtr<SceneWindow> { return nullptr; }),
+    };
+
+    NewItemWindow::NewItemWindow(const std::string &name)
+        : ImWindow(name), m_selected_item_index(-1) {
+        ResourceManager &res_manager = GUIApplication::instance().getResourceManager();
+        UUID64 icon_path_uuid        = res_manager.getResourcePathUUID("Images/Icons");
+        m_item_infos.resize(s_default_items.size());
+        std::transform(
+            s_default_items.begin(), s_default_items.end(), m_item_infos.begin(),
+            [&res_manager, &icon_path_uuid](const _BuiltinItemInfo &info) {
+                auto result = res_manager.getImageHandle(info.m_icon_name, icon_path_uuid);
+                if (!result) {
+                    TOOLBOX_ERROR_V("[NEW_ITEM_WINDOW] Failed to find icon \"{}\" for item \"{}\"",
+                                    info.m_icon_name, info.m_name);
+                    return ItemInfo(info.m_name, info.m_extension, info.m_description, nullptr,
+                                    info.m_win_factory);
+                }
+                return ItemInfo(info.m_name, info.m_extension, info.m_description, result.value(),
+                                info.m_win_factory);
+            });
+    }
+
+    void NewItemWindow::onRenderBody(TimeStep delta_time) {
+        ImGuiStyle &style = ImGui::GetStyle();
+
+        bool regex_valid = true;
+
+        std::regex search_regex;
+        try {
+            search_regex = std::regex(m_search_buffer, std::regex::icase | std::regex::grep);
+        } catch (std::regex_error &e) {
+            TOOLBOX_DEBUG_LOG_V("[NEW_ITEM_WINDOW] Failed to compile regex: {}", e.what());
+            regex_valid = false;
+        }
+
+        float window_height = ImGui::GetWindowSize().y;
+        float table_height  = window_height - style.WindowPadding.y * 4 - style.FramePadding.y * 2;
+
+        const ImVec2 row_size = {400, 60};
+
+        ImGui::GetWindowDrawList()->AddRectFilled(
+            ImGui::GetCursorScreenPos(),
+            ImGui::GetCursorScreenPos() + ImVec2(row_size.x, table_height),
+            ImGui::ColorConvertFloat4ToU32(style.Colors[ImGuiCol_TableRowBgAlt]));
+
+        if (ImGui::BeginTable("##item_list", 1,
+                              ImGuiTableFlags_BordersOuter | ImGuiTableFlags_ScrollY,
+                              ImVec2(row_size.x, table_height))) {
+            for (size_t i = 0; i < m_item_infos.size(); ++i) {
+                const ItemInfo &info = m_item_infos[i];
+
+#ifndef TOOLBOX_DEBUG
+                if (info.m_win_factory == nullptr) {
+                    continue;
+                }
+#endif
+
+                bool matches_search = false;
+                if (regex_valid) {
+                    matches_search = std::regex_search(info.m_name, search_regex);
+                } else {
+                    matches_search = info.m_name.find(m_search_buffer) != std::string::npos;
+                }
+
+                if (!matches_search) {
+                    continue;
+                }
+
+                ImGui::TableNextRow(ImGuiTableRowFlags_None, row_size.y);
+
+                ImGui::GetCurrentWindow()->SkipItems =
+                    false;  // Fix issue caused by table for future rows.
+
+                bool selected = m_selected_item_index == i;
+
+                std::string id_name = std::format("item_{}", i);
+                ImGuiID bb_id = ImGui::GetID(id_name.c_str(), id_name.c_str() + id_name.size());
+
+                ImVec2 bb_pos = ImGui::GetCursorScreenPos();
+
+                const ImRect bb(bb_pos, bb_pos + row_size);
+                if (!ImGui::ItemAdd(bb, bb_id)) {
+                    TOOLBOX_DEBUG_LOG_V("[NEW_ITEM_WINDOW] Item {} is failed to add interactor", i);
+                }
+
+                bool hovered, held;
+                bool pressed = ImGui::ButtonBehavior(bb, bb_id, &hovered, &held);
+
+                if (pressed) {
+                    m_selected_item_index = i;
+                    selected              = true;
+                }
+
+                if (hovered) {
+                    ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
+                }
+
+                ImGui::BeginGroup();
+                renderItemRow(info, selected, pressed, hovered, bb_pos, row_size);
+                ImGui::EndGroup();
+
+                // ImGui::SetCursorScreenPos({pos.x, pos.y + row_size.y + style.ItemSpacing.y});
+            }
+            ImGui::EndTable();
+        }
+
+        ImGui::SameLine();
+
+        ImGui::BeginGroup();
+
+        char search_buffer[256];
+        std::strncpy(search_buffer, m_search_buffer.c_str(), sizeof(search_buffer));
+
+        ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
+        if (ImGui::InputTextWithHint("##search", "Search...", search_buffer,
+                                     sizeof(search_buffer))) {
+            m_search_buffer = search_buffer;
+        }
+
+        ImGui::Separator();
+
+        if (m_selected_item_index >= 0) {
+            const ItemInfo &info = m_item_infos[m_selected_item_index];
+            ImGui::BeginGroup();
+            renderItemDescription(info, ImGui::GetCursorScreenPos(), {500, 500});
+            ImGui::EndGroup();
+        }
+
+        renderControlPanel();
+
+        ImGui::EndGroup();
+    }
+
+    void NewItemWindow::renderItemRow(const ItemInfo &info, bool selected, bool pressed,
+                                      bool hovered, const ImVec2 &row_pos, const ImVec2 &row_size) {
+        ImGuiStyle &style     = ImGui::GetStyle();
+        ImDrawList *draw_list = ImGui::GetWindowDrawList();
+
+        ImVec4 bg_color;
+        if (hovered || pressed) {
+            bg_color = style.Colors[ImGuiCol_ButtonHovered];
+        } else if (selected) {
+            bg_color = style.Colors[ImGuiCol_ButtonActive];
+        } else {
+            bg_color = style.Colors[ImGuiCol_TableRowBg];
+        }
+
+        draw_list->AddRectFilled(row_pos, row_pos + row_size,
+                                 ImGui::ColorConvertFloat4ToU32(bg_color));
+
+        const ImVec2 icon_size = {48, 48};
+
+        // Render icon
+        {
+            ImVec2 icon_pos = ImVec2(style.WindowPadding.x, row_size.y / 2 - icon_size.x / 2);
+
+            ImagePainter painter;
+            painter.render(*info.m_icon, row_pos + icon_pos, icon_size);
+        }
+
+        // Render name text
+        {
+            ImVec2 name_text_size = ImGui::CalcTextSize(
+                info.m_name.c_str(), info.m_name.c_str() + info.m_name.size(), false, 0);
+            ImVec2 name_text_pos = ImVec2(style.WindowPadding.x + icon_size.x + style.ItemSpacing.x,
+                                          row_size.y / 2 - name_text_size.y / 2);
+
+            draw_list->AddText(row_pos + name_text_pos,
+                               ImGui::ColorConvertFloat4ToU32(style.Colors[ImGuiCol_Text]),
+                               info.m_name.c_str(), info.m_name.c_str() + info.m_name.size());
+        }
+
+        // Render extension text
+        {
+            const std::string &type = info.m_extension.empty() ? "General" : info.m_extension;
+
+            ImVec2 ext_text_size =
+                ImGui::CalcTextSize(type.c_str(), type.c_str() + type.size(), false, 0);
+            ImVec2 ext_text_pos = ImVec2(row_size.x - ext_text_size.x - style.WindowPadding.x - 16,
+                                         row_size.y / 2 - ext_text_size.y / 2);
+
+            draw_list->AddText(row_pos + ext_text_pos,
+                               ImGui::ColorConvertFloat4ToU32(style.Colors[ImGuiCol_Text]),
+                               type.c_str(), type.c_str() + type.size());
+        }
+    }
+
+    void NewItemWindow::renderItemDescription(const ItemInfo &info, const ImVec2 &pos,
+                                              const ImVec2 &size) {
+        ImGui::Text("Type:");
+        ImGui::SameLine();
+
+        const std::string &type = info.m_extension.empty() ? "General" : info.m_extension;
+        ImGui::TextWrapped(type.c_str());
+
+        ImGui::TextWrapped(info.m_description.c_str());
+    }
+
+    void NewItemWindow::renderControlPanel() {
+        ImGuiStyle &style = ImGui::GetStyle();
+
+        ImVec2 win_size = ImGui::GetWindowSize();
+
+        ImVec2 cancel_text_size = ImGui::CalcTextSize("Cancel");
+        ImVec2 open_text_size   = ImGui::CalcTextSize("Open");
+
+        ImVec2 cancel_button_size = cancel_text_size + (style.FramePadding * 2);
+        ImVec2 open_button_size   = open_text_size + (style.FramePadding * 2);
+
+        float y_pos =
+            win_size.y - style.WindowPadding.y - (style.FramePadding.y * 2) - ImGui::GetFontSize();
+        ImVec2 cancel_button_pos = {win_size.x - cancel_button_size.x - style.WindowPadding.x,
+                                    y_pos};
+        ImVec2 open_button_pos   = {cancel_button_pos.x - open_button_size.x - style.ItemSpacing.x,
+                                    y_pos};
+
+        ImGui::SetCursorPos(open_button_pos);
+        if (ImGui::Button("Open", open_button_size)) {
+            if (m_selected_item_index >= 0) {
+                const ItemInfo &info    = m_item_infos[m_selected_item_index];
+                RefPtr<ImWindow> window = info.m_win_factory(m_context_path);
+                if (!window) {
+                    TOOLBOX_DEBUG_LOG("[NEW_ITEM_WINDOW] Failed to create window");
+                } else {
+                    close();
+                }
+            }
+        }
+
+        ImGui::SetCursorPos(cancel_button_pos);
+        if (ImGui::Button("Cancel", cancel_button_size)) {
+            close();
+        }
+    }
+
+    void NewItemWindow::onAttach() {}
+
+    void NewItemWindow::onDetach() {}
+
+    void NewItemWindow::onImGuiUpdate(TimeStep delta_time) {}
+
+}  // namespace Toolbox::UI
\ No newline at end of file
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index e5e29dba..97ff2106 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -1,6 +1,7 @@
 #include "gui/project/window.hpp"
 #include "gui/application.hpp"
 #include "gui/dragdrop/dragdropmanager.hpp"
+#include "gui/new_item/window.hpp"
 #include "model/fsmodel.hpp"
 
 #include <cmath>
@@ -325,7 +326,7 @@ namespace Toolbox::UI {
         m_tree_proxy.setDirsOnly(true);
         m_view_proxy.setSourceModel(m_file_system_model);
         m_view_proxy.setSortRole(FileSystemModelSortRole::SORT_ROLE_NAME);
-        m_view_index = m_view_proxy.getIndex(0, 0);
+        m_view_index = m_file_system_model->getIndex(0, 0);
         return true;
     }
 
@@ -494,7 +495,11 @@ namespace Toolbox::UI {
             "New...", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N}),
             [this]() { return m_selected_indices_ctx.size() == 0; },
             [this](const ModelIndex &view_index) {
-                // TODO: Open a dialog that gives the user different file types to create.
+                RefPtr<NewItemWindow> window =
+                    GUIApplication::instance().createWindow<NewItemWindow>("New Item");
+                if (window) {
+                    window->setContextPath(m_file_system_model->getPath(view_index));
+                }
             });
     }
 
@@ -546,8 +551,7 @@ namespace Toolbox::UI {
     void ProjectViewWindow::actionPasteIntoIndex(const ModelIndex &index,
                                                  const std::vector<fs_path> &paths) {
         for (const fs_path &src_path : paths) {
-            m_file_system_model->copy(src_path, index,
-                                      src_path.filename().string());
+            m_file_system_model->copy(src_path, index, src_path.filename().string());
         }
     }
 
diff --git a/src/gui/scene/window.cpp b/src/gui/scene/window.cpp
index 18cda6d8..bcc9b71b 100644
--- a/src/gui/scene/window.cpp
+++ b/src/gui/scene/window.cpp
@@ -152,6 +152,10 @@ namespace Toolbox::UI {
                     return Result<void, SerialError>();
                 });
 
+            if (result) {
+                m_io_context_path = path;
+            }
+
             return result;
         }
 
@@ -2679,15 +2683,16 @@ void SceneWindow::onRenderMenuBar() {
 
     if (m_is_save_default_ready) {
         m_is_save_default_ready = false;
-        if (m_current_scene->rootPath())
-            (void)onSaveData(m_current_scene->rootPath());
-        else
+        if (!m_io_context_path.empty()) {
+            (void)onSaveData(m_io_context_path);
+        } else {
             m_is_save_as_dialog_open = true;
+        }
     }
 
     if (m_is_save_as_dialog_open) {
-        ImGuiFileDialog::Instance()->OpenDialog("SaveSceneDialog", "Choose Directory", nullptr, "",
-                                                "");
+        ImGuiFileDialog::Instance()->OpenDialog("SaveSceneDialog", "Choose Directory", nullptr,
+                                                m_io_context_path.string(), "");
     }
 
     if (ImGuiFileDialog::Instance()->Display("SaveSceneDialog")) {

From 966250675665df12a2aecdc4984c31c69a7716db Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 21 Oct 2024 09:59:30 -0500
Subject: [PATCH 104/129] Make some adjustments and add folder creation

---
 include/model/fsmodel.hpp            |  6 +++
 src/gui/dragdrop/dragdropmanager.cpp |  4 +-
 src/gui/project/window.cpp           | 23 +++++++++--
 src/model/fsmodel.cpp                | 59 ++++++++++++++++++++++++++--
 4 files changed, 84 insertions(+), 8 deletions(-)

diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index 7400dea7..d654a41c 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -103,6 +103,9 @@ namespace Toolbox {
 
         [[nodiscard]] std::any getData(const ModelIndex &index, int role) const override;
 
+        [[nodiscard]] std::string findUniqueName(const ModelIndex &index,
+                                                 const std::string &name) const;
+
         ModelIndex mkdir(const ModelIndex &parent, const std::string &name);
         ModelIndex touch(const ModelIndex &parent, const std::string &name);
         ModelIndex rename(const ModelIndex &file, const std::string &new_name);
@@ -157,6 +160,9 @@ namespace Toolbox {
         // Implementation of public API for mutex locking reasons
         [[nodiscard]] std::any getData_(const ModelIndex &index, int role) const;
 
+        [[nodiscard]] std::string findUniqueName_(const ModelIndex &index,
+                                                  const std::string &name) const;
+
         ModelIndex mkdir_(const ModelIndex &parent, const std::string &name);
         ModelIndex touch_(const ModelIndex &parent, const std::string &name);
         ModelIndex rename_(const ModelIndex &file, const std::string &new_name);
diff --git a/src/gui/dragdrop/dragdropmanager.cpp b/src/gui/dragdrop/dragdropmanager.cpp
index fbef7221..3c6bb970 100644
--- a/src/gui/dragdrop/dragdropmanager.cpp
+++ b/src/gui/dragdrop/dragdropmanager.cpp
@@ -36,7 +36,9 @@ namespace Toolbox::UI {
 
     void DragDropManager::shutdown() {
         OleUninitialize();
-        m_drag_thread.join();
+        if (m_is_thread_running) {
+            m_drag_thread.join();
+        }
     }
 
     static std::vector<std::string_view> splitLines(std::string_view s) {
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 97ff2106..e90d9483 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -492,7 +492,19 @@ namespace Toolbox::UI {
         m_folder_view_context_menu.addDivider();
 
         m_folder_view_context_menu.addOption(
-            "New...", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N}),
+            "New Folder", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTSHIFT, KeyCode::KEY_N}),
+            [this]() { return m_selected_indices_ctx.size() == 0; },
+            [this](const ModelIndex &view_index) {
+                std::string folder_name =
+                    m_file_system_model->findUniqueName(view_index, "New Folder");
+                ModelIndex new_index = m_file_system_model->mkdir(view_index, folder_name);
+                if (m_file_system_model->validateIndex(new_index)) {
+                    actionRenameIndex(new_index);
+                }
+            });
+
+        m_folder_view_context_menu.addOption(
+            "New Item...", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N}),
             [this]() { return m_selected_indices_ctx.size() == 0; },
             [this](const ModelIndex &view_index) {
                 RefPtr<NewItemWindow> window =
@@ -786,11 +798,16 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::renderFolderTree(const ModelIndex &index) {
         bool is_open = false;
-        if (m_tree_proxy.hasChildren(index)) {
+        if (m_tree_proxy.isDirectory(index)) {
             if (m_tree_proxy.canFetchMore(index)) {
                 m_tree_proxy.fetchMore(index);
             }
-            ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_OpenOnArrow;
+            ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_None;
+            if (m_tree_proxy.hasChildren(index)) {
+                flags |= ImGuiTreeNodeFlags_OpenOnArrow;
+            } else {
+                flags |= ImGuiTreeNodeFlags_Leaf;
+            }
 
             if (m_view_index == m_tree_proxy.toSourceIndex(index)) {
                 flags |= ImGuiTreeNodeFlags_Selected;
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 0a65ddde..2119e4ad 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -206,6 +206,12 @@ namespace Toolbox {
         return getData_(index, role);
     }
 
+    std::string FileSystemModel::findUniqueName(const ModelIndex &index,
+                                                const std::string &name) const {
+        std::scoped_lock lock(m_mutex);
+        return findUniqueName_(index, name);
+    }
+
     ModelIndex FileSystemModel::mkdir(const ModelIndex &parent, const std::string &name) {
         std::scoped_lock lock(m_mutex);
         return mkdir_(parent, name);
@@ -484,6 +490,45 @@ namespace Toolbox {
         }
     }
 
+    std::string FileSystemModel::findUniqueName_(const ModelIndex &parent,
+                                                 const std::string &name) const {
+        if (!validateIndex(parent)) {
+            return name;
+        }
+
+        if (isFile_(parent)) {
+            return name;
+        }
+
+        if (isArchive_(parent)) {
+            // TODO: Implement for virtual FS
+            TOOLBOX_ERROR("[FileSystemModel] Archive probing is unimplemented!");
+            return name;
+        }
+
+        std::string result_name = name;
+        size_t collisions = 0;
+        std::vector<std::string> child_paths;
+
+        size_t dir_size = getDirSize_(parent, false);
+        for (size_t i = 0; i < dir_size; ++i) {
+            ModelIndex child = getIndex_(i, 0, parent);
+            child_paths.emplace_back(std::move(getPath_(child).filename().string()));
+        }
+
+        for (size_t i = 0; i < child_paths.size();) {
+            if (child_paths[i] == result_name) {
+                collisions += 1;
+                result_name = std::format("{} ({})", name, collisions);
+                i           = 0;
+                continue;
+            }
+            ++i;
+        }
+
+        return result_name;
+    }
+
     ModelIndex FileSystemModel::mkdir_(const ModelIndex &parent, const std::string &name) {
         if (!validateIndex(parent)) {
             return ModelIndex();
@@ -519,7 +564,7 @@ namespace Toolbox {
             return ModelIndex();
         }
 
-        return makeIndex(parent.data<_FileSystemIndexData>()->m_path / name, getRowCount(parent),
+        return makeIndex(parent.data<_FileSystemIndexData>()->m_path / name, getRowCount_(parent),
                          parent);
     }
 
@@ -549,7 +594,7 @@ namespace Toolbox {
             return ModelIndex();
         }
 
-        return makeIndex(parent.data<_FileSystemIndexData>()->m_path / name, getRowCount(parent),
+        return makeIndex(parent.data<_FileSystemIndexData>()->m_path / name, getRowCount_(parent),
                          parent);
     }
 
@@ -604,6 +649,7 @@ namespace Toolbox {
                                                           parent_data->m_children.end(),
                                                           index.getUUID()),
                                               parent_data->m_children.end());
+                parent_data->m_size -= 1;
             }
             delete index.data<_FileSystemIndexData>();
             m_index_map.erase(index.getUUID());
@@ -649,6 +695,7 @@ namespace Toolbox {
                                                           parent_data->m_children.end(),
                                                           index.getUUID()),
                                               parent_data->m_children.end());
+                parent_data->m_size -= 1;
             }
             delete index.data<_FileSystemIndexData>();
             m_index_map.erase(index.getUUID());
@@ -681,6 +728,7 @@ namespace Toolbox {
         parent_data->m_children.erase(std::remove(parent_data->m_children.begin(),
                                                   parent_data->m_children.end(), file.getUUID()),
                                       parent_data->m_children.end());
+        parent_data->m_size -= 1;
         return makeIndex(to, dest_index, parent);
     }
     ModelIndex FileSystemModel::copy_(const fs_path &file, const ModelIndex &new_parent,
@@ -690,8 +738,7 @@ namespace Toolbox {
             return ModelIndex();
         }
         if (!Filesystem::exists(file)) {
-            TOOLBOX_ERROR_V("[FileSystemModel] \"{}\" is not a directory or file!",
-                            file.string());
+            TOOLBOX_ERROR_V("[FileSystemModel] \"{}\" is not a directory or file!", file.string());
             return ModelIndex();
         }
         fs_path to = new_parent.data<_FileSystemIndexData>()->m_path / new_name;
@@ -941,6 +988,7 @@ namespace Toolbox {
             if (parent_data) {
                 parent_data->m_children.insert(parent_data->m_children.begin() + row,
                                                index.getUUID());
+                parent_data->m_size += 1;
             }
 
             m_index_map[index.getUUID()] = std::move(index);
@@ -1130,6 +1178,7 @@ namespace Toolbox {
                                                               old_parent_data->m_children.end(),
                                                               index.getUUID()),
                                                   old_parent_data->m_children.end());
+                old_parent_data->m_size -= 1;
 
                 ModelIndex new_parent = getIndex_(new_path.parent_path());
                 if (!validateIndex(new_parent)) {
@@ -1138,6 +1187,7 @@ namespace Toolbox {
 
                 _FileSystemIndexData *new_parent_data = new_parent.data<_FileSystemIndexData>();
                 new_parent_data->m_children.push_back(index.getUUID());
+                new_parent_data->m_size += 1;
             }
         }
 
@@ -1169,6 +1219,7 @@ namespace Toolbox {
                                                           parent_data->m_children.end(),
                                                           index.getUUID()),
                                               parent_data->m_children.end());
+                parent_data->m_size -= 1;
                 delete index.data<_FileSystemIndexData>();
                 m_index_map.erase(index.getUUID());
             }

From 7011bec30f041c8ca8562e77acb24c934d6eadb0 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 21 Oct 2024 11:30:33 -0500
Subject: [PATCH 105/129] Enhance fsmodel logic and signaling process

---
 include/model/fsmodel.hpp       |   3 +
 include/watchdog/fswatchdog.hpp |  14 +-
 src/gui/project/window.cpp      |  12 +-
 src/model/fsmodel.cpp           | 238 +++++++++++++++++++++++++-------
 src/watchdog/fswatchdog.cpp     |  38 ++++-
 5 files changed, 241 insertions(+), 64 deletions(-)

diff --git a/include/model/fsmodel.hpp b/include/model/fsmodel.hpp
index d654a41c..ccf323fc 100644
--- a/include/model/fsmodel.hpp
+++ b/include/model/fsmodel.hpp
@@ -42,6 +42,7 @@ namespace Toolbox {
         EVENT_FOLDER_MODIFIED = BIT(3),
         EVENT_PATH_RENAMED    = BIT(4),
         EVENT_PATH_REMOVED    = BIT(5),
+        EVENT_IS_VIRTUAL      = BIT(6),
         EVENT_FILE_ANY =
             EVENT_FILE_ADDED | EVENT_FILE_MODIFIED | EVENT_PATH_RENAMED | EVENT_PATH_REMOVED,
         EVENT_FOLDER_ANY =
@@ -214,6 +215,8 @@ namespace Toolbox {
 
         void pathRemoved(const fs_path &path);
 
+        void signalEventListeners(const fs_path &path, FileSystemModelEventFlags flags);
+
     private:
         UUID64 m_uuid;
 
diff --git a/include/watchdog/fswatchdog.hpp b/include/watchdog/fswatchdog.hpp
index 064eb54e..d96d1b0a 100644
--- a/include/watchdog/fswatchdog.hpp
+++ b/include/watchdog/fswatchdog.hpp
@@ -41,9 +41,7 @@ namespace Toolbox {
         ScopePtr<filewatch::FileWatch<fs_path>> m_watch;
     };
 
-}
-
-
+}  // namespace Toolbox
 
 namespace std {
 
@@ -73,6 +71,9 @@ namespace Toolbox {
         void sleep();
         void wake();
 
+        void ignorePathOnce(const fs_path &path);
+        void ignorePathOnce(fs_path &&path);
+
         void addPath(const fs_path &path);
         void addPath(fs_path &&path);
 
@@ -93,8 +94,7 @@ namespace Toolbox {
     protected:
         void tRun(void *param) override;
 
-        void observePath(const fs_path &path);
-        void observePathF(const fs_path &path);
+        bool wasSleepingForAlert(const fs_path &path);
 
         struct FileInfo {
             Filesystem::file_status m_status;
@@ -109,6 +109,10 @@ namespace Toolbox {
 
     private:
         bool m_asleep = false;
+        std::chrono::time_point<std::chrono::system_clock> m_sleep_start;
+        std::chrono::time_point<std::chrono::system_clock> m_sleep_end;
+
+        std::unordered_set<fs_path> m_ignore_paths;
 
         std::unordered_map<fs_path, FileInfo> m_path_infos;
 
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index e90d9483..915b08b1 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -492,13 +492,17 @@ namespace Toolbox::UI {
         m_folder_view_context_menu.addDivider();
 
         m_folder_view_context_menu.addOption(
-            "New Folder", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTSHIFT, KeyCode::KEY_N}),
+            "New Folder",
+            KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTSHIFT, KeyCode::KEY_N}),
             [this]() { return m_selected_indices_ctx.size() == 0; },
             [this](const ModelIndex &view_index) {
                 std::string folder_name =
                     m_file_system_model->findUniqueName(view_index, "New Folder");
                 ModelIndex new_index = m_file_system_model->mkdir(view_index, folder_name);
                 if (m_file_system_model->validateIndex(new_index)) {
+                    m_selected_indices.clear();
+                    m_selected_indices.push_back(new_index);
+                    m_selected_indices_ctx = m_selected_indices;
                     actionRenameIndex(new_index);
                 }
             });
@@ -529,7 +533,11 @@ namespace Toolbox::UI {
 
     void ProjectViewWindow::actionDeleteIndexes(std::vector<ModelIndex> &indices) {
         for (auto &item_index : indices) {
-            m_file_system_model->remove(item_index);
+            if (m_file_system_model->isDirectory(item_index)) {
+                m_file_system_model->rmdir(item_index);
+            } else {
+                m_file_system_model->remove(item_index);
+            }
         }
         indices.clear();
     }
diff --git a/src/model/fsmodel.cpp b/src/model/fsmodel.cpp
index 2119e4ad..8eed0455 100644
--- a/src/model/fsmodel.cpp
+++ b/src/model/fsmodel.cpp
@@ -5,6 +5,10 @@
 #include "gui/application.hpp"
 #include "model/fsmodel.hpp"
 
+#ifndef TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+#define TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE 0
+#endif
+
 namespace Toolbox {
 
     struct _FileSystemIndexData {
@@ -507,7 +511,7 @@ namespace Toolbox {
         }
 
         std::string result_name = name;
-        size_t collisions = 0;
+        size_t collisions       = 0;
         std::vector<std::string> child_paths;
 
         size_t dir_size = getDirSize_(parent, false);
@@ -536,9 +540,21 @@ namespace Toolbox {
 
         bool result = false;
 
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.sleep();
+#endif
+        fs_path path = getPath_(parent) / name;
+
+#if !TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.ignorePathOnce(path);
+#endif
+
+        FileSystemModelEventFlags event_flags = FileSystemModelEventFlags::EVENT_FOLDER_ADDED;
+        if (isArchive_(parent) || validateIndex(getParentArchive(parent))) {
+            event_flags |= FileSystemModelEventFlags::EVENT_IS_VIRTUAL;
+        }
+
         if (isDirectory_(parent)) {
-            fs_path path = getPath_(parent);
-            path /= name;
             Filesystem::create_directory(path)
                 .and_then([&](bool created) {
                     if (!created) {
@@ -560,12 +576,18 @@ namespace Toolbox {
             TOOLBOX_ERROR("[FileSystemModel] Parent index is not a directory!");
         }
 
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.wake();
+#endif
+
         if (!result) {
             return ModelIndex();
         }
 
-        return makeIndex(parent.data<_FileSystemIndexData>()->m_path / name, getRowCount_(parent),
-                         parent);
+        ModelIndex ret_index = makeIndex(parent.data<_FileSystemIndexData>()->m_path / name,
+                                         getRowCount_(parent), parent);
+        signalEventListeners(path, event_flags);
+        return ret_index;
     }
 
     ModelIndex FileSystemModel::touch_(const ModelIndex &parent, const std::string &name) {
@@ -575,8 +597,22 @@ namespace Toolbox {
 
         bool result = false;
 
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.sleep();
+#endif
+
+        fs_path path = parent.data<_FileSystemIndexData>()->m_path / name;
+
+#if !TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.ignorePathOnce(path);
+#endif
+
+        FileSystemModelEventFlags event_flags = FileSystemModelEventFlags::EVENT_FILE_ADDED;
+        if (isArchive_(parent) || validateIndex(getParentArchive(parent))) {
+            event_flags |= FileSystemModelEventFlags::EVENT_IS_VIRTUAL;
+        }
+
         if (isDirectory_(parent)) {
-            fs_path path = parent.data<_FileSystemIndexData>()->m_path / name;
             std::ofstream file(path);
             if (!file.is_open()) {
                 TOOLBOX_ERROR_V("[FileSystemModel] Failed to create file: {}", path.string());
@@ -590,12 +626,18 @@ namespace Toolbox {
             TOOLBOX_ERROR("[FileSystemModel] Parent index is not a directory!");
         }
 
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.wake();
+#endif
+
         if (!result) {
             return ModelIndex();
         }
 
-        return makeIndex(parent.data<_FileSystemIndexData>()->m_path / name, getRowCount_(parent),
-                         parent);
+        ModelIndex ret_index = makeIndex(parent.data<_FileSystemIndexData>()->m_path / name,
+                                         getRowCount_(parent), parent);
+        signalEventListeners(path, event_flags);
+        return ret_index;
     }
 
     bool FileSystemModel::rmdir_(const ModelIndex &index) {
@@ -603,14 +645,26 @@ namespace Toolbox {
             return false;
         }
 
-        bool result = false;
+        bool result        = false;
+        fs_path index_path = getPath_(index);
+
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.sleep();
+#else
+        m_watchdog.ignorePathOnce(index_path);
+#endif
+
+        FileSystemModelEventFlags event_flags = FileSystemModelEventFlags::EVENT_PATH_REMOVED;
+        if (validateIndex(getParentArchive(index))) {
+            event_flags |= FileSystemModelEventFlags::EVENT_IS_VIRTUAL;
+        }
 
         if (isDirectory_(index)) {
-            Filesystem::remove_all(getPath_(index))
+            Filesystem::remove_all(index_path)
                 .and_then([&](bool removed) {
                     if (!removed) {
                         TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove directory: {}",
-                                        getPath(index).string());
+                                        index_path.string());
                         return Result<bool, FSError>();
                     }
                     result = true;
@@ -622,11 +676,11 @@ namespace Toolbox {
                     return Result<bool, FSError>();
                 });
         } else if (isArchive_(index)) {
-            Filesystem::remove(getPath_(index))
+            Filesystem::remove(index_path)
                 .and_then([&](bool removed) {
                     if (!removed) {
                         TOOLBOX_ERROR_V("[FileSystemModel] Failed to remove archive: {}",
-                                        getPath(index).string());
+                                        index_path.string());
                         return Result<bool, FSError>();
                     }
                     result = true;
@@ -641,6 +695,10 @@ namespace Toolbox {
             TOOLBOX_ERROR("[FileSystemModel] Index is not a directory!");
         }
 
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.wake();
+#endif
+
         if (result) {
             ModelIndex parent = getParent_(index);
             if (validateIndex(parent)) {
@@ -653,6 +711,8 @@ namespace Toolbox {
             }
             delete index.data<_FileSystemIndexData>();
             m_index_map.erase(index.getUUID());
+
+            signalEventListeners(index_path, event_flags);
         }
 
         return result;
@@ -663,7 +723,19 @@ namespace Toolbox {
             return false;
         }
 
-        bool result = false;
+        bool result        = false;
+        fs_path index_path = getPath_(index);
+
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.sleep();
+#else
+        m_watchdog.ignorePathOnce(index_path);
+#endif
+
+        FileSystemModelEventFlags event_flags = FileSystemModelEventFlags::EVENT_PATH_REMOVED;
+        if (validateIndex(getParentArchive(index))) {
+            event_flags |= FileSystemModelEventFlags::EVENT_IS_VIRTUAL;
+        }
 
         if (isFile_(index)) {
             Filesystem::remove(getPath_(index))
@@ -687,6 +759,10 @@ namespace Toolbox {
             TOOLBOX_ERROR("[FileSystemModel] Index is not a file!");
         }
 
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.wake();
+#endif
+
         if (result) {
             ModelIndex parent = getParent_(index);
             if (validateIndex(parent)) {
@@ -699,6 +775,8 @@ namespace Toolbox {
             }
             delete index.data<_FileSystemIndexData>();
             m_index_map.erase(index.getUUID());
+
+            signalEventListeners(index_path, event_flags);
         }
 
         return result;
@@ -712,7 +790,10 @@ namespace Toolbox {
             TOOLBOX_ERROR("[FileSystemModel] Not a directory or file!");
             return ModelIndex();
         }
-        fs_path from                      = file.data<_FileSystemIndexData>()->m_path;
+
+        bool result = false;
+
+        fs_path from                      = getPath_(file);
         fs_path to                        = from.parent_path() / new_name;
         ModelIndex parent                 = getParent_(file);
         _FileSystemIndexData *parent_data = parent.data<_FileSystemIndexData>();
@@ -721,7 +802,35 @@ namespace Toolbox {
                                    file.getUUID()) -
                          parent_data->m_children.begin();
 
-        Filesystem::rename(from, to);
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.sleep();
+#else
+        m_watchdog.ignorePathOnce(from);
+        m_watchdog.ignorePathOnce(to);
+#endif
+
+        FileSystemModelEventFlags event_flags = FileSystemModelEventFlags::EVENT_PATH_RENAMED;
+        if (validateIndex(getParentArchive(file))) {
+            event_flags |= FileSystemModelEventFlags::EVENT_IS_VIRTUAL;
+        }
+
+        Filesystem::rename(from, to)
+            .and_then([&result]() {
+                result = true;
+                return Result<bool, FSError>();
+            })
+            .or_else([&](const FSError &error) {
+                TOOLBOX_ERROR_V("[FileSystemModel] Failed to rename file: {}", error.m_message[0]);
+                return Result<bool, FSError>();
+            });
+
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.wake();
+#endif
+
+        if (!result) {
+            return ModelIndex();
+        }
 
         delete file.data<_FileSystemIndexData>();
         m_index_map.erase(file.getUUID());
@@ -729,8 +838,12 @@ namespace Toolbox {
                                                   parent_data->m_children.end(), file.getUUID()),
                                       parent_data->m_children.end());
         parent_data->m_size -= 1;
-        return makeIndex(to, dest_index, parent);
+
+        ModelIndex ret_index = makeIndex(to, dest_index, parent);
+        signalEventListeners(to, event_flags);
+        return ret_index;
     }
+
     ModelIndex FileSystemModel::copy_(const fs_path &file, const ModelIndex &new_parent,
                                       const std::string &new_name) {
         if (!validateIndex(new_parent)) {
@@ -741,13 +854,53 @@ namespace Toolbox {
             TOOLBOX_ERROR_V("[FileSystemModel] \"{}\" is not a directory or file!", file.string());
             return ModelIndex();
         }
-        fs_path to = new_parent.data<_FileSystemIndexData>()->m_path / new_name;
+
+        FileSystemModelEventFlags event_flags = FileSystemModelEventFlags::EVENT_FOLDER_ADDED;
+        {
+            ModelIndex src_index = getIndex_(file);
+            if (validateIndex(src_index)) {
+                if (isFile_(src_index)) {
+                    // TODO: Detect when destination path is part of a valid archive.
+                    if (false) {
+                        event_flags |= FileSystemModelEventFlags::EVENT_IS_VIRTUAL;
+                    }
+                    event_flags = FileSystemModelEventFlags::EVENT_FILE_ADDED;
+                }
+            } else {
+                if (Filesystem::is_regular_file(file).value_or(false)) {
+                    event_flags = FileSystemModelEventFlags::EVENT_FILE_ADDED;
+                }
+            }
+        }
+
+        bool result = false;
+        fs_path to  = new_parent.data<_FileSystemIndexData>()->m_path / new_name;
 
         int dest_index = getRowCount_(new_parent);
 
-        Filesystem::copy(file, to);
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.sleep();
+#else
+        m_watchdog.ignorePathOnce(to);
+#endif
+
+        Filesystem::copy(file, to)
+            .and_then([&result]() {
+                result = true;
+                return Result<bool, FSError>();
+            })
+            .or_else([&](const FSError &error) {
+                TOOLBOX_ERROR_V("[FileSystemModel] Failed to copy file: {}", error.m_message[0]);
+                return Result<bool, FSError>();
+            });
+
+#if TOOLBOX_FS_WATCHDOG_SLEEP_ON_SELF_UPDATE
+        m_watchdog.wake();
+#endif
 
-        return getIndex_(to);
+        ModelIndex ret_index = makeIndex(to, getRowCount_(new_parent), new_parent);
+        signalEventListeners(to, event_flags);
+        return ret_index;
     }
 
     ModelIndex FileSystemModel::getIndex_(const fs_path &path) const {
@@ -1047,12 +1200,7 @@ namespace Toolbox {
             makeIndex(path, getRowCount_(parent), parent);
         }
 
-        for (const auto &[key, listener] : m_listeners) {
-            if ((listener.second & FileSystemModelEventFlags::EVENT_FOLDER_ADDED) !=
-                FileSystemModelEventFlags::NONE) {
-                listener.first(path, FileSystemModelEventFlags::EVENT_FOLDER_ADDED);
-            }
-        }
+        signalEventListeners(path, FileSystemModelEventFlags::EVENT_FOLDER_ADDED);
     }
 
     void FileSystemModel::folderModified(const fs_path &path) {
@@ -1078,12 +1226,7 @@ namespace Toolbox {
                 });
         }
 
-        for (const auto &[key, listener] : m_listeners) {
-            if ((listener.second & FileSystemModelEventFlags::EVENT_FOLDER_MODIFIED) !=
-                FileSystemModelEventFlags::NONE) {
-                listener.first(path, FileSystemModelEventFlags::EVENT_FOLDER_MODIFIED);
-            }
-        }
+        signalEventListeners(path, FileSystemModelEventFlags::EVENT_FOLDER_MODIFIED);
     }
 
     void FileSystemModel::fileAdded(const fs_path &path) {
@@ -1098,12 +1241,7 @@ namespace Toolbox {
             makeIndex(path, getRowCount_(parent), parent);
         }
 
-        for (const auto &[key, listener] : m_listeners) {
-            if ((listener.second & FileSystemModelEventFlags::EVENT_FILE_ADDED) !=
-                FileSystemModelEventFlags::NONE) {
-                listener.first(path, FileSystemModelEventFlags::EVENT_FILE_ADDED);
-            }
-        }
+        signalEventListeners(path, FileSystemModelEventFlags::EVENT_FILE_ADDED);
     }
 
     void FileSystemModel::fileModified(const fs_path &path) {
@@ -1140,12 +1278,7 @@ namespace Toolbox {
                 });
         }
 
-        for (const auto &[key, listener] : m_listeners) {
-            if ((listener.second & FileSystemModelEventFlags::EVENT_FILE_MODIFIED) !=
-                FileSystemModelEventFlags::NONE) {
-                listener.first(path, FileSystemModelEventFlags::EVENT_FILE_MODIFIED);
-            }
-        }
+        signalEventListeners(path, FileSystemModelEventFlags::EVENT_FILE_MODIFIED);
     }
 
     void FileSystemModel::pathRenamedSrc(const fs_path &old_path) {
@@ -1191,12 +1324,7 @@ namespace Toolbox {
             }
         }
 
-        for (const auto &[key, listener] : m_listeners) {
-            if ((listener.second & FileSystemModelEventFlags::EVENT_PATH_RENAMED) !=
-                FileSystemModelEventFlags::NONE) {
-                listener.first(new_path, FileSystemModelEventFlags::EVENT_PATH_RENAMED);
-            }
-        }
+        signalEventListeners(new_path, FileSystemModelEventFlags::EVENT_PATH_RENAMED);
     }
 
     void FileSystemModel::pathRemoved(const fs_path &path) {
@@ -1225,10 +1353,14 @@ namespace Toolbox {
             }
         }
 
+        signalEventListeners(path, FileSystemModelEventFlags::EVENT_PATH_REMOVED);
+    }
+
+    void FileSystemModel::signalEventListeners(const fs_path &path,
+                                               FileSystemModelEventFlags flags) {
         for (const auto &[key, listener] : m_listeners) {
-            if ((listener.second & FileSystemModelEventFlags::EVENT_PATH_REMOVED) !=
-                FileSystemModelEventFlags::NONE) {
-                listener.first(path, FileSystemModelEventFlags::EVENT_PATH_REMOVED);
+            if ((listener.second & flags) != FileSystemModelEventFlags::NONE) {
+                listener.first(path, flags);
             }
         }
     }
diff --git a/src/watchdog/fswatchdog.cpp b/src/watchdog/fswatchdog.cpp
index 69dea6ba..6ae9841a 100644
--- a/src/watchdog/fswatchdog.cpp
+++ b/src/watchdog/fswatchdog.cpp
@@ -15,12 +15,20 @@ namespace Toolbox {
 
     void FileSystemWatchdog::sleep() {
         std::scoped_lock lock(m_mutex);
-        m_asleep = true;
+        m_asleep      = true;
+        m_sleep_start = std::chrono::system_clock::now();
     }
 
     void FileSystemWatchdog::wake() {
         std::scoped_lock lock(m_mutex);
-        m_asleep = false;
+        m_asleep    = false;
+        m_sleep_end = std::chrono::system_clock::now();
+    }
+
+    void FileSystemWatchdog::ignorePathOnce(const fs_path &path) { m_ignore_paths.emplace(path); }
+
+    void FileSystemWatchdog::ignorePathOnce(fs_path &&path) {
+        m_ignore_paths.emplace(std::move(path));
     }
 
     void FileSystemWatchdog::addPath(const fs_path &path) {
@@ -133,6 +141,22 @@ namespace Toolbox {
         }
     }
 
+    bool FileSystemWatchdog::wasSleepingForAlert(const fs_path &path) {
+        if (m_asleep) {
+            return true;
+        }
+
+        bool result = false;
+        Filesystem::last_write_time(path).and_then(
+            [this, &result](const Filesystem::file_time_type &file_time) {
+                auto system_file_time =
+                    std::chrono::clock_cast<std::chrono::system_clock>(file_time);
+                result = m_sleep_start <= system_file_time && m_sleep_end >= system_file_time;
+                return Result<Filesystem::file_time_type, FSError>();
+            });
+        return result;
+    }
+
     PathWatcher_::PathWatcher_(FileSystemWatchdog *watchdog, const fs_path &path) {
         m_watchdog = watchdog;
         m_path     = path;
@@ -172,11 +196,17 @@ namespace Toolbox {
     void PathWatcher_::callback_(const fs_path &path, const filewatch::Event event) {
         std::scoped_lock lock(m_watchdog->m_mutex);
 
-        if (m_watchdog->m_asleep) {
+        fs_path abs_path = m_path / path;
+
+        if (m_watchdog->wasSleepingForAlert(abs_path)) {
+            return;
+        }
+
+        if (m_watchdog->m_ignore_paths.contains(abs_path)) {
+            m_watchdog->m_ignore_paths.erase(abs_path);
             return;
         }
 
-        fs_path abs_path = m_path / path;
         bool is_dir      = Filesystem::is_directory(abs_path).value_or(false);
 
         switch (event) {

From 69ac1f8eea594bf173da3af514146679d3032632 Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Mon, 21 Oct 2024 13:04:20 -0500
Subject: [PATCH 106/129] Adjust code to hopefully make Linux compatible

---
 include/watchdog/fswatchdog.hpp | 4 ++--
 src/watchdog/fswatchdog.cpp     | 8 +++-----
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/include/watchdog/fswatchdog.hpp b/include/watchdog/fswatchdog.hpp
index d96d1b0a..3f87fdf5 100644
--- a/include/watchdog/fswatchdog.hpp
+++ b/include/watchdog/fswatchdog.hpp
@@ -109,8 +109,8 @@ namespace Toolbox {
 
     private:
         bool m_asleep = false;
-        std::chrono::time_point<std::chrono::system_clock> m_sleep_start;
-        std::chrono::time_point<std::chrono::system_clock> m_sleep_end;
+        Filesystem::file_time_type m_sleep_start;
+        Filesystem::file_time_type m_sleep_end;
 
         std::unordered_set<fs_path> m_ignore_paths;
 
diff --git a/src/watchdog/fswatchdog.cpp b/src/watchdog/fswatchdog.cpp
index 6ae9841a..aff4f48c 100644
--- a/src/watchdog/fswatchdog.cpp
+++ b/src/watchdog/fswatchdog.cpp
@@ -16,13 +16,13 @@ namespace Toolbox {
     void FileSystemWatchdog::sleep() {
         std::scoped_lock lock(m_mutex);
         m_asleep      = true;
-        m_sleep_start = std::chrono::system_clock::now();
+        m_sleep_start = Filesystem::file_time_type::clock::now();
     }
 
     void FileSystemWatchdog::wake() {
         std::scoped_lock lock(m_mutex);
         m_asleep    = false;
-        m_sleep_end = std::chrono::system_clock::now();
+        m_sleep_end = Filesystem::file_time_type::clock::now();
     }
 
     void FileSystemWatchdog::ignorePathOnce(const fs_path &path) { m_ignore_paths.emplace(path); }
@@ -149,9 +149,7 @@ namespace Toolbox {
         bool result = false;
         Filesystem::last_write_time(path).and_then(
             [this, &result](const Filesystem::file_time_type &file_time) {
-                auto system_file_time =
-                    std::chrono::clock_cast<std::chrono::system_clock>(file_time);
-                result = m_sleep_start <= system_file_time && m_sleep_end >= system_file_time;
+                result = m_sleep_start <= file_time && m_sleep_end >= file_time;
                 return Result<Filesystem::file_time_type, FSError>();
             });
         return result;

From 0ee4920b136ea26803679c7980962f96762be26d Mon Sep 17 00:00:00 2001
From: JoshuaMKW <joshuamkw2002@gmail.com>
Date: Tue, 22 Oct 2024 11:43:48 -0500
Subject: [PATCH 107/129] Remove old comments

---
 src/gui/project/window.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 915b08b1..d1e2e7f6 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -401,7 +401,6 @@ namespace Toolbox::UI {
             },
             [this](auto) {
                 if (m_selected_indices_ctx.size() == 0) {
-                    // TODO: Implement this interface
                     Toolbox::Platform::OpenFileExplorer(m_file_system_model->getPath(m_view_index));
                 } else {
                     std::set<fs_path> paths;
@@ -414,7 +413,6 @@ namespace Toolbox::UI {
                         }
                     }
                     for (const fs_path &path : paths) {
-                        // TODO: Implement this interface
                         Toolbox::Platform::OpenFileExplorer(path);
                     }
                 }

From ed266519824c0ccf292e4ea15c07da770b2d1caf Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Wed, 23 Oct 2024 15:43:54 -0700
Subject: [PATCH 108/129] Undo the bad window sizing fix and introduce a new
 one

---
 src/gui/window.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/gui/window.cpp b/src/gui/window.cpp
index 53af641b..155d5931 100644
--- a/src/gui/window.cpp
+++ b/src/gui/window.cpp
@@ -33,7 +33,6 @@ namespace Toolbox::UI {
         if (size == getSize()) {
             return;
         }
-        m_is_resized = true;
         GUIApplication::instance().dispatchEvent<WindowEvent, true>(getUUID(), EVENT_WINDOW_RESIZE,
                                                                     size);
     }
@@ -41,7 +40,6 @@ namespace Toolbox::UI {
         if (pos == getPos()) {
             return;
         }
-        m_is_repositioned = true;
         GUIApplication::instance().dispatchEvent<WindowEvent, true>(getUUID(), EVENT_WINDOW_MOVE,
                                                                     pos);
     }
@@ -223,20 +221,18 @@ namespace Toolbox::UI {
 
         // Establish window constraints
         if (window) {
-            if (window->Size != m_prev_size && m_is_resized) {
+            if (window->Size != m_prev_size) {
                 if (m_next_size.x >= 0.0f && m_next_size.y >= 0.0f) {
                     GUIApplication::instance().dispatchEvent<WindowEvent, true>(
                         getUUID(), EVENT_WINDOW_RESIZE, window->Size);
                 }
                 ImGui::SetWindowSize(window, m_prev_size, ImGuiCond_Always);
-                m_is_resized = false;
             }
 
-            if (window->Pos != m_prev_pos && m_is_repositioned) {
+            if (window->Pos != m_prev_pos) {
                 GUIApplication::instance().dispatchEvent<WindowEvent, true>(
                     getUUID(), EVENT_WINDOW_MOVE, window->Pos);
                 ImGui::SetWindowPos(window, m_prev_pos, ImGuiCond_Always);
-                m_is_repositioned = false;
             }
         }
 
@@ -268,6 +264,8 @@ namespace Toolbox::UI {
         case EVENT_WINDOW_MOVE: {
             ImVec2 win_pos = ev->getGlobalPoint();
             setLayerPos(win_pos);
+            std::string window_name = std::format("{}###{}", title(), ev->getTargetId());
+            ImGui::SetWindowPos(window_name.c_str(), win_pos, ImGuiCond_Always);
             ev->accept();
             break;
         }
@@ -282,6 +280,8 @@ namespace Toolbox::UI {
                 win_size.y = std::min(win_size.y, m_max_size->y);
             }
             setLayerSize(win_size);
+            std::string window_name = std::format("{}###{}", title(), ev->getTargetId());
+            ImGui::SetWindowSize(window_name.c_str(), win_size, ImGuiCond_Always);
             ev->accept();
             break;
         }

From 8c97e201474bc3e7826583fc38c3aea49973dd50 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Thu, 24 Oct 2024 14:30:52 -0700
Subject: [PATCH 109/129] Fix file watching in subdirectories on Linux

---
 lib/FileWatch.hpp | 56 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 42 insertions(+), 14 deletions(-)

diff --git a/lib/FileWatch.hpp b/lib/FileWatch.hpp
index 8df7621e..8f7fe44f 100644
--- a/lib/FileWatch.hpp
+++ b/lib/FileWatch.hpp
@@ -251,8 +251,8 @@ namespace filewatch {
 
 #if __unix__
         struct FolderInfo {
-            int folder;
-            int watch;
+            int inotify_handle;
+            std::unordered_map<int, std::filesystem::path> watches;
         };
 
         FolderInfo _directory;
@@ -340,7 +340,9 @@ namespace filewatch {
 #ifdef _WIN32
             SetEvent(_close_event);
 #elif __unix__
-            inotify_rm_watch(_directory.folder, _directory.watch);
+            for (auto &[wd, path] : _directory.watches) {
+                inotify_rm_watch(_directory.inotify_handle, wd);
+            }
 #elif FILEWATCH_PLATFORM_MAC
             if (_run_loop) {
                 CFRunLoopStop(_run_loop);
@@ -354,7 +356,7 @@ namespace filewatch {
 #ifdef _WIN32
             CloseHandle(_directory);
 #elif __unix__
-            close(_directory.folder);
+            close(_directory.inotify_handle);
 #elif FILEWATCH_PLATFORM_MAC
             FSEventStreamStop(_directory);
             FSEventStreamInvalidate(_directory);
@@ -560,10 +562,24 @@ namespace filewatch {
             }
             return S_ISREG(statbuf.st_mode);
         }
+        std::vector<std::filesystem::path> get_subdirectories(const std::filesystem::path &path) {
+            std::vector<std::filesystem::path> result;
+            result.push_back(path);
+            for (const auto &entry :
+                 std::filesystem::directory_iterator(std::filesystem::path(path))) {
+                if (entry.is_directory()) {
+                    for (const auto &sub_path : get_subdirectories(entry.path())) {
+                        result.push_back(sub_path);
+                    }
+                    result.push_back(entry.path());
+                }
+            }
+            return result;
+        }
 
         FolderInfo get_directory(const StringType &path) {
-            const auto folder = inotify_init();
-            if (folder < 0) {
+            const auto inotify_handle = inotify_init();
+            if (inotify_handle < 0) {
                 throw std::system_error(errno, std::system_category());
             }
 
@@ -579,12 +595,16 @@ namespace filewatch {
                 }
             }();
 
-            const auto watch =
-                inotify_add_watch(folder, watch_path.c_str(), IN_MODIFY | IN_CREATE | IN_DELETE);
-            if (watch < 0) {
-                throw std::system_error(errno, std::system_category());
+            std::unordered_map<int, std::filesystem::path> watches;
+            for (auto &subdir_path : get_subdirectories(watch_path)) {
+                const auto watch_fd = inotify_add_watch(inotify_handle, watch_path.c_str(),
+                                                        IN_MODIFY | IN_CREATE | IN_DELETE);
+                watches[watch_fd] = subdir_path;
+                if (watch_fd < 0) {
+                    throw std::system_error(errno, std::system_category());
+                }
             }
-            return {folder, watch};
+            return {inotify_handle, watches};
         }
 
         void monitor_directory() {
@@ -593,7 +613,7 @@ namespace filewatch {
             _running.set_value();
             while (_destory == false) {
                 const auto length =
-                    read(_directory.folder, static_cast<void *>(buffer.data()), buffer.size());
+                    read(_directory.inotify_handle, static_cast<void *>(buffer.data()), buffer.size());
                 if (length > 0) {
                     int i = 0;
                     std::vector<std::pair<StringType, Event>> parsed_information;
@@ -601,14 +621,22 @@ namespace filewatch {
                         struct inotify_event *event =
                             reinterpret_cast<struct inotify_event *>(&buffer[i]);  // NOLINT
                         if (event->len) {
-                            const UnderpinningString changed_file{event->name};
+                            const UnderpinningString changed_file{(_directory.watches[event->wd] / event->name).c_str()};
                             if (pass_filter(changed_file)) {
                                 if (event->mask & IN_CREATE) {
                                     parsed_information.emplace_back(StringType{changed_file},
                                                                     Event::added);
+                                    if (std::filesystem::is_directory(changed_file)) {
+                                        int new_watch_fd = inotify_add_watch(_directory.inotify_handle, changed_file.c_str(), IN_MODIFY | IN_CREATE | IN_DELETE);
+                                        _directory.watches[new_watch_fd] = changed_file;
+                                    }
                                 } else if (event->mask & IN_DELETE) {
                                     parsed_information.emplace_back(StringType{changed_file},
                                                                     Event::removed);
+                                    if (std::filesystem::is_directory(changed_file)) {
+                                        inotify_rm_watch(_directory.inotify_handle, event->wd);
+                                        _directory.watches.erase(event->wd);
+                                    }
                                 } else if (event->mask & IN_MODIFY) {
                                     parsed_information.emplace_back(StringType{changed_file},
                                                                     Event::modified);
@@ -698,7 +726,7 @@ namespace filewatch {
 #elif _WIN32
         static StringType absolute_path_of(const StringType &path) {
             constexpr size_t size = IsWChar<C>::value ? MAX_PATH : 32767 * sizeof(wchar_t);
-            char buf[size * 10]        = {};
+            char buf[size * 10]   = {};
 
             DWORD length =
                 IsWChar<C>::value

From 6a05975c2c77b1650a43ad0011fe2c731810a645 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Sat, 26 Oct 2024 13:35:36 -0700
Subject: [PATCH 110/129] Oops not sure how I didn't catch this.

---
 lib/FileWatch.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/FileWatch.hpp b/lib/FileWatch.hpp
index 8f7fe44f..723e0905 100644
--- a/lib/FileWatch.hpp
+++ b/lib/FileWatch.hpp
@@ -597,7 +597,7 @@ namespace filewatch {
 
             std::unordered_map<int, std::filesystem::path> watches;
             for (auto &subdir_path : get_subdirectories(watch_path)) {
-                const auto watch_fd = inotify_add_watch(inotify_handle, watch_path.c_str(),
+                const auto watch_fd = inotify_add_watch(inotify_handle, subdir_path.c_str(),
                                                         IN_MODIFY | IN_CREATE | IN_DELETE);
                 watches[watch_fd] = subdir_path;
                 if (watch_fd < 0) {

From 0d90943c95574f8044142ab5ab4e4e293e0a59eb Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 28 Oct 2024 10:59:15 -0700
Subject: [PATCH 111/129] Debug message instead of error on empty string rename

---
 src/gui/project/window.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index d1e2e7f6..8a3b5523 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -166,8 +166,12 @@ namespace Toolbox::UI {
                                     ImGuiInputTextFlags_AutoSelectAll |
                                         ImGuiInputTextFlags_EnterReturnsTrue);
                                 if (done) {
-                                    m_file_system_model->rename(
-                                        m_view_proxy.toSourceIndex(child_index), m_rename_buffer);
+                                    if (std::strlen(m_rename_buffer) == 0) {
+                                        TOOLBOX_DEBUG_LOG("Attempted to rename to the empty string, ignoring.");
+                                    } else {
+                                        m_file_system_model->rename(
+                                            m_view_proxy.toSourceIndex(child_index), m_rename_buffer);
+                                    }
                                 }
                                 ImGui::SetCursorScreenPos(pos);
                                 ImGui::PopItemWidth();

From 7ed8650c101e63ace998a3d51e1c5cbd368e1015 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 28 Oct 2024 11:31:25 -0700
Subject: [PATCH 112/129] Update glfw fork to include the docs

---
 lib/glfw | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/glfw b/lib/glfw
index 1014db47..06f21df2 160000
--- a/lib/glfw
+++ b/lib/glfw
@@ -1 +1 @@
-Subproject commit 1014db47dc27708d3f71f790579bc67b79ea4ea5
+Subproject commit 06f21df20e7e816acc121636226c878c76addeda

From 5ddc437fda85bdd8ebb46bac7ff4548968ddf62d Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 28 Oct 2024 12:38:29 -0700
Subject: [PATCH 113/129] Visual indicator for invalid rename targets

---
 include/gui/project/window.hpp |  3 ++
 src/gui/project/window.cpp     | 52 +++++++++++++++++++++++++++++++---
 2 files changed, 51 insertions(+), 4 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index dc4a2013..f4113281 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -111,6 +111,8 @@ namespace Toolbox::UI {
         bool isPathForScene(const ModelIndex &index) const;
 
     private:
+
+        bool isValidName(const char* name, const std::vector<ModelIndex> &selected_indices) const;
         fs_path m_project_root;
 
         // TODO: Have filesystem model.
@@ -132,6 +134,7 @@ namespace Toolbox::UI {
 
         bool m_is_renaming = false;
         char m_rename_buffer[128];
+        bool m_is_valid_name = true;
 
         bool m_delete_without_request = false;
         bool m_delete_requested       = false;
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 8a3b5523..2afd4b5b 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -160,12 +160,24 @@ namespace Toolbox::UI {
                                 ImGui::SetCursorScreenPos(rename_pos);
                                 ImGui::SetKeyboardFocusHere();
 
+                                if (m_is_valid_name) {
+                                    ImGui::PushStyleColor(ImGuiCol_Text,
+                                                          ImGui::ColorConvertFloat4ToU32(
+                                                                                         ImGui::GetStyleColorVec4(ImGuiCol_Text)));
+                                } else  {
+                                    ImGui::PushStyleColor(ImGuiCol_Text,
+                                                          ImGui::ColorConvertFloat4ToU32(ImVec4(1.0, 0.3, 0.3, 1.0)));
+                                }
                                 ImGui::PushItemWidth(label_width);
-                                bool done = ImGui::InputText(
+                                bool edited = ImGui::InputText(
                                     "##rename", m_rename_buffer, IM_ARRAYSIZE(m_rename_buffer),
-                                    ImGuiInputTextFlags_AutoSelectAll |
-                                        ImGuiInputTextFlags_EnterReturnsTrue);
-                                if (done) {
+                                    ImGuiInputTextFlags_AutoSelectAll);
+                                // Pop text color
+                                ImGui::PopStyleColor(1);
+                                if (edited) {
+                                    m_is_valid_name = isValidName(m_rename_buffer, m_selected_indices);
+                                }
+                                if (ImGui::IsItemDeactivatedAfterEdit() && m_is_valid_name) {
                                     if (std::strlen(m_rename_buffer) == 0) {
                                         TOOLBOX_DEBUG_LOG("Attempted to rename to the empty string, ignoring.");
                                     } else {
@@ -850,5 +862,37 @@ namespace Toolbox::UI {
     }
 
     void ProjectViewWindow::initFolderAssets(const ModelIndex &index) {}
+    bool ProjectViewWindow::isValidName(const char* name, const std::vector<ModelIndex> &selected_indices) const {
+        TOOLBOX_ASSERT(selected_indices.size() == 1, "Can't rename more than one file!");
+
+        ModelIndex parent = m_file_system_model->getParent(selected_indices[0]);
+        for (size_t i = 0; i < m_file_system_model->getRowCount(parent); ++i) {
+            ModelIndex child_index = m_file_system_model->getIndex(i, 0, parent);
+            if (child_index == selected_indices[0]) {
+                continue;
+            }
+            std::string child_name = m_file_system_model->getDisplayText(child_index);
+            if (std::strcmp(child_name.c_str(), name) == 0) {
+                return false;
+            }
+        }
+        if (std::strchr(name, '/')) {
+            return false;
+        }
+        //#ifdef TOOLBOX_PLATFORM_WINDOWS
+        if (std::strchr(name, '\\') ||
+            std::strchr(name, '<') ||
+            std::strchr(name, '>') ||
+            std::strchr(name, ':') ||
+            std::strchr(name, '"') ||
+            std::strchr(name, '|') ||
+            std::strchr(name, '?') ||
+            std::strchr(name, '*')) {
+            return false;
+        }
+        //#endif
+
+        return true;
+    }
 
 }  // namespace Toolbox::UI

From 9d8ad1758d41d6ab2ceb1900efe732623102755f Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Tue, 29 Oct 2024 16:23:59 -0700
Subject: [PATCH 114/129] Don't put windows file restrictions on Linux builds

---
 src/gui/project/window.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 2afd4b5b..6c1584c1 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -879,7 +879,7 @@ namespace Toolbox::UI {
         if (std::strchr(name, '/')) {
             return false;
         }
-        //#ifdef TOOLBOX_PLATFORM_WINDOWS
+        #ifdef TOOLBOX_PLATFORM_WINDOWS
         if (std::strchr(name, '\\') ||
             std::strchr(name, '<') ||
             std::strchr(name, '>') ||
@@ -890,7 +890,7 @@ namespace Toolbox::UI {
             std::strchr(name, '*')) {
             return false;
         }
-        //#endif
+        #endif
 
         return true;
     }

From 90664b789901edd5ae46686a1907891d15e1bdfa Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Tue, 29 Oct 2024 18:09:52 -0700
Subject: [PATCH 115/129] Case insensitive file name matching for rename on
 windows

---
 include/gui/project/window.hpp |  2 +-
 src/gui/project/window.cpp     | 32 +++++++++++++++++++++-----------
 2 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/include/gui/project/window.hpp b/include/gui/project/window.hpp
index f4113281..8e1a4fc9 100644
--- a/include/gui/project/window.hpp
+++ b/include/gui/project/window.hpp
@@ -112,7 +112,7 @@ namespace Toolbox::UI {
 
     private:
 
-        bool isValidName(const char* name, const std::vector<ModelIndex> &selected_indices) const;
+        bool isValidName(const std::string &name, const std::vector<ModelIndex> &selected_indices) const;
         fs_path m_project_root;
 
         // TODO: Have filesystem model.
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 6c1584c1..59188c57 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -862,7 +862,16 @@ namespace Toolbox::UI {
     }
 
     void ProjectViewWindow::initFolderAssets(const ModelIndex &index) {}
-    bool ProjectViewWindow::isValidName(const char* name, const std::vector<ModelIndex> &selected_indices) const {
+    bool char_equals(char a, char b)
+    {
+#ifdef TOOLBOX_PLATFORM_WINDOWS
+        return std::tolower(static_cast<unsigned char>(a)) ==
+            std::tolower(static_cast<unsigned char>(b));
+#else
+        return a == b;
+#endif
+    }
+    bool ProjectViewWindow::isValidName(const std::string &name, const std::vector<ModelIndex> &selected_indices) const {
         TOOLBOX_ASSERT(selected_indices.size() == 1, "Can't rename more than one file!");
 
         ModelIndex parent = m_file_system_model->getParent(selected_indices[0]);
@@ -872,22 +881,23 @@ namespace Toolbox::UI {
                 continue;
             }
             std::string child_name = m_file_system_model->getDisplayText(child_index);
-            if (std::strcmp(child_name.c_str(), name) == 0) {
+            if (std::equal(child_name.begin(), child_name.end(),
+                           name.begin(), name.end(), char_equals)){
                 return false;
             }
         }
-        if (std::strchr(name, '/')) {
+        if (name.contains('/')) {
             return false;
         }
         #ifdef TOOLBOX_PLATFORM_WINDOWS
-        if (std::strchr(name, '\\') ||
-            std::strchr(name, '<') ||
-            std::strchr(name, '>') ||
-            std::strchr(name, ':') ||
-            std::strchr(name, '"') ||
-            std::strchr(name, '|') ||
-            std::strchr(name, '?') ||
-            std::strchr(name, '*')) {
+        if (name.contains('\\') ||
+            name.contains('<') ||
+            name.contains('>') ||
+            name.contains(':') ||
+            name.contains('"') ||
+            name.contains('|') ||
+            name.contains('?') ||
+            name.contains('*')) {
             return false;
         }
         #endif

From 42111638fc77d3ba0cfb253920ae6c772e7479b0 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Tue, 29 Oct 2024 18:13:27 -0700
Subject: [PATCH 116/129] Document where the windows filename constraints came
 from

---
 src/gui/project/window.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 59188c57..f3f4ecc7 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -890,6 +890,8 @@ namespace Toolbox::UI {
             return false;
         }
         #ifdef TOOLBOX_PLATFORM_WINDOWS
+        // Windows naming constraints sourced from here:
+        // https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
         if (name.contains('\\') ||
             name.contains('<') ||
             name.contains('>') ||

From 68713e5bbb4cccf092600b14f98f3e8f9e6561a8 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Tue, 29 Oct 2024 18:13:43 -0700
Subject: [PATCH 117/129] Windows filenames cannot end with a space or period

---
 src/gui/project/window.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index f3f4ecc7..8be008f1 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -902,6 +902,10 @@ namespace Toolbox::UI {
             name.contains('*')) {
             return false;
         }
+        if (name.back() == ' ' ||
+            name.back() == '.') {
+            return false;
+        }
         #endif
 
         return true;

From c1e228bc36dbd58ec1fa2175ac22687cb2836ac4 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Tue, 29 Oct 2024 18:29:10 -0700
Subject: [PATCH 118/129] More windows file constraints

---
 src/gui/project/window.cpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 8be008f1..3e1c95b5 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -6,6 +6,7 @@
 
 #include <cmath>
 #include <imgui/imgui.h>
+#include <cctype>
 
 namespace Toolbox::UI {
 
@@ -906,6 +907,29 @@ namespace Toolbox::UI {
             name.back() == '.') {
             return false;
         }
+        if (name == "CON" ||
+            name == "PRN" ||
+            name == "AUX" ||
+            name == "NUL"){
+            return false;
+        }
+        if (name.starts_with("CON.") ||
+            name.starts_with("PRN.") ||
+            name.starts_with("AUX.") ||
+            name.starts_with("NUL.")) {
+            return false;
+        }
+        if ((name.starts_with("COM") ||
+             name.starts_with("LPT")) &&
+            name.length() == 4 &&
+            (isdigit(name.back()) ||
+             // The escapes for superscript 1, 2, and 3, which are
+             // also disallowed after these patterns.
+             name.back() == '\XB6' ||
+             name.back() == '\XB2' ||
+             name.back() == '\XB3'){
+            return false;
+        }
         #endif
 
         return true;

From 25eb30d1d353fc0bff0ebe54090ba7f82c825b58 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Tue, 29 Oct 2024 18:29:45 -0700
Subject: [PATCH 119/129] Clang formatting rename validation code

---
 src/gui/project/window.cpp | 40 +++++++++++++-------------------------
 1 file changed, 14 insertions(+), 26 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 3e1c95b5..49b28b24 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -4,9 +4,9 @@
 #include "gui/new_item/window.hpp"
 #include "model/fsmodel.hpp"
 
+#include <cctype>
 #include <cmath>
 #include <imgui/imgui.h>
-#include <cctype>
 
 namespace Toolbox::UI {
 
@@ -863,16 +863,16 @@ namespace Toolbox::UI {
     }
 
     void ProjectViewWindow::initFolderAssets(const ModelIndex &index) {}
-    bool char_equals(char a, char b)
-    {
+    bool char_equals(char a, char b) {
 #ifdef TOOLBOX_PLATFORM_WINDOWS
         return std::tolower(static_cast<unsigned char>(a)) ==
-            std::tolower(static_cast<unsigned char>(b));
+               std::tolower(static_cast<unsigned char>(b));
 #else
         return a == b;
 #endif
     }
-    bool ProjectViewWindow::isValidName(const std::string &name, const std::vector<ModelIndex> &selected_indices) const {
+    bool ProjectViewWindow::isValidName(const std::string &name,
+                                        const std::vector<ModelIndex> &selected_indices) const {
         TOOLBOX_ASSERT(selected_indices.size() == 1, "Can't rename more than one file!");
 
         ModelIndex parent = m_file_system_model->getParent(selected_indices[0]);
@@ -882,40 +882,28 @@ namespace Toolbox::UI {
                 continue;
             }
             std::string child_name = m_file_system_model->getDisplayText(child_index);
-            if (std::equal(child_name.begin(), child_name.end(),
-                           name.begin(), name.end(), char_equals)){
+            if (std::equal(child_name.begin(), child_name.end(), name.begin(), name.end(),
+                           char_equals)) {
                 return false;
             }
         }
         if (name.contains('/')) {
             return false;
         }
-        #ifdef TOOLBOX_PLATFORM_WINDOWS
+#ifdef TOOLBOX_PLATFORM_WINDOWS
         // Windows naming constraints sourced from here:
         // https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
-        if (name.contains('\\') ||
-            name.contains('<') ||
-            name.contains('>') ||
-            name.contains(':') ||
-            name.contains('"') ||
-            name.contains('|') ||
-            name.contains('?') ||
-            name.contains('*')) {
+        if (name.contains('\\') || name.contains('<') || name.contains('>') || name.contains(':') ||
+            name.contains('"') || name.contains('|') || name.contains('?') || name.contains('*')) {
             return false;
         }
-        if (name.back() == ' ' ||
-            name.back() == '.') {
+        if (name.back() == ' ' || name.back() == '.') {
             return false;
         }
-        if (name == "CON" ||
-            name == "PRN" ||
-            name == "AUX" ||
-            name == "NUL"){
+        if (name == "CON" || name == "PRN" || name == "AUX" || name == "NUL") {
             return false;
         }
-        if (name.starts_with("CON.") ||
-            name.starts_with("PRN.") ||
-            name.starts_with("AUX.") ||
+        if (name.starts_with("CON.") || name.starts_with("PRN.") || name.starts_with("AUX.") ||
             name.starts_with("NUL.")) {
             return false;
         }
@@ -930,7 +918,7 @@ namespace Toolbox::UI {
              name.back() == '\XB3'){
             return false;
         }
-        #endif
+#endif
 
         return true;
     }

From 49ec8176d815df5d34401fe77bd4460798dc921b Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Tue, 29 Oct 2024 18:29:59 -0700
Subject: [PATCH 120/129] Clang format some of the naming checking code

---
 src/gui/project/window.cpp | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 49b28b24..09fb5d35 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -162,28 +162,33 @@ namespace Toolbox::UI {
                                 ImGui::SetKeyboardFocusHere();
 
                                 if (m_is_valid_name) {
-                                    ImGui::PushStyleColor(ImGuiCol_Text,
-                                                          ImGui::ColorConvertFloat4ToU32(
-                                                                                         ImGui::GetStyleColorVec4(ImGuiCol_Text)));
-                                } else  {
-                                    ImGui::PushStyleColor(ImGuiCol_Text,
-                                                          ImGui::ColorConvertFloat4ToU32(ImVec4(1.0, 0.3, 0.3, 1.0)));
+                                    ImGui::PushStyleColor(
+                                        ImGuiCol_Text,
+                                        ImGui::ColorConvertFloat4ToU32(
+                                            ImGui::GetStyleColorVec4(ImGuiCol_Text)));
+                                } else {
+                                    ImGui::PushStyleColor(
+                                        ImGuiCol_Text,
+                                        ImGui::ColorConvertFloat4ToU32(ImVec4(1.0, 0.3, 0.3, 1.0)));
                                 }
                                 ImGui::PushItemWidth(label_width);
-                                bool edited = ImGui::InputText(
-                                    "##rename", m_rename_buffer, IM_ARRAYSIZE(m_rename_buffer),
-                                    ImGuiInputTextFlags_AutoSelectAll);
+                                bool edited = ImGui::InputText("##rename", m_rename_buffer,
+                                                               IM_ARRAYSIZE(m_rename_buffer),
+                                                               ImGuiInputTextFlags_AutoSelectAll);
                                 // Pop text color
                                 ImGui::PopStyleColor(1);
                                 if (edited) {
-                                    m_is_valid_name = isValidName(m_rename_buffer, m_selected_indices);
+                                    m_is_valid_name =
+                                        isValidName(m_rename_buffer, m_selected_indices);
                                 }
                                 if (ImGui::IsItemDeactivatedAfterEdit() && m_is_valid_name) {
                                     if (std::strlen(m_rename_buffer) == 0) {
-                                        TOOLBOX_DEBUG_LOG("Attempted to rename to the empty string, ignoring.");
+                                        TOOLBOX_DEBUG_LOG(
+                                            "Attempted to rename to the empty string, ignoring.");
                                     } else {
                                         m_file_system_model->rename(
-                                            m_view_proxy.toSourceIndex(child_index), m_rename_buffer);
+                                            m_view_proxy.toSourceIndex(child_index),
+                                            m_rename_buffer);
                                     }
                                 }
                                 ImGui::SetCursorScreenPos(pos);

From e9e3fc029d4d902441a8f276656177cb92434e7e Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Tue, 29 Oct 2024 18:57:24 -0700
Subject: [PATCH 121/129] Oops bad syntax

---
 src/gui/project/window.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 09fb5d35..27d7b45b 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -920,7 +920,7 @@ namespace Toolbox::UI {
              // also disallowed after these patterns.
              name.back() == '\XB6' ||
              name.back() == '\XB2' ||
-             name.back() == '\XB3'){
+             name.back() == '\XB3')){
             return false;
         }
 #endif

From 2c371d0e05a45fa395d720d159d2879f9fbac263 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Wed, 30 Oct 2024 14:20:42 -0700
Subject: [PATCH 122/129] Check condition on keybind actions *after* taking
 open action

---
 include/gui/context_menu.hpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/include/gui/context_menu.hpp b/include/gui/context_menu.hpp
index 0edcb6c0..5b5c7084 100644
--- a/include/gui/context_menu.hpp
+++ b/include/gui/context_menu.hpp
@@ -134,12 +134,16 @@ namespace Toolbox::UI {
             bool keybind_pressed = option.m_keybind.isInputMatching();
 
             if (keybind_pressed && !option.m_keybind_used) {
-                m_open_event(ctx);
-                option.m_keybind_used = true;
-                option.m_op(ctx);
+                if (m_open_event) {
+                    m_open_event(ctx);
+                }
+                if (option.m_condition()) {
+                    option.m_keybind_used = true;
+                    option.m_op(ctx);
+                }
             }
 
-            if (!keybind_pressed) {
+            if (!keybind_pressed || !option.m_condition()) {
                 option.m_keybind_used = false;
             }
         }

From 6d8875749b653cd8e5f7918b4b7ef598b42c5037 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Wed, 30 Oct 2024 14:57:47 -0700
Subject: [PATCH 123/129] Allow deselecting a single item in project view

---
 src/gui/project/window.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 27d7b45b..ed7cff63 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -684,7 +684,7 @@ namespace Toolbox::UI {
         }
 
         if (is_left_button) {
-            if (m_selected_indices.size() > 1) {
+            if (m_selected_indices.size() > 0) {
                 m_selected_indices.clear();
                 m_last_selected_index = ModelIndex();
                 if (m_view_proxy.validateIndex(child_index)) {

From 58471a5294e85dcc4d7ab9804968b757f5f24f76 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 4 Nov 2024 14:59:34 -0800
Subject: [PATCH 124/129] Allow adding modifiers to keybindings

---
 include/core/input/keycode.hpp   |  1 +
 include/core/keybind/keybind.hpp |  4 +++-
 src/core/input/input.cpp         |  3 +++
 src/core/keybind/keybind.cpp     | 36 ++++++++++++++++++++++++++------
 src/gui/project/window.cpp       | 20 ++++++++----------
 5 files changed, 46 insertions(+), 18 deletions(-)

diff --git a/include/core/input/keycode.hpp b/include/core/input/keycode.hpp
index 642e79f6..5e023237 100644
--- a/include/core/input/keycode.hpp
+++ b/include/core/input/keycode.hpp
@@ -146,6 +146,7 @@ namespace Toolbox::Input {
         KEY_SUPER = (1 << 3),
     };
     TOOLBOX_BITWISE_ENUM(KeyModifier);
+    bool operator!(KeyModifier mod);
 
     using KeyModifiers = KeyModifier;
 
diff --git a/include/core/keybind/keybind.hpp b/include/core/keybind/keybind.hpp
index 8090f322..0fa2df16 100644
--- a/include/core/keybind/keybind.hpp
+++ b/include/core/keybind/keybind.hpp
@@ -19,7 +19,8 @@ namespace Toolbox {
         ~KeyBind()                   = default;
 
         KeyBind(std::initializer_list<Input::KeyCode> keys);
-        explicit KeyBind(const Input::KeyCodes &keys);
+        explicit KeyBind(const Input::KeyCodes &keys,
+                         const Input::KeyModifiers &mods = Input::KeyModifiers::KEY_NONE);
 
         [[nodiscard]] static KeyBind FromString(const std::string &);
 
@@ -45,6 +46,7 @@ namespace Toolbox {
 
     private:
         Input::KeyCodes m_key_combo;
+        Input::KeyModifiers m_key_mods = Input::KeyModifiers::KEY_NONE;
     };
 
 }  // namespace Toolbox
\ No newline at end of file
diff --git a/src/core/input/input.cpp b/src/core/input/input.cpp
index 7c2401e3..24b7791f 100644
--- a/src/core/input/input.cpp
+++ b/src/core/input/input.cpp
@@ -294,5 +294,8 @@ namespace Toolbox::Input {
 
         ImGui_ImplGlfw_ScrollCallback(window, xoffset, yoffset);
     }
+    bool operator!(KeyModifier mod) {
+        return ((u8)mod == 0);
+    }
 
 }  // namespace Toolbox::Input
diff --git a/src/core/keybind/keybind.cpp b/src/core/keybind/keybind.cpp
index f700f6e4..6adbaa9d 100644
--- a/src/core/keybind/keybind.cpp
+++ b/src/core/keybind/keybind.cpp
@@ -12,7 +12,8 @@
 namespace Toolbox {
     KeyBind::KeyBind(std::initializer_list<Input::KeyCode> keys) : m_key_combo(keys) {}
 
-    KeyBind::KeyBind(const Input::KeyCodes &keys) : m_key_combo(keys) {}
+    KeyBind::KeyBind(const Input::KeyCodes &keys, const Input::KeyModifiers &mods)
+        : m_key_combo(keys), m_key_mods(mods) {}
 
     KeyBind KeyBind::FromString(const std::string &bind_str) {
         KeyBind result;
@@ -22,7 +23,17 @@ namespace Toolbox {
             size_t next_delimiter_index = bind_str.find('+', key_begin_index);
             std::string key_name =
                 bind_str.substr(key_begin_index, next_delimiter_index - key_begin_index);
-            result.m_key_combo.push_back(KeyNameToEnum(key_name));
+            if (key_name == "Shift") {
+                result.m_key_mods |= Input::KeyModifier::KEY_SHIFT;
+            } else if (key_name == "Ctrl") {
+                result.m_key_mods |= Input::KeyModifier::KEY_CTRL;
+            } else if (key_name == "Alt") {
+                result.m_key_mods |= Input::KeyModifier::KEY_ALT;
+            } else if (key_name == "Super") {
+                result.m_key_mods |= Input::KeyModifier::KEY_SUPER;
+            } else {
+                result.m_key_combo.push_back(KeyNameToEnum(key_name));
+            }
 
             // Last character is + or we reached end of string
             if (next_delimiter_index >= std::string::npos - 1) {
@@ -37,11 +48,24 @@ namespace Toolbox {
 
     bool KeyBind::isInputMatching() const {
         return std::all_of(m_key_combo.begin(), m_key_combo.end(),
-                           [](Input::KeyCode keybind) { return Input::GetKey(keybind); });
+                           [](Input::KeyCode keybind) { return Input::GetKey(keybind); }) &&
+            (Input::GetPressedKeyModifiers() & m_key_mods) == m_key_mods;
     }
 
     std::string KeyBind::toString() const {
         std::string keybind_name = "";
+        if (!!(m_key_mods & Input::KeyModifier::KEY_CTRL)) {
+            keybind_name += "Ctrl+";
+        }
+        if (!!(m_key_mods & Input::KeyModifier::KEY_SHIFT)) {
+            keybind_name += "Shift+";
+        }
+        if (!!(m_key_mods & Input::KeyModifier::KEY_ALT)) {
+            keybind_name += "Alt+";
+        }
+        if (!!(m_key_mods & Input::KeyModifier::KEY_SUPER)) {
+            keybind_name += "Super+";
+        }
         for (size_t j = 0; j < m_key_combo.size(); ++j) {
             Input::KeyCode key = m_key_combo.at(j);
             keybind_name += KeyNameFromEnum(key);
@@ -55,7 +79,7 @@ namespace Toolbox {
     bool KeyBind::scanNextInputKey() {
         // Check if any of the keys are still being held
         bool any_keys_held = std::any_of(m_key_combo.begin(), m_key_combo.end(),
-                                         [](Input::KeyCode key) { return Input::GetKey(key); });
+                                         [](Input::KeyCode key) { return Input::GetKey(key); }) || !!(Input::GetPressedKeyModifiers() & m_key_mods);
         if (m_key_combo.size() > 0 && !any_keys_held) {
             return true;
         }
@@ -73,11 +97,11 @@ namespace Toolbox {
     }
 
     bool KeyBind::operator==(const KeyBind &other) const {
-        return m_key_combo == other.m_key_combo;
+        return m_key_combo == other.m_key_combo && m_key_mods == other.m_key_mods;
     }
 
     bool KeyBind::operator!=(const KeyBind &other) const {
-        return m_key_combo != other.m_key_combo;
+        return m_key_combo != other.m_key_combo || m_key_mods != other.m_key_mods;
     }
 
 }  // namespace Toolbox
\ No newline at end of file
diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index ed7cff63..2ec87cf1 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -402,7 +402,7 @@ namespace Toolbox::UI {
             [this](const ModelIndex &index) { m_selected_indices_ctx = m_selected_indices; });
 
         m_folder_view_context_menu.addOption(
-            "Open", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_O}),
+            "Open", KeyBind({KeyCode::KEY_O}, KeyModifier::KEY_CTRL),
             [this]() {
                 return m_selected_indices_ctx.size() > 0 &&
                        std::all_of(m_selected_indices_ctx.begin(), m_selected_indices_ctx.end(),
@@ -415,7 +415,7 @@ namespace Toolbox::UI {
 
         m_folder_view_context_menu.addOption(
             "Open in Explorer",
-            KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTSHIFT, KeyCode::KEY_O}),
+            KeyBind({KeyCode::KEY_O}, KeyModifier::KEY_CTRL | KeyModifier::KEY_SHIFT),
             [this]() {
                 return std::all_of(
                     m_selected_indices_ctx.begin(), m_selected_indices_ctx.end(),
@@ -443,8 +443,7 @@ namespace Toolbox::UI {
         m_folder_view_context_menu.addDivider();
 
         m_folder_view_context_menu.addOption(
-            "Copy Path",
-            KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTSHIFT, KeyCode::KEY_C}),
+            "Copy Path", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_CTRL | KeyModifier::KEY_SHIFT),
             [this]() { return true; },
             [this](auto) {
                 std::string paths;
@@ -462,11 +461,11 @@ namespace Toolbox::UI {
         m_folder_view_context_menu.addDivider();
 
         m_folder_view_context_menu.addOption(
-            "Cut", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_X}),
+            "Cut", KeyBind({KeyCode::KEY_X}, KeyModifier::KEY_CTRL),
             [this]() { return m_selected_indices_ctx.size() > 0; }, [this](auto) {});
 
         m_folder_view_context_menu.addOption(
-            "Copy", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C}),
+            "Copy", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_CTRL),
             [this]() { return m_selected_indices_ctx.size() > 0; },
             [this](auto) { actionCopyIndexes(m_selected_indices_ctx); });
 
@@ -484,12 +483,12 @@ namespace Toolbox::UI {
             });
 
         m_folder_view_context_menu.addOption(
-            "Rename", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_R}),
+            "Rename", KeyBind({KeyCode::KEY_R}, KeyModifier::KEY_CTRL),
             [this]() { return m_selected_indices_ctx.size() == 1; },
             [this](auto) { actionRenameIndex(m_selected_indices_ctx[0]); });
 
         m_folder_view_context_menu.addOption(
-            "Paste", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V}),
+            "Paste", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_CTRL),
             [this]() { return m_selected_indices_ctx.size() == 0; },
             [this](auto) {
                 auto content_types = SystemClipboard::instance().getAvailableContentFormats();
@@ -512,8 +511,7 @@ namespace Toolbox::UI {
         m_folder_view_context_menu.addDivider();
 
         m_folder_view_context_menu.addOption(
-            "New Folder",
-            KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTSHIFT, KeyCode::KEY_N}),
+            "New Folder", KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL | KeyModifier::KEY_SHIFT),
             [this]() { return m_selected_indices_ctx.size() == 0; },
             [this](const ModelIndex &view_index) {
                 std::string folder_name =
@@ -528,7 +526,7 @@ namespace Toolbox::UI {
             });
 
         m_folder_view_context_menu.addOption(
-            "New Item...", KeyBind({KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N}),
+            "New Item...", KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL),
             [this]() { return m_selected_indices_ctx.size() == 0; },
             [this](const ModelIndex &view_index) {
                 RefPtr<NewItemWindow> window =

From 97d9523afd72872e57303da4e7caffccc843fd8c Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 4 Nov 2024 15:00:01 -0800
Subject: [PATCH 125/129] Some clang format stuff

---
 src/gui/project/window.cpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/gui/project/window.cpp b/src/gui/project/window.cpp
index 2ec87cf1..f31cd591 100644
--- a/src/gui/project/window.cpp
+++ b/src/gui/project/window.cpp
@@ -910,15 +910,11 @@ namespace Toolbox::UI {
             name.starts_with("NUL.")) {
             return false;
         }
-        if ((name.starts_with("COM") ||
-             name.starts_with("LPT")) &&
-            name.length() == 4 &&
+        if ((name.starts_with("COM") || name.starts_with("LPT")) && name.length() == 4 &&
             (isdigit(name.back()) ||
              // The escapes for superscript 1, 2, and 3, which are
              // also disallowed after these patterns.
-             name.back() == '\XB6' ||
-             name.back() == '\XB2' ||
-             name.back() == '\XB3')){
+             name.back() == '\XB6' || name.back() == '\XB2' || name.back() == '\XB3')) {
             return false;
         }
 #endif

From fa8922e125fe9a65e17ecee891ed0470961b1920 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 4 Nov 2024 15:10:28 -0800
Subject: [PATCH 126/129] Assert that modifier keys aren't passed as normal
 keys

---
 src/core/keybind/keybind.cpp | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/src/core/keybind/keybind.cpp b/src/core/keybind/keybind.cpp
index 6adbaa9d..b8f1653c 100644
--- a/src/core/keybind/keybind.cpp
+++ b/src/core/keybind/keybind.cpp
@@ -6,14 +6,37 @@
 #include <string_view>
 #include <vector>
 
+#include "core/assert.hpp"
 #include "core/input/input.hpp"
 #include "core/keybind/keybind.hpp"
 
 namespace Toolbox {
-    KeyBind::KeyBind(std::initializer_list<Input::KeyCode> keys) : m_key_combo(keys) {}
+    KeyBind::KeyBind(std::initializer_list<Input::KeyCode> keys) : m_key_combo(keys) {
+        for (auto &key : keys) {
+            TOOLBOX_ASSERT(
+                key != Input::KeyCode::KEY_LEFTSHIFT && key != Input::KeyCode::KEY_RIGHTSHIFT &&
+                    key != Input::KeyCode::KEY_LEFTCONTROL &&
+                    key != Input::KeyCode::KEY_RIGHTCONTROL && key != Input::KeyCode::KEY_LEFTALT &&
+                    key != Input::KeyCode::KEY_RIGHTALT && key != Input::KeyCode::KEY_LEFTSUPER &&
+                    key != Input::KeyCode::KEY_RIGHTSUPER,
+                "Cannot use explicit modifier keys as part of keybind, pass them as modifiers "
+                "instead as a second argument bitmask")
+        }
+    }
 
     KeyBind::KeyBind(const Input::KeyCodes &keys, const Input::KeyModifiers &mods)
-        : m_key_combo(keys), m_key_mods(mods) {}
+        : m_key_combo(keys), m_key_mods(mods) {
+        for (auto &key : keys) {
+            TOOLBOX_ASSERT(
+                key != Input::KeyCode::KEY_LEFTSHIFT && key != Input::KeyCode::KEY_RIGHTSHIFT &&
+                    key != Input::KeyCode::KEY_LEFTCONTROL &&
+                    key != Input::KeyCode::KEY_RIGHTCONTROL && key != Input::KeyCode::KEY_LEFTALT &&
+                    key != Input::KeyCode::KEY_RIGHTALT && key != Input::KeyCode::KEY_LEFTSUPER &&
+                    key != Input::KeyCode::KEY_RIGHTSUPER,
+                "Cannot use explicit modifier keys as part of keybind, pass them as modifiers "
+                "instead as a second argument bitmask")
+        }
+    }
 
     KeyBind KeyBind::FromString(const std::string &bind_str) {
         KeyBind result;

From 9b327f894d1883c1d6c1d824721cca5cf4478fdc Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 4 Nov 2024 15:10:45 -0800
Subject: [PATCH 127/129] More format stuff

---
 src/core/keybind/keybind.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/core/keybind/keybind.cpp b/src/core/keybind/keybind.cpp
index b8f1653c..8323c9cb 100644
--- a/src/core/keybind/keybind.cpp
+++ b/src/core/keybind/keybind.cpp
@@ -72,7 +72,7 @@ namespace Toolbox {
     bool KeyBind::isInputMatching() const {
         return std::all_of(m_key_combo.begin(), m_key_combo.end(),
                            [](Input::KeyCode keybind) { return Input::GetKey(keybind); }) &&
-            (Input::GetPressedKeyModifiers() & m_key_mods) == m_key_mods;
+               (Input::GetPressedKeyModifiers() & m_key_mods) == m_key_mods;
     }
 
     std::string KeyBind::toString() const {
@@ -102,7 +102,8 @@ namespace Toolbox {
     bool KeyBind::scanNextInputKey() {
         // Check if any of the keys are still being held
         bool any_keys_held = std::any_of(m_key_combo.begin(), m_key_combo.end(),
-                                         [](Input::KeyCode key) { return Input::GetKey(key); }) || !!(Input::GetPressedKeyModifiers() & m_key_mods);
+                                         [](Input::KeyCode key) { return Input::GetKey(key); }) ||
+                             !!(Input::GetPressedKeyModifiers() & m_key_mods);
         if (m_key_combo.size() > 0 && !any_keys_held) {
             return true;
         }

From d767a4820452b1ee16a0e7218df73cbc43da2814 Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 11 Nov 2024 18:55:28 -0800
Subject: [PATCH 128/129] Update scene window bindings to new system

---
 src/gui/scene/window.cpp | 108 ++++++++++++++++++++-------------------
 1 file changed, 55 insertions(+), 53 deletions(-)

diff --git a/src/gui/scene/window.cpp b/src/gui/scene/window.cpp
index bcc9b71b..66c4a83a 100644
--- a/src/gui/scene/window.cpp
+++ b/src/gui/scene/window.cpp
@@ -1460,7 +1460,7 @@ void SceneWindow::buildContextMenuVirtualObj() {
     m_hierarchy_virtual_node_menu = ContextMenu<SelectionNodeInfo<Object::ISceneObject>>();
 
     m_hierarchy_virtual_node_menu.addOption(
-        "Insert Object Before...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N},
+        "Insert Object Before...", KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             m_create_obj_dialog.setInsertPolicy(CreateObjDialog::InsertPolicy::INSERT_BEFORE);
             m_create_obj_dialog.open();
@@ -1468,7 +1468,7 @@ void SceneWindow::buildContextMenuVirtualObj() {
         });
 
     m_hierarchy_virtual_node_menu.addOption(
-        "Insert Object After...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N},
+        "Insert Object After...", KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             m_create_obj_dialog.setInsertPolicy(CreateObjDialog::InsertPolicy::INSERT_AFTER);
             m_create_obj_dialog.open();
@@ -1477,18 +1477,18 @@ void SceneWindow::buildContextMenuVirtualObj() {
 
     m_hierarchy_virtual_node_menu.addDivider();
 
-    m_hierarchy_virtual_node_menu.addOption("Rename...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_R},
-                                            [this](SelectionNodeInfo<Object::ISceneObject> info) {
-                                                m_rename_obj_dialog.open();
-                                                m_rename_obj_dialog.setOriginalName(
-                                                    info.m_selected->getNameRef().name());
-                                                return;
-                                            });
+    m_hierarchy_virtual_node_menu.addOption(
+        "Rename...", KeyBind({KeyCode::KEY_R}, KeyModifier::KEY_CTRL),
+        [this](SelectionNodeInfo<Object::ISceneObject> info) {
+            m_rename_obj_dialog.open();
+            m_rename_obj_dialog.setOriginalName(info.m_selected->getNameRef().name());
+            return;
+        });
 
     m_hierarchy_virtual_node_menu.addDivider();
 
     m_hierarchy_virtual_node_menu.addOption(
-        "Copy", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C},
+        "Copy", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             info.m_selected = make_deep_clone<ISceneObject>(info.m_selected);
             GUIApplication::instance().getSceneObjectClipboard().setData(info);
@@ -1496,7 +1496,7 @@ void SceneWindow::buildContextMenuVirtualObj() {
         });
 
     m_hierarchy_virtual_node_menu.addOption(
-        "Paste", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V},
+        "Paste", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             auto nodes       = GUIApplication::instance().getSceneObjectClipboard().getData();
             auto this_parent = info.m_selected->getParent();
@@ -1552,7 +1552,7 @@ void SceneWindow::buildContextMenuGroupObj() {
     m_hierarchy_group_node_menu = ContextMenu<SelectionNodeInfo<Object::ISceneObject>>();
 
     m_hierarchy_group_node_menu.addOption(
-        "Add Child Object...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N},
+        "Add Child Object...", KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             m_create_obj_dialog.setInsertPolicy(CreateObjDialog::InsertPolicy::INSERT_CHILD);
             m_create_obj_dialog.open();
@@ -1560,7 +1560,7 @@ void SceneWindow::buildContextMenuGroupObj() {
         });
 
     m_hierarchy_group_node_menu.addOption(
-        "Insert Object Before...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N},
+        "Insert Object Before...", KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             m_create_obj_dialog.setInsertPolicy(CreateObjDialog::InsertPolicy::INSERT_BEFORE);
             m_create_obj_dialog.open();
@@ -1568,7 +1568,7 @@ void SceneWindow::buildContextMenuGroupObj() {
         });
 
     m_hierarchy_group_node_menu.addOption(
-        "Insert Object After...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N},
+        "Insert Object After...", KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             m_create_obj_dialog.setInsertPolicy(CreateObjDialog::InsertPolicy::INSERT_AFTER);
             m_create_obj_dialog.open();
@@ -1577,18 +1577,18 @@ void SceneWindow::buildContextMenuGroupObj() {
 
     m_hierarchy_group_node_menu.addDivider();
 
-    m_hierarchy_group_node_menu.addOption("Rename...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_R},
-                                          [this](SelectionNodeInfo<Object::ISceneObject> info) {
-                                              m_rename_obj_dialog.open();
-                                              m_rename_obj_dialog.setOriginalName(
-                                                  info.m_selected->getNameRef().name());
-                                              return;
-                                          });
+    m_hierarchy_group_node_menu.addOption(
+        "Rename...", KeyBind({KeyCode::KEY_R}, KeyModifier::KEY_CTRL),
+        [this](SelectionNodeInfo<Object::ISceneObject> info) {
+            m_rename_obj_dialog.open();
+            m_rename_obj_dialog.setOriginalName(info.m_selected->getNameRef().name());
+            return;
+        });
 
     m_hierarchy_group_node_menu.addDivider();
 
     m_hierarchy_group_node_menu.addOption(
-        "Copy", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C},
+        "Copy", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             info.m_selected = make_deep_clone<ISceneObject>(info.m_selected);
             GUIApplication::instance().getSceneObjectClipboard().setData(info);
@@ -1596,7 +1596,7 @@ void SceneWindow::buildContextMenuGroupObj() {
         });
 
     m_hierarchy_group_node_menu.addOption(
-        "Paste", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V},
+        "Paste", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             auto nodes       = GUIApplication::instance().getSceneObjectClipboard().getData();
             auto this_parent = std::reinterpret_pointer_cast<GroupSceneObject>(info.m_selected);
@@ -1652,7 +1652,7 @@ void SceneWindow::buildContextMenuPhysicalObj() {
     m_hierarchy_physical_node_menu = ContextMenu<SelectionNodeInfo<Object::ISceneObject>>();
 
     m_hierarchy_physical_node_menu.addOption(
-        "Insert Object Before...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N},
+        "Insert Object Before...", KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             m_create_obj_dialog.setInsertPolicy(CreateObjDialog::InsertPolicy::INSERT_BEFORE);
             m_create_obj_dialog.open();
@@ -1660,7 +1660,7 @@ void SceneWindow::buildContextMenuPhysicalObj() {
         });
 
     m_hierarchy_physical_node_menu.addOption(
-        "Insert Object After...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N},
+        "Insert Object After...", KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             m_create_obj_dialog.setInsertPolicy(CreateObjDialog::InsertPolicy::INSERT_AFTER);
             m_create_obj_dialog.open();
@@ -1670,7 +1670,7 @@ void SceneWindow::buildContextMenuPhysicalObj() {
     m_hierarchy_physical_node_menu.addDivider();
 
     m_hierarchy_physical_node_menu.addOption(
-        "Rename...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_R},
+        "Rename...", KeyBind({KeyCode::KEY_R}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             m_rename_obj_dialog.open();
             m_rename_obj_dialog.setOriginalName(info.m_selected->getNameRef().name());
@@ -1680,7 +1680,7 @@ void SceneWindow::buildContextMenuPhysicalObj() {
     m_hierarchy_physical_node_menu.addDivider();
 
     m_hierarchy_physical_node_menu.addOption(
-        "View in Scene", {KeyCode::KEY_LEFTALT, KeyCode::KEY_V},
+        "View in Scene", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_ALT),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             auto member_result = info.m_selected->getMember("Transform");
             if (!member_result) {
@@ -1708,7 +1708,7 @@ void SceneWindow::buildContextMenuPhysicalObj() {
         });
 
     m_hierarchy_physical_node_menu.addOption(
-        "Move to Camera", {KeyCode::KEY_LEFTALT, KeyCode::KEY_C},
+        "Move to Camera", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_ALT),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             auto member_result = info.m_selected->getMember("Transform");
             if (!member_result) {
@@ -1742,7 +1742,7 @@ void SceneWindow::buildContextMenuPhysicalObj() {
     m_hierarchy_physical_node_menu.addDivider();
 
     m_hierarchy_physical_node_menu.addOption(
-        "Copy", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C},
+        "Copy", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             info.m_selected = make_deep_clone<ISceneObject>(info.m_selected);
             GUIApplication::instance().getSceneObjectClipboard().setData(info);
@@ -1750,7 +1750,7 @@ void SceneWindow::buildContextMenuPhysicalObj() {
         });
 
     m_hierarchy_physical_node_menu.addOption(
-        "Paste", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V},
+        "Paste", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Object::ISceneObject> info) {
             auto nodes       = GUIApplication::instance().getSceneObjectClipboard().getData();
             auto this_parent = reinterpret_cast<GroupSceneObject *>(info.m_selected->getParent());
@@ -1804,7 +1804,8 @@ void SceneWindow::buildContextMenuPhysicalObj() {
     m_hierarchy_physical_node_menu.addDivider();
 
     m_hierarchy_physical_node_menu.addOption(
-        "Copy Player Transform", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTALT, KeyCode::KEY_P},
+        "Copy Player Transform",
+        KeyBind({KeyCode::KEY_P}, KeyModifier::KEY_CTRL | KeyModifier::KEY_ALT),
         [this]() {
             Game::TaskCommunicator &task_communicator =
                 GUIApplication::instance().getTaskCommunicator();
@@ -1820,7 +1821,8 @@ void SceneWindow::buildContextMenuPhysicalObj() {
         });
 
     m_hierarchy_physical_node_menu.addOption(
-        "Copy Player Position", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_LEFTALT, KeyCode::KEY_P},
+        "Copy Player Position",
+        KeyBind({KeyCode::KEY_P}, KeyModifier::KEY_CTRL | KeyModifier::KEY_ALT),
         [this]() {
             Game::TaskCommunicator &task_communicator =
                 GUIApplication::instance().getTaskCommunicator();
@@ -1841,7 +1843,7 @@ void SceneWindow::buildContextMenuMultiObj() {
         ContextMenu<std::vector<SelectionNodeInfo<Object::ISceneObject>>>();
 
     m_hierarchy_multi_node_menu.addOption(
-        "Copy", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C},
+        "Copy", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_CTRL),
         [this](std::vector<SelectionNodeInfo<Object::ISceneObject>> infos) {
             for (auto &info : infos) {
                 info.m_selected = make_deep_clone<ISceneObject>(info.m_selected);
@@ -1851,7 +1853,7 @@ void SceneWindow::buildContextMenuMultiObj() {
         });
 
     m_hierarchy_multi_node_menu.addOption(
-        "Paste", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V},
+        "Paste", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_CTRL),
         [this](std::vector<SelectionNodeInfo<Object::ISceneObject>> infos) {
             auto nodes = GUIApplication::instance().getSceneObjectClipboard().getData();
             for (auto &info : infos) {
@@ -1915,7 +1917,7 @@ void SceneWindow::buildContextMenuRail() {
     m_rail_list_single_node_menu = ContextMenu<SelectionNodeInfo<Rail::Rail>>();
 
     m_rail_list_single_node_menu.addOption("Insert Rail Here...",
-                                           {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N},
+                                           KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL),
                                            [this](SelectionNodeInfo<Rail::Rail> info) {
                                                m_create_rail_dialog.open();
                                                return;
@@ -1923,13 +1925,13 @@ void SceneWindow::buildContextMenuRail() {
 
     m_rail_list_single_node_menu.addDivider();
 
-    m_rail_list_single_node_menu.addOption("Rename...", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_R},
-                                           [this](SelectionNodeInfo<Rail::Rail> info) {
-                                               m_rename_rail_dialog.open();
-                                               m_rename_rail_dialog.setOriginalName(
-                                                   info.m_selected->name());
-                                               return;
-                                           });
+    m_rail_list_single_node_menu.addOption(
+        "Rename...", KeyBind({KeyCode::KEY_R}, KeyModifier::KEY_CTRL),
+        [this](SelectionNodeInfo<Rail::Rail> info) {
+            m_rename_rail_dialog.open();
+            m_rename_rail_dialog.setOriginalName(info.m_selected->name());
+            return;
+        });
 
     // m_rail_list_single_node_menu.addDivider();
     //
@@ -1938,7 +1940,7 @@ void SceneWindow::buildContextMenuRail() {
     m_rail_list_single_node_menu.addDivider();
 
     m_rail_list_single_node_menu.addOption(
-        "Copy", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C},
+        "Copy", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Rail::Rail> info) {
             info.m_selected = make_deep_clone<Rail::Rail>(info.m_selected);
             GUIApplication::instance().getSceneRailClipboard().setData(info);
@@ -1946,7 +1948,7 @@ void SceneWindow::buildContextMenuRail() {
         });
 
     m_rail_list_single_node_menu.addOption(
-        "Paste", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V},
+        "Paste", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Rail::Rail> info) {
             auto nodes = GUIApplication::instance().getSceneRailClipboard().getData();
             if (nodes.size() > 0) {
@@ -1984,7 +1986,7 @@ void SceneWindow::buildContextMenuMultiRail() {
     m_rail_list_multi_node_menu = ContextMenu<std::vector<SelectionNodeInfo<Rail::Rail>>>();
 
     m_rail_list_multi_node_menu.addOption(
-        "Copy", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C},
+        "Copy", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_CTRL),
         [this](std::vector<SelectionNodeInfo<Rail::Rail>> info) {
             for (auto &select : info) {
                 select.m_selected = make_deep_clone<Rail::Rail>(select.m_selected);
@@ -1994,7 +1996,7 @@ void SceneWindow::buildContextMenuMultiRail() {
         });
 
     m_rail_list_multi_node_menu.addOption(
-        "Paste", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V},
+        "Paste", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_CTRL),
         [this](std::vector<SelectionNodeInfo<Rail::Rail>> info) {
             auto nodes = GUIApplication::instance().getSceneRailClipboard().getData();
             if (nodes.size() > 0) {
@@ -2035,7 +2037,7 @@ void SceneWindow::buildContextMenuRailNode() {
     m_rail_node_list_single_node_menu = ContextMenu<SelectionNodeInfo<Rail::RailNode>>();
 
     m_rail_node_list_single_node_menu.addOption("Insert Node Here...",
-                                                {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_N},
+                                                KeyBind({KeyCode::KEY_N}, KeyModifier::KEY_CTRL),
                                                 [this](SelectionNodeInfo<Rail::RailNode> info) {
                                                     m_create_rail_dialog.open();
                                                     return Result<void>();
@@ -2044,7 +2046,7 @@ void SceneWindow::buildContextMenuRailNode() {
     m_rail_node_list_single_node_menu.addDivider();
 
     m_rail_node_list_single_node_menu.addOption(
-        "View in Scene", {KeyCode::KEY_LEFTALT, KeyCode::KEY_V},
+        "View in Scene", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_ALT),
         [this](SelectionNodeInfo<Rail::RailNode> info) {
             glm::vec3 translation = info.m_selected->getPosition();
 
@@ -2055,7 +2057,7 @@ void SceneWindow::buildContextMenuRailNode() {
         });
 
     m_rail_node_list_single_node_menu.addOption(
-        "Move to Camera", {KeyCode::KEY_LEFTALT, KeyCode::KEY_C},
+        "Move to Camera", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_ALT),
         [this](SelectionNodeInfo<Rail::RailNode> info) {
             RefPtr<Rail::Rail> rail =
                 m_current_scene->getRailData().getRail(info.m_selected->getRailUUID());
@@ -2076,7 +2078,7 @@ void SceneWindow::buildContextMenuRailNode() {
     m_rail_node_list_single_node_menu.addDivider();
 
     m_rail_node_list_single_node_menu.addOption(
-        "Copy", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C},
+        "Copy", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Rail::RailNode> info) {
             info.m_selected = make_deep_clone<Rail::RailNode>(info.m_selected);
             GUIApplication::instance().getSceneRailNodeClipboard().setData(info);
@@ -2084,7 +2086,7 @@ void SceneWindow::buildContextMenuRailNode() {
         });
 
     m_rail_node_list_single_node_menu.addOption(
-        "Paste", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V},
+        "Paste", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_CTRL),
         [this](SelectionNodeInfo<Rail::RailNode> info) {
             RefPtr<Rail::Rail> rail =
                 m_current_scene->getRailData().getRail(info.m_selected->getRailUUID());
@@ -2117,7 +2119,7 @@ void SceneWindow::buildContextMenuMultiRailNode() {
         ContextMenu<std::vector<SelectionNodeInfo<Rail::RailNode>>>();
 
     m_rail_node_list_multi_node_menu.addOption(
-        "Copy", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_C},
+        "Copy", KeyBind({KeyCode::KEY_C}, KeyModifier::KEY_CTRL),
         [this](std::vector<SelectionNodeInfo<Rail::RailNode>> info) {
             for (auto &select : info) {
                 select.m_selected = make_deep_clone<Rail::RailNode>(select.m_selected);
@@ -2127,7 +2129,7 @@ void SceneWindow::buildContextMenuMultiRailNode() {
         });
 
     m_rail_node_list_multi_node_menu.addOption(
-        "Paste", {KeyCode::KEY_LEFTCONTROL, KeyCode::KEY_V},
+        "Paste", KeyBind({KeyCode::KEY_V}, KeyModifier::KEY_CTRL),
         [this](std::vector<SelectionNodeInfo<Rail::RailNode>> info) {
             RefPtr<Rail::Rail> rail =
                 m_current_scene->getRailData().getRail(info[0].m_selected->getRailUUID());

From e5e5d1b5b31f88ea1bea782cbd87da0bafa077ea Mon Sep 17 00:00:00 2001
From: Alex Sanchez-Stern <alex.sanchezstern@gmail.com>
Date: Mon, 11 Nov 2024 18:56:39 -0800
Subject: [PATCH 129/129] Fix both file handling paths triggering on dialog
 close

---
 include/gui/application.hpp |  3 +--
 src/gui/application.cpp     | 30 ++++++++++++------------------
 2 files changed, 13 insertions(+), 20 deletions(-)

diff --git a/include/gui/application.hpp b/include/gui/application.hpp
index b9d882e5..e7cc51be 100644
--- a/include/gui/application.hpp
+++ b/include/gui/application.hpp
@@ -204,8 +204,7 @@ namespace Toolbox {
         bool m_dockspace_built;
 
         bool m_opening_options_window = false;
-        bool m_is_file_dialog_open    = false;
-        bool m_is_dir_dialog_open     = false;
+        bool m_browsing_dir = false;
 
         std::thread m_thread_templates_init;
         DolphinCommunicator m_dolphin_communicator;
diff --git a/src/gui/application.cpp b/src/gui/application.cpp
index 7638a37e..504add27 100644
--- a/src/gui/application.cpp
+++ b/src/gui/application.cpp
@@ -521,10 +521,18 @@ namespace Toolbox {
 
         if (ImGui::BeginMenu("File")) {
             if (ImGui::MenuItem(ICON_FK_FOLDER_OPEN " Open...")) {
-                m_is_file_dialog_open = true;
+                if (!FileDialog::instance()->isAlreadyOpen()) {
+                    FileDialogFilter filter;
+                    filter.addFilter("Nintendo Scene Archive", "szs,arc");
+                    FileDialog::instance()->openDialog(m_load_path, m_render_window, false, filter);
+                }
+                m_browsing_dir = false;
             }
             if (ImGui::MenuItem(ICON_FK_FOLDER_OPEN " Open Folder...")) {
-                m_is_dir_dialog_open = true;
+                m_browsing_dir = true;
+                if (!FileDialog::instance()->isAlreadyOpen()) {
+                    FileDialog::instance()->openDialog(m_load_path, m_render_window, true);
+                }
             }
 
             ImGui::Separator();
@@ -569,13 +577,7 @@ namespace Toolbox {
 
         ImGui::EndMainMenuBar();
 
-        if (m_is_dir_dialog_open) {
-            if (!FileDialog::instance()->isAlreadyOpen()) {
-                FileDialog::instance()->openDialog(m_load_path, m_render_window, true);
-            }
-            m_is_dir_dialog_open = false;
-        }
-        if (FileDialog::instance()->isDone()) {
+        if (FileDialog::instance()->isDone() && m_browsing_dir) {
             FileDialog::instance()->close();
             if (FileDialog::instance()->isOk()) {
                 std::filesystem::path selected_path = FileDialog::instance()->getFilenameResult();
@@ -591,15 +593,7 @@ namespace Toolbox {
             }
         }
 
-        if (m_is_file_dialog_open) {
-            if (!FileDialog::instance()->isAlreadyOpen()) {
-                FileDialogFilter filter;
-                filter.addFilter("Nintendo Scene Archive", "szs,arc");
-                FileDialog::instance()->openDialog(m_load_path, m_render_window, false, filter);
-            }
-            m_is_file_dialog_open = false;
-        }
-        if (FileDialog::instance()->isDone()) {
+        if (FileDialog::instance()->isDone() && !m_browsing_dir) {
             FileDialog::instance()->close();
             if (FileDialog::instance()->isOk()) {
                 std::filesystem::path selected_path = FileDialog::instance()->getFilenameResult();