diff --git a/GViewCore/include/GView.hpp b/GViewCore/include/GView.hpp
index 64a8bc96..8023826f 100644
--- a/GViewCore/include/GView.hpp
+++ b/GViewCore/include/GView.hpp
@@ -34,7 +34,7 @@ struct CORE_EXPORT TypeInterface {
 
     virtual std::string_view GetTypeName()                = 0;
     virtual void RunCommand(std::string_view commandName) = 0;
-    virtual ~TypeInterface(){};
+    virtual ~TypeInterface(){}
 
     struct SelectionZone {
         uint64 start, end;
diff --git a/GViewCore/src/App/AboutWindow.cpp b/GViewCore/src/App/AboutWindow.cpp
new file mode 100644
index 00000000..c36fec68
--- /dev/null
+++ b/GViewCore/src/App/AboutWindow.cpp
@@ -0,0 +1,38 @@
+#include "Internal.hpp"
+
+using namespace GView::App;
+using namespace AppCUI::Application;
+using namespace AppCUI::Controls;
+using namespace AppCUI::Input;
+using namespace AppCUI::Utils;
+
+class AboutWindow : public Window, public Handlers::OnButtonPressedInterface
+{
+    Reference<Button> closeButton;
+  public:
+    AboutWindow() : Window("About", "t:10,l:10,w:74,h:13", WindowFlags::Sizeable)
+    {
+        Factory::Label::Create(this, "GView is a cross-platform framework for reverse-engineering. Users can leverage the diverse range of available visualization options to effectively analyze and interpret the information.", "t:2,l:5,w:60");
+        Factory::Label::Create(this, "Users can leverage the diverse range of available visualization options to effectively analyze and interpret the information.", "t:3,l:5,w:64");
+        Factory::Label::Create(this, "options to effectively analyze and interpret the information.", "t:4,l:5,w:64");
+
+        Factory::Label::Create(this, "Read more on https://github.com/gdt050579/GView", "t:6,l:8,w:64");
+
+        Factory::Label::Create(this, "License: MIT", "t:8,l:25,w:64");
+        Factory::Label::Create(this, "Version: " GVIEW_VERSION, "t:9,l:25,w:64");
+
+        closeButton = Factory::Button::Create(this, "Close", "t:11,l:26,w:13", 100, ButtonFlags::Flat);
+        closeButton->Handlers()->OnButtonPressed = this;
+    }
+
+    void OnButtonPressed(Reference<Controls::Button> r) override
+    {
+        Exit();
+    }
+};
+
+void Instance::ShowAboutWindow()
+{
+    AboutWindow aboutWindow{};
+    aboutWindow.Show();
+}
\ No newline at end of file
diff --git a/GViewCore/src/App/CMakeLists.txt b/GViewCore/src/App/CMakeLists.txt
index b4478e15..a465dce5 100644
--- a/GViewCore/src/App/CMakeLists.txt
+++ b/GViewCore/src/App/CMakeLists.txt
@@ -6,4 +6,5 @@ target_sources(GViewCore PRIVATE
     Instance.cpp 
     SelectTypeDialog.cpp 
     TutorialWindow.cpp
+    AboutWindow.cpp
 )
\ No newline at end of file
diff --git a/GViewCore/src/App/GViewApp.cpp b/GViewCore/src/App/GViewApp.cpp
index b492d638..5d3bced9 100644
--- a/GViewCore/src/App/GViewApp.cpp
+++ b/GViewCore/src/App/GViewApp.cpp
@@ -73,7 +73,7 @@ bool GView::App::ResetConfiguration()
     GView::View::TextViewer::Config::Update(ini["View.Text"]);
     GView::View::ImageViewer::Config::Update(ini["View.Image"]);
     GView::View::GridViewer::Config::Update(ini["View.Grid"]);
-    GView::View::DissasmViewer::Config::Update(ini["DissasmView"]);
+    GView::View::DissasmViewer::Config::Update(ini["View.Dissasm"]);
     GView::View::LexicalViewer::Config::Update(ini["View.Lexical"]);
 
     // parse types and add specs
diff --git a/GViewCore/src/App/Instance.cpp b/GViewCore/src/App/Instance.cpp
index fc7310dc..48feee52 100644
--- a/GViewCore/src/App/Instance.cpp
+++ b/GViewCore/src/App/Instance.cpp
@@ -44,6 +44,8 @@ constexpr GViewMenuCommand menuHelpList[] = {
     { "&About", MenuCommands::ABOUT, Key::None },
 };
 
+constexpr ItemHandle menuHelpListDisabledCommandsList[] = { 0 };
+
 bool AddMenuCommands(Menu* mnu, const GViewMenuCommand* list, size_t count)
 {
     while (count > 0) {
@@ -125,6 +127,9 @@ bool Instance::BuildMainMenus()
     CHECK(AddMenuCommands(mnuWindow, menuWindowList, ARRAY_LEN(menuWindowList)), false, "");
     CHECK(mnuHelp = AppCUI::Application::AddMenu("&Help"), false, "Unable to create 'Help' menu");
     CHECK(AddMenuCommands(mnuHelp, menuHelpList, ARRAY_LEN(menuHelpList)), false, "");
+    for (auto itemHandle : menuHelpListDisabledCommandsList) {
+        CHECK(mnuHelp->SetEnable(itemHandle, false), false, "Fail to disable menu item");
+    }
     return true;
 }
 
@@ -552,6 +557,9 @@ bool Instance::OnEvent(Reference<Control> control, Event eventType, int ID)
         case MenuCommands::OPEN_FOLDER:
             OpenFolder();
             return true;
+        case MenuCommands::ABOUT:
+            ShowAboutWindow();
+            return true;
         }
         if ((ID >= GENERIC_PLUGINS_CMDID) && (ID < GENERIC_PLUGINS_CMDID + GENERIC_PLUGINS_FRAME * 1000)) {
             auto packedValue = ((uint32) ID) - GENERIC_PLUGINS_CMDID;
diff --git a/GViewCore/src/View/DissasmViewer/CMakeLists.txt b/GViewCore/src/View/DissasmViewer/CMakeLists.txt
index 61a657db..b6a20d67 100644
--- a/GViewCore/src/View/DissasmViewer/CMakeLists.txt
+++ b/GViewCore/src/View/DissasmViewer/CMakeLists.txt
@@ -15,6 +15,10 @@ target_sources(
 	AdvancedSelection.cpp
 	DissasmDataTypes.hpp
 	DissasmDataTypes.cpp
+	DissasmCodeZone.hpp
+	DissasmCodeZone.cpp
+	DissasmFunctionUtils.hpp
+	DissasmFunctionUtils.cpp
 
 	x86_x64/DissasmX86.hpp        
 	x86_x64/DissasmX86.cpp
diff --git a/GViewCore/src/View/DissasmViewer/Config.cpp b/GViewCore/src/View/DissasmViewer/Config.cpp
index 7b51e4ee..5fe8390f 100644
--- a/GViewCore/src/View/DissasmViewer/Config.cpp
+++ b/GViewCore/src/View/DissasmViewer/Config.cpp
@@ -55,13 +55,15 @@ void ColorManager::OnGainedFocus()
 
 void Config::Update(AppCUI::Utils::IniSection sect)
 {
+    LocalString<128> buffer;
     for (const auto& cmd : AllKeyboardCommands) {
-        sect.UpdateValue(cmd.get().Caption, cmd.get().Key, true);
+        buffer.SetFormat("Key.%s", cmd.get().Caption);
+        sect.UpdateValue(buffer.GetText(), cmd.get().Key, true);
     }
 
-    sect.UpdateValue("ShowFileContent", true, true);
-    sect.UpdateValue("ShowOnlyDissasm", false, true);
-    sect.UpdateValue("DeepScanDissasmOnStart", false, true);
+    sect.UpdateValue("Config.ShowFileContent", true, true);
+    sect.UpdateValue("Config.ShowOnlyDissasm", false, true);
+    sect.UpdateValue("Config.DeepScanDissasmOnStart", false, true);
 }
 void Config::Initialize()
 {
@@ -95,15 +97,15 @@ void Config::Initialize()
     bool foundSettings = false;
     auto ini           = AppCUI::Application::GetAppSettings();
     if (ini) {
-        auto sect = ini->GetSection("DissasmView");
+        auto sect = ini->GetSection("View.Dissasm");
         if (sect.Exists()) {
             for (auto& cmd : AllKeyboardCommands) {
                 cmd.get().Key = sect.GetValue(cmd.get().Caption).ToKey(cmd.get().Key);
             }
 
-            this->ShowFileContent              = sect.GetValue("ShowFileContent").ToBool(true);
-            this->ShowOnlyDissasm              = sect.GetValue("ShowOnlyDissasm").ToBool(false);
-            this->EnableDeepScanDissasmOnStart = sect.GetValue("DeepScanDissasmOnStart").ToBool(false);
+            this->ShowFileContent              = sect.GetValue("Config.ShowFileContent").ToBool(true);
+            this->ShowOnlyDissasm              = sect.GetValue("Config.ShowOnlyDissasm").ToBool(false);
+            this->EnableDeepScanDissasmOnStart = sect.GetValue("Config.DeepScanDissasmOnStart").ToBool(false);
             foundSettings                      = true;
         }
     }
diff --git a/GViewCore/src/View/DissasmViewer/Config.hpp b/GViewCore/src/View/DissasmViewer/Config.hpp
index e703615b..4729f651 100644
--- a/GViewCore/src/View/DissasmViewer/Config.hpp
+++ b/GViewCore/src/View/DissasmViewer/Config.hpp
@@ -28,11 +28,13 @@ constexpr int32 RIGHT_CLICK_CLEAR_SELECTION              = 7;
 constexpr int32 RIGHT_CLICK_DISSASM_COLLAPSE_ZONE        = 8;
 constexpr int32 RIGHT_CLICK_DISSASM_EXPAND_ZONE          = 9;
 
+constexpr int32 RIGHT_CLICK_CODE_ZONE_EDIT = 10;
+
 struct RightClickCommand {
     int commandID;
     std::string_view text;
     // Input::Key shortcutKey = Input::Key::None;
-    AppCUI::Controls::ItemHandle handle = AppCUI::Controls::InvalidItemHandle;
+    // AppCUI::Controls::ItemHandle handle = AppCUI::Controls::InvalidItemHandle;
 };
 
 inline RightClickCommand RIGHT_CLICK_MENU_COMMANDS[] = {
@@ -45,21 +47,20 @@ inline RightClickCommand RIGHT_CLICK_MENU_COMMANDS[] = {
 struct RightClickSubMenus {
     const char* name;
     std::vector<RightClickCommand> commands;
-    AppCUI::Controls::ItemHandle handle;
+    // AppCUI::Controls::ItemHandle handle;
 };
 
-inline RightClickSubMenus RIGHT_CLICK_SUB_MENUS_COMMANDS[] = { { "CollapsibleZone",
-                                                             {
-                                                                   { RIGHT_CLICK_MENU_CMD_NEW_COLLAPSE_ZONE, "Add collapse zone" },
-                                                                   { RIGHT_CLICK_DISSASM_REMOVE_COLLAPSE_ZONE, "Remove collapse zone" },
-                                                                   { RIGHT_CLICK_DISSASM_COLLAPSE_ZONE, "Collapse zone" },
-                                                                   { RIGHT_CLICK_DISSASM_EXPAND_ZONE, "Expand zone" },
-                                                             } },
-                                                           { "Comment",
-                                                             {
-                                                                   { RIGHT_CLICK_ADD_COMMENT, "Add comment" },
-                                                                   { RIGHT_CLICK_REMOVE_COMMENT, "Remove comment" },
-                                                             } } };
+const RightClickSubMenus RIGHT_CLICK_SUB_MENUS_COMMANDS[] = {
+    { "CollapsibleZone",
+      {
+            { RIGHT_CLICK_MENU_CMD_NEW_COLLAPSE_ZONE, "Add collapse zone" },
+            { RIGHT_CLICK_DISSASM_REMOVE_COLLAPSE_ZONE, "Remove collapse zone" },
+            { RIGHT_CLICK_DISSASM_COLLAPSE_ZONE, "Collapse zone" },
+            { RIGHT_CLICK_DISSASM_EXPAND_ZONE, "Expand zone" }
+      } },
+    { "Comment", { { RIGHT_CLICK_ADD_COMMENT, "Add comment" }, { RIGHT_CLICK_REMOVE_COMMENT, "Remove comment" } } },
+    { "CodeZone", { { RIGHT_CLICK_CODE_ZONE_EDIT, "Edit zone" } } }
+};
 
 namespace GView
 {
diff --git a/GViewCore/src/View/DissasmViewer/DissasmCodeZone.cpp b/GViewCore/src/View/DissasmViewer/DissasmCodeZone.cpp
new file mode 100644
index 00000000..b3012cd7
--- /dev/null
+++ b/GViewCore/src/View/DissasmViewer/DissasmCodeZone.cpp
@@ -0,0 +1,446 @@
+#include "DissasmCodeZone.hpp"
+#include "DissasmFunctionUtils.hpp"
+
+using namespace GView::View::DissasmViewer;
+
+constexpr size_t DISSASM_INSTRUCTION_OFFSET_MARGIN = 500;
+
+const uint8 HEX_MAPPER[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0, 0, 0,
+                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0, 0, 0,
+                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 15 };
+
+inline bool ExtractCallsToInsertFunctionNames(
+      vector<AsmOffsetLine>& offsets,
+      DissasmCodeZone* zone,
+      Reference<GView::Object> obj,
+      int internalArchitecture,
+      uint32& totalLines,
+      uint64 maxLocationMemoryMappingSize)
+{
+    csh handle;
+    const auto resCode = cs_open(CS_ARCH_X86, static_cast<cs_mode>(internalArchitecture), &handle);
+    if (resCode != CS_ERR_OK) {
+        // WriteErrorToScreen(dli, cs_strerror(resCode));
+        return false;
+    }
+
+    cs_insn* insn = cs_malloc(handle);
+
+    DisassemblyZone& zoneDetails = zone->zoneDetails;
+    const auto instructionData   = obj->GetData().Get(zoneDetails.startingZonePoint, static_cast<uint32>(zoneDetails.size), false);
+
+    uint32 linesToDecode = totalLines;
+    size_t size          = zoneDetails.size;
+    uint64 address       = offsets[0].offset - zoneDetails.startingZonePoint;
+    auto data            = instructionData.GetData() + address;
+
+    std::vector<std::pair<uint64, std::string>> callsFound;
+    std::unordered_map<uint64, bool> callsMap; // true for offset, false for sub
+    callsFound.reserve(16);
+    bool foundCall     = false;
+    uint64 callAddress = 0;
+    while (cs_disasm_iter(handle, &data, &size, &address, insn) && linesToDecode > 0) {
+        linesToDecode--;
+        const bool isJump = insn->mnemonic[0] == 'j';
+        if (*(uint32*) insn->mnemonic == callOP || isJump) {
+            uint64 value;
+            const bool foundValue = CheckExtractInsnHexValue(insn->op_str, value, maxLocationMemoryMappingSize);
+            if (foundValue && value < zoneDetails.startingZonePoint + zoneDetails.size) {
+                if (value < offsets[0].offset)
+                    value += offsets[0].offset;
+                const char* prefix = isJump ? "offset_0x" : "sub_0x";
+                const auto it      = callsMap.find(value);
+                if (it != callsMap.end()) {
+                    if (isJump == it->second)
+                        continue;
+                }
+                auto callName = FormatFunctionName(value, prefix);
+                callsFound.emplace_back(value, callName.GetText());
+                callsMap.insert({ value, isJump });
+            }
+        } else {
+            const auto mnemonicVal = *(uint32*) insn->mnemonic;
+            if (foundCall) {
+                if (mnemonicVal == movOP && strcmp(insn->op_str, "ebp, esp") == 0) {
+                    if (callAddress < offsets[0].offset)
+                        callAddress += offsets[0].offset;
+                    const auto it = callsMap.find(callAddress);
+                    if (it != callsMap.end()) {
+                        if (!it->second)
+                            continue;
+                    }
+                    const char* prefix = "sub_0x";
+                    auto callName      = FormatFunctionName(callAddress, prefix);
+                    callsFound.emplace_back(callAddress, callName.GetText());
+                    callsMap.insert({ callAddress, true });
+                }
+                foundCall = false;
+            } else {
+                if (mnemonicVal == pushOP) {
+                    if (strcmp(insn->op_str, "ebp") == 0) {
+                        callAddress = insn->address;
+                        foundCall   = true;
+                    }
+                }
+            }
+        }
+    }
+
+    auto val = callsFound[0].first;
+
+    enum labelType { SUB, OFFSET, OTHER };
+    auto getLabelType = [](const std::string& s) -> labelType {
+        assert(!s.empty());
+        if (s.size() < 4)
+            return OTHER;
+        if (memcmp(s.c_str(), "sub_", 4) == 0)
+            return SUB;
+        if (s.size() < 7)
+            return OTHER;
+        if (memcmp(s.c_str(), "offset_", 7) == 0)
+            return OFFSET;
+        return OTHER;
+    };
+
+    std::vector<uint32> indexesToErase;
+    for (int32 i = static_cast<int32>(callsFound.size()) - 1; i >= 0; i--) {
+        const auto& call = callsFound[i];
+        if (call.first == zone->zoneDetails.entryPoint) {
+            indexesToErase.push_back(i);
+            break;
+        }
+    }
+    for (const auto indexToErase : indexesToErase)
+        callsFound.erase(callsFound.begin() + indexToErase);
+
+    callsFound.emplace_back(zone->zoneDetails.entryPoint, "EntryPoint");
+    // TODO: this can be extracted for the user to add / delete its own operations
+    std::sort(callsFound.begin(), callsFound.end(), [getLabelType](const auto& a, const auto& b) {
+        if (a.first < b.first)
+            return true;
+        if (a.first > b.first)
+            return false;
+        return getLabelType(a.second) < getLabelType(b.second);
+
+        // return a.second.compare(b.second) > 0; // move sub instructions first
+    });
+
+    // TODO: if there are missing called improve predicate to delele only sub and offset
+    callsFound.erase(
+          std::unique(callsFound.begin(), callsFound.end(), [](const auto& left, const auto& right) { return left.first == right.first; }), callsFound.end());
+
+    // callsFound.push_back({ 1030, "call2" });
+    // callsFound.push_back({ 1130, "call 3" });
+    // callsFound.push_back({ 1140, "call 5" });
+    uint32 extraLines = 0;
+    for (const auto& call : callsFound) {
+        const uint64 callValue = call.first;
+        uint32 diffLines       = 0;
+        auto callInsn          = GetCurrentInstructionByOffset(callValue, zone, obj, diffLines);
+        if (callInsn) {
+            zone->dissasmType.annotations.insert({ diffLines + extraLines, { call.second, callValue - offsets[0].offset } });
+            cs_free(callInsn, 1);
+            extraLines++;
+        }
+    }
+    totalLines += static_cast<uint32>(callsFound.size());
+    cs_free(insn, 1);
+    cs_close(&handle);
+
+    return true;
+}
+
+inline bool populateOffsetsVector(
+      vector<AsmOffsetLine>& offsets, DisassemblyZone& zoneDetails, GView::Object& obj, int internalArchitecture, uint32& totalLines)
+{
+    csh handle;
+    const auto resCode = cs_open(CS_ARCH_X86, static_cast<cs_mode>(internalArchitecture), &handle);
+    if (resCode != CS_ERR_OK) {
+        // WriteErrorToScreen(dli, cs_strerror(resCode));
+        return false;
+    }
+
+    const auto instructionData = obj.GetData().Get(zoneDetails.startingZonePoint, static_cast<uint32>(zoneDetails.size), false);
+
+    if (offsets.empty()) {
+        offsets.reserve(256);
+        offsets.push_back({ zoneDetails.entryPoint, 0 });
+    }
+
+    size_t minimalValue = offsets[0].offset;
+
+    cs_insn* insn     = cs_malloc(handle);
+    size_t lastOffset = offsets[0].offset;
+
+    constexpr uint32 addInstructionsStop = 30; // TODO: update this -> for now it stops, later will fold
+
+    std::list<uint64> finalOffsets;
+
+    size_t size       = zoneDetails.startingZonePoint + zoneDetails.size;
+    uint64 address    = zoneDetails.entryPoint - zoneDetails.startingZonePoint;
+    uint64 endAddress = zoneDetails.size;
+
+    if (address >= endAddress) {
+        cs_close(&handle);
+        return false;
+    }
+
+    auto data = instructionData.GetData() + address;
+
+    // std::string saved1 = "s1", saved2 = "s2";
+    uint64 startingOffset = offsets[0].offset;
+
+    size_t lastSize = size;
+    // std::vector<uint64> tempStorage;
+    // tempStorage.push_back(lastOffset);
+
+    do {
+        if (size > lastSize) {
+            lastSize = size;
+            // tempStorage.reserve(size / DISSASM_INSTRUCTION_OFFSET_MARGIN + 1);
+        }
+
+        while (address < endAddress) {
+            if (!cs_disasm_iter(handle, &data, &size, &address, insn))
+                break;
+
+            if ((insn->mnemonic[0] == 'j' || *(uint32*) insn->mnemonic == callOP)) // && insn->op_str[0] == '0' /* && insn->op_str[1] == 'x'*/)
+            {
+                uint64 computedValue = 0;
+                if (insn->op_str[1] == 'x') {
+                    // uint64 computedValue = 0;
+                    char* ptr = &insn->op_str[2];
+                    // TODO: also check not to overflow access!
+                    while (*ptr && *ptr != ' ' && *ptr != ',') {
+                        if (!(*ptr >= 'a' && *ptr <= 'f' || *ptr >= '0' && *ptr <= '9')) {
+                            computedValue = 0;
+                            break;
+                        }
+                        computedValue = computedValue * 16 + HEX_MAPPER[static_cast<uint8>(*ptr)];
+                        ptr++;
+                    }
+                } else {
+                    char* ptr = &insn->op_str[0];
+                    while (*ptr && *ptr != ' ' && *ptr != ',') {
+                        if (*ptr < '0' || *ptr > '9') {
+                            computedValue = 0;
+                            break;
+                        }
+                        computedValue = computedValue * 10 + (static_cast<uint8>(*ptr) - '0');
+                        ptr++;
+                    }
+                    if (computedValue < zoneDetails.startingZonePoint)
+                        computedValue += zoneDetails.startingZonePoint;
+                    // if (insn->op_str[1] == '\0') {
+                    //     computedValue = zoneDetails.startingZonePoint;
+                    // }
+                }
+
+                if (computedValue < minimalValue && computedValue >= zoneDetails.startingZonePoint) {
+                    minimalValue = computedValue;
+                    // saved1       = insn->mnemonic;
+                    // saved2       = insn->op_str;
+                }
+            }
+            const size_t adjustedSize = address + zoneDetails.startingZonePoint;
+            if (adjustedSize - lastOffset >= DISSASM_INSTRUCTION_OFFSET_MARGIN) {
+                lastOffset = adjustedSize;
+            }
+        }
+        if (minimalValue >= startingOffset)
+            break;
+
+        // pushBack                       = false;
+        const size_t zoneSizeToAnalyze = startingOffset - minimalValue;
+        // finalOffsets.push_front(minimalValue);
+
+        address        = minimalValue - zoneDetails.startingZonePoint;
+        endAddress     = zoneSizeToAnalyze + address;
+        size           = address + zoneSizeToAnalyze;
+        data           = instructionData.GetData() + address;
+        lastOffset     = minimalValue;
+        startingOffset = minimalValue;
+    } while (true);
+
+    size       = zoneDetails.size;
+    address    = minimalValue - zoneDetails.startingZonePoint;
+    data       = instructionData.GetData() + address;
+    lastOffset = address;
+
+    uint32 lineIndex = 0;
+    offsets.clear();
+    offsets.push_back({ minimalValue, 0 });
+
+    constexpr uint32 alOpStr         = 7102752u; //* (uint32*) " al";
+    uint32 continuousAddInstructions = 0;
+
+    while (cs_disasm_iter(handle, &data, &size, &address, insn)) {
+        lineIndex++;
+        if (address - lastOffset >= DISSASM_INSTRUCTION_OFFSET_MARGIN) {
+            lastOffset                = address;
+            const size_t adjustedSize = address + zoneDetails.startingZonePoint;
+            offsets.push_back({ adjustedSize, lineIndex });
+        }
+
+        if (*(uint32*) insn->mnemonic == addOP && insn->op_str[0] == 'b' && *(uint32*) &insn->op_str[15] == alOpStr) {
+            if (++continuousAddInstructions == addInstructionsStop) {
+                lineIndex -= continuousAddInstructions;
+                break;
+            }
+        } else
+            continuousAddInstructions = 0;
+    }
+
+    totalLines = lineIndex;
+    cs_free(insn, 1);
+    cs_close(&handle);
+    return true;
+}
+
+bool GView::View::DissasmViewer::DissasmCodeZone::InitZone(DissasmCodeZoneInitData& initData)
+{
+    // TODO: move this on init
+    if (!cs_support(CS_ARCH_X86)) {
+        initData.dli->WriteErrorToScreen("Capstone does not support X86");
+        initData.adjustedZoneSize = 1;
+        initData.hasAdjustedSize  = true;
+        return false;
+    }
+
+    switch (zoneDetails.language) {
+    case DisassemblyLanguage::x86:
+        internalArchitecture = CS_MODE_32;
+        break;
+    case DisassemblyLanguage::x64:
+        internalArchitecture = CS_MODE_64;
+        break;
+    default: {
+        initData.dli->WriteErrorToScreen("ERROR: unsupported language!");
+        return false;
+    }
+    }
+
+    uint32 totalLines = 0;
+    if (!populateOffsetsVector(cachedCodeOffsets, zoneDetails, initData.obj, internalArchitecture, totalLines)) {
+        initData.dli->WriteErrorToScreen("ERROR: failed to populate offsets vector!");
+        return false;
+    }
+    if (initData.enableDeepScanDissasmOnStart &&
+        !ExtractCallsToInsertFunctionNames(cachedCodeOffsets, this, initData.obj, internalArchitecture, totalLines, initData.maxLocationMemoryMappingSize)) {
+        initData.dli->WriteErrorToScreen("ERROR: failed to populate offsets vector!");
+        return false;
+    }
+    totalLines++; //+1 for title
+    initData.adjustedZoneSize = totalLines;
+    initData.hasAdjustedSize  = true;
+    // AdjustZoneExtendedSize(zone, totalLines);
+    lastDrawnLine          = 0;
+    const auto closestData = SearchForClosestAsmOffsetLineByLine(cachedCodeOffsets, lastDrawnLine);
+    lastClosestLine        = closestData.line;
+    isInit                 = true;
+
+    asmAddress = 0;
+    asmSize    = zoneDetails.size - asmAddress;
+
+    const auto instructionData = initData.obj->GetData().Get(cachedCodeOffsets[0].offset + asmAddress, static_cast<uint32>(asmSize), false);
+    lastData                   = instructionData;
+    if (!instructionData.IsValid()) {
+        initData.dli->WriteErrorToScreen("ERROR: extract valid data from file!");
+        return false;
+    }
+    asmData = const_cast<uint8*>(instructionData.GetData());
+
+    const uint32 preReverseSize = std::min<uint32>(initData.visibleRows, extendedSize);
+    asmPreCacheData.cachedAsmLines.reserve(preReverseSize);
+
+    structureIndex = 0;
+    types.push_back(dissasmType);
+    levels.push_back(0);
+
+    dissasmType.indexZoneStart = 0; //+1 for the title
+    dissasmType.indexZoneEnd   = totalLines + 1;
+    // dissasmType.annotations.insert({ 2, "loc fn" });
+
+    return true;
+}
+
+void DissasmCodeZone::ReachZoneLine(uint32 line)
+{
+    changedLevel = false;
+    if (lastReachedLine == line)
+        return;
+
+    const uint32 levelToReach = line;
+    uint32& levelNow          = this->structureIndex;
+    bool reAdapt              = false;
+    while (true) {
+        const DissasmCodeInternalType& currentType = types.back();
+        if (currentType.indexZoneStart <= levelToReach && levelToReach < currentType.indexZoneEnd) {
+            if (!currentType.internalTypes.empty())
+                reAdapt = true;
+            break;
+        }
+        types.pop_back();
+        levels.pop_back();
+        reAdapt = true;
+    }
+
+    while (reAdapt && !types.back().get().internalTypes.empty()) {
+        DissasmCodeInternalType& currentType = types.back();
+        for (uint32 i = 0; i < currentType.internalTypes.size(); i++) {
+            auto& internalType = currentType.internalTypes[i];
+            if (internalType.indexZoneStart <= levelToReach && levelToReach < internalType.indexZoneEnd) {
+                types.emplace_back(internalType);
+                levels.push_back(i);
+                changedLevel                   = true;
+                newLevelChangeData.hasName     = !internalType.name.empty();
+                newLevelChangeData.isCollapsed = internalType.isCollapsed;
+                break;
+            }
+        }
+    }
+
+    DissasmCodeInternalType& currentType = types.back();
+    // TODO: do a faster search using a binary search using the annotations and start from there
+    // TODO: maybe use some caching here?
+    if (reAdapt || levelNow < levelToReach && levelNow + 1 != levelToReach || levelNow > levelToReach && levelNow - 1 != levelToReach) {
+        currentType.textLinesPassed = 0;
+        currentType.asmLinesPassed  = 0;
+        for (uint32 i = currentType.indexZoneStart; i <= levelToReach; i++) {
+            if (currentType.annotations.contains(i)) {
+                currentType.textLinesPassed++;
+                continue;
+            }
+            currentType.asmLinesPassed++;
+        }
+    } else {
+        if (currentType.annotations.contains(levelToReach))
+            currentType.textLinesPassed++;
+        else
+            currentType.asmLinesPassed++;
+    }
+
+    levelNow        = levelToReach;
+    lastReachedLine = levelToReach;
+
+    // if (currentType.annotations.contains(levelToReach))
+    //     return {};
+
+    // const uint32 value = currentType.GetCurrentAsmLine();
+    // if (value == 0)
+    //     return {};
+
+    // return value - 1u;
+}
+
+bool DissasmCodeZone::ResetTypesReferenceList()
+{
+    types.clear();
+    levels.clear();
+    structureIndex  = 0;
+    lastReachedLine = static_cast<uint32>(-1);
+    types.emplace_back(dissasmType);
+    levels.push_back(0);
+    ResetZoneCaching();
+    return true;
+}
\ No newline at end of file
diff --git a/GViewCore/src/View/DissasmViewer/DissasmCodeZone.hpp b/GViewCore/src/View/DissasmViewer/DissasmCodeZone.hpp
new file mode 100644
index 00000000..2314ab8f
--- /dev/null
+++ b/GViewCore/src/View/DissasmViewer/DissasmCodeZone.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "DissasmViewer.hpp"
+
+namespace GView::View::DissasmViewer
+{
+
+struct DissasmCodeZone : public ParseZone {
+    enum class CollapseExpandType : uint8 { Collapse, Expand, NegateCurrentState };
+    uint32 lastDrawnLine; // optimization not to recompute buffer every time
+    uint32 lastClosestLine;
+    uint32 offsetCacheMaxLine;
+    BufferView lastData;
+    uint32 lastReachedLine = -1u;
+
+    // fields only for dissasmx86/x64
+    const uint8* asmData;
+    uint64 asmSize, asmAddress;
+
+    uint32 structureIndex;
+    std::list<std::reference_wrapper<DissasmCodeInternalType>> types;
+    std::list<uint32> levels;
+    DissasmCodeInternalType dissasmType;
+
+    DissasmAsmPreCacheData asmPreCacheData;
+
+    std::vector<AsmOffsetLine> cachedCodeOffsets;
+    DisassemblyZone zoneDetails;
+    int internalArchitecture; // used for dissasm libraries
+    bool isInit;
+    bool changedLevel;
+    InternalTypeNewLevelChangeData newLevelChangeData;
+
+    void ResetZoneCaching();
+    bool AddCollapsibleZone(uint32 zoneLineStart, uint32 zoneLineEnd);
+    bool CanAddNewZone(uint32 zoneLineStart, uint32 zoneLineEnd) const
+    {
+        if (zoneLineStart > zoneLineEnd || zoneLineEnd > dissasmType.indexZoneEnd)
+            return false;
+        return dissasmType.CanAddNewZone(zoneLineStart, zoneLineEnd);
+    }
+    bool CollapseOrExtendZone(uint32 zoneLine, CollapseExpandType collapse, int32& difference);
+    bool RemoveCollapsibleZone(uint32 zoneLine);
+
+    bool InitZone(DissasmCodeZoneInitData& initData);
+    void ReachZoneLine(uint32 line);
+
+    bool ResetTypesReferenceList();
+    bool TryRenameLine(uint32 line);
+
+    bool GetComment(uint32 line, std::string& comment);
+    bool AddOrUpdateComment(uint32 line, const std::string& comment, bool showErr = true);
+    bool RemoveComment(uint32 line, bool showErr = true);
+    DissasmAsmPreCacheLine GetCurrentAsmLine(uint32 currentLine, Reference<GView::Object> obj, DissasmInsnExtractLineParams* params);
+};
+
+} // namespace GView::View::DissasmViewer
diff --git a/GViewCore/src/View/DissasmViewer/DissasmFunctionUtils.cpp b/GViewCore/src/View/DissasmViewer/DissasmFunctionUtils.cpp
new file mode 100644
index 00000000..0a362103
--- /dev/null
+++ b/GViewCore/src/View/DissasmViewer/DissasmFunctionUtils.cpp
@@ -0,0 +1,228 @@
+
+#include "DissasmCodeZone.hpp"
+#include "DissasmFunctionUtils.hpp"
+using namespace GView::View::DissasmViewer;
+using namespace AppCUI::Input;
+
+// TODO: maybe add also minimum number?
+bool CheckExtractInsnHexValue(const char* op_str, uint64& value, uint64 maxSize)
+{
+    const char* ptr     = op_str;
+    const char* start   = nullptr;
+    uint32 size         = 0;
+    bool insideBrackets = false;
+
+    auto checkValidSequence = [&ptr, &insideBrackets]() -> bool {
+        while (ptr && *ptr != '\0') {
+            if (*ptr == ' ' || *ptr == '[' || *ptr >= 'a' && *ptr <= 'z' || *ptr >= 'A' && *ptr <= 'Z') {
+                if (*ptr == '[') {
+                    if (insideBrackets)
+                        return false;
+                    insideBrackets = true;
+                }
+                ptr++;
+                continue;
+            }
+            if (*ptr >= '0' && *ptr <= '9') {
+                break;
+            }
+            return false;
+        }
+        return true;
+    };
+
+    if (!checkValidSequence())
+        return false;
+
+    // while (ptr && *ptr != '\0') {
+    //     if (*ptr == ' ' || *ptr == '[' || *ptr >= 'a' && *ptr <= 'z' || *ptr >= 'A' && *ptr <= 'Z') {
+    //         if (*ptr == '[') {
+    //             if (insideBrackets)
+    //                 return false;
+    //             insideBrackets = true;
+    //         }
+    //         ptr++;
+    //         continue;
+    //     }
+    //     if (*ptr >= '0' && *ptr <= '9') {
+    //         break;
+    //     }
+    //     return false;
+    // }
+
+    bool is_hex = false;
+    while (ptr && *ptr != '\0') {
+        if (!start) {
+            if (*ptr == '0') // not hex
+            {
+                ptr++;
+                if (!ptr || *ptr != 'x') {
+                    start = ptr - 1;
+                    size  = 1;
+                    continue;
+                }
+                ptr++;
+                start  = ptr;
+                is_hex = true;
+                continue;
+            } else {
+                is_hex = false;
+                start  = ptr;
+                continue;
+            }
+        } else {
+            if (*ptr >= '0' && *ptr <= '9' || *ptr >= 'a' && *ptr <= 'f') {
+                size++;
+            } else {
+                if (size < maxSize - 2)
+                    return false;
+                break;
+            }
+        }
+        ptr++;
+    }
+
+    if (insideBrackets) {
+        if (!ptr)
+            return false;
+        if (*ptr != ']')
+            return false;
+        ptr++;
+    }
+
+    if (maxSize < size) {
+        const uint32 diff = size - static_cast<uint32>(maxSize);
+        size -= diff;
+        start += diff;
+    }
+
+    if (!size || !start)
+        return false;
+
+    if (size < 2) {
+        ptr = !is_hex ? op_str : op_str + 2;
+        while (ptr && *ptr != '\0') {
+            if (!(*ptr >= '0' && *ptr <= '9' || *ptr >= 'a' && *ptr <= 'f'))
+                return false;
+            ptr++;
+        }
+    }
+
+    if (!checkValidSequence())
+        return false;
+
+    const NumberParseFlags numberFlags = is_hex ? NumberParseFlags::Base16 : NumberParseFlags::Base10;
+    const auto sv                      = std::string_view(start, size);
+    const auto converted               = Number::ToUInt64(sv, numberFlags);
+    if (!converted.has_value())
+        return false;
+
+    value = converted.value();
+
+    return true;
+}
+
+LocalString<64> FormatFunctionName(uint64 functionAddress, const char* prefix)
+{
+    NumericFormatter formatter;
+    auto sv = formatter.ToHex(functionAddress);
+    LocalString<64> callName;
+    callName.AddFormat("%s%09s", prefix, sv.data());
+    return callName;
+}
+
+AsmOffsetLine SearchForClosestAsmOffsetLineByOffset(const std::vector<AsmOffsetLine>& values, uint64 searchedOffset)
+{
+    assert(!values.empty());
+    uint32 left  = 0;
+    uint32 right = static_cast<uint32>(values.size()) - 1u;
+    while (left < right) {
+        const uint32 mid = (left + right) / 2;
+        if (searchedOffset == values[mid].offset)
+            return values[mid];
+        if (searchedOffset < values[mid].offset)
+            right = mid - 1;
+        else
+            left = mid + 1;
+    }
+    if (left > 0 && values[left].offset > searchedOffset)
+        return values[left - 1];
+
+    return values[left];
+}
+
+cs_insn* GetCurrentInstructionByOffset(
+      uint64 offsetToReach, DissasmCodeZone* zone, Reference<GView::Object> obj, uint32& diffLines, DrawLineInfo* dli)
+{
+    const auto closestData = SearchForClosestAsmOffsetLineByOffset(zone->cachedCodeOffsets, offsetToReach);
+    zone->lastClosestLine  = closestData.line;
+    zone->asmAddress       = closestData.offset - zone->cachedCodeOffsets[0].offset;
+    zone->asmSize          = zone->zoneDetails.size - zone->asmAddress;
+
+    // TODO: maybe get less data ?
+    const auto instructionData = obj->GetData().Get(zone->cachedCodeOffsets[0].offset + zone->asmAddress, static_cast<uint32>(zone->asmSize), false);
+    zone->lastData             = instructionData;
+    if (!instructionData.IsValid()) {
+        if (dli)
+            dli->WriteErrorToScreen("ERROR: extract valid data from file!");
+        diffLines = UINT32_MAX;
+        return nullptr;
+    }
+
+    zone->asmData = const_cast<uint8*>(zone->lastData.GetData());
+
+    // TODO: keep the handle open and insn open until the program ends
+    csh handle;
+    const auto resCode = cs_open(CS_ARCH_X86, static_cast<cs_mode>(zone->internalArchitecture), &handle);
+    if (resCode != CS_ERR_OK) {
+        if (dli)
+            dli->WriteErrorToScreen(cs_strerror(resCode));
+        cs_close(&handle);
+        return nullptr;
+    }
+
+    diffLines     = 0;
+    cs_insn* insn = cs_malloc(handle);
+    if (offsetToReach >= zone->cachedCodeOffsets[0].offset)
+        offsetToReach -= zone->cachedCodeOffsets[0].offset;
+    while (zone->asmAddress <= offsetToReach) {
+        if (!cs_disasm_iter(handle, &zone->asmData, (size_t*) &zone->asmSize, &zone->asmAddress, insn)) {
+            if (dli)
+                dli->WriteErrorToScreen("Failed to dissasm!");
+            cs_free(insn, 1);
+            cs_close(&handle);
+            return nullptr;
+        }
+        diffLines++;
+    }
+    diffLines += closestData.line - 1;
+    cs_close(&handle);
+    return insn;
+}
+
+AsmOffsetLine SearchForClosestAsmOffsetLineByLine(const std::vector<AsmOffsetLine>& values, uint64 searchedLine, uint32* index)
+{
+    assert(!values.empty());
+    uint32 left  = 0;
+    uint32 right = static_cast<uint32>(values.size()) - 1u;
+    while (left < right) {
+        const uint32 mid = (left + right) / 2;
+        if (searchedLine == values[mid].line) {
+            if (index)
+                *index = mid;
+            return values[mid];
+        }
+        if (searchedLine < values[mid].line)
+            right = mid - 1;
+        else
+            left = mid + 1;
+    }
+    if (left > 0 && values[left].line > searchedLine) {
+        if (index)
+            *index = left - 1;
+        return values[left - 1];
+    }
+    if (index)
+        *index = left;
+    return values[left];
+}
\ No newline at end of file
diff --git a/GViewCore/src/View/DissasmViewer/DissasmFunctionUtils.hpp b/GViewCore/src/View/DissasmViewer/DissasmFunctionUtils.hpp
new file mode 100644
index 00000000..b1ee4351
--- /dev/null
+++ b/GViewCore/src/View/DissasmViewer/DissasmFunctionUtils.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include "AppCUI/include/AppCUI.hpp"
+#include "Internal.hpp"
+
+constexpr uint32 callOP = 1819042147u; //*(uint32*) "call";
+constexpr uint32 addOP  = 6579297u;    //*((uint32*) "add");
+constexpr uint32 pushOP = 1752397168u; //*((uint32*) "push");
+constexpr uint32 movOP  = 7761773u;    //*((uint32*) "mov");
+
+// TODO: maybe add also minimum number?
+bool CheckExtractInsnHexValue(const char* op_str, AppCUI::uint64& value, AppCUI::uint64 maxSize);
+AppCUI::Utils::LocalString<64> FormatFunctionName(AppCUI::uint64 functionAddress, const char* prefix);
+
+cs_insn* GetCurrentInstructionByOffset(
+      uint64 offsetToReach,
+      GView::View::DissasmViewer::DissasmCodeZone* zone,
+      Reference<GView::Object> obj,
+      uint32& diffLines,
+      GView::View::DissasmViewer::DrawLineInfo* dli = nullptr);
+
+GView::View::DissasmViewer::AsmOffsetLine SearchForClosestAsmOffsetLineByLine(const std::vector<GView::View::DissasmViewer::AsmOffsetLine>& values, uint64 searchedLine, uint32* index = nullptr);
\ No newline at end of file
diff --git a/GViewCore/src/View/DissasmViewer/DissasmKeyEvents.cpp b/GViewCore/src/View/DissasmViewer/DissasmKeyEvents.cpp
index 1812b1fe..0ecd8be3 100644
--- a/GViewCore/src/View/DissasmViewer/DissasmKeyEvents.cpp
+++ b/GViewCore/src/View/DissasmViewer/DissasmKeyEvents.cpp
@@ -295,6 +295,9 @@ bool Instance::OnEvent(Reference<Control>, Event eventType, int ID)
         case RIGHT_CLICK_ADD_COMMENT:
             AddComment();
             return true;
+        case RIGHT_CLICK_CODE_ZONE_EDIT:
+            EditDissasmCodeZoneCommand();
+            return true;
         case RIGHT_CLICK_REMOVE_COMMENT:
             RemoveComment();
             return true;
diff --git a/GViewCore/src/View/DissasmViewer/DissasmViewer.hpp b/GViewCore/src/View/DissasmViewer/DissasmViewer.hpp
index 893ee691..f29345a3 100644
--- a/GViewCore/src/View/DissasmViewer/DissasmViewer.hpp
+++ b/GViewCore/src/View/DissasmViewer/DissasmViewer.hpp
@@ -107,6 +107,7 @@ namespace View
             uint32 line;
         };
 
+        struct DissasmCodeZone;
         struct DissasmInsnExtractLineParams {
             Reference<GView::Object> obj;
             uint32 asmLine;
@@ -369,55 +370,6 @@ namespace View
             bool isCollapsed;
         };
 
-        struct DissasmCodeZone : public ParseZone {
-            enum class CollapseExpandType : uint8 { Collapse, Expand, NegateCurrentState };
-            uint32 lastDrawnLine; // optimization not to recompute buffer every time
-            uint32 lastClosestLine;
-            uint32 offsetCacheMaxLine;
-            BufferView lastData;
-            uint32 lastReachedLine = -1u;
-
-            //fields only for dissasmx86/x64
-            const uint8* asmData;
-            uint64 asmSize, asmAddress;
-
-            uint32 structureIndex;
-            std::list<std::reference_wrapper<DissasmCodeInternalType>> types;
-            std::list<uint32> levels;
-            DissasmCodeInternalType dissasmType;
-
-            DissasmAsmPreCacheData asmPreCacheData;
-
-            std::vector<AsmOffsetLine> cachedCodeOffsets;
-            DisassemblyZone zoneDetails;
-            int internalArchitecture; // used for dissasm libraries
-            bool isInit;
-            bool changedLevel;
-            InternalTypeNewLevelChangeData newLevelChangeData;
-
-            void ResetZoneCaching();
-            bool AddCollapsibleZone(uint32 zoneLineStart, uint32 zoneLineEnd);
-            bool CanAddNewZone(uint32 zoneLineStart, uint32 zoneLineEnd) const
-            {
-                if (zoneLineStart > zoneLineEnd || zoneLineEnd > dissasmType.indexZoneEnd)
-                    return false;
-                return dissasmType.CanAddNewZone(zoneLineStart, zoneLineEnd);
-            }
-            bool CollapseOrExtendZone(uint32 zoneLine, CollapseExpandType collapse, int32& difference);
-            bool RemoveCollapsibleZone(uint32 zoneLine);
-
-            bool InitZone(DissasmCodeZoneInitData& initData);
-            void ReachZoneLine(uint32 line);
-
-            bool ResetTypesReferenceList();
-            bool TryRenameLine(uint32 line);
-
-            bool GetComment(uint32 line, std::string& comment);
-            bool AddOrUpdateComment(uint32 line, const std::string& comment, bool showErr = true);
-            bool RemoveComment(uint32 line, bool showErr = true);
-            DissasmAsmPreCacheLine GetCurrentAsmLine(uint32 currentLine, Reference<GView::Object> obj, DissasmInsnExtractLineParams* params);
-        };
-
         struct MemoryMappingEntry {
             std::string name;
             MemoryMappingType type;
@@ -657,6 +609,8 @@ namespace View
             void CommandExecuteCollapsibleZoneOperation(CollapsibleZoneOperation operation);
             void DissasmZoneProcessSpaceKey(DissasmCodeZone* zone, uint32 line, uint64* offsetToReach = nullptr);
 
+            void EditDissasmCodeZoneCommand();
+
           public:
             Instance(Reference<GView::Object> obj, Settings* settings);
             virtual ~Instance() override;
diff --git a/GViewCore/src/View/DissasmViewer/Instance.cpp b/GViewCore/src/View/DissasmViewer/Instance.cpp
index 97e02860..26335667 100644
--- a/GViewCore/src/View/DissasmViewer/Instance.cpp
+++ b/GViewCore/src/View/DissasmViewer/Instance.cpp
@@ -1,6 +1,7 @@
 #include <array>
 
 #include "DissasmViewer.hpp"
+#include "DissasmCodeZone.hpp"
 
 #include <stdarg.h>
 #include <stdio.h>
@@ -89,16 +90,18 @@ Instance::Instance(Reference<GView::Object> obj, Settings* _settings)
 
     this->codePage = CodePageID::DOS_437;
 
-    for (auto& submenu : RIGHT_CLICK_SUB_MENUS_COMMANDS) {
-        submenu.handle = rightClickMenu.AddSubMenu(submenu.name);
-        auto subMenu   = rightClickMenu.GetSubMenu(submenu.handle);
-        for (auto& command : submenu.commands) {
-            command.handle = subMenu->AddCommandItem(command.text, command.commandID);
+    for (const auto& submenu : RIGHT_CLICK_SUB_MENUS_COMMANDS) {
+        assert(submenu.name);
+        const auto handle = rightClickMenu.AddSubMenu(submenu.name);
+        auto subMenu      = rightClickMenu.GetSubMenu(handle);
+        for (const auto& command : submenu.commands) {
+            assert(!command.text.empty());
+            subMenu->AddCommandItem(command.text, command.commandID);
         }
     }
 
     for (auto& menu_command : RIGHT_CLICK_MENU_COMMANDS) {
-        menu_command.handle = rightClickMenu.AddCommandItem(menu_command.text, menu_command.commandID);
+        rightClickMenu.AddCommandItem(menu_command.text, menu_command.commandID);
     }
     // rightClickOffset = 0;
 
diff --git a/GViewCore/src/View/DissasmViewer/jclass/DissasmJClass.cpp b/GViewCore/src/View/DissasmViewer/jclass/DissasmJClass.cpp
index e87bcd7a..d9a05eec 100644
--- a/GViewCore/src/View/DissasmViewer/jclass/DissasmJClass.cpp
+++ b/GViewCore/src/View/DissasmViewer/jclass/DissasmJClass.cpp
@@ -1,5 +1,6 @@
 #include "class_parser.hpp"
 #include "DissasmViewer.hpp"
+#include "DissasmCodeZone.hpp"
 
 using namespace GView::View::DissasmViewer;
 using namespace GView::View::DissasmViewer::JClass;
diff --git a/GViewCore/src/View/DissasmViewer/tests_dissasmviewer.cpp b/GViewCore/src/View/DissasmViewer/tests_dissasmviewer.cpp
index 4d8febf1..bfa2f859 100644
--- a/GViewCore/src/View/DissasmViewer/tests_dissasmviewer.cpp
+++ b/GViewCore/src/View/DissasmViewer/tests_dissasmviewer.cpp
@@ -1,6 +1,7 @@
 #include <catch.hpp>
-#include "DissasmViewer.hpp"
+#include "DissasmCodeZone.hpp"
 #include "x86_x64/DissasmX86.hpp"
+#include "DissasmFunctionUtils.hpp"
 #include <array>
 
 using namespace GView::View::DissasmViewer;
diff --git a/GViewCore/src/View/DissasmViewer/x86_x64/DissasmX86.cpp b/GViewCore/src/View/DissasmViewer/x86_x64/DissasmX86.cpp
index 375b5367..43ea14cf 100644
--- a/GViewCore/src/View/DissasmViewer/x86_x64/DissasmX86.cpp
+++ b/GViewCore/src/View/DissasmViewer/x86_x64/DissasmX86.cpp
@@ -1,5 +1,7 @@
 #include "DissasmViewer.hpp"
 #include "DissasmX86.hpp"
+#include "DissasmCodeZone.hpp"
+#include "DissasmFunctionUtils.hpp"
 #include <capstone/capstone.h>
 #include <cassert>
 #include <ranges>
@@ -15,16 +17,6 @@ using namespace AppCUI::Input;
 // TODO: performance improvements
 //  consider using the same cs_insn and cs handle for all instructions that are on the same thread instead of creating new ones
 
-constexpr size_t DISSASM_INSTRUCTION_OFFSET_MARGIN = 500;
-constexpr uint32 callOP                            = 1819042147u; //*(uint32*) "call";
-constexpr uint32 addOP                             = 6579297u;    //*((uint32*) "add");
-constexpr uint32 pushOP                            = 1752397168u; //*((uint32*) "push");
-constexpr uint32 movOP                             = 7761773u;    //*((uint32*) "mov");
-
-const uint8 HEX_MAPPER[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0, 0, 0,
-                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0, 0, 0,
-                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 15 };
-
 // Dissasm menu configuration
 constexpr uint32 addressTotalLength                 = 16;
 constexpr uint32 opCodesGroupsShown                 = 8;
@@ -39,54 +31,6 @@ constexpr uint32 textTotalColumnLength =
 constexpr uint32 commentPaddingLength   = 10;
 constexpr uint32 textPaddingLabelsSpace = 3;
 
-// TODO consider inline?
-AsmOffsetLine SearchForClosestAsmOffsetLineByLine(const std::vector<AsmOffsetLine>& values, uint64 searchedLine, uint32* index = nullptr)
-{
-    assert(!values.empty());
-    uint32 left  = 0;
-    uint32 right = static_cast<uint32>(values.size()) - 1u;
-    while (left < right) {
-        const uint32 mid = (left + right) / 2;
-        if (searchedLine == values[mid].line) {
-            if (index)
-                *index = mid;
-            return values[mid];
-        }
-        if (searchedLine < values[mid].line)
-            right = mid - 1;
-        else
-            left = mid + 1;
-    }
-    if (left > 0 && values[left].line > searchedLine) {
-        if (index)
-            *index = left - 1;
-        return values[left - 1];
-    }
-    if (index)
-        *index = left;
-    return values[left];
-}
-
-AsmOffsetLine SearchForClosestAsmOffsetLineByOffset(const std::vector<AsmOffsetLine>& values, uint64 searchedOffset)
-{
-    assert(!values.empty());
-    uint32 left  = 0;
-    uint32 right = static_cast<uint32>(values.size()) - 1u;
-    while (left < right) {
-        const uint32 mid = (left + right) / 2;
-        if (searchedOffset == values[mid].offset)
-            return values[mid];
-        if (searchedOffset < values[mid].offset)
-            right = mid - 1;
-        else
-            left = mid + 1;
-    }
-    if (left > 0 && values[left].offset > searchedOffset)
-        return values[left - 1];
-
-    return values[left];
-}
-
 // TODO: to be moved inside plugin for some sort of API for token<->color
 inline ColorPair GetASMColorPairByKeyword(std::string_view keyword, DissasmColors& colors, const AsmData& data)
 {
@@ -274,271 +218,6 @@ inline void DissasmAddColorsToInstruction(
     // string.SetFormat("0x%" PRIx64 ":           %s %s", insn[j].address, insn[j].mnemonic, insn[j].op_str);
 }
 
-// TODO: maybe add also minimum number?
-bool CheckExtractInsnHexValue(const char* op_str, uint64& value, uint64 maxSize)
-{
-    const char* ptr     = op_str;
-    const char* start   = nullptr;
-    uint32 size         = 0;
-    bool insideBrackets = false;
-
-    auto checkValidSequence = [&ptr, &insideBrackets]() -> bool {
-        while (ptr && *ptr != '\0') {
-            if (*ptr == ' ' || *ptr == '[' || *ptr >= 'a' && *ptr <= 'z' || *ptr >= 'A' && *ptr <= 'Z') {
-                if (*ptr == '[') {
-                    if (insideBrackets)
-                        return false;
-                    insideBrackets = true;
-                }
-                ptr++;
-                continue;
-            }
-            if (*ptr >= '0' && *ptr <= '9') {
-                break;
-            }
-            return false;
-        }
-        return true;
-    };
-
-    if (!checkValidSequence())
-        return false;
-
-    // while (ptr && *ptr != '\0') {
-    //     if (*ptr == ' ' || *ptr == '[' || *ptr >= 'a' && *ptr <= 'z' || *ptr >= 'A' && *ptr <= 'Z') {
-    //         if (*ptr == '[') {
-    //             if (insideBrackets)
-    //                 return false;
-    //             insideBrackets = true;
-    //         }
-    //         ptr++;
-    //         continue;
-    //     }
-    //     if (*ptr >= '0' && *ptr <= '9') {
-    //         break;
-    //     }
-    //     return false;
-    // }
-
-    bool is_hex = false;
-    while (ptr && *ptr != '\0') {
-        if (!start) {
-            if (*ptr == '0') // not hex
-            {
-                ptr++;
-                if (!ptr || *ptr != 'x') {
-                    start = ptr - 1;
-                    size  = 1;
-                    continue;
-                }
-                ptr++;
-                start  = ptr;
-                is_hex = true;
-                continue;
-            } else {
-                is_hex = false;
-                start  = ptr;
-                continue;
-            }
-        } else {
-            if (*ptr >= '0' && *ptr <= '9' || *ptr >= 'a' && *ptr <= 'f') {
-                size++;
-            } else {
-                if (size < maxSize - 2)
-                    return false;
-                break;
-            }
-        }
-        ptr++;
-    }
-
-    if (insideBrackets) {
-        if (!ptr)
-            return false;
-        if (*ptr != ']')
-            return false;
-        ptr++;
-    }
-
-    if (maxSize < size) {
-        const uint32 diff = size - static_cast<uint32>(maxSize);
-        size -= diff;
-        start += diff;
-    }
-
-    if (!size || !start)
-        return false;
-
-    if (size < 2) {
-        ptr = !is_hex ? op_str : op_str + 2;
-        while (ptr && *ptr != '\0') {
-            if (!(*ptr >= '0' && *ptr <= '9' || *ptr >= 'a' && *ptr <= 'f'))
-                return false;
-            ptr++;
-        }
-    }
-
-    if (!checkValidSequence())
-        return false;
-
-    const NumberParseFlags numberFlags = is_hex ? NumberParseFlags::Base16 : NumberParseFlags::Base10;
-    const auto sv                      = std::string_view(start, size);
-    const auto converted               = Number::ToUInt64(sv, numberFlags);
-    if (!converted.has_value())
-        return false;
-
-    value = converted.value();
-
-    return true;
-}
-
-inline bool populateOffsetsVector(
-      vector<AsmOffsetLine>& offsets, DisassemblyZone& zoneDetails, GView::Object& obj, int internalArchitecture, uint32& totalLines)
-{
-    csh handle;
-    const auto resCode = cs_open(CS_ARCH_X86, static_cast<cs_mode>(internalArchitecture), &handle);
-    if (resCode != CS_ERR_OK) {
-        // WriteErrorToScreen(dli, cs_strerror(resCode));
-        return false;
-    }
-
-    const auto instructionData = obj.GetData().Get(zoneDetails.startingZonePoint, static_cast<uint32>(zoneDetails.size), false);
-
-    if (offsets.empty()) {
-        offsets.reserve(256);
-        offsets.push_back({ zoneDetails.entryPoint, 0 });
-    }
-
-    size_t minimalValue = offsets[0].offset;
-
-    cs_insn* insn     = cs_malloc(handle);
-    size_t lastOffset = offsets[0].offset;
-
-    constexpr uint32 addInstructionsStop = 30; // TODO: update this -> for now it stops, later will fold
-
-    std::list<uint64> finalOffsets;
-
-    size_t size       = zoneDetails.startingZonePoint + zoneDetails.size;
-    uint64 address    = zoneDetails.entryPoint - zoneDetails.startingZonePoint;
-    uint64 endAddress = zoneDetails.size;
-
-    if (address >= endAddress) {
-        cs_close(&handle);
-        return false;
-    }
-
-    auto data = instructionData.GetData() + address;
-
-    // std::string saved1 = "s1", saved2 = "s2";
-    uint64 startingOffset = offsets[0].offset;
-
-    size_t lastSize = size;
-    // std::vector<uint64> tempStorage;
-    // tempStorage.push_back(lastOffset);
-
-    do {
-        if (size > lastSize) {
-            lastSize = size;
-            // tempStorage.reserve(size / DISSASM_INSTRUCTION_OFFSET_MARGIN + 1);
-        }
-
-        while (address < endAddress) {
-            if (!cs_disasm_iter(handle, &data, &size, &address, insn))
-                break;
-
-            if ((insn->mnemonic[0] == 'j' || *(uint32*) insn->mnemonic == callOP)) // && insn->op_str[0] == '0' /* && insn->op_str[1] == 'x'*/)
-            {
-                uint64 computedValue = 0;
-                if (insn->op_str[1] == 'x') {
-                    // uint64 computedValue = 0;
-                    char* ptr = &insn->op_str[2];
-                    // TODO: also check not to overflow access!
-                    while (*ptr && *ptr != ' ' && *ptr != ',') {
-                        if (!(*ptr >= 'a' && *ptr <= 'f' || *ptr >= '0' && *ptr <= '9')) {
-                            computedValue = 0;
-                            break;
-                        }
-                        computedValue = computedValue * 16 + HEX_MAPPER[static_cast<uint8>(*ptr)];
-                        ptr++;
-                    }
-                } else {
-                    char* ptr = &insn->op_str[0];
-                    while (*ptr && *ptr != ' ' && *ptr != ',') {
-                        if (*ptr < '0' || *ptr > '9') {
-                            computedValue = 0;
-                            break;
-                        }
-                        computedValue = computedValue * 10 + (static_cast<uint8>(*ptr) - '0');
-                        ptr++;
-                    }
-                    if (computedValue < zoneDetails.startingZonePoint)
-                        computedValue += zoneDetails.startingZonePoint;
-                    // if (insn->op_str[1] == '\0') {
-                    //     computedValue = zoneDetails.startingZonePoint;
-                    // }
-                }
-
-                if (computedValue < minimalValue && computedValue >= zoneDetails.startingZonePoint) {
-                    minimalValue = computedValue;
-                    // saved1       = insn->mnemonic;
-                    // saved2       = insn->op_str;
-                }
-            }
-            const size_t adjustedSize = address + zoneDetails.startingZonePoint;
-            if (adjustedSize - lastOffset >= DISSASM_INSTRUCTION_OFFSET_MARGIN) {
-                lastOffset = adjustedSize;
-            }
-        }
-        if (minimalValue >= startingOffset)
-            break;
-
-        // pushBack                       = false;
-        const size_t zoneSizeToAnalyze = startingOffset - minimalValue;
-        // finalOffsets.push_front(minimalValue);
-
-        address        = minimalValue - zoneDetails.startingZonePoint;
-        endAddress     = zoneSizeToAnalyze + address;
-        size           = address + zoneSizeToAnalyze;
-        data           = instructionData.GetData() + address;
-        lastOffset     = minimalValue;
-        startingOffset = minimalValue;
-    } while (true);
-
-    size       = zoneDetails.size;
-    address    = minimalValue - zoneDetails.startingZonePoint;
-    data       = instructionData.GetData() + address;
-    lastOffset = address;
-
-    uint32 lineIndex = 0;
-    offsets.clear();
-    offsets.push_back({ minimalValue, 0 });
-
-    constexpr uint32 alOpStr         = 7102752u; //* (uint32*) " al";
-    uint32 continuousAddInstructions = 0;
-
-    while (cs_disasm_iter(handle, &data, &size, &address, insn)) {
-        lineIndex++;
-        if (address - lastOffset >= DISSASM_INSTRUCTION_OFFSET_MARGIN) {
-            lastOffset                = address;
-            const size_t adjustedSize = address + zoneDetails.startingZonePoint;
-            offsets.push_back({ adjustedSize, lineIndex });
-        }
-
-        if (*(uint32*) insn->mnemonic == addOP && insn->op_str[0] == 'b' && *(uint32*) &insn->op_str[15] == alOpStr) {
-            if (++continuousAddInstructions == addInstructionsStop) {
-                lineIndex -= continuousAddInstructions;
-                break;
-            }
-        } else
-            continuousAddInstructions = 0;
-    }
-
-    totalLines = lineIndex;
-    cs_free(insn, 1);
-    cs_close(&handle);
-    return true;
-}
-
 inline cs_insn* GetCurrentInstructionByLine(
       uint32 lineToReach, DissasmCodeZone* zone, Reference<GView::Object> obj, uint32& diffLines, DrawLineInfo* dli = nullptr)
 {
@@ -607,205 +286,6 @@ inline cs_insn* GetCurrentInstructionByLine(
     return insn;
 }
 
-inline cs_insn* GetCurrentInstructionByOffset(
-      uint64 offsetToReach, DissasmCodeZone* zone, Reference<GView::Object> obj, uint32& diffLines, DrawLineInfo* dli = nullptr)
-{
-    const auto closestData = SearchForClosestAsmOffsetLineByOffset(zone->cachedCodeOffsets, offsetToReach);
-    zone->lastClosestLine  = closestData.line;
-    zone->asmAddress       = closestData.offset - zone->cachedCodeOffsets[0].offset;
-    zone->asmSize          = zone->zoneDetails.size - zone->asmAddress;
-
-    // TODO: maybe get less data ?
-    const auto instructionData = obj->GetData().Get(zone->cachedCodeOffsets[0].offset + zone->asmAddress, static_cast<uint32>(zone->asmSize), false);
-    zone->lastData             = instructionData;
-    if (!instructionData.IsValid()) {
-        if (dli)
-            dli->WriteErrorToScreen("ERROR: extract valid data from file!");
-        diffLines = UINT32_MAX;
-        return nullptr;
-    }
-
-    zone->asmData = const_cast<uint8*>(zone->lastData.GetData());
-
-    // TODO: keep the handle open and insn open until the program ends
-    csh handle;
-    const auto resCode = cs_open(CS_ARCH_X86, static_cast<cs_mode>(zone->internalArchitecture), &handle);
-    if (resCode != CS_ERR_OK) {
-        if (dli)
-            dli->WriteErrorToScreen(cs_strerror(resCode));
-        cs_close(&handle);
-        return nullptr;
-    }
-
-    diffLines     = 0;
-    cs_insn* insn = cs_malloc(handle);
-    if (offsetToReach >= zone->cachedCodeOffsets[0].offset)
-        offsetToReach -= zone->cachedCodeOffsets[0].offset;
-    while (zone->asmAddress <= offsetToReach) {
-        if (!cs_disasm_iter(handle, &zone->asmData, (size_t*) &zone->asmSize, &zone->asmAddress, insn)) {
-            if (dli)
-                dli->WriteErrorToScreen("Failed to dissasm!");
-            cs_free(insn, 1);
-            cs_close(&handle);
-            return nullptr;
-        }
-        diffLines++;
-    }
-    diffLines += closestData.line - 1;
-    cs_close(&handle);
-    return insn;
-}
-
-inline LocalString<64> FormatFunctionName(uint64 functionAddress, const char* prefix)
-{
-    NumericFormatter formatter;
-    auto sv = formatter.ToHex(functionAddress);
-    LocalString<64> callName;
-    callName.AddFormat("%s%09s", prefix, sv.data());
-    return callName;
-}
-
-inline bool ExtractCallsToInsertFunctionNames(
-      vector<AsmOffsetLine>& offsets,
-      DissasmCodeZone* zone,
-      Reference<GView::Object> obj,
-      int internalArchitecture,
-      uint32& totalLines,
-      uint64 maxLocationMemoryMappingSize)
-{
-    csh handle;
-    const auto resCode = cs_open(CS_ARCH_X86, static_cast<cs_mode>(internalArchitecture), &handle);
-    if (resCode != CS_ERR_OK) {
-        // WriteErrorToScreen(dli, cs_strerror(resCode));
-        return false;
-    }
-
-    cs_insn* insn = cs_malloc(handle);
-
-    DisassemblyZone& zoneDetails = zone->zoneDetails;
-    const auto instructionData   = obj->GetData().Get(zoneDetails.startingZonePoint, static_cast<uint32>(zoneDetails.size), false);
-
-    uint32 linesToDecode = totalLines;
-    size_t size          = zoneDetails.size;
-    uint64 address       = offsets[0].offset - zoneDetails.startingZonePoint;
-    auto data            = instructionData.GetData() + address;
-
-    std::vector<std::pair<uint64, std::string>> callsFound;
-    std::unordered_map<uint64, bool> callsMap; // true for offset, false for sub
-    callsFound.reserve(16);
-    bool foundCall     = false;
-    uint64 callAddress = 0;
-    while (cs_disasm_iter(handle, &data, &size, &address, insn) && linesToDecode > 0) {
-        linesToDecode--;
-        const bool isJump = insn->mnemonic[0] == 'j';
-        if (*(uint32*) insn->mnemonic == callOP || isJump) {
-            uint64 value;
-            const bool foundValue = CheckExtractInsnHexValue(insn->op_str, value, maxLocationMemoryMappingSize);
-            if (foundValue && value < zoneDetails.startingZonePoint + zoneDetails.size) {
-                if (value < offsets[0].offset)
-                    value += offsets[0].offset;
-                const char* prefix = isJump ? "offset_0x" : "sub_0x";
-                const auto it      = callsMap.find(value);
-                if (it != callsMap.end()) {
-                    if (isJump == it->second)
-                        continue;
-                }
-                auto callName = FormatFunctionName(value, prefix);
-                callsFound.emplace_back(value, callName.GetText());
-                callsMap.insert({ value, isJump });
-            }
-        } else {
-            const auto mnemonicVal = *(uint32*) insn->mnemonic;
-            if (foundCall) {
-                if (mnemonicVal == movOP && strcmp(insn->op_str, "ebp, esp") == 0) {
-                    if (callAddress < offsets[0].offset)
-                        callAddress += offsets[0].offset;
-                    const auto it = callsMap.find(callAddress);
-                    if (it != callsMap.end()) {
-                        if (!it->second)
-                            continue;
-                    }
-                    const char* prefix = "sub_0x";
-                    auto callName      = FormatFunctionName(callAddress, prefix);
-                    callsFound.emplace_back(callAddress, callName.GetText());
-                    callsMap.insert({ callAddress, true });
-                }
-                foundCall = false;
-            } else {
-                if (mnemonicVal == pushOP) {
-                    if (strcmp(insn->op_str, "ebp") == 0) {
-                        callAddress = insn->address;
-                        foundCall   = true;
-                    }
-                }
-            }
-        }
-    }
-
-    auto val = callsFound[0].first;
-
-    enum labelType { SUB, OFFSET, OTHER };
-    auto getLabelType = [](const std::string& s) -> labelType {
-        assert(!s.empty());
-        if (s.size() < 4)
-            return OTHER;
-        if (memcmp(s.c_str(), "sub_", 4) == 0)
-            return SUB;
-        if (s.size() < 7)
-            return OTHER;
-        if (memcmp(s.c_str(), "offset_", 7) == 0)
-            return OFFSET;
-        return OTHER;
-    };
-
-    std::vector<uint32> indexesToErase;
-    for (int32 i = static_cast<int32>(callsFound.size()) - 1; i >= 0; i--) {
-        const auto& call = callsFound[i];
-        if (call.first == zone->zoneDetails.entryPoint) {
-            indexesToErase.push_back(i);
-            break;
-        }
-    }
-    for (const auto indexToErase : indexesToErase)
-        callsFound.erase(callsFound.begin() + indexToErase);
-
-    callsFound.emplace_back(zone->zoneDetails.entryPoint, "EntryPoint");
-    // TODO: this can be extracted for the user to add / delete its own operations
-    std::sort(callsFound.begin(), callsFound.end(), [getLabelType](const auto& a, const auto& b) {
-        if (a.first < b.first)
-            return true;
-        if (a.first > b.first)
-            return false;
-        return getLabelType(a.second) < getLabelType(b.second);
-
-        // return a.second.compare(b.second) > 0; // move sub instructions first
-    });
-
-    // TODO: if there are missing called improve predicate to delele only sub and offset
-    callsFound.erase(
-          std::unique(callsFound.begin(), callsFound.end(), [](const auto& left, const auto& right) { return left.first == right.first; }), callsFound.end());
-
-    // callsFound.push_back({ 1030, "call2" });
-    // callsFound.push_back({ 1130, "call 3" });
-    // callsFound.push_back({ 1140, "call 5" });
-    uint32 extraLines = 0;
-    for (const auto& call : callsFound) {
-        const uint64 callValue = call.first;
-        uint32 diffLines       = 0;
-        auto callInsn          = GetCurrentInstructionByOffset(callValue, zone, obj, diffLines);
-        if (callInsn) {
-            zone->dissasmType.annotations.insert({ diffLines + extraLines, { call.second, callValue - offsets[0].offset } });
-            cs_free(callInsn, 1);
-            extraLines++;
-        }
-    }
-    totalLines += static_cast<uint32>(callsFound.size());
-    cs_free(insn, 1);
-    cs_close(&handle);
-
-    return true;
-}
-
 inline const MemoryMappingEntry* TryExtractMemoryMapping(const Pointer<SettingsData>& settings, uint64 initialLocation, const uint64 possibleLocationAdjustment)
 {
     const auto& mapping = settings->memoryMappings.find(initialLocation);
@@ -1546,6 +1026,11 @@ void Instance::DissasmZoneProcessSpaceKey(DissasmCodeZone* zone, uint32 line, ui
     Cursor.hasMovedView  = true;
 }
 
+void Instance::EditDissasmCodeZoneCommand()
+{
+    AppCUI::Dialogs::MessageBox::ShowError("Error", "Not implemented yet !");
+}
+
 void Instance::CommandExecuteCollapsibleZoneOperation(CollapsibleZoneOperation operation)
 {
     if (operation == CollapsibleZoneOperation::Add && !selection.HasSelection(0)) {
@@ -1622,154 +1107,6 @@ void Instance::CommandExecuteCollapsibleZoneOperation(CollapsibleZoneOperation o
     }
 }
 
-bool DissasmCodeZone::InitZone(DissasmCodeZoneInitData& initData)
-{
-    // TODO: move this on init
-    if (!cs_support(CS_ARCH_X86)) {
-        initData.dli->WriteErrorToScreen("Capstone does not support X86");
-        initData.adjustedZoneSize = 1;
-        initData.hasAdjustedSize  = true;
-        return false;
-    }
-
-    switch (zoneDetails.language) {
-    case DisassemblyLanguage::x86:
-        internalArchitecture = CS_MODE_32;
-        break;
-    case DisassemblyLanguage::x64:
-        internalArchitecture = CS_MODE_64;
-        break;
-    default: {
-        initData.dli->WriteErrorToScreen("ERROR: unsupported language!");
-        return false;
-    }
-    }
-
-    uint32 totalLines = 0;
-    if (!populateOffsetsVector(cachedCodeOffsets, zoneDetails, initData.obj, internalArchitecture, totalLines)) {
-        initData.dli->WriteErrorToScreen("ERROR: failed to populate offsets vector!");
-        return false;
-    }
-    if (initData.enableDeepScanDissasmOnStart &&
-        !ExtractCallsToInsertFunctionNames(cachedCodeOffsets, this, initData.obj, internalArchitecture, totalLines, initData.maxLocationMemoryMappingSize)) {
-        initData.dli->WriteErrorToScreen("ERROR: failed to populate offsets vector!");
-        return false;
-    }
-    totalLines++; //+1 for title
-    initData.adjustedZoneSize = totalLines;
-    initData.hasAdjustedSize  = true;
-    // AdjustZoneExtendedSize(zone, totalLines);
-    lastDrawnLine          = 0;
-    const auto closestData = SearchForClosestAsmOffsetLineByLine(cachedCodeOffsets, lastDrawnLine);
-    lastClosestLine        = closestData.line;
-    isInit                 = true;
-
-    asmAddress = 0;
-    asmSize    = zoneDetails.size - asmAddress;
-
-    const auto instructionData = initData.obj->GetData().Get(cachedCodeOffsets[0].offset + asmAddress, static_cast<uint32>(asmSize), false);
-    lastData                   = instructionData;
-    if (!instructionData.IsValid()) {
-        initData.dli->WriteErrorToScreen("ERROR: extract valid data from file!");
-        return false;
-    }
-    asmData = const_cast<uint8*>(instructionData.GetData());
-
-    const uint32 preReverseSize = std::min<uint32>(initData.visibleRows, extendedSize);
-    asmPreCacheData.cachedAsmLines.reserve(preReverseSize);
-
-    structureIndex = 0;
-    types.push_back(dissasmType);
-    levels.push_back(0);
-
-    dissasmType.indexZoneStart = 0; //+1 for the title
-    dissasmType.indexZoneEnd   = totalLines + 1;
-    // dissasmType.annotations.insert({ 2, "loc fn" });
-
-    return true;
-}
-
-void DissasmCodeZone::ReachZoneLine(uint32 line)
-{
-    changedLevel = false;
-    if (lastReachedLine == line)
-        return;
-
-    const uint32 levelToReach = line;
-    uint32& levelNow          = this->structureIndex;
-    bool reAdapt              = false;
-    while (true) {
-        const DissasmCodeInternalType& currentType = types.back();
-        if (currentType.indexZoneStart <= levelToReach && levelToReach < currentType.indexZoneEnd) {
-            if (!currentType.internalTypes.empty())
-                reAdapt = true;
-            break;
-        }
-        types.pop_back();
-        levels.pop_back();
-        reAdapt = true;
-    }
-
-    while (reAdapt && !types.back().get().internalTypes.empty()) {
-        DissasmCodeInternalType& currentType = types.back();
-        for (uint32 i = 0; i < currentType.internalTypes.size(); i++) {
-            auto& internalType = currentType.internalTypes[i];
-            if (internalType.indexZoneStart <= levelToReach && levelToReach < internalType.indexZoneEnd) {
-                types.emplace_back(internalType);
-                levels.push_back(i);
-                changedLevel                   = true;
-                newLevelChangeData.hasName     = !internalType.name.empty();
-                newLevelChangeData.isCollapsed = internalType.isCollapsed;
-                break;
-            }
-        }
-    }
-
-    DissasmCodeInternalType& currentType = types.back();
-    // TODO: do a faster search using a binary search using the annotations and start from there
-    // TODO: maybe use some caching here?
-    if (reAdapt || levelNow < levelToReach && levelNow + 1 != levelToReach || levelNow > levelToReach && levelNow - 1 != levelToReach) {
-        currentType.textLinesPassed = 0;
-        currentType.asmLinesPassed  = 0;
-        for (uint32 i = currentType.indexZoneStart; i <= levelToReach; i++) {
-            if (currentType.annotations.contains(i)) {
-                currentType.textLinesPassed++;
-                continue;
-            }
-            currentType.asmLinesPassed++;
-        }
-    } else {
-        if (currentType.annotations.contains(levelToReach))
-            currentType.textLinesPassed++;
-        else
-            currentType.asmLinesPassed++;
-    }
-
-    levelNow        = levelToReach;
-    lastReachedLine = levelToReach;
-
-    // if (currentType.annotations.contains(levelToReach))
-    //     return {};
-
-    // const uint32 value = currentType.GetCurrentAsmLine();
-    // if (value == 0)
-    //     return {};
-
-    // return value - 1u;
-}
-
-bool DissasmCodeZone::ResetTypesReferenceList()
-{
-    types.clear();
-    levels.clear();
-    structureIndex  = 0;
-    lastReachedLine = static_cast<uint32>(-1);
-    types.emplace_back(dissasmType);
-    levels.push_back(0);
-    ResetZoneCaching();
-    return true;
-}
-
 using ValidChildCallback = bool(DissasmCodeInternalType*, void*);
 
 DissasmCodeInternalType* SearchBottomWithFnUpCollapsibleZoneRecursive(
diff --git a/GViewCore/src/View/DissasmViewer/x86_x64/DissasmX86.hpp b/GViewCore/src/View/DissasmViewer/x86_x64/DissasmX86.hpp
index c9d7d2bb..04024061 100644
--- a/GViewCore/src/View/DissasmViewer/x86_x64/DissasmX86.hpp
+++ b/GViewCore/src/View/DissasmViewer/x86_x64/DissasmX86.hpp
@@ -1,8 +1,6 @@
 #pragma once
 #include <AppCUI/include/AppCUI.hpp>
 
-bool CheckExtractInsnHexValue(const char* op_str, AppCUI::uint64& value, AppCUI::uint64 maxSize);
-
 namespace GView::View::DissasmViewer
 {
 struct DissasmCodeInternalType;
diff --git a/GViewCore/src/include/Internal.hpp b/GViewCore/src/include/Internal.hpp
index 38d94f95..9dac246e 100644
--- a/GViewCore/src/include/Internal.hpp
+++ b/GViewCore/src/include/Internal.hpp
@@ -472,6 +472,7 @@ namespace App
         void OpenFolder();
         void ShowErrors();
         void ShowTutorial();
+        void ShowAboutWindow();
 
         Reference<Type::Plugin> IdentifyTypePlugin_FirstMatch(
               const std::string_view& extension,
diff --git a/GenericPlugins/CharacterTable/src/CharacterTable.cpp b/GenericPlugins/CharacterTable/src/CharacterTable.cpp
index a40f7600..3adf1f9e 100644
--- a/GenericPlugins/CharacterTable/src/CharacterTable.cpp
+++ b/GenericPlugins/CharacterTable/src/CharacterTable.cpp
@@ -40,6 +40,6 @@ extern "C"
 
     PLUGIN_EXPORT void UpdateSettings(IniSection sect)
     {
-        sect["command.CharacterTable"] = Input::Key::Ctrl | Input::Key::Alt | Input::Key::Shift | Input::Key::F1;
+        sect["Command.CharacterTable"] = Input::Key::Ctrl | Input::Key::Alt | Input::Key::Shift | Input::Key::F1;
     }
 }
diff --git a/GenericPlugins/Dropper/src/Dropper.cpp b/GenericPlugins/Dropper/src/Dropper.cpp
index df0538f0..128edd28 100644
--- a/GenericPlugins/Dropper/src/Dropper.cpp
+++ b/GenericPlugins/Dropper/src/Dropper.cpp
@@ -41,7 +41,7 @@ PLUGIN_EXPORT bool Run(const string_view command, Reference<GView::Object> objec
 
 PLUGIN_EXPORT void UpdateSettings(IniSection sect)
 {
-    sect["command.Dropper"] = Input::Key::F10;
+    sect["Command.Dropper"] = Input::Key::F10;
 }
 }
 
diff --git a/GenericPlugins/EntropyVisualizer/src/EntropyVisualizer.cpp b/GenericPlugins/EntropyVisualizer/src/EntropyVisualizer.cpp
index d8918fc2..89e354a4 100644
--- a/GenericPlugins/EntropyVisualizer/src/EntropyVisualizer.cpp
+++ b/GenericPlugins/EntropyVisualizer/src/EntropyVisualizer.cpp
@@ -17,7 +17,7 @@ PLUGIN_EXPORT bool Run(const string_view command, Reference<GView::Object> objec
 
 PLUGIN_EXPORT void UpdateSettings(IniSection sect)
 {
-    sect["command.EntropyVisualizer"] = Input::Key::F12;
+    sect["Command.EntropyVisualizer"] = Input::Key::F12;
 }
 }
 
diff --git a/GenericPlugins/SyncCompare/src/SyncCompare.cpp b/GenericPlugins/SyncCompare/src/SyncCompare.cpp
index 30ea0bcc..63956dd8 100644
--- a/GenericPlugins/SyncCompare/src/SyncCompare.cpp
+++ b/GenericPlugins/SyncCompare/src/SyncCompare.cpp
@@ -537,9 +537,9 @@ extern "C"
 
     PLUGIN_EXPORT void UpdateSettings(IniSection sect)
     {
-        sect["command.SyncCompare"]        = Input::Key::Ctrl | Input::Key::Shift | Input::Key::Space;
-        sect["command.ToggleSync"]         = Input::Key::Shift | Input::Key::Space;
-        sect["command.FindNextDifference"] = Input::Key::Shift | Input::Key::F11;
-        sect["command.FindNextDC"]         = Input::Key::Ctrl | Input::Key::Shift | Input::Key::F11;
+        sect["Command.SyncCompare"]        = Input::Key::Ctrl | Input::Key::Shift | Input::Key::Space;
+        sect["Command.ToggleSync"]         = Input::Key::Shift | Input::Key::Space;
+        sect["Command.FindNextDifference"] = Input::Key::Shift | Input::Key::F11;
+        sect["Command.FindNextDC"]         = Input::Key::Ctrl | Input::Key::Shift | Input::Key::F11;
     }
 }
diff --git a/GenericPlugins/Unpacker/src/Unpacker.cpp b/GenericPlugins/Unpacker/src/Unpacker.cpp
index 490a813b..32cb06c7 100644
--- a/GenericPlugins/Unpacker/src/Unpacker.cpp
+++ b/GenericPlugins/Unpacker/src/Unpacker.cpp
@@ -221,7 +221,7 @@ PLUGIN_EXPORT bool Run(const string_view command, Reference<GView::Object> curre
 
 PLUGIN_EXPORT void UpdateSettings(IniSection sect)
 {
-    sect["command.Unpacker"] = Input::Key::Alt | Input::Key::F10;
+    sect["Command.Unpacker"] = Input::Key::Alt | Input::Key::F10;
 }
 }
 } // namespace GView::GenericPlugins::Unpackers
\ No newline at end of file