Develop and implement the most enhanced UI design that you can do based off this code:
Provide the full redesign ( a.k.a provide the full main.rs )

main.rs:
use arch::x86::ArchSyntax;
use capstone::{prelude::*, Capstone};
use eframe::{
    egui::{
        self, menu, CentralPanel, Color32, Context, FontId, Layout, RichText, ScrollArea,
        SidePanel, TopBottomPanel,
    },
    emath::Align,
    App, CreationContext, Frame, NativeOptions,
};
use object::{Object, ObjectSection, SectionKind, SymbolKind, SymbolScope};
use rfd::FileDialog;
use rustc_demangle::demangle;
use std::str;
use std::sync::Arc;
use std::{borrow::Cow, collections::HashMap, fs::File, io::Read};

mod symbol;
use symbol::{extract_symbols, SymbolInfo};

fn main() {
    let app = BinaryAnalyzerApp::default();
    let native_options = NativeOptions {
        viewport: egui::ViewportBuilder::default().with_inner_size([1024.0, 768.0]),
        ..Default::default()
    };
    eframe::run_native(
        "Rust Binary Analyzer",
        native_options,
        Box::new(|cc| Ok(Box::new(app.setup(cc)))),
    )
    .expect("Failed to start eframe");
}

struct BinaryAnalyzerApp {
    binary_path: String,
    analysis_result: AnalysisResult,
    error_message: Option<String>,
    selected_section: Option<SectionInfo>,
    selected_symbol: Option<SymbolInfo>,
    dark_mode: bool,
    recent_files: Vec<String>,
    disassembly_cache: HashMap<u64, String>,
    search_query: String,
    tab_index: usize,
    selected_string: Option<StringInfo>,
}

impl Default for BinaryAnalyzerApp {
    fn default() -> Self {
        Self {
            binary_path: String::new(),
            analysis_result: AnalysisResult::default(),
            error_message: None,
            selected_section: None,
            selected_symbol: None,
            dark_mode: true,
            recent_files: Vec::new(),
            disassembly_cache: HashMap::new(),
            search_query: String::new(),
            tab_index: 0,
            selected_string: None,
        }
    }
}

impl BinaryAnalyzerApp {
    fn setup(self, cc: &CreationContext) -> Self {
        // Set initial dark mode
        if self.dark_mode {
            cc.egui_ctx.set_visuals(egui::Visuals::dark());
        } else {
            cc.egui_ctx.set_visuals(egui::Visuals::light());
        }
        self
    }
}

impl App for BinaryAnalyzerApp {
    fn update(&mut self, ctx: &Context, _frame: &mut Frame) {
        self.top_panel(ctx);
        self.side_panel(ctx);
        self.central_panel(ctx);
        self.status_bar(ctx);
        self.handle_file_drop(ctx);
    }
}

impl BinaryAnalyzerApp {
    /// Draws the top menu bar
    fn top_panel(&mut self, ctx: &Context) {
        TopBottomPanel::top("menu_bar").show(ctx, |ui| {
            menu::bar(ui, |ui| {
                // File Menu
                ui.menu_button("File", |ui| {
                    if ui.button("Open...").clicked() {
                        self.open_file_dialog();
                        ui.close_menu();
                    }
                    if ui.button("Exit").clicked() {
                        std::process::exit(0);
                    }
                });

                // View Menu
                ui.menu_button("View", |ui| {
                    if ui.checkbox(&mut self.dark_mode, "Dark Mode").clicked() {
                        if self.dark_mode {
                            ctx.set_visuals(egui::Visuals::dark());
                        } else {
                            ctx.set_visuals(egui::Visuals::light());
                        }
                    }
                    ui.separator();
                    if ui.button("Refresh").clicked() {
                        self.perform_analysis();
                        ui.close_menu();
                    }
                });

                // Help Menu
                ui.menu_button("Help", |ui| {
                    if ui.button("About").clicked() {
                        ui.close_menu();
                        self.show_about(ctx);
                    }
                });

                ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
                    ui.label(
                        RichText::new("🔍 Rust Binary Analyzer").font(FontId::proportional(12.0)),
                    );
                });
            });
        });
    }

    /// Draws the side panel for navigation
    fn side_panel(&mut self, ctx: &Context) {
        SidePanel::left("side_panel")
            .min_width(250.0)
            .resizable(true)
            .show(ctx, |ui| {
                ui.heading("Explorer");
                ui.separator();

                if !self.analysis_result.is_empty() {
                    // Search bar
                    ui.horizontal(|ui| {
                        ui.label("🔎 Search:");
                        ui.text_edit_singleline(&mut self.search_query);
                    });
                    ui.add_space(10.0);

                    ui.vertical(|ui| {
                        ui.spacing_mut().item_spacing.y = 10.0;
                        ui.collapsing("📁 Sections", |ui| {
                            ScrollArea::vertical().show(ui, |ui| {
                                for section in &self.analysis_result.sections {
                                    if ui
                                        .selectable_label(
                                            self.selected_section
                                                .as_ref()
                                                .map_or(false, |s| s.name == section.name),
                                            section.name.clone(),
                                        )
                                        .clicked()
                                    {
                                        self.selected_section = Some(section.clone());
                                        self.selected_symbol = None;
                                        self.selected_string = None;
                                        self.tab_index = 0;
                                    }
                                }
                            });
                        });

                        ui.collapsing("🔖 Symbols", |ui| {
                            ScrollArea::vertical().show(ui, |ui| {
                                let symbols = if !self.search_query.is_empty() {
                                    let query = self.search_query.to_lowercase();
                                    self.analysis_result
                                        .symbols
                                        .iter()
                                        .filter(|symbol| {
                                            symbol.demangled_name.to_lowercase().contains(&query)
                                        })
                                        .cloned()
                                        .collect::<Vec<SymbolInfo>>()
                                } else {
                                    self.analysis_result.symbols.clone()
                                };

                                for symbol in symbols {
                                    let display_name = symbol.demangled_name.clone();
                                    if ui
                                        .selectable_label(
                                            self.selected_symbol
                                                .as_ref()
                                                .map_or(false, |s| s.name == symbol.name),
                                            display_name,
                                        )
                                        .clicked()
                                    {
                                        self.selected_symbol = Some(symbol.clone());
                                        self.selected_section = None;
                                        self.selected_string = None;
                                        self.tab_index = 1;
                                    }
                                }
                            });
                        });

                        ui.collapsing("💬 Strings", |ui| {
                            ScrollArea::vertical().show(ui, |ui| {
                                let strings = if !self.search_query.is_empty() {
                                    let query = self.search_query.to_lowercase();
                                    self.analysis_result
                                        .strings
                                        .iter()
                                        .filter(|string_info| {
                                            string_info.value.to_lowercase().contains(&query)
                                        })
                                        .cloned()
                                        .collect::<Vec<StringInfo>>()
                                } else {
                                    self.analysis_result.strings.clone()
                                };

                                for string_info in strings {
                                    if ui
                                        .selectable_label(
                                            self.selected_string.as_ref().map_or(false, |s| {
                                                s.address == string_info.address
                                            }),
                                            &string_info.value,
                                        )
                                        .clicked()
                                    {
                                        self.selected_string = Some(string_info.clone());
                                        self.selected_section = None;
                                        self.selected_symbol = None;
                                        self.tab_index = 2;
                                    }
                                }
                            });
                        });
                    });
                } else {
                    ui.label("No file loaded.");
                }
            });
    }

    /// Draws the central panel displaying analysis results
    fn central_panel(&mut self, ctx: &Context) {
        CentralPanel::default().show(ctx, |ui| {
            if self.analysis_result.is_empty() {
                ui.centered_and_justified(|ui| {
                    ui.label(
                        RichText::new(
                            "Drag and drop a binary file here or use File > Open to start.",
                        )
                        .italics(),
                    );
                });
            } else {
                egui::TopBottomPanel::top("info_panel").show_inside(ui, |ui| {
                    ui.horizontal_wrapped(|ui| {
                        ui.label("Format:");
                        ui.monospace(format!("{:?}", self.analysis_result.format));
                        ui.separator();
                        ui.label("Arch:");
                        ui.monospace(format!("{:?}", self.analysis_result.architecture));
                        ui.separator();
                        ui.label("Endianness:");
                        ui.monospace(format!("{:?}", self.analysis_result.endianness));
                        ui.separator();
                        ui.label("File Size:");
                        ui.monospace(format!(
                            "{:.2} KB",
                            self.analysis_result.file_size as f64 / 1024.0
                        ));
                    });
                });

                ui.add_space(5.0);

                let tabs = vec![
                    "Section Details",
                    "Symbol Details",
                    "String Details",
                    "Disassembly",
                ];
                ui.horizontal(|ui| {
                    for (i, tab) in tabs.iter().enumerate() {
                        let selected = self.tab_index == i;
                        if ui.selectable_label(selected, *tab).clicked() {
                            self.tab_index = i;
                        }
                    }
                });
                ui.separator();
                ui.add_space(5.0);

                match self.tab_index {
                    0 => self.display_section_details(ui),
                    1 => self.display_symbol_details(ui),
                    2 => self.display_string_details(ui),
                    3 => self.display_disassembly(ui),
                    _ => {}
                }
            }
        });
    }

    /// Displays the status bar at the bottom
    fn status_bar(&self, ctx: &Context) {
        TopBottomPanel::bottom("status_bar").show(ctx, |ui| {
            ui.horizontal(|ui| {
                if !self.binary_path.is_empty() {
                    ui.label(format!("📄 File: {}", self.binary_path));
                }
                ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
                    ui.label("Ready");
                });
            });
        });
    }

    /// Displays section details in the central panel
    fn display_section_details(&mut self, ui: &mut egui::Ui) {
        if let Some(section) = &self.selected_section {
            ui.heading(format!("📄 Section: {}", section.name));
            ui.separator();
            ui.monospace(format!("Address: 0x{:X}", section.address));
            ui.monospace(format!("Size: {}", section.size));
            ui.monospace(format!("Flags: {:?}", section.flags));
            ui.add_space(10.0);
            ui.monospace(format!("Type: {:?}", section.kind));
            ui.monospace(format!("Relocation Entries: {}", section.relocations.len()));
            ui.add_space(10.0);

            if !section.data.is_empty() {
                ui.collapsing("🔎 Hex View", |ui| {
                    ScrollArea::both().show(ui, |ui| {
                        self.display_hex_view(ui, &section.data);
                    });
                });
            }
        } else {
            ui.label("Select a section from the left panel to view details.");
        }
    }

    /// Displays symbol details in the central panel
    fn display_symbol_details(&mut self, ui: &mut egui::Ui) {
        if let Some(symbol) = &self.selected_symbol {
            ui.heading(format!("🔖 Symbol: {}", symbol.demangled_name));
            ui.separator();
            ui.monospace(format!("Name: {}", symbol.name));
            ui.monospace(format!("Address: 0x{:X}", symbol.address));
            ui.monospace(format!("Size: {}", symbol.size));
            ui.monospace(format!("Kind: {:?}", symbol.kind));
            ui.monospace(format!("Scope: {:?}", symbol.scope));
            ui.monospace(format!("Section: {:?}", symbol.section));
            ui.monospace(format!("Import: {}", symbol.is_import));
            ui.monospace(format!("Export: {}", symbol.is_export));
            ui.add_space(10.0);
        } else {
            ui.label("Select a symbol from the left panel to view details.");
        }
    }

    /// Displays string details in the central panel
    fn display_string_details(&mut self, ui: &mut egui::Ui) {
        if let Some(string_info) = &self.selected_string {
            ui.heading("💬 String Details");
            ui.separator();
            ui.monospace(format!("Address: 0x{:X}", string_info.address));
            ui.monospace(format!("Value: {}", string_info.value));
            ui.add_space(10.0);
        } else {
            ui.label("Select a string from the left panel to view details.");
        }
    }

    /// Displays disassembly of code sections
    fn display_disassembly(&mut self, ui: &mut egui::Ui) {
        if let Some(section) = &self.selected_section {
            if section.is_executable {
                ui.heading(format!("🧩 Disassembly of {}", section.name));
                ui.separator();
                if let Some(disassembly) = self.disassembly_cache.get(&section.address) {
                    ScrollArea::vertical().show(ui, |ui| {
                        self.display_syntax_highlighted_disassembly(ui, disassembly);
                    });
                } else {
                    ui.label("Disassembling...");
                    if let Ok(disassembly) = self.perform_disassembly(section) {
                        self.disassembly_cache
                            .insert(section.address, disassembly.clone());
                        ScrollArea::vertical().show(ui, |ui| {
                            self.display_syntax_highlighted_disassembly(ui, &disassembly);
                        });
                    } else {
                        ui.label("Failed to disassemble section.");
                    }
                }
            } else {
                ui.label("Selected section is not executable.");
            }
        } else {
            ui.label("Select an executable section to disassemble.");
        }
    }

    /// Performs the binary analysis
    fn perform_analysis(&mut self) {
        match analyze_binary(&self.binary_path) {
            Ok(result) => {
                self.analysis_result = result;
                self.error_message = None;
                self.selected_section = None;
                self.selected_symbol = None;
                self.selected_string = None;
                self.disassembly_cache.clear();
            }
            Err(e) => {
                self.analysis_result = AnalysisResult::default();
                self.error_message = Some(e);
                self.selected_section = None;
                self.selected_symbol = None;
                self.selected_string = None;
                self.disassembly_cache.clear();
            }
        }
    }

    /// Opens the file dialog to select a binary file
    fn open_file_dialog(&mut self) {
        if let Some(path) = FileDialog::new().pick_file() {
            self.binary_path = path.display().to_string();
            self.perform_analysis();
            self.recent_files.push(self.binary_path.clone());
        }
    }

    /// Displays the hex view of the data
    fn display_hex_view(&self, ui: &mut egui::Ui, data: &[u8]) {
        let bytes_per_row = 16;
        let mut offset = 0;
        while offset < data.len() {
            let end = usize::min(offset + bytes_per_row, data.len());
            let row = &data[offset..end];

            let hex_row: String = row.iter().map(|b| format!("{:02X} ", b)).collect();
            let ascii_row: String = row
                .iter()
                .map(|b| {
                    if b.is_ascii_graphic() {
                        *b as char
                    } else {
                        '.'
                    }
                })
                .collect();

            ui.horizontal_wrapped(|ui| {
                ui.label(format!("{:08X}: ", offset));
                ui.monospace(&hex_row);
                ui.add_space(10.0);
                ui.monospace(&ascii_row);
            });

            offset += bytes_per_row;
        }
    }

    /// Performs disassembly on the given section
    fn perform_disassembly(&self, section: &SectionInfo) -> Result<String, String> {
        let cs = Capstone::new()
            .x86()
            .mode(self.analysis_result.capstone_mode)
            .syntax(capstone::arch::x86::ArchSyntax::Intel)
            .detail(true)
            .build()
            .map_err(|e| format!("Capstone error: {}", e))?;

        let insns = cs
            .disasm_all(&section.data, section.address)
            .map_err(|e| format!("Disassembly error: {}", e))?;

        let mut disassembly = String::new();
        for i in insns.iter() {
            disassembly.push_str(&format!(
                "0x{:08X}\t{}\t{}\n",
                i.address(),
                i.mnemonic().unwrap_or(""),
                i.op_str().unwrap_or(""),
            ));
        }
        Ok(disassembly)
    }

    /// Display disassembly with basic syntax highlighting
    fn display_syntax_highlighted_disassembly(&self, ui: &mut egui::Ui, disassembly: &str) {
        for line in disassembly.lines() {
            let parts: Vec<&str> = line.splitn(3, '\t').collect();
            if parts.len() == 3 {
                ui.horizontal(|ui| {
                    ui.monospace(parts[0]);
                    ui.add_space(10.0);
                    ui.colored_label(Color32::LIGHT_BLUE, parts[1]);
                    ui.add_space(10.0);
                    ui.monospace(parts[2]);
                });
            } else {
                ui.monospace(line);
            }
        }
    }

    /// Shows the About dialog
    fn show_about(&self, ctx: &Context) {
        egui::Window::new("About Rust Binary Analyzer")
            .resizable(false)
            .show(ctx, |ui| {
                ui.label("Rust Binary Analyzer");
                ui.label("Version 1.0.0");
                ui.label("Developed with 💖 in Rust and egui");
            });
    }

    /// Handles file drop events
    fn handle_file_drop(&mut self, ctx: &egui::Context) {
        let dropped_file = ctx.input(|i| i.raw.dropped_files.first().cloned());
        if let Some(file) = dropped_file {
            if let Some(path) = file.path {
                self.binary_path = path.display().to_string();
                self.perform_analysis();
            }
        }
    }
}

struct AnalysisResult {
    format: object::BinaryFormat,
    architecture: object::Architecture,
    endianness: object::Endianness,
    capstone_arch: capstone::Arch,
    capstone_mode: capstone::arch::x86::ArchMode,
    file_size: u64,
    sections: Vec<SectionInfo>,
    symbols: Vec<SymbolInfo>,
    strings: Vec<StringInfo>,
}

impl Default for AnalysisResult {
    fn default() -> Self {
        AnalysisResult {
            format: object::BinaryFormat::Elf,
            architecture: object::Architecture::Unknown,
            endianness: object::Endianness::Little,
            capstone_arch: capstone::Arch::X86,
            capstone_mode: capstone::arch::x86::ArchMode::Mode64.into(),
            file_size: 0,
            sections: Vec::new(),
            symbols: Vec::new(),
            strings: Vec::new(),
        }
    }
}

impl AnalysisResult {
    fn is_empty(&self) -> bool {
        self.sections.is_empty() && self.symbols.is_empty() && self.strings.is_empty()
    }
}

#[derive(Clone)]
struct SectionInfo {
    name: String,
    address: u64,
    size: u64,
    data: Vec<u8>,
    flags: object::SectionFlags,
    kind: SectionKind,
    relocations: Arc< Vec<object::Relocation> >,
    is_executable: bool,
}

#[derive(Clone)]
struct StringInfo {
    address: u64,
    value: String,
}

fn analyze_binary(path: &str) -> Result<AnalysisResult, String> {
    let mut file = File::open(path).map_err(|e| format!("Failed to open file: {}", e))?;
    let metadata = file
        .metadata()
        .map_err(|e| format!("Failed to get file metadata: {}", e))?;
    let file_size = metadata.len();

    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer)
        .map_err(|e| format!("Failed to read file: {}", e))?;

    let obj_file =
        object::File::parse(&*buffer).map_err(|e| format!("Failed to parse binary: {}", e))?;

    let mut sections = Vec::new();
    for section in obj_file.sections() {
        let data = section
            .uncompressed_data()
            .unwrap_or(Cow::Borrowed(&[]))
            .to_vec();
        let is_executable = section.kind() == SectionKind::Text;
        let section_info = SectionInfo {
            name: section.name().unwrap_or("Unknown").to_string(),
            address: section.address(),
            size: section.size(),
            data,
            flags: section.flags(),
            kind: section.kind(),
            relocations: Arc::new(section.relocations().map(|(_, reloc)| reloc).collect()), // Wrap in Arc::new
            is_executable,
        };
        sections.push(section_info);
    }

    // Use the extract_symbols function from symbol.rs
    let symbols = extract_symbols(&obj_file);

    // Extract strings from the collected sections
    let strings = extract_strings(&sections);

    // Determine Capstone architecture and mode based on object file architecture
    let (capstone_arch, capstone_mode) = get_capstone_arch_mode(&obj_file);

    Ok(AnalysisResult {
        format: obj_file.format(),
        architecture: obj_file.architecture(),
        endianness: obj_file.endianness(),
        capstone_arch,
        capstone_mode,
        file_size,
        sections,
        symbols,
        strings,
    })
}

/// Maps object architecture to Capstone architecture and mode
fn get_capstone_arch_mode(
    obj_file: &object::File,
) -> (capstone::Arch, capstone::arch::x86::ArchMode) {
    match obj_file.architecture() {
        object::Architecture::X86_64 => (
            capstone::Arch::X86,
            capstone::arch::x86::ArchMode::Mode64.into(),
        ),
        object::Architecture::I386 => (
            capstone::Arch::X86,
            capstone::arch::x86::ArchMode::Mode32.into(),
        ),
        _ => (
            capstone::Arch::X86,
            capstone::arch::x86::ArchMode::Mode64.into(),
        ),
    }
}

/// Extract printable ASCII strings from the sections likely to contain strings
fn extract_strings(sections: &[SectionInfo]) -> Vec<StringInfo> {
    let mut strings = Vec::new();

    for section in sections {
        // Check if the section is likely to contain strings
        if !section.name.contains(".rodata")
            && !section.name.contains(".data")
            && !section.name.contains(".rdata")
            && !section.name.contains(".text")
        {
            continue;
        }

        let data = &section.data;
        let mut i = 0;
        while i < data.len() {
            // Skip non-printable characters
            while i < data.len() && !(data[i].is_ascii_graphic() || data[i].is_ascii_whitespace()) {
                i += 1;
            }
            let start = i;
            // Collect printable ASCII characters
            while i < data.len() && (data[i].is_ascii_graphic() || data[i].is_ascii_whitespace()) {
                i += 1;
            }
            let end = i;
            // If the collected string is long enough, add it to the list
            if end - start >= 4 {
                if let Ok(s) = String::from_utf8(data[start..end].to_vec()) {
                    strings.push(StringInfo {
                        address: section.address + start as u64,
                        value: s,
                    });
                }
            }
        }
    }

    strings
}

symbol.rs:


use object::{Object, ObjectSymbol, ObjectSymbolTable, SymbolFlags, SymbolKind, SymbolScope, SymbolSection};
use rustc_demangle::demangle;
use std::collections::HashMap;

/// Represents detailed information about a symbol.
#[derive(Clone)]
pub struct SymbolInfo {
    pub name: String,
    pub demangled_name: String,
    pub address: u64,
    pub size: u64,
    pub kind: SymbolKind,
    pub scope: SymbolScope,
    pub section: SymbolSection,
    pub is_import: bool,
    pub is_export: bool,
}

/// Extracts symbols from the given object file, including dynamic and debug symbols.
/// It returns a vector of SymbolInfo with detailed information about each symbol.
pub fn extract_symbols<'data, 'file>(
    obj_file: &object::File<'data>,
) -> Vec<SymbolInfo> {
    let mut symbols = Vec::new();

    // Collect symbols from the symbol table
    for symbol in obj_file.symbols() {
        if let Some(symbol_info) = process_symbol(&symbol) {
            symbols.push(symbol_info);
        }
    }

    // Collect dynamic symbols (useful for shared libraries and executables)
    for symbol in obj_file.dynamic_symbols() {
        if let Some(symbol_info) = process_symbol(&symbol) {
            symbols.push(symbol_info);
        }
    }
    // Optionally, collect symbols from debug sections if available
    if let Some(symbol_table) = obj_file.symbol_table() {
        for symbol in symbol_table.symbols() {
            if let Some(symbol_info) = process_symbol(&symbol) {
                symbols.push(symbol_info);
            }
        }
    }

    // Remove duplicates based on the symbol's address and name
    let mut seen = HashMap::new();
    symbols.retain(|s| {
        let key = (s.address, s.name.clone());
        if seen.contains_key(&key) {
            false
        } else {
            seen.insert(key, true);
            true
        }
    });

    // Sort symbols by address
    symbols.sort_by_key(|s| s.address);

    symbols
}

/// Processes a single symbol and returns Some(SymbolInfo) if valid, or None otherwise.
fn process_symbol<'data, 'file>(symbol: &object::Symbol<'data, 'file>) -> Option<SymbolInfo> {
    if symbol.address() == 0 {
        return None;
    }

    if symbol.kind() == SymbolKind::Section {
        return None;
    }

    if let Ok(name) = symbol.name() {
        let demangled_name = demangle(name).to_string();
        Some(SymbolInfo {
            name: name.to_string(),
            demangled_name,
            address: symbol.address(),
            size: symbol.size(),
            kind: symbol.kind(),
            scope: symbol.scope(),
            section: symbol.section(),
            is_import: false,
            is_export: false,
        })
    } else {
        None
    }
}