diff --git a/src/geargrafx_core.cpp b/src/geargrafx_core.cpp
index d652829..31ced4a 100644
--- a/src/geargrafx_core.cpp
+++ b/src/geargrafx_core.cpp
@@ -82,8 +82,7 @@ void GeargrafxCore::RunToVBlank(u8* frame_buffer, s16* sample_buffer, int* sampl
         int totalClocks = 0;
         while (!vblank)
         {
-            //unsigned int clockCycles = m_huc6280->Tick();
-            unsigned int clockCycles = 1;
+            unsigned int clockCycles = m_huc6280->Tick();
             // vblank = m_huc6270->Tick(clockCycles);
             m_audio->Tick(clockCycles);
 
@@ -96,33 +95,49 @@ void GeargrafxCore::RunToVBlank(u8* frame_buffer, s16* sample_buffer, int* sampl
         m_audio->EndFrame(sample_buffer, sample_count);
         RenderFrameBuffer(frame_buffer);
     }
+}
 
-    // if (!m_paused && m_cartridge->IsReady())
-    // {
-    //     bool vblank = false;
-    //     int totalClocks = 0;
-    //     while (!vblank)
-    //     {
-    //         unsigned int clockCycles = m_processor->RunFor(1);
-    //         // vblank = m_video->Tick(clockCycles);
-    //         m_audio->Tick(clockCycles);
+bool GeargrafxCore::DebugRun(u8* frame_buffer, s16* sample_buffer, int* sample_count, GG_Debugger_Command command)
+{
+    bool breakpoint = false;
+
+    if (!m_paused && m_cartridge->IsReady())
+    {
+        bool vblank = false;
+        int totalClocks = 0;
+        while (!vblank)
+        {
+            unsigned int clockCycles = m_huc6280->Tick();
+            // vblank = m_huc6270->Tick(clockCycles);
+            m_audio->Tick(clockCycles);
+            totalClocks += clockCycles;
 
-    //         totalClocks += clockCycles;
+            switch (command)
+            {
+                case GG_Debugger_Command_Continue:
+                    break;
+                case GG_Debugger_Command_StepInto:
+                    vblank = true;
+                    break;
+                case GG_Debugger_Command_StepOver:
+                    vblank = true;
+                    break;
+                case GG_Debugger_Command_StepOut:
+                    break;
+            }
+
+            // if (m_processor->BreakpointHit())
+            //     breakpoint = true;
 
-    //         // if ((step || (stopOnBreakpoints && m_processor->BreakpointHit())) && !m_processor->DuringInputOpcode())
-    //         // {
-    //         //     vblank = true;
-    //         //     if (m_processor->BreakpointHit())
-    //         //         breakpoint = true;
-    //         // }
+            if (totalClocks > 702240)
+                vblank = true;
+        }
 
-    //         if (totalClocks > 702240)
-    //             vblank = true;
-    //     }
+        m_audio->EndFrame(sample_buffer, sample_count);
+        RenderFrameBuffer(frame_buffer);
+    }
 
-    //     m_audio->EndFrame(sample_buffer, sample_count);
-    //     RenderFrameBuffer(frame_buffer);
-    // }
+    return breakpoint;
 }
 
 bool GeargrafxCore::LoadROM(const char* file_path)
diff --git a/src/geargrafx_core.h b/src/geargrafx_core.h
index 1694a73..7cd56c1 100644
--- a/src/geargrafx_core.h
+++ b/src/geargrafx_core.h
@@ -36,6 +36,7 @@ class GeargrafxCore
     ~GeargrafxCore();
     void Init(GG_Pixel_Format pixel_format = GG_PIXEL_RGB888);
     void RunToVBlank(u8* frame_buffer, s16* sample_buffer, int* sample_count);
+    bool DebugRun(u8* frame_buffer, s16* sample_buffer, int* sample_count, GG_Debugger_Command command);
     bool LoadROM(const char* file_path);
     bool LoadROMFromBuffer(const u8* buffer, int size);
     void ResetROM(bool preserve_ram);
diff --git a/src/huc6280.cpp b/src/huc6280.cpp
index 9c2d06a..8e4cf45 100644
--- a/src/huc6280.cpp
+++ b/src/huc6280.cpp
@@ -22,6 +22,7 @@
 #include "huc6280_names.h"
 #include "memory.h"
 #include <stdlib.h>
+#include <string.h>
 
 HuC6280::HuC6280(Memory* memory)
 {
@@ -50,8 +51,8 @@ void HuC6280::Init()
 
 void HuC6280::Reset()
 {
-    m_PC.SetLow(m_memory->Read(0x1FFE));
-    m_PC.SetHigh(m_memory->Read(0x1FFF));
+    m_PC.SetLow(m_memory->Read(0xFFFE));
+    m_PC.SetHigh(m_memory->Read(0xFFFF));
     m_A.SetValue(0x00);
     m_X.SetValue(0x00);
     m_Y.SetValue(0x00);
@@ -89,6 +90,7 @@ unsigned int HuC6280::Tick()
         m_PC.SetLow(m_memory->Read(0xFFFA));
         m_PC.SetHigh(m_memory->Read(0xFFFB));
         m_t_states += 7;
+        DisassembleNextOPCode();
         return m_t_states;
     }
     else if (!IsSetFlag(FLAG_IRQ) && m_interrupt_asserted)
@@ -100,37 +102,123 @@ unsigned int HuC6280::Tick()
         m_PC.SetLow(m_memory->Read(0xFFFE));
         m_PC.SetHigh(m_memory->Read(0xFFFF));
         m_t_states += 7;
+        DisassembleNextOPCode();
         return m_t_states;
     } 
 
     u8 opcode = Fetch8();
+    (this->*m_opcodes[opcode])();
+    DisassembleNextOPCode();
+
+    m_t_states += k_opcode_tstates[opcode];
+
+    return m_t_states;
+}
+
+HuC6280::Processor_State* HuC6280::GetState()
+{
+    return &m_processor_state;
+}
+
+void HuC6280::DisassembleNextOPCode()
+{
+#ifndef GG_DISABLE_DISASSEMBLER
+
+    u16 address = m_PC.GetValue();
+    Memory::GG_Disassembler_Record* record = m_memory->GetOrCreatDisassemblerRecord(address);
 
-#ifdef HuC6280_DISASM
+    if (!IsValidPointer(record))
     {
-        u16 opcode_address = m_PC.GetValue() - 1;
+        return;
+    }
+
+    u8 opcode = m_memory->Read(address);
+    u8 opcode_size = k_opcode_sizes[opcode];
 
-        if (!m_memory->IsDisassembled(opcode_address))
+    bool changed = false;
+
+    for (int i = 0; i < opcode_size; i++)
+    {
+        u8 mem_byte = m_memory->Read(address + i);
+
+        if (record->opcodes[i] != mem_byte)
         {
-            m_memory->Disassemble(opcode_address, kOPCodeNames[opcode]);
+            changed = true;
+            record->opcodes[i] = mem_byte;
         }
     }
-#endif
 
-#ifdef HuC6280_DEBUG
+    if (changed || record->size == 0)
     {
-        u16 opcode_address = m_PC.GetValue() - 1;
-        printf("HuC6280 -->  $%.4X  %s\n", opcode_address, kOPCodeNames[opcode]);
-    }
-#endif
+        record->size = opcode_size;
+        record->name[0] = 0;
+        record->bytes[0] = 0;
+        record->jump = false;
+        record->jump_address = 0;
 
-    (this->*m_opcodes[opcode])();
+        for (int i = 0; i < opcode_size; i++)
+        {
+            char value[4];
+            snprintf(value, 4, "%02X", record->opcodes[i]);
+            strncat(record->bytes, value, 20);
+            strncat(record->bytes, " ", 20);
+        }
 
-    m_t_states += k_opcode_tstates[opcode];
+        switch (k_opcode_names[opcode].type)
+        {
+            case GG_OPCode_Type_Implied:
+            {
+                snprintf(record->name, 64, "%s", k_opcode_names[opcode].name);
+                break;
+            }
+            case GG_OPCode_Type_1b:
+            {
+                snprintf(record->name, 64, k_opcode_names[opcode].name, m_memory->Read(address + 1));
+                break;
+            }
+            case GG_OPCode_Type_1b_1b:
+            {
+                snprintf(record->name, 64, k_opcode_names[opcode].name, m_memory->Read(address + 1), m_memory->Read(address + 2));
+                break;
+            }
+            case GG_OPCode_Type_1b_2b:
+            {
+                snprintf(record->name, 64, k_opcode_names[opcode].name, m_memory->Read(address + 1), m_memory->Read(address + 2) | (m_memory->Read(address + 3) << 8));
+                break;
+            }
+            case GG_OPCode_Type_2b:
+            {
+                snprintf(record->name, 64, k_opcode_names[opcode].name, m_memory->Read(address + 1) | (m_memory->Read(address + 2) << 8));
+                break;
+            }
+            case GG_OPCode_Type_2b_2b_2b:
+            {
+                snprintf(record->name, 64, k_opcode_names[opcode].name, m_memory->Read(address + 1) | (m_memory->Read(address + 2) << 8), m_memory->Read(address + 3) | (m_memory->Read(address + 4) << 8), m_memory->Read(address + 5) | (m_memory->Read(address + 6) << 8));
+                break;
+            }
+            case GG_OPCode_Type_1b_Relative:
+            {
+                s8 rel = m_memory->Read(address + 1);
+                u16 jump_address = address + 2 + rel;
+                snprintf(record->name, 64, k_opcode_names[opcode].name, jump_address, rel);
+                break;
+            }
+            case GG_OPCode_Type_1b_1b_Relative:
+            {
+                u8 zero_page = m_memory->Read(address + 1);
+                s8 rel = m_memory->Read(address + 2);
+                u16 jump_address = address + 3 + rel;
+                snprintf(record->name, 64, k_opcode_names[opcode].name, zero_page, jump_address, rel);
+                break;
+            }
+            default:
+            {
+                break;
+            }   
+        }
+    }
 
-    return m_t_states;
-}
+    Debug("--> PC: %04X %s %s", address, record->bytes, record->name);
 
-HuC6280::Processor_State* HuC6280::GetState()
-{
-    return &m_processor_state;
+#endif
 }
diff --git a/src/huc6280.h b/src/huc6280.h
index c53982a..d071900 100644
--- a/src/huc6280.h
+++ b/src/huc6280.h
@@ -60,6 +60,7 @@ class HuC6280
     void SetHighSpeed(bool high_speed);
     bool IsHighSpeed();
     Processor_State* GetState();
+    void DisassembleNextOPCode();
 
 private:
     typedef void (HuC6280::*opcodeptr) (void);
diff --git a/src/huc6280_names.h b/src/huc6280_names.h
index f3b9e57..6e8efde 100644
--- a/src/huc6280_names.h
+++ b/src/huc6280_names.h
@@ -80,7 +80,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "BIT $%02X,X", GG_OPCode_Type_1b },
     { "AND $%02X,X", GG_OPCode_Type_1b },
     { "ROL $%02X,X", GG_OPCode_Type_1b },
-    { "RMB3 $%02X", GG_OPCode_Type_1b },
+    { "RMB 3,$%02X", GG_OPCode_Type_1b },
     { "SEC", GG_OPCode_Type_Implied },
     { "AND $%04X,Y", GG_OPCode_Type_2b },
     { "DEC A", GG_OPCode_Type_Implied },
@@ -88,7 +88,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "BIT $%04X,X", GG_OPCode_Type_2b },
     { "AND $%04X,X", GG_OPCode_Type_2b },
     { "ROL $%04X,X", GG_OPCode_Type_2b },
-    { "BBR3 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBR 3,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "RTI", GG_OPCode_Type_Implied },
     { "EOR $(%02X,X)", GG_OPCode_Type_1b },
@@ -97,7 +97,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "BSR $%04X", GG_OPCode_Type_2b },
     { "EOR $%02X", GG_OPCode_Type_1b },
     { "LSR $%02X", GG_OPCode_Type_1b },
-    { "RMB4 $%02X", GG_OPCode_Type_1b },
+    { "RMB 4,$%02X", GG_OPCode_Type_1b },
     { "PHA", GG_OPCode_Type_Implied },
     { "EOR #$%02X", GG_OPCode_Type_1b },
     { "LSR A", GG_OPCode_Type_Implied },
@@ -105,7 +105,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "JMP $%04X", GG_OPCode_Type_2b },
     { "EOR $%04X", GG_OPCode_Type_2b },
     { "LSR $%04X", GG_OPCode_Type_2b },
-    { "BBR4 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBR 4,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "BVC $%04X  [%+d]", GG_OPCode_Type_1b_Relative },
     { "EOR ($%02X),Y", GG_OPCode_Type_1b },
@@ -114,7 +114,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "CSL", GG_OPCode_Type_Implied },
     { "EOR $%02X,X", GG_OPCode_Type_1b },
     { "LSR $%02X,X", GG_OPCode_Type_1b },
-    { "RMB5 $%02X", GG_OPCode_Type_1b },
+    { "RMB 5,$%02X", GG_OPCode_Type_1b },
     { "CLI", GG_OPCode_Type_Implied },
     { "EOR $%04X,Y", GG_OPCode_Type_2b },
     { "PHY", GG_OPCode_Type_Implied },
@@ -122,7 +122,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "NOP (UNOF)", GG_OPCode_Type_Implied },
     { "EOR $%04X,X", GG_OPCode_Type_2b },
     { "LSR $%04X,X", GG_OPCode_Type_2b },
-    { "BBR5 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBR 5,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "RTS", GG_OPCode_Type_Implied },
     { "ADC $(%02X,X)", GG_OPCode_Type_1b },
@@ -131,7 +131,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "STZ $%02X", GG_OPCode_Type_1b },
     { "ADC $%02X", GG_OPCode_Type_1b },
     { "ROR $%02X", GG_OPCode_Type_1b },
-    { "RMB6 $%02X", GG_OPCode_Type_1b },
+    { "RMB 6,$%02X", GG_OPCode_Type_1b },
     { "PLA", GG_OPCode_Type_Implied },
     { "ADC #$%02X", GG_OPCode_Type_1b },
     { "ROR A", GG_OPCode_Type_Implied },
@@ -139,7 +139,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "JMP ($%04X)", GG_OPCode_Type_2b },
     { "ADC $%04X", GG_OPCode_Type_2b },
     { "ROR $%04X", GG_OPCode_Type_2b },
-    { "BBR6 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBR 6,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "BVS $%04X  [%+d]", GG_OPCode_Type_1b_Relative },
     { "ADC ($%02X),Y", GG_OPCode_Type_1b },
@@ -148,7 +148,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "STZ $%02X,X", GG_OPCode_Type_1b },
     { "ADC $%02X,X", GG_OPCode_Type_1b },
     { "ROR $%02X,X", GG_OPCode_Type_1b },
-    { "RMB7 $%02X", GG_OPCode_Type_1b },
+    { "RMB 7,$%02X", GG_OPCode_Type_1b },
     { "SEI", GG_OPCode_Type_Implied },
     { "ADC $%04X,Y", GG_OPCode_Type_2b },
     { "PLY", GG_OPCode_Type_Implied },
@@ -156,7 +156,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "JMP $(%04X,X)", GG_OPCode_Type_2b },
     { "ADC $%04X,X", GG_OPCode_Type_2b },
     { "ROR $%04X,X", GG_OPCode_Type_2b },
-    { "BBR7 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBR 7,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "BRA $%04X  [%+d]", GG_OPCode_Type_1b_Relative },
     { "STA $(%02X,X)", GG_OPCode_Type_1b },
@@ -165,7 +165,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "STY $%02X", GG_OPCode_Type_1b },
     { "STA $%02X", GG_OPCode_Type_1b },
     { "STX $%02X", GG_OPCode_Type_1b },
-    { "SMB0 $%02X", GG_OPCode_Type_1b },
+    { "SMB 0,$%02X", GG_OPCode_Type_1b },
     { "DEY", GG_OPCode_Type_Implied },
     { "BIT #$%02X", GG_OPCode_Type_1b },
     { "TXA", GG_OPCode_Type_Implied },
@@ -173,7 +173,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "STY $%04X", GG_OPCode_Type_2b },
     { "STA $%04X", GG_OPCode_Type_2b },
     { "STX $%04X", GG_OPCode_Type_2b },
-    { "BBS0 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBS 0,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "BCC $%04X  [%+d]", GG_OPCode_Type_1b_Relative },
     { "STA ($%02X),Y", GG_OPCode_Type_1b },
@@ -182,7 +182,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "STY $%02X,X", GG_OPCode_Type_1b },
     { "STA $%02X,X", GG_OPCode_Type_1b },
     { "STX $%02X,Y", GG_OPCode_Type_1b },
-    { "SMB1 $%02X", GG_OPCode_Type_1b },
+    { "SMB 1,$%02X", GG_OPCode_Type_1b },
     { "TYA", GG_OPCode_Type_Implied },
     { "STA $%04X,Y", GG_OPCode_Type_2b },
     { "TXS", GG_OPCode_Type_Implied },
@@ -190,7 +190,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "STZ $%04X", GG_OPCode_Type_2b },
     { "STA $%04X,X", GG_OPCode_Type_2b },
     { "STZ $%04X,X", GG_OPCode_Type_2b },
-    { "BBS1 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBS 1,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "LDY #$%02X", GG_OPCode_Type_1b },
     { "LDA $(%02X,X)", GG_OPCode_Type_1b },
@@ -199,7 +199,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "LDY $%02X", GG_OPCode_Type_1b },
     { "LDA $%02X", GG_OPCode_Type_1b },
     { "LDX $%02X", GG_OPCode_Type_1b },
-    { "SMB2 $%02X", GG_OPCode_Type_1b },
+    { "SMB 2,$%02X", GG_OPCode_Type_1b },
     { "TAY", GG_OPCode_Type_Implied },
     { "LDA #$%02X", GG_OPCode_Type_1b },
     { "TAX", GG_OPCode_Type_Implied },
@@ -207,7 +207,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "LDY $%04X", GG_OPCode_Type_2b },
     { "LDA $%04X", GG_OPCode_Type_2b },
     { "LDX $%04X", GG_OPCode_Type_2b },
-    { "BBS2 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBS 2,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "BCS $%04X  [%+d]", GG_OPCode_Type_1b_Relative },
     { "LDA ($%02X),Y", GG_OPCode_Type_1b },
@@ -216,7 +216,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "LDY $%02X,X", GG_OPCode_Type_1b },
     { "LDA $%02X,X", GG_OPCode_Type_1b },
     { "LDX $%02X,Y", GG_OPCode_Type_1b },
-    { "SMB3 $%02X", GG_OPCode_Type_1b },
+    { "SMB 3,$%02X", GG_OPCode_Type_1b },
     { "CLV", GG_OPCode_Type_Implied },
     { "LDA $%04X,Y", GG_OPCode_Type_2b },
     { "TSX", GG_OPCode_Type_Implied },
@@ -224,7 +224,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "LDY $%04X,X", GG_OPCode_Type_2b },
     { "LDA $%04X,X", GG_OPCode_Type_2b },
     { "LDX $%04X,Y", GG_OPCode_Type_2b },
-    { "BBS3 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBS 3,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "CPY #$%02X", GG_OPCode_Type_1b },
     { "CMP $(%02X,X)", GG_OPCode_Type_1b },
@@ -233,7 +233,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "CPY $%02X", GG_OPCode_Type_1b },
     { "CMP $%02X", GG_OPCode_Type_1b },
     { "DEC $%02X", GG_OPCode_Type_1b },
-    { "SMB4 $%02X", GG_OPCode_Type_1b },
+    { "SMB 4,$%02X", GG_OPCode_Type_1b },
     { "INY", GG_OPCode_Type_Implied },
     { "CMP #$%02X", GG_OPCode_Type_1b },
     { "DEX", GG_OPCode_Type_Implied },
@@ -241,7 +241,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "CPY $%04X", GG_OPCode_Type_2b },
     { "CMP $%04X", GG_OPCode_Type_2b },
     { "DEC $%04X", GG_OPCode_Type_2b },
-    { "BBS4 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBS 4,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "BNE $%04X  [%+d]", GG_OPCode_Type_1b_Relative },
     { "CMP ($%02X),Y", GG_OPCode_Type_1b },
@@ -250,7 +250,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "CSH", GG_OPCode_Type_Implied },
     { "CMP $%02X,X", GG_OPCode_Type_1b },
     { "DEC $%02X,X", GG_OPCode_Type_1b },
-    { "SMB5 $%02X", GG_OPCode_Type_1b },
+    { "SMB 5,$%02X", GG_OPCode_Type_1b },
     { "CLD", GG_OPCode_Type_Implied },
     { "CMP $%04X,Y", GG_OPCode_Type_2b },
     { "PHX", GG_OPCode_Type_Implied },
@@ -258,7 +258,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "NOP (UNOF)", GG_OPCode_Type_Implied },
     { "CMP $%04X,X", GG_OPCode_Type_2b },
     { "DEC $%04X,X", GG_OPCode_Type_2b },
-    { "BBS5 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBS 5,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "CPX #$%02X", GG_OPCode_Type_1b },
     { "SBC $(%02X,X)", GG_OPCode_Type_1b },
@@ -267,7 +267,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "CPX $%02X", GG_OPCode_Type_1b },
     { "SBC $%02X", GG_OPCode_Type_1b },
     { "INC $%02X", GG_OPCode_Type_1b },
-    { "SMB6 $%02X", GG_OPCode_Type_1b },
+    { "SMB 6,$%02X", GG_OPCode_Type_1b },
     { "INX", GG_OPCode_Type_Implied },
     { "SBC #$%02X", GG_OPCode_Type_1b },
     { "NOP", GG_OPCode_Type_Implied },
@@ -275,7 +275,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "CPX $%04X", GG_OPCode_Type_2b },
     { "SBC $%04X", GG_OPCode_Type_2b },
     { "INC $%04X", GG_OPCode_Type_2b },
-    { "BBS6 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
+    { "BBS 6,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative },
 
     { "BEQ $%04X  [%+d]", GG_OPCode_Type_1b_Relative },
     { "SBC ($%02X),Y", GG_OPCode_Type_1b },
@@ -284,7 +284,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "SET", GG_OPCode_Type_Implied },
     { "SBC $%02X,X", GG_OPCode_Type_1b },
     { "INC $%02X,X", GG_OPCode_Type_1b },
-    { "SMB7 $%02X", GG_OPCode_Type_1b },
+    { "SMB 7,$%02X", GG_OPCode_Type_1b },
     { "SED", GG_OPCode_Type_Implied },
     { "SBC $%04X,Y", GG_OPCode_Type_2b },
     { "PLX", GG_OPCode_Type_Implied },
@@ -292,7 +292,7 @@ static const GG_OPCode_Info k_opcode_names[256] = {
     { "NOP (UNOF)", GG_OPCode_Type_Implied },
     { "SBC $%04X,X", GG_OPCode_Type_2b },
     { "INC $%04X,X", GG_OPCode_Type_2b },
-    { "BBS7 $%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative }
+    { "BBS 7,$%02X,$%04X  [%+d]", GG_OPCode_Type_1b_1b_Relative }
 };
 
 #endif /* HUC6280_NAME_H */
\ No newline at end of file
diff --git a/src/memory.cpp b/src/memory.cpp
index 26158cc..d8a1478 100644
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -24,16 +24,34 @@ Memory::Memory(Cartridge* cartridge)
 {
     m_cartridge = cartridge;
     InitPointer(m_wram);
+    InitPointer(m_disassemblerMemoryMap);
 }
 
 Memory::~Memory()
 {
     SafeDeleteArray(m_wram);
+    if (IsValidPointer(m_disassemblerMemoryMap))
+    {
+        for (int i = 0; i < 0x200000; i++)
+        {
+            SafeDelete(m_disassemblerMemoryMap[i]);
+        }
+        SafeDeleteArray(m_disassemblerMemoryMap);
+    }
 }
 
 void Memory::Init()
 {
     m_wram = new u8[0x2000];
+
+#ifndef GG_DISABLE_DISASSEMBLER
+    m_disassemblerMemoryMap = new GG_Disassembler_Record*[0x200000];
+    for (int i = 0; i < 0x200000; i++)
+    {
+        InitPointer(m_disassemblerMemoryMap[i]);
+    }
+#endif
+
     Reset();
 }
 
@@ -52,4 +70,25 @@ void Memory::Reset()
     }
 }
 
+Memory::GG_Disassembler_Record* Memory::GetOrCreatDisassemblerRecord(u16 address)
+{
+    u32 physical_address = GetPhysicalAddress(address);
+
+    GG_Disassembler_Record* record = m_disassemblerMemoryMap[physical_address];
+
+    if (!IsValidPointer(record))
+    {
+        record = new GG_Disassembler_Record();
+        record->address = physical_address;
+        record->name[0] = 0;
+        record->bytes[0] = 0;
+        record->size = 0;
+        for (int i = 0; i < 7; i++) record->opcodes[i] = 0;
+        record->jump = false;
+        record->jump_address = 0;
+        m_disassemblerMemoryMap[physical_address] = record;
+    }
+
+    return record;
 
+}
\ No newline at end of file
diff --git a/src/memory.h b/src/memory.h
index e266c2f..302978a 100644
--- a/src/memory.h
+++ b/src/memory.h
@@ -26,6 +26,18 @@ class Cartridge;
 
 class Memory
 {
+public:
+    struct GG_Disassembler_Record
+    {
+        u32 address;
+        char name[64];
+        char bytes[20];
+        int size;
+        u8 opcodes[7];
+        bool jump;
+        u16 jump_address;
+    };
+
 public:
     Memory(Cartridge* cartridge);
     ~Memory();
@@ -35,11 +47,13 @@ class Memory
     void Write(u16 address, u8 value);
     void SetMpr(u8 index, u8 value);
     u8 GetMpr(u8 index);
+    GG_Disassembler_Record* GetOrCreatDisassemblerRecord(u16 address);
 
 private:
     Cartridge* m_cartridge;
     u8 m_mpr[8];
     u8* m_wram;
+    GG_Disassembler_Record** m_disassemblerMemoryMap;
 
 private:
     u32 GetPhysicalAddress(u16 address);
diff --git a/src/types.h b/src/types.h
index 07b3889..a679da3 100644
--- a/src/types.h
+++ b/src/types.h
@@ -81,7 +81,7 @@ enum GG_OPCode_Type
     GG_OPCode_Type_2b,
     GG_OPCode_Type_2b_2b_2b,
     GG_OPCode_Type_1b_Relative,
-    GG_OPCode_Type_1b_1b_Relative,
+    GG_OPCode_Type_1b_1b_Relative
 };
 
 struct GG_OPCode_Info
@@ -90,4 +90,12 @@ struct GG_OPCode_Info
     GG_OPCode_Type type;
 };
 
+enum GG_Debugger_Command
+{
+    GG_Debugger_Command_Continue,
+    GG_Debugger_Command_StepInto,
+    GG_Debugger_Command_StepOver,
+    GG_Debugger_Command_StepOut
+};
+
 #endif /* TYPES_H */
\ No newline at end of file