Respan Dataset Explorer

There are fifteen girls standing in a line facing North. Suman is standing at 11th position from the right side. Radhika is standing at 9th position from the left side. Mina is standing between Suman and Radhika. Find the number of girls standing to the right of Mina.

7 girls  
6 girls  
8 girls  
5 girls

To determine the number of girls standing to the right of Mina, let's break down the information provided:

1. **Total Girls:** 15
2. **Suman's Position:**
   - **From the Right:** 11th position
   - **From the Left:** \( 15 - 11 + 1 = 5 \)th position
3. **Radhika's Position:** 9th position from the left
4. **Mina's Position:** Between Suman (5th) and Radhika (9th), so Mina can be at the 6th, 7th, or 8th position.

To find the number of girls to the right of Mina:

- **If Mina is at the 6th position:** \( 15 - 6 = 9 \) girls to the right
- **If Mina is at the 7th position:** \( 15 - 7 = 8 \) girls to the right
- **If Mina is at the 8th position:** \( 15 - 8 = 7 \) girls to the right

Among the given options (7, 6, 8, 5), the most appropriate answer is when Mina is at the **8th position**, resulting in **7 girls** standing to her right.

**Answer:**  
7 girls

only take out these functinality and make a separate script, drawing recatngle using mouse, screenshot being taken, sent to ocr, extraced text and than that extracted text should be sent to clipboard : import re
import mss
from PIL import Image, ImageEnhance
import pytesseract
import speech_recognition as sr
import pyttsx3
import keyboard
import threading
import os
import logging
import tkinter as tk
import ctypes
import sys
import ollama
import asyncio
from datetime import datetime
from word2number import w2n
from langchain.vectorstores import FAISS
from langchain_huggingface import HuggingFaceEmbeddings
from sentence_transformers import SentenceTransformer

# -------------------- Configuration --------------------

# Define a custom logging filter to exclude specific messages
class ExcludeFilter(logging.Filter):
    def __init__(self, exclude_keywords):
        super().__init__()
        self.exclude_keywords = exclude_keywords

    def filter(self, record):
        return not any(keyword in record.getMessage() for keyword in self.exclude_keywords)

# Configure logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)  # Set to INFO to include INFO and higher level logs

# Create a stream handler
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)

# Define the log format
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(message)s')
stream_handler.setFormatter(formatter)

# Define keywords to exclude from logging
excluded_keywords = [
    "Mouse moved to",
    "Width:",
    "Height:",
    "Monitor for capture:"
]

# Add the custom filter to the handler
stream_handler.addFilter(ExcludeFilter(excluded_keywords))

# Add the handler to the logger
if not logger.handlers:
    logger.addHandler(stream_handler)
else:
    # Remove existing handlers to prevent duplicate logs
    logger.handlers = []
    logger.addHandler(stream_handler)

# Initialize TTS engine
tts_engine = pyttsx3.init()
is_listening = False
ocr_text = ""

lock = threading.Lock()
tts_lock = threading.Lock()

OUTPUT_DIR = r"D:\AI\EXP2\TempS"

# Initialize RAG components
embedding_model_name = "all-mpnet-base-v2"  # Use a more robust model
embeddings = HuggingFaceEmbeddings(model_name=embedding_model_name)
vector_store = FAISS.load_local(r"D:\AI\EXP2\faiss_index", embeddings,allow_dangerous_deserialization=True)

def set_dpi_awareness():
    try:
        if sys.platform.startswith('win'):
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
            logging.info("Process DPI awareness set to SYSTEM_AWARE.")
    except Exception as e:
        logging.warning(f"Could not set DPI awareness: {e}. Continuing without setting DPI awareness.")

def get_scaling_factor():
    try:
        if sys.platform.startswith('win'):
            user32 = ctypes.windll.user32
            try:
                user32.SetProcessDPIAware()
                dpi = user32.GetDpiForWindow(user32.GetForegroundWindow())
                scaling_factor = dpi / 96
                logging.info(f"DPI Scaling Factor detected: {scaling_factor}")
                return scaling_factor
            except AttributeError:
                user32.SetProcessDPIAware()
                hdc = user32.GetDC(0)
                LOGPIXELSX = 88
                dpi = ctypes.windll.gdi32.GetDeviceCaps(hdc, LOGPIXELSX)
                scaling_factor = dpi / 96
                ctypes.windll.user32.ReleaseDC(0, hdc)
                logging.info(f"DPI Scaling Factor detected via fallback: {scaling_factor}")
                return scaling_factor
        else:
            logging.info("Non-Windows OS detected. Defaulting DPI scaling factor to 1.0.")
            return 1.0
    except Exception as e:
        logging.warning(f"Could not retrieve DPI scaling factor: {e}. Defaulting to 1.0.")
        return 1.0

def convert_number_words(text):
    """
    Converts number words in the speech text to digits.
    Example: "five hundred ninety-seven" -> "597"
    """
    try:
        # Attempt to convert the entire text
        number = w2n.word_to_num(text)
        return str(number)
    except:
        # Attempt to extract digits directly if conversion fails
        digits = re.findall(r'\d+', text)
        return ''.join(digits) if digits else text  # Return the number if found, else original text

def strip_markdown(text):
    """Function to remove Markdown syntax from text."""
    # Remove asterisks, underscores, and backticks
    text = re.sub(r'[*_`]', '', text)
    # Remove links [text](url)
    text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)
    # Remove headings ## Heading
    text = re.sub(r'#+\s?', '', text)
    # Add more patterns as necessary
    return text

def speak_text(text):
    global tts_engine
    logging.info(f"Speaking out the response: {text}")
    with tts_lock:
        try:
            tts_engine.say(text)

            # Add hotkeys for pausing (F4) and stopping (F5)
            keyboard.add_hotkey('f4', pause_speaking)
            keyboard.add_hotkey('f5', stop_speaking)

            tts_engine.runAndWait()
            logging.info("Text-to-Speech completed.")
        except RuntimeError as e:
            logging.error(f"TTS Error: {e}")
        finally:
            keyboard.remove_hotkey('f4')
            keyboard.remove_hotkey('f5')

def pause_speaking():
    global tts_engine
    logging.info("Paused speaking...")
    # pyttsx3 does not support pausing natively. Placeholder.

def stop_speaking():
    global tts_engine
    logging.info("Stopped speaking.")
    tts_engine.stop()

def save_captured_image(image, output_dir, prefix="captured_region"):
    try:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = os.path.join(output_dir, f"{prefix}_{timestamp}.png")
        image.save(filename)
        logging.info(f"Captured image saved as {filename}")
    except Exception as e:
        logging.error(f"Failed to save captured image: {e}")

def save_preprocessed_image(image, output_dir, prefix="preprocessed_image"):
    try:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = os.path.join(output_dir, f"{prefix}_{timestamp}.png")
        image.save(filename)
        logging.info(f"Preprocessed image saved as {filename}")
    except Exception as e:
        logging.error(f"Failed to save preprocessed image: {e}")

def perform_ocr(image):
    global ocr_text
    try:
        logging.info("Starting OCR process with image preprocessing...")

        save_captured_image(image, OUTPUT_DIR)

        gray = image.convert('L')
        # Removed DEBUG logs related to image processing

        enhancer = ImageEnhance.Contrast(gray)
        gray_enhanced = enhancer.enhance(1.0)
        # Removed DEBUG logs related to image processing

        threshold = 190
        gray_threshold = gray_enhanced.point(lambda x: 0 if x < threshold else 255, '1')
        # Removed DEBUG logs related to image processing

        final_image = gray_threshold

        save_preprocessed_image(final_image, OUTPUT_DIR)

        logging.info("Image preprocessing complete. Performing OCR...")

        custom_config = r'--oem 3 --psm 6'
        raw_text = pytesseract.image_to_string(final_image, lang='eng', config=custom_config)

        if not raw_text.strip():
            logging.warning("OCR returned empty text.")
            speak_text("I couldn't detect any text in the selected area. Please try again with a different region.")
        else:
            ocr_text = raw_text.strip()
            logging.info(f"OCR Text: {ocr_text}")  # Log the extracted OCR text
            logging.info("OCR process completed successfully.")
    except pytesseract.TesseractNotFoundError:
        logging.error("Tesseract executable not found. Please ensure Tesseract is installed and PATH is set correctly.")
        speak_text("Tesseract is not installed or not found. Please install Tesseract and try again.")
        ocr_text = ""
    except Exception as e:
        logging.error(f"OCR Error: {e}")
        speak_text("An error occurred during OCR processing. Please try again.")
        ocr_text = ""

def get_selected_region(scaling_factor):
    root = tk.Tk()
    root.title("Select Region (Press Esc to Cancel)")
    root.attributes('-alpha', 0.3)
    root.attributes("-topmost", True)
    root.overrideredirect(True)

    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()
    root.geometry(f"{screen_width}x{screen_height}")

    canvas = tk.Canvas(root, cursor="cross", bg="grey")
    canvas.pack(fill=tk.BOTH, expand=True)

    rect = None
    start_x = start_y = end_x = end_y = 0

    def on_button_press(event):
        nonlocal start_x, start_y, rect
        start_x = int(event.x * scaling_factor)
        start_y = int(event.y * scaling_factor)
        rect = canvas.create_rectangle(event.x, event.y, event.x, event.y, outline='red', width=2)
        logging.info("Please select the region by clicking and dragging the mouse.")

    def on_move_press(event):
        nonlocal end_x, end_y
        end_x = int(event.x * scaling_factor)
        end_y = int(event.y * scaling_factor)
        canvas.coords(rect, start_x / scaling_factor, start_y / scaling_factor, event.x, event.y)

    def on_button_release(event):
        root.quit()
        root.destroy()

    def on_escape(event):
        logging.info("Capture cancelled by user.")
        root.quit()
        root.destroy()
        sys.exit()

    canvas.bind("<ButtonPress-1>", on_button_press)
    canvas.bind("<B1-Motion>", on_move_press)
    canvas.bind("<ButtonRelease-1>", on_button_release)
    root.bind("<Escape>", on_escape)

    root.mainloop()

    left = min(start_x, end_x)
    top = min(start_y, end_y)
    right = max(start_x, end_x)
    bottom = max(start_y, end_y)

    logging.info(f"Selected region coordinates (scaled): Left={left}, Top={top}, Right={right}, Bottom={bottom}")
    return (left, top, right, bottom)

def generate_final_response(ocr_text):
    logging.info("Generating final response...")
    
    # Retrieve relevant documents from the knowledge base
    query = ocr_text
    retrieved_docs = vector_store.similarity_search(query, k=5)  # Adjust 'k' as needed
    retrieved_text = "\n".join([doc.page_content for doc in retrieved_docs])

    # Combine OCR text with retrieved context
    context = f"""Assume the role of a strategist who excels at logical problem-solving and planning based on the following information.

Retrieved Information:
{retrieved_text}

OCR Text:
{ocr_text}

Instructions:
1. Understand the OCR text and treat it as a comprehensive multiple-choice question.
2. Identify the correct answer from options (if provided within text).
3. Respond in plain text without any Markdown formatting.
4. Eliminate all Markdown syntax such as asterisks (*), underscores (_), backticks (`), and brackets ([]).
5. Keep your answer strictly to 100 words.
6. If there is calculation involved, follow this structure:
   - We have been given (calculation_data),
   - The formula to be used is (formula),
   - We need to find (answer_variable).
7. Perform calculations attentively.

Provide the answer below:
"""

    try:
        # Generate response from the LLM with the enriched context
        response = ollama.generate(model='llama3.1', prompt=context)
        raw_response = response.get('response', '').strip()

        # Strip Markdown formatting
        plain_text_response = strip_markdown(raw_response)

        # Provide the response
        if "because" in plain_text_response:
            formatted_answer = plain_text_response
            logging.info("Generated formatted response.")
        else:
            formatted_answer = "The response could not be structured correctly."
            logging.warning(formatted_answer)

        if formatted_answer:
            speak_text(formatted_answer)
        else:
            logging.warning("No valid response could be generated.")
        
        return formatted_answer
    except Exception as e:
        logging.error(f"LLM Error during final response generation: {e}")
        return ""

def reset_state():
    global ocr_text
    ocr_text = ""

# -------------------- Helper Functions --------------------


def transcribe_speech(short_timeout=5, phrase_time_limit=5):
    """
    Transcribes speech from the microphone with a short timeout.
    If no speech is detected within the timeout, proceeds without user input.

    Args:
        short_timeout (int): Maximum number of seconds to wait for a phrase to start.
        phrase_time_limit (int): Maximum number of seconds a phrase can last.
    """
    global is_listening, speech_text
    recognizer = sr.Recognizer()
    with sr.Microphone() as source:
        logging.info("Listening for voice input... Please say your query or question.")
        recognizer.adjust_for_ambient_noise(source, duration=1)  # Adjust for noise for 1 second
        try:
            # Listen for speech with shorter timeout and phrase time limit
            audio = recognizer.listen(source, timeout=short_timeout, phrase_time_limit=phrase_time_limit)
            logging.info("Processing the audio with Google Speech Recognition...")
            text = recognizer.recognize_google(audio)
            # Convert number words to digits if necessary
            speech_text = convert_number_words(text)
            logging.info(f"Speech Transcribed: {speech_text}")

            # Provide confirmation
            speak_text(f"I heard: {speech_text}.")
        except sr.WaitTimeoutError:
            logging.warning("Listening timed out, no speech detected. Proceeding without voice input.")
            speech_text = ""  # Ensure speech_text is empty
        except sr.UnknownValueError:
            logging.warning("Speech recognition could not understand audio. Proceeding without voice input.")
            speech_text = ""  # Ensure speech_text is empty
        except sr.RequestError as e:
            logging.error(f"Could not request results from speech recognition service; {e}")
            speech_text = ""  # Ensure speech_text is empty
        finally:
            with lock:
                is_listening = False  # Ensure listening flag is reset

def configure_tts_voice():
    """
    Configures the TTS engine's voice, rate, and volume.
    """
    global tts_engine
    voices = tts_engine.getProperty('voices')

    # List available voices (optional)
    # Commented out DEBUG logs as they are now suppressed
    # for index, voice in enumerate(voices):
    #     logging.debug(f"Voice {index}: {voice.name}, {voice.gender}, {voice.languages}")

    # Change voice (select male/female, adjust the index as per your preference)
    if len(voices) > 1:
        tts_engine.setProperty('voice', voices[1].id)  # Change index to select a different voice
        logging.info(f"TTS voice set to: {voices[1].name}")
    else:
        logging.info("Only one voice available. Using default voice.")

    # Adjust speaking rate (lower is slower and more human-like)
    tts_engine.setProperty('rate', 150)  # Default is 200, lowering makes it more human-like

    # Adjust volume (0.0 to 1.0)
    tts_engine.setProperty('volume', 1.0)

def capture_and_save_image():
    global ocr_text, is_listening  # Added is_listening to globals

    region = get_selected_region(scaling_factor)
    left, top, right, bottom = region
    width = right - left
    height = bottom - top

    # Removed detailed dimension logging
    logging.info("Starting OCR process with image preprocessing...")

    if width <= 0 or height <= 0:
        logging.error("Invalid region selected. Please try again.")
        speak_text("Invalid region selected. Please try again by pressing F2.")
        reset_state()
        with lock:
            is_listening = False  # Reset the listening flag
        return

    with mss.mss() as sct:
        monitor = {
            "top": int(top / scaling_factor),
            "left": int(left / scaling_factor),
            "width": int(width / scaling_factor),
            "height": int(height / scaling_factor)
        }

        try:
            screenshot = sct.grab(monitor)
            img = Image.frombytes("RGB", screenshot.size, screenshot.bgra, "raw", "BGRX")
        except Exception as e:
            logging.error(f"Screen capture failed: {e}")
            speak_text("Screen capture failed. Please ensure the selected area is correct and try again.")
            reset_state()
            with lock:
                is_listening = False  # Reset the listening flag
            return

    perform_ocr(img)
    if not ocr_text.strip():
        logging.error("OCR returned empty text. Please ensure the selected region contains readable text.")
        speak_text("OCR did not detect any text. Please ensure the selected area contains readable text and try again.")
        reset_state()
        with lock:
            is_listening = False  # Reset the listening flag
        return

    generate_final_response(ocr_text)
    reset_state()
    with lock:
        is_listening = False  # Reset the listening flag after processing

def start_listening(scaling):
    global is_listening
    with lock:
        if not is_listening:
            is_listening = True
            logging.info("Started listening...")
            threading.Thread(target=capture_and_save_image, args=(), daemon=True).start()

def stop_listening():
    global is_listening
    with lock:
        if is_listening:
            is_listening = False
            logging.info("Stopped listening.")
            speak_text("Stopped listening.")

async def main():
    global scaling_factor

    configure_tts_voice()

    set_dpi_awareness()
    scaling_factor = get_scaling_factor()

    keyboard.add_hotkey('f2', start_listening, args=(scaling_factor,))
    keyboard.add_hotkey('f3', stop_listening)

    logging.info("QA Assistant is running.")
    logging.info("Press 'F2' to select a region and answer a question, 'F3' to stop listening, 'Esc' to exit.")

    while True:
        await asyncio.sleep(0.1)
        if keyboard.is_pressed('esc'):
            logging.info("Exiting...")
            speak_text("Exiting the QA Assistant. Goodbye!")
            break

    keyboard.unhook_all()

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        logging.info("Program terminated by user.")
    except Exception as e:
        logging.error(f"An unexpected error occurred: {e}")
    finally:
        keyboard.unhook_all()

Certainly! Below is a separate Python script that allows you to:

1. **Draw a Rectangle Using the Mouse:** Select a specific region on your screen by clicking and dragging the mouse.
2. **Take a Screenshot of the Selected Region:** Capture the selected area of the screen.
3. **Perform OCR on the Screenshot:** Extract text from the captured image using Optical Character Recognition (OCR).
4. **Copy Extracted Text to Clipboard:** Automatically copy the extracted text to your clipboard for easy pasting.

### **Prerequisites**

Before running the script, ensure you have the following installed on your system:

1. **Python 3.x**: If you don't have Python installed, download it from [here](https://www.python.org/downloads/).

2. **Tesseract OCR Engine**:
   
   - **Windows**:
     - Download the installer from [Tesseract at UB Mannheim](https://github.com/UB-Mannheim/tesseract/wiki).
     - Run the installer and follow the installation instructions.
     - Add the Tesseract installation directory (e.g., `C:\Program Files\Tesseract-OCR`) to your system's PATH environment variable.
   
   - **macOS**:
     ```bash
     brew install tesseract
     ```
   
   - **Linux**:
     ```bash
     sudo apt-get update
     sudo apt-get install tesseract-ocr
     ```

3. **Python Libraries**: Install the required Python libraries using `pip`:

   ```bash
   pip install mss pillow pytesseract pyperclip
   ```

   - **mss**: For taking screenshots.
   - **Pillow**: For image processing.
   - **pytesseract**: Python wrapper for Tesseract OCR.
   - **pyperclip**: For copying text to the clipboard.

### **The Script**

```python
import sys
import tkinter as tk
from tkinter import messagebox
from PIL import Image
import mss
import pytesseract
import pyperclip

# Optional: If Tesseract is not in your PATH, uncomment and set the path manually
# pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'

def select_region():
    """
    Allows the user to select a region on the screen by dragging the mouse.
    Returns the coordinates of the selected region.
    """
    root = tk.Tk()
    root.attributes('-alpha', 0.3)  # Make the window semi-transparent
    root.attributes("-topmost", True)  # Keep the window on top
    root.overrideredirect(True)  # Remove window decorations

    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()
    root.geometry(f"{screen_width}x{screen_height}")

    canvas = tk.Canvas(root, cursor="cross", bg="grey")
    canvas.pack(fill=tk.BOTH, expand=True)

    rect = None
    start_x = start_y = end_x = end_y = 0

    def on_button_press(event):
        nonlocal start_x, start_y, rect
        start_x = root.winfo_pointerx()
        start_y = root.winfo_pointery()
        rect = canvas.create_rectangle(event.x, event.y, event.x, event.y, outline='red', width=2)

    def on_move_press(event):
        nonlocal end_x, end_y
        end_x = root.winfo_pointerx()
        end_y = root.winfo_pointery()
        canvas.coords(rect, start_x - root.winfo_rootx(), start_y - root.winfo_rooty(),
                      event.x, event.y)

    def on_button_release(event):
        root.quit()

    canvas.bind("<ButtonPress-1>", on_button_press)
    canvas.bind("<B1-Motion>", on_move_press)
    canvas.bind("<ButtonRelease-1>", on_button_release)

    try:
        root.mainloop()
    except KeyboardInterrupt:
        sys.exit()

    # Calculate the selected region
    left = min(start_x, end_x)
    top = min(start_y, end_y)
    right = max(start_x, end_x)
    bottom = max(start_y, end_y)

    root.destroy()
    return (left, top, right, bottom)

def capture_screenshot(region):
    """
    Captures a screenshot of the specified region.
    :param region: Tuple of (left, top, right, bottom)
    :return: PIL Image of the captured region
    """
    left, top, right, bottom = region
    width = right - left
    height = bottom - top

    if width <= 0 or height <= 0:
        messagebox.showerror("Error", "Invalid region selected. Please try again.")
        sys.exit()

    with mss.mss() as sct:
        monitor = {"top": top, "left": left, "width": width, "height": height}
        try:
            sct_img = sct.grab(monitor)
            img = Image.frombytes("RGB", sct_img.size, sct_img.rgb)
            return img
        except Exception as e:
            messagebox.showerror("Error", f"Failed to capture the screen: {e}")
            sys.exit()

def perform_ocr(image):
    """
    Performs OCR on the given image and returns the extracted text.
    :param image: PIL Image
    :return: Extracted text as string
    """
    try:
        text = pytesseract.image_to_string(image, lang='eng')
        if not text.strip():
            messagebox.showwarning("No Text Detected", "No text was detected in the selected region.")
        return text
    except pytesseract.TesseractNotFoundError:
        messagebox.showerror("Tesseract Not Found", "Tesseract OCR is not installed or not found in PATH.")
        sys.exit()
    except Exception as e:
        messagebox.showerror("OCR Error", f"An error occurred during OCR: {e}")
        sys.exit()

def copy_to_clipboard(text):
    """
    Copies the given text to the clipboard.
    :param text: Text to copy
    """
    try:
        pyperclip.copy(text)
        messagebox.showinfo("Success", "Extracted text has been copied to the clipboard.")
    except Exception as e:
        messagebox.showerror("Clipboard Error", f"Failed to copy text to clipboard: {e}")
        sys.exit()

def main():
    messagebox.showinfo("Start", "Press OK and then click and drag to select a region for OCR.")
    region = select_region()
    if region == (0, 0, 0, 0):
        messagebox.showwarning("No Selection", "No region was selected.")
        sys.exit()
    image = capture_screenshot(region)
    text = perform_ocr(image)
    if text.strip():
        copy_to_clipboard(text)

if __name__ == "__main__":
    main()
```

### **How It Works**

1. **Select Region**: When you run the script, a semi-transparent fullscreen window appears. Click and drag your mouse to select the desired region. Release the mouse button to finalize the selection.

2. **Capture Screenshot**: The selected region is captured as an image.

3. **Perform OCR**: The captured image is processed using Tesseract OCR to extract any text present.

4. **Copy to Clipboard**: The extracted text is automatically copied to your clipboard. A confirmation message will appear to notify you of the successful operation.

### **Running the Script**

1. **Save the Script**: Copy the above code into a file named, for example, `ocr_to_clipboard.py`.

2. **Run the Script**:

   ```bash
   python ocr_to_clipboard.py
   ```

3. **Follow the Prompts**:
   - A message box will appear instructing you to press OK and select the region.
   - After selecting the region, the script will process the image, perform OCR, and copy the text to your clipboard.
   - Notifications will inform you of success or any errors encountered.

### **Troubleshooting**

- **Tesseract Not Found**: If you encounter an error stating that Tesseract is not found, ensure that:
  - Tesseract OCR is installed on your system.
  - The Tesseract executable is added to your system's PATH.
  - If Tesseract is installed in a non-standard directory, uncomment and set the `pytesseract.pytesseract.tesseract_cmd` path in the script accordingly.

- **No Text Detected**: If no text is detected:
  - Ensure that the selected region contains clear and readable text.
  - High-contrast images yield better OCR results.
  - Consider preprocessing the image (e.g., converting to grayscale, increasing contrast) for improved accuracy.

- **Clipboard Issues**: If the text is not copied to the clipboard:
  - Ensure that the `pyperclip` library is properly installed.
  - Check for any operating system restrictions or permissions that may prevent clipboard access.

### **Customization**

- **Change OCR Language**: To perform OCR in a language other than English, ensure that the corresponding language data is installed for Tesseract and modify the `lang` parameter in the `pytesseract.image_to_string` function.

  ```python
  text = pytesseract.image_to_string(image, lang='your_language_code')
  ```

- **Image Preprocessing**: For better OCR results, consider adding image preprocessing steps such as resizing, thresholding, or denoising before performing OCR.

### **Conclusion**

This script provides a straightforward way to extract text from any region of your screen and have it readily available in your clipboard. It leverages powerful libraries and tools to deliver accurate OCR results with minimal user intervention.

Feel free to enhance and customize the script further to fit your specific needs!

how to detect div click outside html css js

Detecting a click outside of a specific `<div>` element involves using JavaScript, as HTML and CSS alone don't provide the functionality to handle events like clicks. Here’s a step-by-step guide to achieve this:

1. **HTML Setup:**
   Create your basic HTML structure. For this example, let's assume you have a `<div>` that you want to monitor for outside clicks.

   ```html
   <div id="myDiv">
       <!-- Your content here -->
   </div>

   <button id="anotherElement">
       Another Element
   </button>
   ```

2. **JavaScript Setup:**
   You can use JavaScript to detect clicks outside the specified `<div>`. You'll generally add an event listener to the document to detect any clicks, then check if the click target is outside your specific `<div>`.

   ```javascript
   const myDiv = document.getElementById("myDiv");

   document.addEventListener("click", function(event) {
       // Check if the clicked target is not the div or any of its descendants
       if (!myDiv.contains(event.target)) {
           console.log("Clicked outside of #myDiv");
           // Add your logic to handle clicks outside here
       }
   });
   ```

3. **Explanation:**

   - **Event Listener**: We add a `click` event listener to the entire document. This means any click anywhere on the page gets detected.
   - **Event Target**: The `event.target` is the element that triggered the click event.
   - **Node.contains**: The `contains` method checks if the clicked element (`event.target`) is inside `myDiv`. If not, it indicates that the click occurred outside of `myDiv`.

4. **CSS (optional):**
   If you want to have some visual cues, such as highlighting the `<div>` or changing styles when the outside click is detected, you can add some CSS:

   ```css
   #myDiv {
       border: 1px solid black;
       padding: 20px;
   }

   /* Apply a different style when interacted or clicked outside - just an example */
   #myDiv.outsideClicked {
       background-color: lightcoral;
   }
   ```

   You can toggle the `outsideClicked` class when an outside click is detected as part of your JavaScript logic.

5. **Handling Multiple Elements:**
   If you have more than one element that you want to check for outside clicks, you can extend the logic to handle an array of elements and iterate through them, using `Array.prototype.every()` or a simple `for` loop to check if the click was outside all specified elements.

This approach should work in most scenarios, but remember to test thoroughly, especially if your webpage has complex nodes or other event listeners that might interfere.

// Instructions.cpp
#include "Emulator.h"
#include <iostream>
#include <stdint.h>
#include <string>
// Реализация обработчиков инструкций

// MOV EAX, imm32
void Emulator::instr_MOV_EAX_imm32() {
    uint32_t imm = fetch_dword();
    regs.EAX = imm;
}

void Emulator::instr_PUSH_EAX() {
    push(regs.EAX);
}

void Emulator::instr_PUSH_ECX() {
    push(regs.ECX);
}

void Emulator::instr_PUSH_EDX() {
    push(regs.EDX);
}

void Emulator::instr_PUSH_EBX() {
    push(regs.EBX);
}

void Emulator::instr_PUSH_ESP() {
    push(regs.ESP);
}

void Emulator::instr_PUSH_EBP() {
    push(regs.EBP);
}

void Emulator::instr_PUSH_ESI() {
    push(regs.ESI);
}

void Emulator::instr_PUSH_EDI() {
    push(regs.EDI);
}
void Emulator::instr_CLD() {
    // Clear the Direction Flag (DF), which is bit 10 in EFLAGS
    regs.EFLAGS &= ~DF;

    // Optionally, print debug information
    std::cout << "Выполнена инструкция CLD (Direction Flag сброшен).\n";
}
void Emulator::instr_PUSH_imm8() {
    int8_t imm8 = static_cast<int8_t>(fetch_byte()); // Получаем 8-битное значение
    push(static_cast<uint32_t>(imm8)); // Преобразуем в 32-битное знаковое значение и помещаем в стек
}
void Emulator::push(uint32_t value) {
    if (regs.ESP < 4) {
        std::cerr << "Stack overflow при попытке записать в стек.\n";
        error_flag = true;
        running = false;
        return;
    }
    regs.ESP -= 4;  // Уменьшаем указатель стека
    write_memory_dword(regs.ESP, value);  // Записываем значение в стек
}
void Emulator::instr_NOP_EAX() {
    // Эта инструкция ничего не делает, можно просто вывести сообщение
    std::cout << "Выполнен NOP [EAX]\n";
}
void Emulator::instr_STI() {
    // Устанавливаем флаг прерываний (IF)
    regs.EFLAGS |= IF_FLAG;
    std::cout << "Выполнен STI: Установлен флаг прерываний (IF).\n";
}
void Emulator::instr_POP_ESP() {
    if (regs.ESP + 4 > memory.size()) {
        std::cerr << "Stack underflow on POP ESP.\n";
        error_flag = true;
        running = false;
        return;
    }
    regs.ESP = read_memory_dword(regs.ESP);
    regs.ESP += 4;
}
void Emulator::instr_POP_EBX() {
    if (regs.ESP + 4 > memory.size()) {
        std::cerr << "Stack underflow on POP EBX.\n";
        error_flag = true;
        running = false;
        return;
    }
    regs.EBX = read_memory_dword(regs.ESP);
    regs.ESP += 4;
}
void Emulator::instr_POP_EDX() {
    if (regs.ESP + 4 > memory.size()) {
        std::cerr << "Stack underflow on POP EDX.\n";
        error_flag = true;
        running = false;
        return;
    }
    regs.EDX = read_memory_dword(regs.ESP);
    regs.ESP += 4;
}
void Emulator::instr_POP_ECX() {
    if (regs.ESP + 4 > memory.size()) {
        std::cerr << "Stack underflow on POP ECX.\n";
        error_flag = true;
        running = false;
        return;
    }
    regs.ECX = read_memory_dword(regs.ESP);
    regs.ESP += 4;
}
void Emulator::instr_POP_EAX() {
    if (regs.ESP + 4 > memory.size()) {
        std::cerr << "Stack underflow on POP EAX.\n";
        error_flag = true;
        running = false;
        return;
    }
    regs.EAX = read_memory_dword(regs.ESP);
    regs.ESP += 4;
}
void Emulator::instr_POP_ESI() {
    if (regs.ESP + 4 > memory.size()) {
        std::cerr << "Stack underflow on POP ESI.\n";
        error_flag = true;
        running = false;
        return;
    }

    // Считываем значение со стека и сохраняем его в регистр ESI
    regs.ESI = read_memory_dword(regs.ESP);
    regs.ESP += 4;  // Увеличиваем указатель стека

    std::cout << "Выполнен POP ESI. Значение в регистре ESI: " << std::hex << regs.ESI << "\n";
}
void Emulator::instr_POP_EDI() {
    if (regs.ESP + 4 > memory.size()) {
        std::cerr << "Stack underflow on POP EDI.\n";
        error_flag = true;
        running = false;
        return;
    }
    regs.EDI = read_memory_dword(regs.ESP);
    regs.ESP += 4;
}
void Emulator::instr_MOV_Ev_Iv() {
    uint8_t modrm = fetch_byte();
    Operand operand = decode_operand(modrm);

    uint32_t immediate = fetch_dword();

    if (operand.is_memory) {
        write_memory_dword(operand.address, immediate);
    } else {
        uint32_t* reg = get_register_by_code(operand.register_code);
        if (!reg) {
            std::cout << "Unknown register in MOV Ev, Iv.\n";
            error_flag = true;
            running = false;
            return;
        }
        *reg = immediate;
    }
}
// Реализация инструкции INC r/m32
void Emulator::instr_INC_rm32(uint8_t modrm) {
    Operand operand = decode_operand(modrm);
    if (operand.is_memory) {
        uint32_t value = read_memory_dword(operand.address);
        value++;
        write_memory_dword(operand.address, value);
    }
    else {
        uint32_t* reg = get_register_by_code(operand.register_code);
        (*reg)++;
    }
    update_ZF(operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code));
}

// Реализация инструкции DEC r/m32
void Emulator::instr_DEC_rm32(uint8_t modrm) {
    Operand operand = decode_operand(modrm);
    if (operand.is_memory) {
        uint32_t value = read_memory_dword(operand.address);
        value--;
        write_memory_dword(operand.address, value);
    }
    else {
        uint32_t* reg = get_register_by_code(operand.register_code);
        (*reg)--;
    }
    update_ZF(operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code));
}
void Emulator::instr_LEAVE() {
    // Set ESP to EBP
    regs.ESP = regs.EBP;

    // POP EBP
    if (regs.ESP + 4 > memory.size()) {
        std::cerr << "Stack underflow on LEAVE.\n";
        error_flag = true;
        running = false;
        return;
    }

    regs.EBP = read_memory_dword(regs.ESP);
    regs.ESP += 4;

    std::cout << "Выполнена инструкция LEAVE. ESP: 0x" << std::hex << regs.ESP
        << ", EBP: 0x" << regs.EBP << "\n";
}
// Реализация инструкции CALL r/m32
void Emulator::instr_CALL_rm32(uint8_t modrm) {
    Operand operand = decode_operand(modrm);
    uint32_t address = operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code);

    // Сохраняем текущий адрес возврата в стек
    push(regs.EIP);

    // Переходим к новому адресу
    regs.EIP = address;
}

// Реализация инструкции JMP r/m32
void Emulator::instr_JMP_rm32(uint8_t modrm) {
    Operand operand = decode_operand(modrm);
    uint32_t address = operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code);
    regs.EIP = address;
}

// Реализация инструкции PUSH r/m32
void Emulator::instr_PUSH_rm32(uint8_t modrm) {
    Operand operand = decode_operand(modrm);
    uint32_t value = operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code);
    push(value);
}
void Emulator::instr_PUSH_imm32() {
    uint32_t imm32 = fetch_dword();  // Чтение 32-битного непосредственного значения
    push(imm32);  // Помещение значения в стек
}
void Emulator::instr_GROUP5() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg = (modrm >> 3) & 0x07;  // Поле reg в ModR/M указывает на операцию
    uint8_t rm = modrm & 0x07;

    switch (reg) {
    case 0: // INC r/m32
        instr_INC_rm32(modrm);
        break;
    case 1: // DEC r/m32
        instr_DEC_rm32(modrm);
        break;
    case 2: // CALL r/m32
        instr_CALL_rm32(modrm);
        break;
    case 3: // CALL far
        std::cout << "CALL far не поддерживается.\n";
        error_flag = true;
        running = false;
        break;
    case 4: // JMP r/m32
        instr_JMP_rm32(modrm);
        break;
    case 5: // JMP far
        std::cout << "JMP far не поддерживается.\n";
        error_flag = true;
        running = false;
        break;
    case 6: // PUSH r/m32
        instr_PUSH_rm32(modrm);
        break;
    default:
        std::cout << "Неизвестный подтип команды 0xFF: " << (int)reg << "\n";
        error_flag = true;
        running = false;
        break;
    }
}
void Emulator::instr_ENDBR32() {
    // Мы уже обработали префикс 0xF3 и прочитали опкод 0x0F
    // Теперь нужно убедиться, что следующий байт 0x1E, уже считан
    // Считываем последний байт инструкции
    uint8_t modrm = fetch_byte();
    if (modrm != 0xFB) {
        std::cout << "Ожидаемый байт 0xFB не найден после opcode 0x1E для ENDBR32.\n";
        error_flag = true;
        running = false;
        return;
    }
    // Инструкция корректно распознана, выполняем NOP
    std::cout << "Выполнена инструкция ENDBR32 (пропущена).\n";
}
void Emulator::instr_STD() {
    // Set the Direction Flag (DF), which is bit 10 in EFLAGS
    regs.EFLAGS |= DF;
    std::cout << "Выполнена инструкция STD (Direction Flag установлен).\n";
}
void Emulator::instr_NOP() {
    // NOP does nothing
    std::cout << "Выполнена инструкция NOP.\n";
}
void Emulator::instr_PUSHAD() {
    uint32_t temp_esp = regs.ESP;
    push(regs.EAX);
    push(regs.ECX);
    push(regs.EDX);
    push(regs.EBX);
    push(temp_esp);     // Original value of ESP
    push(regs.EBP);
    push(regs.ESI);
    push(regs.EDI);
    std::cout << "Выполнена инструкция PUSHAD.\n";
}
void Emulator::instr_REP_MOVSB() {
    while (regs.ECX != 0) {
        uint8_t byte = read_memory_byte(regs.ESI);
        write_memory_byte(regs.EDI, byte);

        // Update ESI and EDI based on the Direction Flag
        if (regs.EFLAGS & DF) {
            regs.ESI -= 1;
            regs.EDI -= 1;
        }
        else {
            regs.ESI += 1;
            regs.EDI += 1;
        }

        regs.ECX -= 1;
    }
    std::cout << "Выполнена инструкция REP MOVSB.\n";
}
void Emulator::instr_NOP_m16_m32() {
    // Инструкция NOP m16/32 имеет модификатор размера операнда
    // Если установлен префикс 0x66, то размер операнда 16 бит, иначе 32 бита
    bool operand_size = regs.operand_size_override;

    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;

    if (mod == 3) {
        // Mod == 3 означает, что операнд — регистр
        // В этом случае NOP не делает ничего
        uint8_t rm = modrm & 0x07;
        // Можно просто считать регистр для эмуляции чтения
        uint32_t* reg = get_register_by_code(rm);
        if (reg) {
            uint32_t temp = *reg;
            // NOP ничего не делает, поэтому не изменяем значение
        }
        else {
            std::cout << "Неизвестный регистр в NOP r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else {
        // Если Mod != 3, то вычисляем адрес и читаем операнд из памяти
        uint32_t address = calculate_address(modrm);

        if (operand_size) {
            // Чтение 16-битного операнда для NOP m16
            uint16_t temp = read_memory_byte(address) | (read_memory_byte(address + 1) << 8);
            // NOP не изменяет ничего, просто читаем для эмуляции
        }
        else {
            // Чтение 32-битного операнда для NOP m32
            uint32_t temp = read_memory_dword(address);
            // NOP не изменяет ничего, просто читаем для эмуляции
        }
    }

    // NOP ничего не делает, поэтому ничего не изменяем
}
// MOV EBX, imm32
void Emulator::instr_MOV_EBX_imm32() {
    uint32_t imm = fetch_dword();
    regs.EBX = imm;
}

// MOV ECX, imm32
void Emulator::instr_MOV_ECX_imm32() {
    uint32_t imm = fetch_dword();
    regs.ECX = imm;
}

// MOV EDX, imm32
void Emulator::instr_MOV_EDX_imm32() {
    uint32_t imm = fetch_dword();
    regs.EDX = imm;
}

// ADD EAX, imm32
void Emulator::instr_ADD_EAX_imm32() {
    if (regs.rep_prefix || regs.repne_prefix) {
        std::cout << "Warning: REP prefix is ignored for ADD EAX, imm32.\n";
        reset_prefixes();
    }
    uint32_t imm = fetch_dword();
    std::cout << "Executing ADD EAX, " << imm << " (Before EAX: " << regs.EAX << ")\n";
    regs.EAX += imm;
    std::cout << "After EAX: " << regs.EAX << "\n";
    update_ZF(regs.EAX);
}



// SUB EAX, imm32
void Emulator::instr_SUB_EAX_imm32() {
    uint32_t imm = fetch_dword();
    regs.EAX -= imm;
    update_ZF(regs.EAX);
}

// INC EAX
void Emulator::instr_INC_EAX() {
    regs.EAX += 1;
    update_ZF(regs.EAX);
}

// DEC EAX
void Emulator::instr_DEC_EAX() {
    regs.EAX -= 1;
    update_ZF(regs.EAX);
}

// MUL EAX
void Emulator::instr_MUL_EAX() {
    uint8_t modrm = fetch_byte();
    // Для простоты реализуем только MUL EAX
    if ((modrm & 0x38) == 0x20) { // Проверяем, что это MUL r/m32
        regs.EAX *= regs.EAX;
        update_ZF(regs.EAX);
    }
    else {
        std::cout << "MUL instruction with unsupported operand.\n";
        // Можно установить флаг ошибки или завершить выполнение
    }
}

// JMP rel32
void Emulator::instr_JMP_rel32() {
    int32_t rel = fetch_dword();
    regs.EIP += rel;
}

// CMP регистр, imm8
void Emulator::instr_CMP_reg_imm8() {
    uint8_t modrm = fetch_byte();
    uint8_t reg = (modrm >> 3) & 0x07;
    uint8_t imm8 = fetch_byte();
    uint32_t* reg_ptr = get_register_by_code(regm_rm(modrm));
    if (reg_ptr) {
        uint32_t result = *reg_ptr - imm8;

        // Zero Flag
        if (result == 0)
            regs.EFLAGS |= ZF;
        else
            regs.EFLAGS &= ~ZF;

        // Carry Flag
        if (*reg_ptr < imm8)
            regs.EFLAGS |= CF;
        else
            regs.EFLAGS &= ~CF;

        // Sign Flag (SF)
        if (result & (1 << 31))
            regs.EFLAGS |= (1 << 7); // Предполагаем, что SF находится в бит 7
        else
            regs.EFLAGS &= ~(1 << 7);

        // Overflow Flag (OF) - необходимо корректно реализовать
        // Здесь может быть упрощение, для точной реализации требуется дополнительная логика
    }
    else {
        std::cout << "CMP instruction with unsupported register.\n";
        // Можно установить флаг ошибки или завершить выполнение
    }
}

// JE rel8
void Emulator::instr_JE_rel8() {
    int8_t rel = fetch_byte();
    if (regs.EFLAGS & ZF) {
        regs.EIP += rel;
    }
}

// JNE rel8
void Emulator::instr_JNE_rel8() {
    int8_t rel = fetch_byte();
    if (!(regs.EFLAGS & ZF)) {
        regs.EIP += rel;
    }
}

// AND EAX, imm32
void Emulator::instr_AND_EAX_imm32() {
    uint32_t imm = fetch_dword();
    regs.EAX &= imm;
    update_ZF(regs.EAX);
}

// AND ECX, imm32
void Emulator::instr_AND_ECX_imm32() {
    uint32_t imm = fetch_dword();
    regs.ECX &= imm;
    update_ZF(regs.ECX);
}

// OR EAX, imm32
void Emulator::instr_OR_EAX_imm32() {
    uint32_t imm = fetch_dword();
    regs.EAX |= imm;
    update_ZF(regs.EAX);
}

// OR ECX, imm32
void Emulator::instr_OR_ECX_imm32() {
    uint32_t imm = fetch_dword();
    regs.ECX |= imm;
    update_ZF(regs.ECX);
}

// XOR EAX, imm32
void Emulator::instr_XOR_EAX_imm32() {
    uint32_t imm = fetch_dword();
    regs.EAX ^= imm;
    update_ZF(regs.EAX);
}

// SUB EBX, imm32
void Emulator::instr_SUB_EBX_imm32() {
    uint32_t imm = fetch_dword();
    regs.EBX -= imm;
    update_ZF(regs.EBX);
}

// CMP EAX, imm32
void Emulator::instr_CMP_EAX_imm32() {
    uint32_t imm = fetch_dword();
    uint32_t result = regs.EAX - imm;
    if (regs.EAX == imm)
        regs.EFLAGS |= ZF;
    else
        regs.EFLAGS &= ~ZF;
    // Дополнительно можно установить другие флаги (CF, OF и т.д.)
}

// Обработчик инструкции RET
void Emulator::instr_RET() {
    if (regs.ESP + 4 > memory.size()) {
        std::cout << "Stack underflow on RET.\n";
        error_flag = true;
        running = false;
        return;
    }

    // Pop the return address from the stack
    uint32_t return_address = read_memory_dword(regs.ESP);
    regs.ESP += 4;

    // Jump to the return address
    regs.EIP = return_address;
}

// Обработчик инструкции SUB r32, imm32
void Emulator::instr_SUB_r32_imm32() {
    uint8_t modrm = fetch_byte();
    uint8_t reg_opcode = (modrm >> 3) & 0x07; // Извлекаем поле reg из ModRM

    if (reg_opcode != 5) { // Для инструкции SUB reg, imm32, reg_opcode должен быть 5
        std::cout << "Unsupported SUB instruction with reg opcode: " << (int)reg_opcode << "\n";
        return;
    }

    uint32_t imm32 = fetch_dword(); // Извлекаем непосредственное значение
    uint8_t rm = regm_rm(modrm); // Извлекаем регистр назначения из ModRM
    uint32_t* reg_ptr = get_register_by_code(rm);

    if (reg_ptr) {
        *reg_ptr -= imm32;
        update_ZF(*reg_ptr);
    }
    else {
        std::cout << "SUB instruction with unsupported register.\n";
    }
}
void Emulator::instr_CMP_r32_rm32() {
    uint8_t modrm = fetch_byte();

    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg_code = (modrm >> 3) & 0x07; // Источник: r32
    uint8_t rm_code = modrm & 0x07;         // Назначение: r/m32

    uint32_t* reg = get_register_by_code(reg_code); // Источник
    uint32_t* rm;

    if (mod == 3) {
        rm = get_register_by_code(rm_code);

        if (!rm) {
            std::cout << "Неизвестный регистр в CMP r/m32, r32.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else {
        // Для простоты реализуем только регистровый режим
        std::cout << "Поддерживается только регистровый режим для CMP r/m32, r32.\n";
        error_flag = true;
        running = false;
        return;
    }

    // Выполняем сравнение
    uint32_t result = *rm - *reg;

    // Обновляем флаги
    // Zero Flag (ZF)
    if (result == 0)
        regs.EFLAGS |= ZF;
    else
        regs.EFLAGS &= ~ZF;

    // Sign Flag (SF)
    if (result & 0x80000000)
        regs.EFLAGS |= SF;
    else
        regs.EFLAGS &= ~SF;

    // Carry Flag (CF)
    if (*rm < *reg)
        regs.EFLAGS |= CF;
    else
        regs.EFLAGS &= ~CF;

    // Overflow Flag (OF)
    uint32_t sign_rm = *rm & 0x80000000;
    uint32_t sign_reg = *reg & 0x80000000;
    uint32_t sign_result = result & 0x80000000;
    if ((sign_rm != sign_reg) && (sign_rm != sign_result))
        regs.EFLAGS |= OF;
    else
        regs.EFLAGS &= ~OF;
}
// Обработчик инструкции JE rel32 (0x0F 0x84)
void Emulator::instr_JE_rel32() {
    int32_t rel32 = fetch_dword(); // Читаем относительное смещение
    if (regs.EFLAGS & ZF) { // Проверка флага равенства
        regs.EIP += rel32;
    }
}

// Обработчик инструкции JNE rel32 (0x0F 0x85)
void Emulator::instr_JNE_rel32() {
    int32_t rel32 = fetch_dword(); // Читаем относительное смещение
    if (!(regs.EFLAGS & ZF)) { // Проверка флага неравенства
        regs.EIP += rel32;
    }
}

// Обработчик инструкции JG rel32 (0x0F 0x8F)
void Emulator::instr_JG_rel32() {
    int32_t rel32 = fetch_dword(); // Читаем относительное смещение
    bool zf = (regs.EFLAGS & ZF) != 0;
    bool sf = (regs.EFLAGS & SF) != 0;
    bool of = (regs.EFLAGS & OF) != 0;
    if (!zf && (sf == of)) {
        regs.EIP += rel32;
    }
}
void Emulator::instr_MOV_rm8_imm8() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm & 0xC0) >> 6;
    // uint8_t reg = (modrm & 0x38) >> 3; // Не используется для MOV r/m8, imm8
    uint8_t rm = (modrm & 0x07);       // Назначение: r/m8

    uint8_t imm8 = fetch_byte();

    if (mod == 3) { // Регистр
        uint32_t* dest_reg = get_register_by_code(rm);
        if (dest_reg) {
            // Только младший байт регистра
            uint8_t* dest_reg_byte = reinterpret_cast<uint8_t*>(dest_reg);
            dest_reg_byte[0] = imm8;
        }
        else {
            std::cout << "Неизвестный регистр в MOV r/m8, imm8.\n";
            error_flag = true;
            running = false;
        }
    }
    else { // Память
        uint32_t address = calculate_address(modrm);
        if (error_flag) {
            return; // Ошибка уже установлена в calculate_address
        }

        if (address >= memory.size()) {
            std::cout << "Memory access out of bounds in MOV r/m8, imm8.\n";
            error_flag = true;
            running = false;
            return;
        }

        memory[address] = imm8;
    }
}

// Обработчик инструкции MUL r/m32
void Emulator::instr_MUL_rm32(uint8_t modrm) {
    uint8_t mod = (modrm & 0xC0) >> 6;
    // uint8_t reg = (modrm & 0x38) >> 3; // Не используется для MUL r/m32
    uint8_t rm = (modrm & 0x07);       // Источник: r/m32

    uint32_t operand = 0;

    if (mod == 3) { // Регистр
        uint32_t* src_reg = get_register_by_code(rm);
        if (src_reg) {
            operand = *src_reg;
        }
        else {
            std::cout << "Неизвестный регистр в MUL r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else {
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        operand = read_memory_dword(address);
    }

    // Выполнение умножения: EDX:EAX = EAX * operand
    uint64_t result = static_cast<uint64_t>(regs.EAX) * static_cast<uint64_t>(operand);
    regs.EAX = static_cast<uint32_t>(result & 0xFFFFFFFF);
    regs.EDX = static_cast<uint32_t>((result >> 32) & 0xFFFFFFFF);

    update_ZF(regs.EAX);
}

// Реализация обработчика для DIV r/m32
void Emulator::instr_DIV_rm32(uint8_t modrm) {
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t rm = modrm & 0x07;

    uint32_t operand = 0;

    if (mod == 3) { // Регистровый операнд
        uint32_t* src_reg = get_register_by_code(rm);
        if (src_reg) {
            operand = *src_reg;
        }
        else {
            std::cout << "Неизвестный регистр в DIV r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else { // Операнд из памяти
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        operand = read_memory_dword(address); // Чтение операнда из памяти
    }

    if (operand == 0) {
        std::cout << "Деление на ноль.\n";
        error_flag = true;
        running = false;
        return;
    }

    // Выполнение деления: EDX:EAX = EAX / operand
    uint64_t dividend = (static_cast<uint64_t>(regs.EDX) << 32) | regs.EAX;
    regs.EAX = static_cast<uint32_t>(dividend / operand);
    regs.EDX = static_cast<uint32_t>(dividend % operand);

    //std::cout << "DIV instruction: Dividend = " << dividend << ", Operand = " << operand
        //<< ", EAX = " << regs.EAX << ", EDX = " << regs.EDX << "\n";

    update_ZF(regs.EAX);
}
void Emulator::instr_LEA_r32_m() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = modrm >> 6;
    uint8_t reg = (modrm >> 3) & 0x07; // Destination register code
    uint8_t rm = modrm & 0x07;         // Source operand

    // LEA is invalid with mod == 3 (register-direct mode)
    if (mod == 3) {
        std::cout << "Invalid LEA instruction with mod == 3.\n";
        error_flag = true;
        running = false;
        return;
    }

    // Calculate the effective address
    uint32_t address = calculate_address(modrm);
    if (error_flag)
        return;

    // Get the destination register
    uint32_t* dest_reg = get_register_by_code(reg);
    if (!dest_reg) {
        std::cout << "Unknown destination register in LEA.\n";
        error_flag = true;
        running = false;
        return;
    }

    // Store the effective address into the destination register
    *dest_reg = address;
}
void Emulator::instr_IDIV_rm32(uint8_t modrm) {
    uint8_t mod = (modrm & 0xC0) >> 6;
    uint8_t rm = (modrm & 0x07);       // Источник: r/m32

    int32_t operand = 0;

    if (mod == 3) { // Регистр
        int32_t* src_reg = reinterpret_cast<int32_t*>(get_register_by_code(rm));
        if (src_reg) {
            operand = *src_reg;
        }
        else {
            std::cout << "Неизвестный регистр в IDIV r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else { // Операнд из памяти
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        operand = read_memory_dword(address); // Чтение операнда из памяти
    }

    if (operand == 0) {
        std::cout << "Деление на ноль.\n";
        error_flag = true;
        running = false;
        return;
    }

    // Выполнение деления: EDX:EAX = EAX / operand
    int64_t dividend = (static_cast<int64_t>(regs.EDX) << 32) | regs.EAX;
    regs.EAX = static_cast<uint32_t>(dividend / operand);
    regs.EDX = static_cast<uint32_t>(dividend % operand);

    update_ZF(regs.EAX);
}

// Общий обработчик для opcode 0xF7
void Emulator::instr_F7() {
    uint8_t modrm = fetch_byte();
    uint8_t reg = (modrm >> 3) & 0x07; // /digit

    switch (reg) {
    case 4: // MUL r/m32
        instr_MUL_rm32(modrm);
        break;
    case 6: // DIV r/m32
        instr_DIV_rm32(modrm);
        break;
    case 7: // IDIV r/m32
        instr_IDIV_rm32(modrm);
        break;
    default:
        std::cout << "F7 instruction with unsupported /digit: " << static_cast<int>(reg) << "\n";
        error_flag = true;
        running = false;
        break;
    }
}

void Emulator::instr_MOV_rm8_r8() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t rm = modrm & 0x07;
    uint8_t reg = (modrm >> 3) & 0x07;

    uint8_t* src_reg = get_register8_by_code(reg);
    if (!src_reg) {
        std::cout << "Unknown source register in MOV r/m8, r8.\n";
        error_flag = true;
        running = false;
        return;
    }
    uint8_t value = *src_reg;

    if (mod == 3) {
        // Режим регистр-регистр
        uint8_t* dest_reg = get_register8_by_code(rm);
        if (!dest_reg) {
            std::cout << "Unknown destination register in MOV r/m8, r8.\n";
            error_flag = true;
            running = false;
            return;
        }
        *dest_reg = value;
    }

    else {
        // Режим регистр-память
        uint32_t address = 0;
        if (rm == 4) {
            // SIB байт
            uint8_t sib = fetch_byte();
            int32_t displacement = 0;
            if (mod == 1) {
                displacement = static_cast<int8_t>(fetch_byte());
            }
            else if (mod == 2) {
                displacement = static_cast<int32_t>(fetch_dword());
            }
            address = calculate_sib_address(mod, sib, displacement);
        }
        else {
            int32_t displacement = 0;
            if (mod == 1) {
                displacement = static_cast<int8_t>(fetch_byte());
            }
            else if (mod == 2) {
                displacement = static_cast<int32_t>(fetch_dword());
            }
            address = *get_register_by_code(rm) + displacement;
        }
        if (address >= memory.size()) {
            std::cout << "Memory access out of bounds in MOV r/m8, r8.\n";
            error_flag = true;
            running = false;
            return;
        }
        memory[address] = value;
    }
    
}

void Emulator::instr_ADD_AL_imm8() {
    uint8_t imm8 = fetch_byte();
    uint8_t* al = reinterpret_cast<uint8_t*>(&regs.EAX);
    *al += imm8;
    update_ZF(*al); // Обновляем флаг ZF на основе 8-битного результата
}
void Emulator::instr_POP_EBP() {
    if (regs.ESP + 4 > memory.size()) {
        std::cerr << "Stack underflow on POP EBP.\n";
        error_flag = true;
        running = false;
        return;
    }
    // Pop the value from the stack into EBP
    regs.EBP = read_memory_dword(regs.ESP);
    regs.ESP += 4;

    std::cout << "Выполнен POP EBP. Значение в регистре EBP: 0x" << std::hex << regs.EBP << "\n";
}
void Emulator::instr_MOV_ESI_imm32() {
    regs.ESI = fetch_dword();
}

// INT n (0xCD)
void Emulator::instr_INT() {
    uint8_t int_number = fetch_byte();
    if (int_number == 0x80) {
        // Обработка системного вызова Linux
        uint32_t syscall_number = regs.EAX;
        switch (syscall_number) {
        case 1: // sys_exit
            running = false;
            break;
        case 3: { // sys_read
            uint32_t fd = regs.EBX;
            uint32_t buf = regs.ECX;
            uint32_t count = regs.EDX;

            if (fd == 0) { // stdin
                std::string input;
                std::getline(std::cin, input);

                // Читаем не более count байтов
                input = input.substr(0, count);

                // Записываем введённые данные в память
                for (size_t i = 0; i < input.size(); ++i) {
                    memory[buf + i] = static_cast<uint8_t>(input[i]);
                }

                // Если введённых данных меньше, чем запрошено, заполняем оставшиеся нулями
                for (size_t i = input.size(); i < count; ++i) {
                    memory[buf + i] = 0;
                }

                // Возвращаем количество прочитанных байтов в EAX
                regs.EAX = input.size();
            }
            else {
                std::cout << "Unsupported file descriptor in sys_read: " << fd << "\n";
                regs.EAX = -1; // Возвращаем -1 в случае ошибки
            }
        }
        case 4: { // sys_write
            uint32_t fd = regs.EBX;
            uint32_t buf = regs.ECX;
            uint32_t count = regs.EDX;
            // Debug output
            std::cout << "sys_write called with fd=" << fd
                << ", buf=0x" << std::hex << buf
                << ", count=" << std::dec << count << "\n";
            if (fd == 1) { // stdout
                // Ensure the buffer address is within memory bounds
                if (buf + count > memory.size()) {
                    std::cout << "Buffer out of bounds in sys_write.\n";
                    regs.EAX = -1; // Return -1 on error
                    break;
                }
                std::string output;
                for (uint32_t i = 0; i < count; ++i) {
                    output += static_cast<char>(memory[buf + i]);
                }
                std::cout << output; // Output the string

                // Return the number of bytes written
                regs.EAX = count;
            }

            else {
                std::cout << "Unsupported file descriptor in sys_write: " << fd << "\n";
                regs.EAX = -1; // Return -1 on error
            }
            break;
        }
        case 45: { // sys_brk
            uint32_t addr = regs.EBX;
            if (addr == 0) {
                // Возвращаем текущий адрес brk
                regs.EAX = current_brk;
            }
            else {
                // Устанавливаем новый адрес brk
                if (addr >= data_segment_start && addr < memory.size()) {
                    current_brk = addr;
                    regs.EAX = current_brk;
                }
                else {
                    // Ошибка: попытка установить brk за пределами памяти
                    regs.EAX = 0; // Ошибка
                }
            }
            break;
        }
        case 90: // sys_mmap
            // Реализация sys_mmap
            break;
        case 91: { // sys_munmap
            uint32_t addr = regs.EBX;
            uint32_t length = regs.ECX;
            // Для простоты, можно игнорировать освобождение памяти
            regs.EAX = 0;
            break;
        }
        case 5: { // sys_open
            const char* filename = reinterpret_cast<const char*>(&memory[regs.EBX]); // Путь к файлу
            uint32_t flags = regs.ECX;
            uint32_t mode = regs.EDX;
            // Для простоты, возвращаем фиктивный файловый дескриптор, например 3
            regs.EAX = 3;
            break;
        }
        case 6: { // sys_close
            uint32_t fd = regs.EBX;
            // Ничего не делаем, возвращаем успех
            regs.EAX = 0;
            break;
        }
        case 192: { // sys_mmap2
            uint32_t addr = regs.EBX;
            uint32_t length = regs.ECX;
            uint32_t prot = regs.EDX;
            uint32_t flags = regs.ESI;
            uint32_t fd = regs.EDI;
            uint32_t pgoffset = regs.EBP;

            // Если addr равен 0, выбираем свободный адрес
            if (addr == 0) {
                addr = allocate_memory(0, length);
            }
            else {
                // Проверяем, можем ли мы выделить память по запрошенному адресу
                addr = allocate_memory(addr, length);
            }

            if (addr == 0) {
                // Ошибка при выделении памяти
                regs.EAX = -1;
            }
            else {
                // Успешное выделение памяти
                regs.EAX = addr;
            }
            break;
        }
        case 195: // sys_fstat
            // Реализация sys_fstat
            break;
        case 197: { // sys_fstat64
            uint32_t fd = regs.EBX;
            uint32_t buf = regs.ECX;
            // Возвращаем фиктивные данные
            // В структуре struct stat64 около 104 байт
            memset(&memory[buf], 0, 104);
            regs.EAX = 0;
            break;
        }
        default:
            std::cout << "Неизвестный системный вызов: " << syscall_number << "\n";
            running = false;
            break;
        }
    }
    else {
        std::cout << "Неизвестное прерывание: INT " << (int)int_number << "\n";
        error_flag = true;
        running = false;
    }
}

void Emulator::instr_MOV_MEM_EAX() {
    uint32_t address = fetch_dword();
    if (address + 4 > memory.size()) {
        throw std::runtime_error("Выход за пределы памяти при MOV [address], EAX");
    }
    memory[address] = regs.EAX & 0xFF;
    memory[address + 1] = (regs.EAX >> 8) & 0xFF;
    memory[address + 2] = (regs.EAX >> 16) & 0xFF;
    memory[address + 3] = (regs.EAX >> 24) & 0xFF;
}

void Emulator::instr_MOV_EAX_MEM() {
    uint32_t address = fetch_dword();
    if (address + 4 > memory.size()) {
        throw std::runtime_error("Выход за пределы памяти при MOV EAX, [address]");
    }
    regs.EAX = memory[address] |
        (memory[address + 1] << 8) |
        (memory[address + 2] << 16) |
        (memory[address + 3] << 24);
}
// CMP EAX, EBX
void Emulator::instr_CMP_EAX_EBX() {
    uint8_t modrm = fetch_byte(); // Получаем ModRM байт
    uint8_t reg = (modrm >> 3) & 0x07; // Извлекаем регистры
    uint8_t rm = modrm & 0x07;

    // Проверяем, что регистры соответствуют EAX и EBX
    if (reg == 0 && rm == 3) { // 0 для EAX и 3 для EBX
        uint32_t result = regs.EAX - regs.EBX;

        // Zero Flag (ZF)
        if (result == 0)
            regs.EFLAGS |= ZF;
        else
            regs.EFLAGS &= ~ZF;

        // Sign Flag (SF)
        if (result & (1 << 31))
            regs.EFLAGS |= SF;
        else
            regs.EFLAGS &= ~SF;

        // Остальная обработка флагов
    }
    else {
        std::cout << "CMP instruction with unsupported register combination.\n";
        error_flag = true;
        running = false;
    }
}

void Emulator::instr_JG_rel8() {
    int8_t rel = fetch_byte();

    bool zf = (regs.EFLAGS & ZF) != 0;
    bool sf = (regs.EFLAGS & SF) != 0;
    bool of = (regs.EFLAGS & OF) != 0;

    // JG переходит, если ZF = 0 и SF = OF
    if (!zf && (sf == of)) {
        regs.EIP += rel;
    }
}
// Реализация инструкции IMUL reg, r/m32, imm32
void Emulator::instr_IMUL_reg_rm32_imm32() {
    // Before reading ModRM byte, EIP points to it
    std::cout << "EIP before fetch_byte (ModRM): 0x" << std::hex << regs.EIP << "\n";

    uint8_t modrm = fetch_byte(); // Read ModRM byte
    uint8_t mod = modrm >> 6;
    uint8_t reg_code = (modrm >> 3) & 0x07; // Destination register
    uint8_t rm_code = modrm & 0x07;         // Source operand

    // Debug output
    std::cout << "Executing IMUL with modrm: 0x" << std::hex << (int)modrm << "\n";
    std::cout << "Destination reg code: " << (int)reg_code << ", Source rm code: " << (int)rm_code << "\n";
    std::cout << "EIP after fetch_byte (ModRM): 0x" << std::hex << regs.EIP << "\n";

    uint32_t* dest_reg = get_register_by_code(reg_code);
    uint32_t* src_reg = nullptr;

    if (mod == 3) { // Register-register mode
        src_reg = get_register_by_code(rm_code);
        if (!src_reg) {
            std::cout << "Unknown source register in IMUL.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else {
        std::cout << "Unsupported addressing mode in IMUL.\n";
        error_flag = true;
        running = false;
        return;
    }

    // Check if dest_reg is valid
    if (!dest_reg) {
        std::cout << "Unknown destination register in IMUL.\n";
        error_flag = true;
        running = false;
        return;
    }

    // Before reading imm32, EIP points to it
    std::cout << "EIP before fetch_dword (imm32): 0x" << std::hex << regs.EIP << "\n";

    uint32_t imm32 = fetch_dword(); // Read immediate value imm32

    // After reading imm32, EIP should have been incremented by 4
    std::cout << "EIP after fetch_dword (imm32): 0x" << std::hex << regs.EIP << "\n";
    // Debug output of imm32
    std::cout << "Immediate value: " << std::dec << imm32 << "\n";

    // Perform signed multiplication
    int32_t result = static_cast<int32_t>(*src_reg) * static_cast<int32_t>(imm32);
    *dest_reg = static_cast<uint32_t>(result);

    // Update flags appropriately
    update_ZF(*dest_reg);
    // Update other flags (CF, OF) if necessary
}

void Emulator::instr_SUB_AL_imm8() {
    uint8_t imm8 = fetch_byte();
    uint8_t* al = reinterpret_cast<uint8_t*>(&regs.EAX);
    *al -= imm8;
    update_ZF(*al);
}
void Emulator::instr_JMP_rel8() {
    int8_t rel = fetch_byte();
    regs.EIP += rel;
}
void Emulator::instr_JB_rel8() {
    int8_t rel = fetch_byte();
    if (regs.EFLAGS & CF) {
        regs.EIP += rel;
    }
}

void Emulator::instr_JA_rel8() {
    int8_t rel = fetch_byte();
    bool cf = (regs.EFLAGS & CF) != 0;
    bool zf = (regs.EFLAGS & ZF) != 0;
    if (!cf && !zf) {
        regs.EIP += rel;
    }
}
void Emulator::instr_INC_ECX() {
    regs.ECX += 1;
    update_ZF(regs.ECX);
}
void Emulator::instr_MOV_r8_imm8() {
    uint8_t opcode = memory[regs.EIP - 1]; // Последний прочитанный опкод
    uint8_t reg_code = opcode - 0xB0; // Регистры AL, CL, DL, BL, AH, CH, DH, BH идут от 0xB0 до 0xB7

    uint8_t imm8 = fetch_byte();
    uint8_t* reg = get_register8_by_code(reg_code);

    if (!reg) {
        std::cout << "Unknown register in MOV r8, imm8.\n";
        error_flag = true;
        running = false;
        return;
    }

    *reg = imm8;
}
void Emulator::instr_SUB_rm8_imm8() {
    uint8_t modrm = fetch_byte();
    uint8_t opcode = (modrm >> 3) & 0x07;
    uint8_t rm_code = modrm & 0x07;

    if (opcode != 5) {
        std::cout << "Unsupported opcode in SUB rm8, imm8.\n";
        error_flag = true;
        running = false;
        return;
    }

    uint8_t imm8 = fetch_byte();
    uint8_t* dest = get_register8_by_code(rm_code);

    if (!dest) {
        std::cout << "Unknown register in SUB rm8, imm8.\n";
        error_flag = true;
        running = false;
        return;
    }

    *dest -= imm8;

    update_ZF(*dest);
}
void Emulator::instr_MOV_r8_rm8() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = modrm >> 6;
    uint8_t reg_code = (modrm >> 3) & 0x07; // Назначение: r8
    uint8_t rm = modrm & 0x07;              // Источник: r/m8

    uint8_t* reg = get_register8_by_code(reg_code);
    if (!reg) {
        std::cout << "Unknown register in MOV r8, rm8.\n";
        error_flag = true;
        running = false;
        return;
    }

    uint32_t address = 0;

    if (mod == 0) {
        if (rm == 4) {
            // Обработка SIB байта
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, 0);
        }
        else if (rm == 5) {
            // [disp32]
            address = fetch_dword();
        }
        else {
            // [reg]
            uint32_t* rm_reg = get_register_by_code(rm);
            if (rm_reg) {
                address = *rm_reg;
            }
            else {
                std::cout << "Unknown base register in MOV r8, rm8.\n";
                error_flag = true;
                running = false;
                return;
            }
        }
    }
    else if (mod == 1) {
        int8_t disp8 = static_cast<int8_t>(fetch_byte());
        if (rm == 4) {
            // Обработка SIB байта
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, disp8);
        }
        else {
            // [reg + disp8]
            uint32_t* rm_reg = get_register_by_code(rm);
            if (rm_reg) {
                address = *rm_reg + disp8;
            }
            else {
                std::cout << "Unknown base register in MOV r8, rm8.\n";
                error_flag = true;
                running = false;
                return;
            }
        }
    }
    else if (mod == 2) {
        int32_t disp32 = static_cast<int32_t>(fetch_dword());
        if (rm == 4) {
            // Обработка SIB байта
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, disp32);
        }
        else {
            // [reg + disp32]
            uint32_t* rm_reg = get_register_by_code(rm);
            if (rm_reg) {
                address = *rm_reg + disp32;
            }
            else {
                std::cout << "Unknown base register in MOV r8, rm8.\n";
                error_flag = true;
                running = false;
                return;
            }
        }
    }
    else if (mod == 3) {
        // MOV r8, r8
        uint8_t* rm_reg = get_register8_by_code(rm);
        if (rm_reg) {
            *reg = *rm_reg;
        }
        else {
            std::cout << "Unknown register in MOV r8, rm8.\n";
            error_flag = true;
            running = false;
        }
        return;
    }
    else {
        std::cout << "Unsupported mod in MOV r8, rm8.\n";
        error_flag = true;
        running = false;
        return;
    }

    if (address >= memory.size()) {
        std::cout << "Memory access out of bounds in MOV r8, [address].\n";
        error_flag = true;
        running = false;
        return;
    }

    *reg = memory[address];
}
// MOV EBP, imm32
void Emulator::instr_MOV_EBP_imm32() {
    uint32_t imm = fetch_dword();
    regs.EBP = imm;
}
// MOV ESP, imm32
void Emulator::instr_MOV_ESP_imm32() {
    uint32_t imm = fetch_dword();
    regs.ESP = imm;
}

// MOV EDI, imm32
void Emulator::instr_MOV_EDI_imm32() {
    uint32_t imm = fetch_dword();
    regs.EDI = imm;
}
void Emulator::instr_MOV_r32_r_m32() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg = (modrm >> 3) & 0x07; // Destination register (r32)
    uint8_t rm = modrm & 0x07;         // Source (r/m32)

    uint32_t* dest_reg = get_register_by_code(reg);

    if (mod == 3) { // Register-register mode
        uint32_t* src_reg = get_register_by_code(rm);
        if (dest_reg && src_reg) {
            *dest_reg = *src_reg;
        }
        else {
            std::cout << "Unknown register in MOV r32, r/m32.\n";
            error_flag = true;
            running = false;
        }
    }
    else { // Memory to register
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;

        uint32_t value = read_memory_dword(address);
        if (dest_reg) {
            *dest_reg = value;
        }
        else {
            std::cout << "Unknown destination register in MOV r32, r/m32.\n";
            error_flag = true;
            running = false;
        }
    }
}
void Emulator::instr_ADD_r32_rm32() {
    uint8_t modrm = fetch_byte();
    Operand operand = decode_operand(modrm); // Предполагается, что вы реализовали структуру Operand

    uint8_t reg_code = (modrm >> 3) & 0x07;
    uint8_t rm_code = modrm & 0x07;

    uint32_t* reg = get_register_by_code(reg_code);

    if (!reg) {
        std::cout << "Unknown destination register in ADD r32, r/m32.\n";
        error_flag = true;
        running = false;
        return;
    }

    if (operand.is_memory) {
        uint32_t value = read_memory_dword(operand.address);
        *reg += value;
    }
    else {
        uint32_t* src_reg = get_register_by_code(rm_code);
        if (!src_reg) {
            std::cout << "Unknown source register in ADD r32, r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
        *reg += *src_reg;
    }

    update_ZF(*reg);
    // Обновите другие флаги при необходимости
}

void Emulator::instr_ADD_rm32_r32() {
    bool is_locked = regs.lock_prefix;

    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg_code = (modrm >> 3) & 0x07; // Source register (r32)
    uint8_t rm_code = modrm & 0x07;         // Destination (r/m32)

    uint32_t* src_reg = get_register_by_code(reg_code);

    if (mod == 3) { // Register-register mode
        uint32_t* dest_reg = get_register_by_code(rm_code);
        if (src_reg && dest_reg) {
            if (is_locked) {
                std::cout << "LOCK prefix applied to ADD r32, r/m32.\n";
            }
            *dest_reg += *src_reg;
            update_ZF(*dest_reg);
            // Update other flags as needed
        }
        else {
            std::cout << "Unknown register in ADD r/m32, r32.\n";
            error_flag = true;
            running = false;
        }
    }
    else { // Memory operand
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;

        uint32_t value = read_memory_dword(address);
        value += *src_reg;
        write_memory_dword(address, value);
        update_ZF(value);
        // Update other flags as needed
    }
    reset_prefixes();
}
void Emulator::instr_CMP_AL_imm8() {
    uint8_t imm8 = fetch_byte();
    uint8_t al = regs.EAX & 0xFF;
    uint8_t result = al - imm8;

    // Update Zero Flag (ZF)
    if (result == 0)
        regs.EFLAGS |= ZF;
    else
        regs.EFLAGS &= ~ZF;

    // Update Sign Flag (SF)
    if (result & 0x80)
        regs.EFLAGS |= SF;
    else
        regs.EFLAGS &= ~SF;

    // Update Carry Flag (CF)
    if (al < imm8)
        regs.EFLAGS |= CF;
    else
        regs.EFLAGS &= ~CF;

    // Update Overflow Flag (OF)
    bool overflow = ((al ^ imm8) & (al ^ result) & 0x80) != 0;
    if (overflow)
        regs.EFLAGS |= OF;
    else
        regs.EFLAGS &= ~OF;
}
void Emulator::instr_JL_rel8() {
    int8_t rel = fetch_byte();

    bool sf = (regs.EFLAGS & SF) != 0;
    bool of = (regs.EFLAGS & OF) != 0;

    // JL переходит, если SF != OF
    if (sf != of) {
        regs.EIP += rel;
    }
}

void Emulator::instr_XOR_r32_rm32() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg = (modrm >> 3) & 0x07; // Source register (r32)
    uint8_t rm = modrm & 0x07;         // Destination (r/m32)

    if (mod == 3) { // Register-register mode
        uint32_t* src_reg = get_register_by_code(reg);
        uint32_t* dest_reg = get_register_by_code(rm);

        if (src_reg && dest_reg) {
            *dest_reg ^= *src_reg;
            update_ZF(*dest_reg);
        }
        else {
            std::cout << "Unknown register in XOR r/m32, r32.\n";
            error_flag = true;
            running = false;
        }
    }
    // ...
}
void Emulator::instr_CALL_rel32() {
    int32_t rel32 = fetch_dword();
    // Push the next instruction address onto the stack
    push(regs.EIP);
    // Jump to the target address
    regs.EIP += rel32;
}
// Обработчик для opcode 0x81 (32-битное непосредственное значение)
void Emulator::instr_GROUP1_Ev_Iz_81() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg_opcode = (modrm >> 3) & 0x07; // Поле reg в ModRM
    uint8_t rm = modrm & 0x07;

    uint32_t* dest_reg = nullptr;
    if (mod == 3) { // Режим регистр-регистр
        dest_reg = get_register_by_code(rm);
    }
    else {
        // Обработка памяти (не реализовано)
        std::cout << "Memory operands not implemented for opcode 0x81.\n";
        error_flag = true;
        running = false;
        return;
    }

    uint32_t imm32 = fetch_dword(); // Чтение 32-битного непосредственного значения

    switch (reg_opcode) {
    case 0: // ADD
        *dest_reg += imm32;
        update_ZF(*dest_reg);
        break;
    case 1: // OR
        *dest_reg |= imm32;
        update_ZF(*dest_reg);
        break;
    case 2: // ADC
        // Реализуйте ADC при необходимости
        break;
    case 3: // SBB
        // Реализуйте SBB при необходимости
        break;
    case 4: // AND
        *dest_reg &= imm32;
        update_ZF(*dest_reg);
        break;
    case 5: // SUB
        *dest_reg -= imm32;
        update_ZF(*dest_reg);
        break;
    case 6: // XOR
        *dest_reg ^= imm32;
        update_ZF(*dest_reg);
        break;
    case 7: // CMP
    {
        uint32_t result = *dest_reg - imm32;
        update_ZF(result);
        // Обновите другие флаги при необходимости
    }
    break;
    default:
        std::cout << "Unsupported reg opcode in opcode 0x81: " << (int)reg_opcode << "\n";
        error_flag = true;
        running = false;
        break;
    }
}

// Обработчик для opcode 0x83 (8-битное непосредственное значение)
void Emulator::instr_GROUP1_Ev_Iz_83() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg_opcode = (modrm >> 3) & 0x07; // Поле reg в ModRM
    uint8_t rm = modrm & 0x07;

    uint32_t* dest_reg = nullptr;
    if (mod == 3) { // Режим регистр-регистр
        dest_reg = get_register_by_code(rm);
    }
    else {
        // Обработка памяти (не реализовано)
        std::cout << "Memory operands not implemented for opcode 0x83.\n";
        error_flag = true;
        running = false;
        return;
    }

    int8_t imm8 = static_cast<int8_t>(fetch_byte()); // Чтение 8-битного непосредственного значения

    // Знаковое расширение до 32 бит
    int32_t sign_extended_imm = static_cast<int32_t>(imm8);

    switch (reg_opcode) {
    case 0: // ADD
        *dest_reg += sign_extended_imm;
        update_ZF(*dest_reg);
        break;
    case 1: // OR
        *dest_reg |= sign_extended_imm;
        update_ZF(*dest_reg);
        break;
    case 2: // ADC
        // Реализуйте ADC при необходимости
        break;
    case 3: // SBB
        // Реализуйте SBB при необходимости
        break;
    case 4: // AND
        *dest_reg &= sign_extended_imm;
        update_ZF(*dest_reg);
        break;
    case 5: // SUB
        *dest_reg -= sign_extended_imm;
        update_ZF(*dest_reg);
        break;
    case 6: // XOR
        *dest_reg ^= sign_extended_imm;
        update_ZF(*dest_reg);
        break;
    case 7: // CMP
    {
        uint32_t result = *dest_reg - sign_extended_imm;
        update_ZF(result);
        // Обновите другие флаги при необходимости
    }
    break;
    default:
        std::cout << "Unsupported reg opcode in opcode 0x83: " << (int)reg_opcode << "\n";
        error_flag = true;
        running = false;
        break;
    }
}
void Emulator::instr_JL_rel32() {
    int32_t rel32 = fetch_dword(); // Читаем относительное смещение
    bool sf = (regs.EFLAGS & SF) != 0;
    bool of = (regs.EFLAGS & OF) != 0;
    if (sf != of) {
        regs.EIP += rel32;
    }
}
void Emulator::instr_MOVSB() {
    // Обработка префиксов REP/REPE/REPNE
    if (regs.rep_prefix || regs.repne_prefix) {
        // Определяем тип префикса
        bool is_rep = regs.rep_prefix;
        bool is_repne = regs.repne_prefix;

        while (regs.ECX != 0) {
            uint8_t byte = read_memory_byte(regs.ESI);
            write_memory_byte(regs.EDI, byte);
            regs.ESI += 1;
            regs.EDI += 1;
            regs.ECX -= 1;

            // Обновление флагов по необходимости
            update_ZF(byte);

            // Для `REPNE` можно добавить условия выхода
            if (is_repne && (regs.EFLAGS & ZF)) {
                break;
            }

            if (is_rep && regs.ECX == 0) {
                break;
            }
        }

        // Сброс префиксов после выполнения
        reset_prefixes();
    }
    else {
        // Обычное выполнение MOVSB без повторения
        uint8_t byte = read_memory_byte(regs.ESI);
        write_memory_byte(regs.EDI, byte);
        regs.ESI += 1;
        regs.EDI += 1;

        // Обновление флагов по необходимости
        update_ZF(byte);
    }
}
void Emulator::instr_ADD_rm8_r8() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg_code = (modrm >> 3) & 0x07; // Source register (r8)
    uint8_t rm = modrm & 0x07;              // Destination (r/m8)

    uint8_t* src_reg = get_register8_by_code(reg_code);
    if (!src_reg) {
        std::cout << "Unknown source register in ADD r/m8, r8.\n";
        error_flag = true;
        running = false;
        return;
    }

    if (mod == 3) { // Register to register
        uint8_t* dest_reg = get_register8_by_code(rm);
        if (!dest_reg) {
            std::cout << "Unknown destination register in ADD r/m8, r8.\n";
            error_flag = true;
            running = false;
            return;
        }
        *dest_reg += *src_reg;
        update_ZF(*dest_reg);
    }
    else {
        // Memory operand
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        uint8_t value = read_memory_byte(address);
        value += *src_reg;
        write_memory_byte(address, value);
        update_ZF(value);
    }
    // Update other flags (CF, OF, etc.) as necessary
}
// XOR AL, imm8
void Emulator::instr_XOR_AL_imm8() {
    uint8_t imm8 = fetch_byte();
    uint8_t* al = reinterpret_cast<uint8_t*>(&regs.EAX); // Access the AL register
    *al ^= imm8; // Perform XOR operation

    // Update Zero Flag (ZF)
    if (*al == 0)
        regs.EFLAGS |= ZF;
    else
        regs.EFLAGS &= ~ZF;

    // Update Sign Flag (SF)
    if (*al & 0x80)
        regs.EFLAGS |= SF;
    else
        regs.EFLAGS &= ~SF;

    // Parity Flag (PF)
    update_PF(*al);

    // Clear Carry Flag (CF) and Overflow Flag (OF) as XOR resets them
    regs.EFLAGS &= ~CF;
    regs.EFLAGS &= ~OF;

    std::cout << "Выполнена инструкция XOR AL, imm8. AL: 0x" << std::hex << static_cast<int>(*al) << "\n";
}

// Function to update Parity Flag based on the result
void Emulator::update_PF(uint8_t result) {
    // Count the number of set bits
    result ^= result >> 4;
    result &= 0xF;
    bool parity = (0x6996 >> result) & 1;
    if (parity)
        regs.EFLAGS |= PF; // PF is set if parity is even
    else
        regs.EFLAGS &= ~PF;
}
void Emulator::instr_AND_rm8_r8() {
    uint8_t modrm = fetch_byte();

    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg_code = (modrm >> 3) & 0x07; // r8
    uint8_t rm = modrm & 0x07;              // r/m8 (может быть регистром или памятью)

    uint8_t* reg = get_register8_by_code(reg_code);
    if (!reg) {
        std::cout << "Unknown source register in AND r/m8, r8.\n";
        error_flag = true;
        running = false;
        return;
    }

    if (mod == 3) { // Режим регистр-регистр
        uint8_t* dest_reg = get_register8_by_code(rm);
        if (!dest_reg) {
            std::cout << "Unknown destination register in AND r/m8, r8.\n";
            error_flag = true;
            running = false;
            return;
        }
        *dest_reg &= *reg;
        update_ZF(*dest_reg);
    }
    else {
        // Операнд - память
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        uint8_t value = read_memory_byte(address);
        value &= *reg;
        write_memory_byte(address, value);
        update_ZF(value);
    }

    // Обновление флагов
    // Обновите флаги SF, PF, CF, OF по необходимости
    // Флаги CF и OF сбрасываются при логических операциях
    regs.EFLAGS &= ~(CF | OF);

    // Обновление SF
    if ((value & 0x80) != 0)
        regs.EFLAGS |= SF;
    else
        regs.EFLAGS &= ~SF;

    // Обновление PF
    update_PF(value);

    std::cout << "Выполнена инструкция AND r/m8, r8.\n";
}
void Emulator::instr_MOV_r32_rm32() {
    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg = (modrm >> 3) & 0x07; // Source register (r32)
    uint8_t rm = modrm & 0x07;         // Destination (r/m32)

    if (mod == 3) { // Register-register mode
        uint32_t* src_reg = get_register_by_code(reg);
        uint32_t* dest_reg = get_register_by_code(rm);

        if (src_reg && dest_reg) {
            *dest_reg = *src_reg;
        }
        else {
            std::cout << "Unknown register in MOV r/m32, r32.\n";
            error_flag = true;
            running = false;
        }
    }
}
#ifndef EMULATOR_H
#define EMULATOR_H

#include <vector>
#include <unordered_map>
#include <functional>
#include <cstdint>

class Emulator {
public:
    const std::vector<uint8_t> prefixes = {
        0xF2, // REPNE/REPNZ
        0xF3, // REP/REPE/REPZ
        0xF0, // LOCK
        0x2E, // CS segment override
        0x36, // SS segment override
        0x3E, // DS segment override
        0x26, // ES segment override
        0x64, // FS segment override
        0x65, // GS segment override
        0x66, // Operand-size override
        0x67  // Address-size override
    };
    struct Operand {
        bool is_memory;
        uint32_t address; // Если is_memory = true
        uint32_t register_code; // Если is_memory = false
    };

    Operand decode_operand(uint8_t modrm);

    Emulator(size_t memory_size);
    void load_program(const std::vector<uint8_t>& program, size_t load_address, bool set_eip);
    void run();
    void print_registers(bool hex_output = false) const;
    bool has_error() const { return error_flag; }

    // Добавленные методы
    void write_memory(uint32_t address, const uint8_t* data, size_t size);
    size_t get_memory_size() const { return memory.size(); }
    void set_eip(uint32_t address);
    void reset_prefixes();
    void initialize_stack();
    struct Registers {
        uint32_t EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP;
        uint32_t EIP;
        uint32_t EFLAGS;
        // Сегментные регистры
        uint32_t CS;
        uint32_t DS;
        uint32_t SS;
        uint32_t ES;
        uint32_t FS;
        uint32_t GS;
        // Флаги для префиксов
        bool lock_prefix = false;
        bool rep_prefix = false;
        bool repne_prefix = false;
        bool operand_size_override = false;
        bool address_size_override = false;
        // Конструктор для инициализации сегментных регистров
        Registers() : EAX(0), EBX(0), ECX(0), EDX(0),
            ESI(0), EDI(0), ESP(0), EBP(0),
            EIP(0), EFLAGS(0),
            CS(0), DS(0), SS(0), ES(0), FS(0), GS(0) {}
    } regs;
private:
    std::vector<uint8_t> memory;
    bool running = false;
    bool error_flag = false;
    uint32_t current_brk = 0;
    uint32_t data_segment_start = 0x08000000; // Начальный адрес сегмента данных
    // Метод для сброса сегментных префиксов
    void reset_segment_override();
    // Метод для установки сегментного префикса
    void set_segment_override(uint8_t prefix);
    // Flags
    static constexpr uint32_t ZF = 1 << 6;  // Zero Flag
    static constexpr uint32_t CF = 1 << 0;  // Carry Flag
    static constexpr uint32_t DF = 1 << 10; // Direction Flag
    static constexpr uint32_t SF = 1 << 7;  // Sign Flag
    static constexpr uint32_t OF = 1 << 11; // Overflow Flag
    static constexpr uint32_t IF_FLAG = 1 << 9; // Interrupt Flag
    static constexpr uint32_t PF = 1 << 2;  // Parity Flag
    // Instruction handling
    typedef void (Emulator::* InstructionHandler)();
    std::unordered_map<uint8_t, InstructionHandler> instruction_set;
    std::unordered_map<uint8_t, InstructionHandler> extended_instruction_set;
    void initialize_instruction_set();

    // Объявление указателей на текущие сегменты
    uint32_t* current_data_segment;
    uint32_t* current_code_segment;

    // Instruction implementations
    // [Ваши существующие методы обработчиков инструкций]
    void instr_MOV_Ev_Iv();
    void instr_MOV_EAX_imm32();
    void instr_MOV_EBX_imm32();
    void instr_MOV_ECX_imm32();
    void instr_MOV_EDX_imm32();
    void instr_ADD_EAX_imm32();
    void instr_SUB_EAX_imm32();
    void instr_INC_EAX();
    void instr_DEC_EAX();
    void instr_MUL_EAX(); // Not used
    void instr_JMP_rel32();
    void instr_CMP_reg_imm8();
    void instr_JE_rel8();
    void instr_JNE_rel8();
    void instr_AND_EAX_imm32();
    void instr_AND_ECX_imm32();
    void instr_OR_EAX_imm32();
    void instr_XOR_EAX_imm32();
    void instr_SUB_r32_imm32();
    void instr_CMP_EAX_imm32();
    void instr_OR_ECX_imm32();
    void instr_RET(); // Обработчик RET
    void instr_MOV_MEM_EAX(); // MOV [address], EAX
    void instr_MOV_EAX_MEM(); // MOV EAX, [address]
    void instr_CMP_EAX_EBX();
    void instr_JG_rel8();     // JG rel8
    void instr_JL_rel8();     // JL rel8
    void instr_CMP_r32_rm32();
    void instr_IMUL_reg_rm32_imm32();
    void instr_JB_rel8();
    void instr_JA_rel8();
    void instr_INC_ECX();
    void instr_JMP_rel8();
    void instr_MOV_r8_imm8();
    void instr_SUB_AL_imm8();
    void instr_SUB_rm8_imm8();
    void instr_MOV_rm8_r8();
    void instr_MOV_rm8_imm8();
    void instr_MOV_r8_rm8();
    void instr_ADD_AL_imm8();
    void instr_MOV_ESI_imm32();
    void instr_INT();
    void instr_F7();
    void instr_MUL_rm32(uint8_t modrm);
    void instr_DIV_rm32(uint8_t modrm);
    void instr_IDIV_rm32(uint8_t modrm);
    void instr_XOR_r32_rm32();
    void instr_MOV_r32_rm32();
    void instr_ADD_rm32_r32();
    void instr_CMP_AL_imm8();
    void instr_ADD_r32_rm32();
    void instr_SUB_EBX_imm32();
    void instr_IMUL_reg_rm32_imm8();
    void instr_MOV_r32_r_m32();
    void instr_MOV_EBP_imm32();
    void instr_MOV_ESP_imm32();
    void instr_MOV_EDI_imm32();
    void instr_CALL_rel32();
    void instr_GROUP1_Ev_Iz_81();
    void instr_GROUP1_Ev_Iz_83();
    void instr_LEA_r32_m();
    void instr_MOVSB();
    void instr_JNE_rel32();
    void instr_JG_rel32();
    void instr_JE_rel32();
    void instr_NOP_EAX();
    void instr_NOP_m16_m32();
    void instr_JL_rel32();
    void instr_STI();
    void instr_ENDBR32();
    void instr_PUSH_EDI();
    void instr_PUSH_ESI();
    void instr_PUSH_EBP();
    void instr_PUSH_EBX();
    void instr_PUSH_EDX();
    void instr_PUSH_ECX();
    void instr_PUSH_EAX();
    void instr_PUSH_ESP();
    void instr_POP_EAX();
    void instr_POP_ECX();
    void instr_POP_EDX();
    void instr_POP_EBX();
    void instr_POP_ESP();
    void instr_POP_EBP();
    void instr_POP_ESI();
    void instr_POP_EDI();
    void instr_PUSH_imm8();
    void instr_GROUP5();
    void instr_INC_rm32(uint8_t modrm);
    void instr_DEC_rm32(uint8_t modrm);
    void instr_CALL_rm32(uint8_t modrm);
    void instr_JMP_rm32(uint8_t modrm);
    void instr_PUSH_rm32(uint8_t modrm);
    void instr_PUSH_imm32();
    void instr_ADD_rm8_r8();
    void instr_CLD();
    void instr_NOP();
    void instr_STD();
    void instr_PUSHAD();
    void instr_REP_MOVSB();
    void instr_XOR_AL_imm8();
    void instr_LEAVE();
    void instr_AND_rm8_r8();
    // Utility methods
    uint8_t fetch_byte();
    uint32_t fetch_dword();
    uint32_t* get_register_by_code(uint8_t code);
    uint8_t* get_register8_by_code(uint8_t code);
    uint8_t regm_rm(uint8_t modrm);
    uint32_t calculate_address(uint8_t modrm);
    uint32_t calculate_sib_address(uint8_t mod, uint8_t sib, int32_t displacement);
    void update_ZF(uint32_t result);
    void update_PF(uint8_t result);
    uint8_t read_memory_byte(uint32_t address) const;
    uint32_t read_memory_dword(uint32_t address) const;
    void write_memory_dword(uint32_t address, uint32_t value);
    void write_memory_byte(uint32_t address, uint8_t value);
    uint32_t allocate_memory(uint32_t addr, uint32_t length);
    void push(uint32_t value);
};

#endif // EMULATOR_H
// Emulator.cpp
#include "Emulator.h"
#include <iostream>
#include <algorithm>

// Конструктор
Emulator::Emulator(size_t memory_size) {
    memory.resize(memory_size, 0);
    initialize_instruction_set();
    regs.ESP = static_cast<uint32_t>(memory_size - 16); // Отступаем на 16 байт от конца памяти
    initialize_stack();
    regs.CS = 0;
    regs.DS = 0;
    regs.SS = 0;
    regs.ES = 0;
    regs.FS = 0;
    regs.GS = 0;

    current_data_segment = &regs.DS;
    current_code_segment = &regs.CS;
    current_brk = data_segment_start;
}
uint32_t Emulator::allocate_memory(uint32_t addr, uint32_t length) {
    // Простая реализация: просто сдвигаем brk
    if (addr == 0) {
        addr = current_brk;
    }

    uint32_t new_brk = addr + length;
    if (new_brk > memory.size()) {
        // Недостаточно памяти в эмуляторе
        return 0;
    }

    current_brk = new_brk;
    return addr;
}
void Emulator::set_segment_override(uint8_t prefix) {
    switch (prefix) {
    case 0x2E: // CS
        current_code_segment = &regs.CS;
        break;
    case 0x36: // SS
        current_data_segment = &regs.SS;
        break;
    case 0x3E: // DS
        current_data_segment = &regs.DS;
        break;
    case 0x26: // ES
        current_data_segment = &regs.ES;
        break;
    case 0x64: // FS
        current_data_segment = &regs.FS;
        break;
    case 0x65: // GS
        current_data_segment = &regs.GS;
        break;
    default:
        // Неизвестный префикс сегмента, можно игнорировать или установить ошибку
        std::cout << "Неизвестный сегментный префикс: 0x" << std::hex << (int)prefix << "\n";
        break;
    }
}
// Реализация метода write_memory
void Emulator::write_memory(uint32_t address, const uint8_t* data, size_t size) {
    if (address + size > memory.size()) {
        std::cerr << "Ошибка: Пытаетесь записать за пределы памяти. Адрес: 0x"
            << std::hex << address << ", Размер: " << std::dec << size << "\n";
        error_flag = true;
        running = false;
        return;
    }
    std::memcpy(&memory[address], data, size);
}
// Реализация метода set_eip
void Emulator::set_eip(uint32_t address) {
    if (address >= memory.size()) {
        std::cerr << "Ошибка: Установка EIP за пределами памяти. Адрес: 0x"
            << std::hex << address << "\n";
        error_flag = true;
        running = false;
        return;
    }
    regs.EIP = address;
}
uint8_t Emulator::read_memory_byte(uint32_t address) const {
    if (address >= memory.size()) {
        throw std::runtime_error("Чтение памяти вне границ");
    }
    return memory[address];
}

uint32_t Emulator::read_memory_dword(uint32_t address) const {
    if (address + 4 > memory.size()) {
        throw std::runtime_error("Чтение памяти вне границ");
    }
    uint32_t value = 0;
    value |= static_cast<uint32_t>(memory[address]);
    value |= static_cast<uint32_t>(memory[address + 1]) << 8;
    value |= static_cast<uint32_t>(memory[address + 2]) << 16;
    value |= static_cast<uint32_t>(memory[address + 3]) << 24;
    return value;
}

// Метод load_program
void Emulator::load_program(const std::vector<uint8_t>& program, size_t load_address, bool set_eip) {
    if (load_address + program.size() > memory.size()) {
        throw std::runtime_error("Размер программы превышает лимиты памяти");
    }
    std::copy(program.begin(), program.end(), memory.begin() + load_address);
    if (set_eip) {
        regs.EIP = load_address;
    }
}

// Метод run
void Emulator::run() {
    running = true;
    while (running) {
        try {
            std::cout << "EIP: 0x" << std::hex << regs.EIP << "\n";
            std::cout << "ESP: " << std::hex << regs.ESP << ", Значение на вершине стека: " << read_memory_dword(regs.ESP) << "\n";

            uint8_t opcode = fetch_byte();

            // Список префиксов
            const std::vector<uint8_t> prefixes = {
                0xF2, // REPNE/REPNZ
                0xF3, // REP/REPE/REPZ
                0xF0, // LOCK
                0x2E, // CS segment override
                0x36, // SS segment override
                0x3E, // DS segment override
                0x26, // ES segment override
                0x64, // FS segment override
                0x65, // GS segment override
                0x66, // Operand-size override
                0x67  // Address-size override
            };

            // Сбор префиксов
            while (std::find(prefixes.begin(), prefixes.end(), opcode) != prefixes.end()) {
                switch (opcode) {
                case 0xF2:
                    regs.repne_prefix = true;
                    break;
                case 0xF3:
                    regs.rep_prefix = true;
                    break;
                case 0xF0:
                    regs.lock_prefix = true;
                    break;
                case 0x66:
                    regs.operand_size_override = true;
                    break;
                case 0x67:
                    regs.address_size_override = true;
                    break;
                case 0x2E:
                case 0x36:
                case 0x3E:
                case 0x26:
                case 0x64:
                case 0x65:
                    set_segment_override(opcode);
                    break;
                default:
                    break;
                }

                std::cout << "Обнаружен префикс: 0x" << std::hex << (int)opcode << "\n";

                // Проверяем на ENDBR32
                if (opcode == 0xF3) {
                    uint8_t next_opcode = memory[regs.EIP];
                    if (next_opcode == 0x0F) {
                        // Потенциально ENDBR32, прерываем сбор префиксов
                        break;
                    }
                }

                opcode = fetch_byte(); // Читаем следующий байт как опкод инструкции
            }

            // Проверяем на ENDBR32
            if (regs.rep_prefix && memory[regs.EIP] == 0x0F) {
                regs.EIP++; // Пропускаем 0x0F
                uint8_t opcode1 = fetch_byte(); // Считываем следующий байт
                if (opcode1 == 0x1E) {
                    instr_ENDBR32();
                    continue; // Переходим к следующей инструкции
                }
                else {
                    std::cout << "Неизвестный opcode: 0x" << std::hex << (int)opcode1 << "\n";
                    error_flag = true;
                    running = false;
                    continue;
                }
            }

            // Проверка на двухбайтовый опкод
            bool is_extended = false;
            if (opcode == 0x0F) {
                is_extended = true;
                opcode = fetch_byte(); // Читаем второй байт опкода
            }

            if (is_extended) {
                auto it = extended_instruction_set.find(opcode);
                if (it != extended_instruction_set.end()) {
                    InstructionHandler handler = it->second;
                    (this->*handler)();
                }
                else {
                    std::cout << "Неизвестный двухбайтовый opcode: 0x0F 0x"
                        << std::hex << (int)opcode << "\n";
                    error_flag = true;
                    running = false;
                }
            }
            else {
                auto it = instruction_set.find(opcode);
                if (it != instruction_set.end()) {
                    InstructionHandler handler = it->second;
                    (this->*handler)();
                }
                else {
                    std::cout << "Неизвестный opcode: 0x" << std::hex << (int)opcode << "\n";
                    error_flag = true;
                    running = false;
                }
            }
            print_registers(true);
            std::cout << "EFLAGS: 0x" << std::hex << regs.EFLAGS << std::endl;
            // После выполнения инструкции сбросить префиксы
            reset_segment_override();
            reset_prefixes();

        }
        catch (const std::exception& e) {
            std::cerr << "Exception caught: " << e.what() << "\n";
            error_flag = true;
            running = false;
        }
    }
}

void Emulator::reset_prefixes() {
    regs.lock_prefix = false;
    regs.rep_prefix = false;
    regs.repne_prefix = false;
    regs.operand_size_override = false;
    regs.address_size_override = false;
    // Сброс других префиксов при необходимости
}
void Emulator::reset_segment_override() {
    // Сброс текущих сегментов к стандартным значениям
    current_data_segment = &regs.DS;
    current_code_segment = &regs.CS;
}
// Метод print_registers
void Emulator::print_registers(bool hex_output) const {
    if (hex_output) {
        std::cout << std::hex;
        std::cout << "EAX: 0x" << regs.EAX << "\n";
        std::cout << "EBX: 0x" << regs.EBX << "\n";
        std::cout << "ECX: 0x" << regs.ECX << "\n";
        std::cout << "EDX: 0x" << regs.EDX << "\n";
        std::cout << "ESI: 0x" << regs.ESI << "\n";
        std::cout << "EDI: 0x" << regs.EDI << "\n";
        std::cout << "ESP: 0x" << regs.ESP << "\n";
        std::cout << "EBP: 0x" << regs.EBP << "\n";
        std::cout << "EIP: 0x" << regs.EIP << "\n";
        std::cout << "EFLAGS: 0x" << regs.EFLAGS << "\n";
        std::cout << std::dec; // Возвращаемся к десятичной системе счисления
    }
    else {
        std::cout << "EAX: " << regs.EAX << "\n";
        std::cout << "EBX: " << regs.EBX << "\n";
        std::cout << "ECX: " << regs.ECX << "\n";
        std::cout << "EDX: " << regs.EDX << "\n";
        std::cout << "ESI: " << regs.ESI << "\n";
        std::cout << "EDI: " << regs.EDI << "\n";
        std::cout << "ESP: " << regs.ESP << "\n";
        std::cout << "EBP: " << regs.EBP << "\n";
        std::cout << "EIP: " << regs.EIP << "\n";
        std::cout << "EFLAGS: " << regs.EFLAGS << "\n";
    }
}

uint32_t Emulator::calculate_sib_address(uint8_t mod, uint8_t sib, int32_t displacement) {
    uint8_t scale = (sib >> 6) & 0x03;
    uint8_t index = (sib >> 3) & 0x07;
    uint8_t base = sib & 0x07;

    uint32_t base_value = 0;
    uint32_t index_value = 0;

    // Получаем значение base
    if (base == 5) {
        if (mod == 0) {
            // base = 0, disp32 используется вместо base
            base_value = 0;
            displacement += fetch_dword(); // Дополнительный disp32
        }
        else {
            base_value = *get_register_by_code(base);
        }
    }
    else {
        base_value = *get_register_by_code(base);
    }

    // Получаем значение index
    if (index != 4) { // Если index не равно 4 (4 означает, что index не используется)
        index_value = *get_register_by_code(index) << scale;
    }

    uint32_t address = base_value + index_value + displacement;
    return address;
}

uint32_t Emulator::calculate_address(uint8_t modrm) {
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t rm = modrm & 0x07;
    //std::cout << "calculate_address called with mod=" << (int)mod << ", rm=" << (int)rm << "\n";
    uint32_t address = 0;

    if (mod == 0) {
        if (rm == 5) {
            // [disp32]
            uint32_t disp32 = fetch_dword();
            address = disp32;
        }
        else if (rm == 4) {
            // SIB byte
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, 0);
        }
        else {
            // [reg]
            address = *get_register_by_code(rm);
        }
    }
    else if (mod == 1) {
        int8_t disp8 = static_cast<int8_t>(fetch_byte());
        if (rm == 4) {
            // SIB byte с disp8
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, disp8);
        }
        else {
            // [reg + disp8]
            address = *get_register_by_code(rm) + disp8;
        }
    }
    else if (mod == 2) {
        int32_t disp32 = static_cast<int32_t>(fetch_dword());
        if (rm == 4) {
            // SIB byte с disp32
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, disp32);
        }
        else {
            // [reg + disp32]
            address = *get_register_by_code(rm) + disp32;
        }
    }
    else if (mod == 3) {
        // Mod == 3 indicates register-direct mode, address calculation is not applicable.
        std::cout << "Error: calculate_address() called with mod == 3 (register-direct mode) which is invalid for memory addressing.\n";
        error_flag = true;
        running = false;
        return 0;
    }
    else {
        std::cout << "Unsupported ModR/M mod value in calculate_address.\n";
        error_flag = true;
        running = false;
        return 0;
    }

    // Добавьте базу сегмента к вычисленному адресу
    // Для Data Segment
    address += *current_data_segment;

    if (address >= memory.size()) {
        std::cout << "Address out of bounds: 0x" << std::hex << address << "\n";
        error_flag = true;
        running = false;
    }

    return address;
}

// Инициализация таблицы инструкций
void Emulator::initialize_instruction_set() {
    instruction_set[0xB8] = &Emulator::instr_MOV_EAX_imm32;   
    instruction_set[0xC7] = &Emulator::instr_MOV_Ev_Iv;
    instruction_set[0x34] = &Emulator::instr_XOR_AL_imm8;
    instruction_set[0x50] = &Emulator::instr_PUSH_EAX;
    instruction_set[0x51] = &Emulator::instr_PUSH_ECX;
    instruction_set[0x52] = &Emulator::instr_PUSH_EDX;
    instruction_set[0x53] = &Emulator::instr_PUSH_EBX;
    instruction_set[0x54] = &Emulator::instr_PUSH_ESP;
    instruction_set[0x55] = &Emulator::instr_PUSH_EBP;
    instruction_set[0x56] = &Emulator::instr_PUSH_ESI;
    instruction_set[0x57] = &Emulator::instr_PUSH_EDI;
    instruction_set[0x6A] = &Emulator::instr_PUSH_imm8;
    instruction_set[0x58] = &Emulator::instr_POP_EAX;
    instruction_set[0x59] = &Emulator::instr_POP_ECX;
    instruction_set[0x5A] = &Emulator::instr_POP_EDX;
    instruction_set[0x5B] = &Emulator::instr_POP_EBX;
    instruction_set[0x5C] = &Emulator::instr_POP_ESP;
    instruction_set[0x5D] = &Emulator::instr_POP_EBP;
    instruction_set[0x5E] = &Emulator::instr_POP_ESI;
    instruction_set[0x5F] = &Emulator::instr_POP_EDI;
    instruction_set[0xB9] = &Emulator::instr_MOV_ECX_imm32;
    instruction_set[0xBA] = &Emulator::instr_MOV_EDX_imm32;
    instruction_set[0x05] = &Emulator::instr_ADD_EAX_imm32;
    instruction_set[0x2D] = &Emulator::instr_SUB_EAX_imm32;
    instruction_set[0x40] = &Emulator::instr_INC_EAX;
    instruction_set[0x48] = &Emulator::instr_DEC_EAX;
    instruction_set[0xF7] = &Emulator::instr_F7;
    instruction_set[0xE9] = &Emulator::instr_JMP_rel32;
    instruction_set[0x83] = &Emulator::instr_GROUP1_Ev_Iz_83;
    instruction_set[0x74] = &Emulator::instr_JE_rel8;
    instruction_set[0x75] = &Emulator::instr_JNE_rel8;
    instruction_set[0x25] = &Emulator::instr_AND_EAX_imm32;
    instruction_set[0x21] = &Emulator::instr_AND_ECX_imm32;
    instruction_set[0x0D] = &Emulator::instr_OR_EAX_imm32;
    instruction_set[0x35] = &Emulator::instr_XOR_EAX_imm32;
    instruction_set[0x81] = &Emulator::instr_GROUP1_Ev_Iz_81;
    instruction_set[0x3D] = &Emulator::instr_CMP_EAX_imm32;
    instruction_set[0x0E] = &Emulator::instr_OR_ECX_imm32;
    instruction_set[0xC3] = &Emulator::instr_RET; // Обработчик RET
    instruction_set[0xA3] = &Emulator::instr_MOV_MEM_EAX; // MOV [address], EAX
    instruction_set[0xA1] = &Emulator::instr_MOV_EAX_MEM; // MOV EAX, [address]
    instruction_set[0xCD] = &Emulator::instr_INT; // INT n
    instruction_set[0x89] = &Emulator::instr_MOV_r32_rm32;
    instruction_set[0x31] = &Emulator::instr_XOR_r32_rm32;
    instruction_set[0x04] = &Emulator::instr_ADD_AL_imm8;
    instruction_set[0x88] = &Emulator::instr_MOV_rm8_r8;
    instruction_set[0xC6] = &Emulator::instr_MOV_rm8_imm8;
    instruction_set[0x39] = &Emulator::instr_CMP_r32_rm32; // CMP r/m32, r32
    instruction_set[0x7F] = &Emulator::instr_JG_rel8;     // JG rel8
    instruction_set[0x7C] = &Emulator::instr_JL_rel8;     // JL rel8
    instruction_set[0x8A] = &Emulator::instr_MOV_r8_rm8;
    instruction_set[0x80] = &Emulator::instr_SUB_rm8_imm8;
    instruction_set[0xB7] = &Emulator::instr_MOV_r8_imm8;
    instruction_set[0x69] = &Emulator::instr_IMUL_reg_rm32_imm32;
    instruction_set[0x72] = &Emulator::instr_JB_rel8;
    instruction_set[0x77] = &Emulator::instr_JA_rel8;
    instruction_set[0x41] = &Emulator::instr_INC_ECX;
    instruction_set[0xEB] = &Emulator::instr_JMP_rel8;
    instruction_set[0x2C] = &Emulator::instr_SUB_AL_imm8;
    instruction_set[0x3C] = &Emulator::instr_CMP_AL_imm8;
    instruction_set[0x01] = &Emulator::instr_ADD_rm32_r32;
    instruction_set[0x03] = &Emulator::instr_ADD_r32_rm32; // ADD r32, r/m32
    instruction_set[0x6B] = &Emulator::instr_IMUL_reg_rm32_imm8;
    instruction_set[0x8B] = &Emulator::instr_MOV_r32_r_m32; // Добавляем обработчик для MOV r32, r/m32
    instruction_set[0xBB] = &Emulator::instr_MOV_EBX_imm32;
    instruction_set[0xBD] = &Emulator::instr_MOV_EBP_imm32; // MOV EBP, imm32
    instruction_set[0xBC] = &Emulator::instr_MOV_ESP_imm32; // MOV ESP, imm32
    instruction_set[0xBE] = &Emulator::instr_MOV_ESI_imm32;
    instruction_set[0xBF] = &Emulator::instr_MOV_EDI_imm32; // MOV EDI, imm32
    instruction_set[0xE8] = &Emulator::instr_CALL_rel32; // MOV rel32, CALL rel32
    instruction_set[0x8D] = &Emulator::instr_LEA_r32_m;
    instruction_set[0xA4] = &Emulator::instr_MOVSB;
    instruction_set[0x5E] = &Emulator::instr_POP_ESI;
    instruction_set[0xFF] = &Emulator::instr_GROUP5;
    instruction_set[0x68] = &Emulator::instr_PUSH_imm32;
    instruction_set[0x00] = &Emulator::instr_ADD_rm8_r8; // ADD r/m8, r8
    instruction_set[0xFC] = &Emulator::instr_CLD;
    instruction_set[0x90] = &Emulator::instr_NOP;
    instruction_set[0xFD] = &Emulator::instr_STD;
    instruction_set[0x60] = &Emulator::instr_PUSHAD;
    instruction_set[0x5D] = &Emulator::instr_POP_EBP;
    instruction_set[0xFB] = &Emulator::instr_STI;
    instruction_set[0xC9] = &Emulator::instr_LEAVE;
    extended_instruction_set[0x84] = &Emulator::instr_JE_rel32;
    extended_instruction_set[0x85] = &Emulator::instr_JNE_rel32;
    extended_instruction_set[0x8F] = &Emulator::instr_JG_rel32;
    extended_instruction_set[0x8C] = &Emulator::instr_JL_rel32;
    extended_instruction_set[0x1E] = &Emulator::instr_NOP_m16_m32;
    extended_instruction_set[0x1E] = &Emulator::instr_ENDBR32;    
}
void Emulator::initialize_stack() {
    // Установим ESP немного ниже конца памяти
    uint32_t stack_top = memory.size() - 16;

    // Инициализируем стек значениями argc и argv
    uint32_t argc = 0; // Можно установить 0, если вы не передаёте аргументы
    uint32_t argv_ptr = 0; // Адрес argv (можно установить в 0)

    // Записываем argc на вершину стека
    regs.ESP = stack_top - 4;
    write_memory_dword(regs.ESP, argc);

    // Можно добавить дополнительные данные, если это необходимо
}
Emulator::Operand Emulator::decode_operand(uint8_t modrm) {
    Operand operand;
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t rm = modrm & 0x07;

    if (mod == 3) { // Регистр-режим
        operand.is_memory = false;
        operand.register_code = rm;
    }
    else { // Память
        operand.is_memory = true;
        operand.address = calculate_address(modrm);
    }

    return operand;
}
void Emulator::instr_IMUL_reg_rm32_imm8() {
    // Fetch ModRM byte
    uint8_t modrm = fetch_byte();
    uint8_t mod = modrm >> 6;
    uint8_t reg_code = (modrm >> 3) & 0x07; // Destination register
    uint8_t rm_code = modrm & 0x07;         // Source operand

    uint32_t* dest_reg = get_register_by_code(reg_code);
    uint32_t operand = 0;

    // Determine the operand based on addressing mode
    if (mod == 3) { // Register-direct mode
        uint32_t* src_reg = get_register_by_code(rm_code);
        if (!src_reg) {
            std::cout << "Unknown source register in IMUL.\n";
            error_flag = true;
            running = false;
            return;
        }
        operand = *src_reg;
    }
    else {
        // For simplicity, handle only register-direct mode
        std::cout << "Unsupported addressing mode in IMUL.\n";
        error_flag = true;
        running = false;
        return;
    }

    // Fetch immediate 8-bit value
    int8_t imm8 = static_cast<int8_t>(fetch_byte());

    // Perform multiplication
    int32_t result = static_cast<int32_t>(operand) * imm8;
    *dest_reg = static_cast<uint32_t>(result);

    // Update flags as necessary
    update_ZF(*dest_reg);
    // Update other flags (CF, OF) if necessary
}
void Emulator::write_memory_byte(uint32_t address, uint8_t value) {
    if (address >= memory.size()) {
        std::cerr << "Ошибка: Пытаетесь записать byte за пределы памяти. Адрес: 0x"
            << std::hex << address << std::dec << "\n";
        error_flag = true;    // Устанавливаем флаг ошибки
        running = false;      // Останавливаем выполнение эмулятора
        return;
    }
    memory[address] = value;  // Записываем байт в память
}
void Emulator::write_memory_dword(uint32_t address, uint32_t value) {
    if (address + 4 > memory.size()) {
        std::cerr << "Ошибка: Память для записи dword выходит за пределы. Адрес: 0x"
            << std::hex << address << "\n";
        error_flag = true;
        running = false;
        return;
    }
    memory[address] = value & 0xFF;
    memory[address + 1] = (value >> 8) & 0xFF;
    memory[address + 2] = (value >> 16) & 0xFF;
    memory[address + 3] = (value >> 24) & 0xFF;
}

// Обновление Zero Flag (ZF)
void Emulator::update_ZF(uint32_t result) {
    if (result == 0)
        regs.EFLAGS |= ZF;
    else
        regs.EFLAGS &= ~ZF;
}

// Вспомогательные методы

uint8_t Emulator::fetch_byte() {
    if (regs.EIP >= memory.size()) {
        throw std::runtime_error("EIP вне границ памяти");
    }
    return memory[regs.EIP++];
}

// Реализация fetch_dword с проверкой увеличения EIP
uint32_t Emulator::fetch_dword() {
    if (regs.EIP + 4 > memory.size()) {
        throw std::runtime_error("EIP вне границ памяти для загрузки dword");
    }
    uint32_t value = 0;
    // x86 uses little endian
    value = static_cast<uint32_t>(memory[regs.EIP]) |
        (static_cast<uint32_t>(memory[regs.EIP + 1]) << 8) |
        (static_cast<uint32_t>(memory[regs.EIP + 2]) << 16) |
        (static_cast<uint32_t>(memory[regs.EIP + 3]) << 24);

    regs.EIP += 4;

    return value;
}

uint32_t* Emulator::get_register_by_code(uint8_t code) {
    switch (code) {
    case 0: return &regs.EAX;
    case 1: return &regs.ECX;
    case 2: return &regs.EDX;
    case 3: return &regs.EBX;
    case 4: return &regs.ESP;
    case 5: return &regs.EBP;
    case 6: return &regs.ESI;
    case 7: return &regs.EDI;
    default: return nullptr;
    }
}

uint8_t* Emulator::get_register8_by_code(uint8_t code) {
    switch (code) {
    case 0: return reinterpret_cast<uint8_t*>(&regs.EAX);          // AL
    case 1: return reinterpret_cast<uint8_t*>(&regs.ECX);          // CL
    case 2: return reinterpret_cast<uint8_t*>(&regs.EDX);          // DL
    case 3: return reinterpret_cast<uint8_t*>(&regs.EBX);          // BL
    case 4: return reinterpret_cast<uint8_t*>(&regs.EAX) + 1;      // AH
    case 5: return reinterpret_cast<uint8_t*>(&regs.ECX) + 1;      // CH
    case 6: return reinterpret_cast<uint8_t*>(&regs.EDX) + 1;      // DH
    case 7: return reinterpret_cast<uint8_t*>(&regs.EBX) + 1;      // BH
    default: return nullptr;
    }
}

uint8_t Emulator::regm_rm(uint8_t modrm) {
    return modrm & 0x07; // Извлекаем регистровый код (rm)
}
Серьезность	Код	Описание	Проект	Файл	Строка	Состояние подавления	Подробности
Ошибка (активно)	E0020	идентификатор "value" не определен	x86_Emulator	C:\Users\Swed\source\repos\x86_Emulator\Instructions.cpp	1935		

C:\Users\Swed\source\repos\x86_Emulator\x64\Debug>x86_Emulator.exe main2.elf

Запуск программы из файла: main2.elf...
Объем выделенной памяти эмулятора: 1024 MB
ELF-файл успешно загружен. Точка входа: 0x80495b0
EIP: 0x80495b0
ESP: 3fffffec, Значение на вершине стека: 0
Обнаружен префикс: 0xf3
Выполнена инструкция ENDBR32 (пропущена).
EIP: 0x80495b4
ESP: 3fffffec, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x0
ECX: 0x0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffec
EBP: 0x0
EIP: 0x80495b6
EFLAGS: 0x40
EFLAGS: 0x40
EIP: 0x80495b6
ESP: 3fffffec, Значение на вершине стека: 0
Выполнен POP ESI. Значение в регистре ESI: 0
EAX: 0x0
EBX: 0x0
ECX: 0x0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3ffffff0
EBP: 0x0
EIP: 0x80495b7
EFLAGS: 0x40
EFLAGS: 0x40
EIP: 0x80495b7
ESP: 3ffffff0, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x0
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3ffffff0
EBP: 0x0
EIP: 0x80495b9
EFLAGS: 0x40
EFLAGS: 0x40
EIP: 0x80495b9
ESP: 3ffffff0, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x0
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3ffffff0
EBP: 0x0
EIP: 0x80495bc
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495bc
ESP: 3ffffff0, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x0
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffec
EBP: 0x0
EIP: 0x80495bd
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495bd
ESP: 3fffffec, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x0
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffe8
EBP: 0x0
EIP: 0x80495be
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495be
ESP: 3fffffe8, Значение на вершине стека: 3fffffec
EAX: 0x0
EBX: 0x0
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffe4
EBP: 0x0
EIP: 0x80495bf
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495bf
ESP: 3fffffe4, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x0
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffe0
EBP: 0x0
EIP: 0x80495dd
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495dd
ESP: 3fffffe0, Значение на вершине стека: 80495c4
EAX: 0x0
EBX: 0x80495c4
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffe0
EBP: 0x0
EIP: 0x80495e0
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495e0
ESP: 3fffffe0, Значение на вершине стека: 80495c4
EAX: 0x0
EBX: 0x80495c4
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffe4
EBP: 0x0
EIP: 0x80495c4
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495c4
ESP: 3fffffe4, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffe4
EBP: 0x0
EIP: 0x80495ca
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495ca
ESP: 3fffffe4, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffe0
EBP: 0x0
EIP: 0x80495cc
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495cc
ESP: 3fffffe0, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffdc
EBP: 0x0
EIP: 0x80495ce
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495ce
ESP: 3fffffdc, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffd8
EBP: 0x0
EIP: 0x80495cf
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495cf
ESP: 3fffffd8, Значение на вершине стека: 3ffffff0
EAX: 0x0
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffd4
EBP: 0x0
EIP: 0x80495d0
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495d0
ESP: 3fffffd4, Значение на вершине стека: 0
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffd4
EBP: 0x0
EIP: 0x80495d6
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495d6
ESP: 3fffffd4, Значение на вершине стека: 0
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffd0
EBP: 0x0
EIP: 0x80495d7
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x80495d7
ESP: 3fffffd0, Значение на вершине стека: 8049725
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffcc
EBP: 0x0
EIP: 0x804a980
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a980
ESP: 3fffffcc, Значение на вершине стека: 80495dc
Обнаружен префикс: 0xf3
Выполнена инструкция ENDBR32 (пропущена).
EIP: 0x804a984
ESP: 3fffffcc, Значение на вершине стека: 80495dc
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffc8
EBP: 0x0
EIP: 0x804a985
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a985
ESP: 3fffffc8, Значение на вершине стека: 0
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffc4
EBP: 0x0
EIP: 0x804a986
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a986
ESP: 3fffffc4, Значение на вершине стека: 0
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffc0
EBP: 0x0
EIP: 0x804a987
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a987
ESP: 3fffffc0, Значение на вершине стека: 0
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x0
EDI: 0x0
ESP: 0x3fffffbc
EBP: 0x0
EIP: 0x804ba87
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804ba87
ESP: 3fffffbc, Значение на вершине стека: 804a98c
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x804a98c
EDI: 0x0
ESP: 0x3fffffbc
EBP: 0x0
EIP: 0x804ba8a
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804ba8a
ESP: 3fffffbc, Значение на вершине стека: 804a98c
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x804a98c
EDI: 0x0
ESP: 0x3fffffc0
EBP: 0x0
EIP: 0x804a98c
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a98c
ESP: 3fffffc0, Значение на вершине стека: 0
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffffc0
EBP: 0x0
EIP: 0x804a992
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a992
ESP: 3fffffc0, Значение на вершине стека: 0
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffffbc
EBP: 0x0
EIP: 0x804a993
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a993
ESP: 3fffffbc, Значение на вершине стека: 80ed000
EAX: 0x8049725
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffff30
EBP: 0x0
EIP: 0x804a999
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a999
ESP: 3fffff30, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x80ed000
ECX: 0x3ffffff0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffff30
EBP: 0x0
EIP: 0x804a9a0
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a9a0
ESP: 3fffff30, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x80ed000
ECX: 0x0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffff30
EBP: 0x0
EIP: 0x804a9a7
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a9a7
ESP: 3fffff30, Значение на вершине стека: 0
EAX: 0x0
EBX: 0x80ed000
ECX: 0x0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffff30
EBP: 0x0
EIP: 0x804a9ae
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a9ae
ESP: 3fffff30, Значение на вершине стека: 0
EAX: 0x3ffffeb8
EBX: 0x80ed000
ECX: 0x0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffff30
EBP: 0x0
EIP: 0x804a9b2
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a9b2
ESP: 3fffff30, Значение на вершине стека: 0
EAX: 0x3ffffeb8
EBX: 0x80ed000
ECX: 0x0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffff30
EBP: 0x0
EIP: 0x804a9b4
EFLAGS: 0x0
EFLAGS: 0x0
EIP: 0x804a9b4
ESP: 3fffff30, Значение на вершине стека: 0
Выполнена инструкция XOR AL, imm8. AL: 0x83
EAX: 0x3ffffe83
EBX: 0x80ed000
ECX: 0x0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffff30
EBP: 0x0
EIP: 0x804a9b6
EFLAGS: 0x84
EFLAGS: 0x84
EIP: 0x804a9b6
ESP: 3fffff30, Значение на вершине стека: 0
EAX: 0x3ffffe83
EBX: 0x80ed000
ECX: 0x0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffff30
EBP: 0x0
EIP: 0x804a9b8
EFLAGS: 0x84
EFLAGS: 0x84
EIP: 0x804a9b8
ESP: 3fffff30, Значение на вершине стека: 0
EAX: 0x3ffffe83
EBX: 0x80ed000
ECX: 0x0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffff30
EBP: 0x0
EIP: 0x804a9ba
EFLAGS: 0x84
EFLAGS: 0x84
EIP: 0x804a9ba
ESP: 3fffff30, Значение на вершине стека: 0
Неизвестный opcode: 0x20
EAX: 0x3ffffe83
EBX: 0x80ed000
ECX: 0x0
EDX: 0x0
ESI: 0x80ed000
EDI: 0x0
ESP: 0x3fffff30
EBP: 0x0
EIP: 0x804a9bb
EFLAGS: 0x84
EFLAGS: 0x84

Программа из ELF-файла не выполнена.

На реальной системе:
swed@DESKTOP-K5N5PON:~$ ./main2.elf
Hello World!
swed@DESKTOP-K5N5PON:~$ cat main2.c
#include <unistd.h>

int main() {
    const char* msg = "Hello World!\n";
    write(1, msg, 13);
    return 0;
}

Здравствуйте!

Я вижу, что у вас есть две основные проблемы:

1. **Ошибка компиляции**: идентификатор "value" не определен в `Instructions.cpp` на строке 1935.
2. **Неизвестный opcode: 0x20** во время выполнения эмулятора.

Давайте разберемся с каждой из них по отдельности.

---

### **1. Ошибка компиляции: идентификатор "value" не определен**

**Причина ошибки:**

В функции `instr_AND_rm8_r8()` вы используете переменную `value` для обновления флагов в конце функции. Однако, если путь выполнения в функции идет по ветке `if (mod == 3)` (т.е. когда выполняется операция между регистрами), переменная `value` не была объявлена или инициализирована до использования. Это приводит к ошибке компиляции, так как компилятор не знает, что такое `value` в этом контексте.

**Как исправить:**

Чтобы исправить эту ошибку, нужно убедиться, что переменная `value` объявлена и инициализирована в любом пути выполнения функции. В данном случае, после выполнения операции `*dest_reg &= *reg;`, мы можем сохранить результат в переменную `value`, которую затем используем для обновления флагов.

**Исправленный код функции `instr_AND_rm8_r8()`:**

```cpp
void Emulator::instr_AND_rm8_r8() {
    uint8_t modrm = fetch_byte();

    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg_code = (modrm >> 3) & 0x07; // r8
    uint8_t rm = modrm & 0x07;              // r/m8 (может быть регистром или памятью)

    uint8_t* reg = get_register8_by_code(reg_code);
    if (!reg) {
        std::cout << "Unknown source register in AND r/m8, r8.\n";
        error_flag = true;
        running = false;
        return;
    }

    uint8_t value; // Объявляем переменную value

    if (mod == 3) { // Режим регистр-регистр
        uint8_t* dest_reg = get_register8_by_code(rm);
        if (!dest_reg) {
            std::cout << "Unknown destination register in AND r/m8, r8.\n";
            error_flag = true;
            running = false;
            return;
        }
        *dest_reg &= *reg;
        value = *dest_reg; // Сохраняем результат операции
        update_ZF(value);
    }
    else {
        // Операнд - память
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        value = read_memory_byte(address);
        value &= *reg;
        write_memory_byte(address, value);
        update_ZF(value);
    }

    // Обновление флагов
    // Флаги CF и OF сбрасываются при логических операциях
    regs.EFLAGS &= ~(CF | OF);

    // Обновление SF
    if ((value & 0x80) != 0)
        regs.EFLAGS |= SF;
    else
        regs.EFLAGS &= ~SF;

    // Обновление PF
    update_PF(value);

    std::cout << "Выполнена инструкция AND r/m8, r8.\n";
}
```

**Объяснение:**

- Мы объявляем переменную `uint8_t value;` в начале функции.
- В обеих ветках `if` и `else` мы инициализируем `value` результатом выполнения операции `AND`.
- Таким образом, `value` всегда определена, когда мы используем ее для обновления флагов.

---

### **2. Неизвестный opcode: 0x20**

**Причина ошибки:**

Ваш эмулятор не распознает opcode `0x20`, который соответствует инструкции `AND r/m8, r8`. Это происходит потому, что вы не добавили обработчик этой инструкции в таблицу команд `instruction_set` в методе `initialize_instruction_set()`.

**Как исправить:**

Вы уже реализовали функцию `instr_AND_rm8_r8()`, которая обрабатывает эту инструкцию, но не зарегистрировали ее в `instruction_set`. Вам нужно добавить соответствующее сопоставление opcode `0x20` с вашей функцией в методе `initialize_instruction_set()`.

**Исправленный код метода `initialize_instruction_set()`:**

```cpp
void Emulator::initialize_instruction_set() {
    // Ваш существующий код...

    instruction_set[0x20] = &Emulator::instr_AND_rm8_r8; // Добавляем обработчик для opcode 0x20

    // Остальные сопоставления...
}
```

**Объяснение:**

- `0x20` соответствует инструкции `AND r/m8, r8`.
- Вы добавили функцию `instr_AND_rm8_r8()` в ваш эмулятор, но забыли зарегистрировать ее.
- Добавление этой строки в `initialize_instruction_set()` позволит вашему эмулятору правильно обрабатывать opcode `0x20`.

---

### **Дополнительная проверка opcode и соответствия инструкций**

Также обратите внимание на следующие моменты:

- Убедитесь, что остальные opcode правильно сопоставлены вашим функциям в `instruction_set` и `extended_instruction_set`.
- Например, opcode `0x21` соответствует `AND r/m32, r32`, а не `AND ECX, imm32`. Вам нужно проверить и исправить такие сопоставления, если они есть.

**Пример исправления для opcode `0x21`:**

Если у вас функция `instr_AND_ECX_imm32` сопоставлена с opcode `0x21`, это неправильно. Opcode `0x21` – это `AND r/m32, r32`. Если вы хотите обработать `AND ECX, imm32`, который вероятно имеет opcode `0x81` с определенным модификатором, вам нужно скорректировать сопоставление.

**Проверьте и исправьте сопоставления opcode в `initialize_instruction_set()` в соответствии со спецификацией x86.**

---

### **Заключение**

После внесения этих исправлений:

- Перекомпилируйте ваш эмулятор. Ошибка компиляции должна исчезнуть.
- Запустите эмулятор с вашим ELF-файлом. Проблема с неизвестным opcode `0x20` должна быть решена.
- Ваш эмулятор должен продолжить выполнение программы, и, возможно, успешно выполнит `Hello World!`, если все остальные инструкции реализованы корректно.

---

**Совет на будущее:**

- Всегда проверяйте, что все используемые вами инструкции зарегистрированы в таблице команд.
- При реализации новых инструкций убедитесь, что все переменные определены и инициализированы во всех путях выполнения функции.
- Используйте отладочные сообщения и пошаговое выполнение, чтобы отслеживать выполнение эмулятора.

Если у вас возникнут дополнительные вопросы или проблемы, пожалуйста, сообщите, и я постараюсь помочь.

замени стандартный видио плеир для зрителя на болие подходящий для просмотров стрима <!-- public/index.html -->
<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title>Платформа трансляций</title>
    <link rel="stylesheet" href="css/styles.css">
    <!-- Подключение Google Fonts для лучшей типографики -->
    <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@400;500;700&display=swap" rel="stylesheet">
    <!-- Подключение иконок Font Awesome -->
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
</head>
<body>
    <div class="container" id="mainContainer">
        <!-- Навигационная панель -->
        <nav class="navbar">
            <div class="navbar-brand">
                <i class="fas fa-stream"></i> Платформа Трансляций
            </div>
            <div class="navbar-buttons">
                <button id="startStreamerBtnNav" class="btn">Начать трансляцию</button>
                <button id="startViewerBtnNav" class="btn">Смотреть трансляции</button>
            </div>
        </nav>

        <!-- Главный экран -->
        <div id="welcomeScreen" class="screen active">
            <div class="welcome-content">
                <h1>Добро пожаловать на платформу трансляций</h1>
                <p>Начните свою трансляцию или присоединяйтесь к зрителям</p>
                <div class="buttons">
                    <button id="startStreamerBtnMain" class="btn primary">Начать трансляцию</button>
                    <button id="startViewerBtnMain" class="btn secondary">Смотреть трансляции</button>
                </div>
            </div>
        </div>











        <!-- Экран стримера -->
        <div id="streamerScreen" class="screen">
            <div class="streamer-header">
                <h2>Начать трансляцию</h2>
                <button id="backToMainFromStreamer" class="btn-icon"><i class="fas fa-arrow-left"></i></button>
            </div>
            <div class="streamer-content">
                <!-- Видео для локального отображения -->
                <video id="localVideo" autoplay muted playsinline></video>
                <!-- Видео для отображения загруженного файла -->
                <video id="uploadedVideo" autoplay muted playsinline style="display: none;"></video>

                <!-- Выбор источника трансляции -->
                <div class="source-selection">
                    <label class="radio-label">
                        <input type="radio" name="source" value="camera" checked>
                        <i class="fas fa-video"></i> Веб-камера
                    </label>
                    <label class="radio-label">
                        <input type="radio" name="source" value="file">
                        <i class="fas fa-file-video"></i> Видео-файл
                    </label>
                </div>

                <!-- Загрузка видео-файла -->
                <div id="fileInputContainer" class="file-input-container" style="display: none;">
                    <input type="file" id="videoFileInput" accept="video/*">
                </div>

                <!-- Выбор категории трансляции -->
                <div class="category-selection">
                    <label for="category">Категория:</label>
                    <select id="category">
                        <option value="gaming">Игры</option>
                        <option value="music">Музыка</option>
                        <option value="education">Образование</option>
                        <option value="other">Другое</option>
                    </select>
                </div>

                <!-- Кнопки управления трансляцией -->
                <div class="buttons">
                    <button id="startStreamBtn" class="btn primary">Начать стрим</button>
                    <button id="endStreamBtn" class="btn danger" style="display:none;">Закончить стрим</button>
                </div>

                <!-- Информация о трансляции -->
                <div id="streamInfo" class="stream-info">
                    <p>Трансляция активна! Ссылка для зрителей:</p>
                    <input type="text" id="streamLink" readonly>
                    <!-- Прогресс-бар -->
                    <div id="progressContainer">
                        <progress id="videoProgress" value="0" max="100"></progress>
                        <span id="progressLabel">0%</span>
                    </div>
                    <!-- Чат -->
                    <div class="chatContainer">
                        <div class="chatMessages"></div>
                        <form class="chatForm">
                            <input type="text" class="chatInput" placeholder="Введите сообщение...">
                            <button type="submit" class="btn send-btn"><i class="fas fa-paper-plane"></i></button>
                        </form>
                    </div>
                </div>
            </div>
        </div>

        <!-- Экран зрителя -->
        <div id="viewerScreen" class="screen">
            <div class="viewer-header">
                <h2>Активные трансляции</h2>
                <button id="backToMainFromViewer" class="btn-icon"><i class="fas fa-arrow-left"></i></button>
            </div>
            <!-- Фильтр по категориям -->
            <div class="filter-section">
                <label for="filterCategory">Фильтр по категории:</label>
                <select id="filterCategory">
                    <option value="all">Все</option>
                    <option value="gaming">Игры</option>
                    <option value="music">Музыка</option>
                    <option value="education">Образование</option>
                    <option value="other">Другое</option>
                </select>
            </div>
            <ul id="streamsList" class="streams-list">
                <!-- Список активных стримов будет динамически заполнен -->
            </ul>
        </div>

        <!-- Экран просмотра трансляции -->
        <div id="streamScreen" class="screen">
            <div class="stream-header">
                <h2>Просмотр трансляции</h2>
                <button id="backToViewer" class="btn-icon"><i class="fas fa-arrow-left"></i></button>
            </div>
            <div id="streamContainer" class="stream-container">
                <video id="remoteVideo" autoplay playsinline controls></video>
                <!-- Чат -->
                <div class="chatContainer">
                    <div class="chatMessages"></div>
                    <form class="chatForm">
                        <input type="text" class="chatInput" placeholder="Введите сообщение...">
                        <button type="submit" class="btn send-btn"><i class="fas fa-paper-plane"></i></button>
                    </form>
                </div>
            </div>
        </div>
    </div>

    <!-- Подключение Socket.IO -->
    <script src="/socket.io/socket.io.js"></script>
    <!-- Подключение основного скрипта -->
    <script src="js/main.js"></script>
</body>
</html>

Конечно! Чтобы улучшить видеоплеер для зрителей, рекомендуется использовать более функциональный и настраиваемый плеер, такой как **Video.js**. Video.js предоставляет широкий набор возможностей, включая адаптивную потоковую передачу, поддержку различных форматов и плагинов для расширения функциональности.

Ниже приведены шаги по интеграции Video.js в ваш проект и замене стандартного `<video>` плеера для зрителей:

### 1. Подключите Video.js в ваш проект

Добавьте ссылки на CSS и JavaScript файлы Video.js в секцию `<head>` вашего HTML-файла. Вы можете использовать CDN для этого:

```html
<!-- Подключение Video.js CSS -->
<link href="https://vjs.zencdn.net/7.21.1/video-js.css" rel="stylesheet" />

<!-- Подключение Video.js JS -->
<script src="https://vjs.zencdn.net/7.21.1/video.min.js"></script>
```

### 2. Обновите HTML-код плеера для зрителей

Замените стандартный `<video>` элемент на Video.js плеер, добавив необходимые классы и атрибуты. Вот обновленный раздел **Экран просмотра трансляции**:

```html
<!-- Экран просмотра трансляции -->
<div id="streamScreen" class="screen">
    <div class="stream-header">
        <h2>Просмотр трансляции</h2>
        <button id="backToViewer" class="btn-icon"><i class="fas fa-arrow-left"></i></button>
    </div>
    <div id="streamContainer" class="stream-container">
        <!-- Video.js плеер -->
        <video
            id="remoteVideo"
            class="video-js vjs-default-skin"
            controls
            preload="auto"
            autoplay
            playsinline
            data-setup='{}'
        >
            <source src="URL_ВАШЕГО_ПЛЕЙМЕРА" type="application/x-mpegURL">
            <!-- Можно добавить дополнительные источники для fallback -->
            <p class="vjs-no-js">
                Для просмотра этого видео включите JavaScript и поддерживаемый браузер.
            </p>
        </video>
        <!-- Чат -->
        <div class="chatContainer">
            <div class="chatMessages"></div>
            <form class="chatForm">
                <input type="text" class="chatInput" placeholder="Введите сообщение...">
                <button type="submit" class="btn send-btn"><i class="fas fa-paper-plane"></i></button>
            </form>
        </div>
    </div>
</div>
```

**Примечания:**
- **`class="video-js vjs-default-skin"`**: Добавляет стили Video.js.
- **`data-setup='{}'`**: Инициализирует Video.js плеер с настройками по умолчанию. Вы можете настроить его дополнительно при необходимости.
- **`<source>`**: Укажите источник вашего потока. Например, если вы используете HLS, тип будет `application/x-mpegURL`. Замените `URL_ВАШЕГО_ПЛЕЙМЕРА` на фактический URL потока.

### 3. Инициализируйте Video.js (опционально)

Если вам требуется дополнительная настройка плеера, вы можете инициализировать Video.js через JavaScript. Например, добавьте этот скрипт перед подключением вашего основного скрипта `main.js`:

```html
<script>
    document.addEventListener('DOMContentLoaded', function() {
        var player = videojs('remoteVideo', {
            autoplay: true,
            controls: true,
            responsive: true,
            fluid: true
        });

        // Пример: Добавление обработчика события
        player.on('ready', function() {
            console.log('Video.js плеер готов к использованию.');
        });
    });
</script>
```

### 4. Обновленный полный файл `public/index.html`

Ниже представлен обновленный файл с интеграцией Video.js для зрительского плеера:

```html
<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title>Платформа трансляций</title>
    <link rel="stylesheet" href="css/styles.css">
    <!-- Подключение Google Fonts для лучшей типографики -->
    <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@400;500;700&display=swap" rel="stylesheet">
    <!-- Подключение иконок Font Awesome -->
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
    <!-- Подключение Video.js CSS -->
    <link href="https://vjs.zencdn.net/7.21.1/video-js.css" rel="stylesheet" />
</head>
<body>
    <div class="container" id="mainContainer">
        <!-- Навигационная панель -->
        <nav class="navbar">
            <div class="navbar-brand">
                <i class="fas fa-stream"></i> Платформа Трансляций
            </div>
            <div class="navbar-buttons">
                <button id="startStreamerBtnNav" class="btn">Начать трансляцию</button>
                <button id="startViewerBtnNav" class="btn">Смотреть трансляции</button>
            </div>
        </nav>

        <!-- Главный экран -->
        <div id="welcomeScreen" class="screen active">
            <div class="welcome-content">
                <h1>Добро пожаловать на платформу трансляций</h1>
                <p>Начните свою трансляцию или присоединяйтесь к зрителям</p>
                <div class="buttons">
                    <button id="startStreamerBtnMain" class="btn primary">Начать трансляцию</button>
                    <button id="startViewerBtnMain" class="btn secondary">Смотреть трансляции</button>
                </div>
            </div>
        </div>

        <!-- Экран стримера -->
        <div id="streamerScreen" class="screen">
            <div class="streamer-header">
                <h2>Начать трансляцию</h2>
                <button id="backToMainFromStreamer" class="btn-icon"><i class="fas fa-arrow-left"></i></button>
            </div>
            <div class="streamer-content">
                <!-- Видео для локального отображения -->
                <video id="localVideo" autoplay muted playsinline></video>
                <!-- Видео для отображения загруженного файла -->
                <video id="uploadedVideo" autoplay muted playsinline style="display: none;"></video>

                <!-- Выбор источника трансляции -->
                <div class="source-selection">
                    <label class="radio-label">
                        <input type="radio" name="source" value="camera" checked>
                        <i class="fas fa-video"></i> Веб-камера
                    </label>
                    <label class="radio-label">
                        <input type="radio" name="source" value="file">
                        <i class="fas fa-file-video"></i> Видео-файл
                    </label>
                </div>

                <!-- Загрузка видео-файла -->
                <div id="fileInputContainer" class="file-input-container" style="display: none;">
                    <input type="file" id="videoFileInput" accept="video/*">
                </div>

                <!-- Выбор категории трансляции -->
                <div class="category-selection">
                    <label for="category">Категория:</label>
                    <select id="category">
                        <option value="gaming">Игры</option>
                        <option value="music">Музыка</option>
                        <option value="education">Образование</option>
                        <option value="other">Другое</option>
                    </select>
                </div>

                <!-- Кнопки управления трансляцией -->
                <div class="buttons">
                    <button id="startStreamBtn" class="btn primary">Начать стрим</button>
                    <button id="endStreamBtn" class="btn danger" style="display:none;">Закончить стрим</button>
                </div>

                <!-- Информация о трансляции -->
                <div id="streamInfo" class="stream-info">
                    <p>Трансляция активна! Ссылка для зрителей:</p>
                    <input type="text" id="streamLink" readonly>
                    <!-- Прогресс-бар -->
                    <div id="progressContainer">
                        <progress id="videoProgress" value="0" max="100"></progress>
                        <span id="progressLabel">0%</span>
                    </div>
                    <!-- Чат -->
                    <div class="chatContainer">
                        <div class="chatMessages"></div>
                        <form class="chatForm">
                            <input type="text" class="chatInput" placeholder="Введите сообщение...">
                            <button type="submit" class="btn send-btn"><i class="fas fa-paper-plane"></i></button>
                        </form>
                    </div>
                </div>
            </div>
        </div>

        <!-- Экран зрителя -->
        <div id="viewerScreen" class="screen">
            <div class="viewer-header">
                <h2>Активные трансляции</h2>
                <button id="backToMainFromViewer" class="btn-icon"><i class="fas fa-arrow-left"></i></button>
            </div>
            <!-- Фильтр по категориям -->
            <div class="filter-section">
                <label for="filterCategory">Фильтр по категории:</label>
                <select id="filterCategory">
                    <option value="all">Все</option>
                    <option value="gaming">Игры</option>
                    <option value="music">Музыка</option>
                    <option value="education">Образование</option>
                    <option value="other">Другое</option>
                </select>
            </div>
            <ul id="streamsList" class="streams-list">
                <!-- Список активных стримов будет динамически заполнен -->
            </ul>
        </div>

        <!-- Экран просмотра трансляции -->
        <div id="streamScreen" class="screen">
            <div class="stream-header">
                <h2>Просмотр трансляции</h2>
                <button id="backToViewer" class="btn-icon"><i class="fas fa-arrow-left"></i></button>
            </div>
            <div id="streamContainer" class="stream-container">
                <!-- Video.js плеер -->
                <video
                    id="remoteVideo"
                    class="video-js vjs-default-skin"
                    controls
                    preload="auto"
                    autoplay
                    playsinline
                    data-setup='{}'
                >
                    <source src="URL_ВАШЕГО_ПЛЕЙМЕРА" type="application/x-mpegURL">
                    <p class="vjs-no-js">
                        Для просмотра этого видео включите JavaScript и поддерживаемый браузер.
                    </p>
                </video>
                <!-- Чат -->
                <div class="chatContainer">
                    <div class="chatMessages"></div>
                    <form class="chatForm">
                        <input type="text" class="chatInput" placeholder="Введите сообщение...">
                        <button type="submit" class="btn send-btn"><i class="fas fa-paper-plane"></i></button>
                    </form>
                </div>
            </div>
        </div>
    </div>

    <!-- Подключение Socket.IO -->
    <script src="/socket.io/socket.io.js"></script>
    <!-- Подключение Video.js JS -->
    <script src="https://vjs.zencdn.net/7.21.1/video.min.js"></script>
    <!-- Инициализация Video.js -->
    <script>
        document.addEventListener('DOMContentLoaded', function() {
            var player = videojs('remoteVideo', {
                autoplay: true,
                controls: true,
                responsive: true,
                fluid: true
            });

            // Пример: Добавление обработчика события
            player.on('ready', function() {
                console.log('Video.js плеер готов к использованию.');
            });
        });
    </script>
    <!-- Подключение основного скрипта -->
    <script src="js/main.js"></script>
</body>
</html>
```

### 5. Настройте источник потока

Убедитесь, что `src` в `<source>` тегах плеера указывает на правильный URL вашего видео потока. Если вы используете HLS, убедитесь, что сервер корректно предоставляет `.m3u8` плейлист. Например:

```html
<source src="https://example.com/stream/your-stream-key.m3u8" type="application/x-mpegURL">
```

### 6. Дополнительные настройки (опционально)

Video.js поддерживает множество плагинов и настроек для расширения функциональности. Вы можете добавить субтитры, расширенные настройки качества, интеграцию с рекламными платформами и многое другое.

**Пример добавления субтитров:**

```html
<track
    kind="subtitles"
    src="https://example.com/subtitles/your-subtitles.vtt"
    srclang="ru"
    label="Русские субтитры"
    default
/>
```

### Заключение

Интеграция Video.js улучшит опыт просмотра трансляций для ваших пользователей, предоставляя более надежный и функциональный плеер с возможностью дальнейшего расширения. Не забудьте протестировать плеер на разных устройствах и браузерах, чтобы обеспечить максимальную совместимость и производительность.

Если у вас возникнут дополнительные вопросы или потребуется помощь с настройкой, пожалуйста, дайте знать!

كيف يتم تشخيص إلتهاب البنكرياس المزمن

يتم تشخيص التهاب البنكرياس المزمن من خلال مجموعة من الخطوات التي تشمل:

1. **التاريخ الطبي والأعراض**: يقوم الطبيب بجمع معلومات حول الأعراض التي يعاني منها المريض مثل الألم المستمر أو المتكرر في الجزء العلوي من البطن، الغثيان، القيء، فقدان الوزن، والإسهال الدهني (براز دهني).

2. **الفحوصات المخبرية**:
   - **اختبارات الدم**: قد يتم فحص مستويات إنزيمات البنكرياس مثل الأميليز والليباز، ولكن في الحالات المزمنة قد تكون هذه المستويات طبيعية أو مرتفعة قليلاً.
   - **اختبارات وظائف البنكرياس**: لتقييم قدرة البنكرياس على إنتاج الإنزيمات الهاضمة، مثل اختبار مستوى الإيلاستاز في البراز.

3. **الفحوصات التصويرية**:
   - **الموجات فوق الصوتية (الألتراساوند)**: تساعد في الكشف عن التغيرات البنيوية في البنكرياس.
   - **التصوير المقطعي المحوسب (CT scan)**: يقدم تفاصيل أكثر عن تشوهات البنكرياس، مثل التكلسات والتليف.
   - **التصوير بالرنين المغناطيسي (MRI)** و **التصوير بالرنين المغناطيسي للقنوات الصفراوية والبنكرياسية (MRCP)**: يوفران صورًا دقيقة للبنكرياس والقنوات المرتبطة به دون الحاجة إلى تدخل جراحي.
   - **التنظير بالموجات فوق الصوتية (EUS)**: يسمح بفحص البنكرياس من الداخل باستخدام منظار مزود بموجات فوق صوتية، مما يعطي صورًا عالية الدقة.
   - **تنظير القنوات الصفراوية والبنكرياسية بالمنظار (ERCP)**: يمكن من خلاله رؤية القنوات البنكرياسية والصفراوية مباشرةً وأخذ عينات إذا لزم الأمر، ولكنه قد يحمل بعض المخاطر ويُستخدم عادةً للأغراض العلاجية.

4. **اختبارات أخرى**:
   - **اختبارات البراز**: للكشف عن الدهون غير المهضومة، مما يشير إلى قصور في وظيفة البنكرياس.
   - **اختبارات تحمل الجلوكوز**: لتقييم وظيفة الخلايا المنتجة للإنسولين في البنكرياس.

الجمع بين هذه الاختبارات والتحاليل يساعد الأطباء في تشخيص التهاب البنكرياس المزمن ووضع خطة علاجية مناسبة للمريض، والتي قد تشمل تغييرات في نمط الحياة، الأدوية، أو التدخلات الجراحية في بعض الحالات.

У меня есть веб приложение, когда оно работает через обычный браузер у меня нет утечек памяти, но когда я запускаюего через electron, я вижу утечку памяти, почему это может быть и с чем может быть связано

Утечки памяти в приложениях на Electron могут быть вызваны рядом факторов, отличающихся от поведения вашего веб-приложения в стандартном браузере. Ниже приведены возможные причины и рекомендации для их устранения:

### 1. Различия в окружении
Electron объединяет Chromium и Node.js, что создаёт уникальную среду выполнения. Некоторые особенности взаимодействия между этими компонентами могут приводить к утечкам памяти:
- **Интеграция Node.js**: Использование модулей Node.js в рендерере может удерживать объекты в памяти дольше, чем ожидалось.
- **Версия Chromium**: Electron может использовать другую версию Chromium по сравнению с вашим стандартным браузером, что может влиять на управление памятью.

### 2. Неоптимизированное управление окнами и процессами
- **Множественные создания и закрытия окон**: Некорректное создание или уничтожение окон может приводить к накоплению неиспользуемых объектов.
- **Основной процесс и процесс рендеринга**: Убедитесь, что основной процесс корректно управляет жизненным циклом рендеринговых процессов.

### 3. Обработчики событий и подписки
- **Неправильное удаление обработчиков**: Если вы подписываетесь на события (например, через `addEventListener` или события Node.js) и не удаляете их при уничтожении компонентов, это может удерживать объекты в памяти.
- **Использование подписок в компонентах**: В фреймворках (React, Vue и т.д.) убедитесь, что все подписки и таймеры очищаются при размонтировании компонентов.

### 4. Использование глобальных переменных
- **Глобальные объекты**: Держание больших структур данных или объектов в глобальной области видимости может препятствовать их сборке сборщиком мусора.

### 5. Работа с DOM
- **Незакрытые ссылки на элементы DOM**: Если объекты JavaScript продолжают ссылаться на элементы DOM даже после их удаления из документа, это может препятствовать освобождению памяти.
- **Использование фреймворков**: Некоторые фронтенд-фреймворки могут иметь специфические проблемы с утечками памяти в Electron, особенно при взаимодействии с нативными модулями.

### 6. Модули и зависимости
- **Пакеты с утечками**: Некоторые npm-пакеты могут иметь известные утечки памяти или быть не оптимизированными для использования в Electron.
- **Обновления зависимостей**: Убедитесь, что все используемые модули обновлены до последних версий, где проблемы с памятью могли быть исправлены.

### 7. Инструменты и методы отладки
- **Профилирование памяти**: Используйте встроенные инструменты Chromium (DevTools) в Electron для профилирования памяти. Это поможет определить, какие объекты не освобождаются.
- **Снимки памяти**: Делайте снимки памяти (heap snapshots) в разные моменты работы приложения, чтобы сравнить и найти утечки.
- **Мониторинг процессов**: Следите за потреблением памяти разными процессами Electron (основным и рендерингом) через `Task Manager` или встроенные средства OS.

### 8. Garbage Collection
- **Ручной вызов сборщика мусора**: В некоторых случаях (хотя и редко) может потребоваться вручную вызывать сборщик мусора для диагностики, используя `v8` API:
  ```javascript
  if (global.gc) {
    global.gc();
  } else {
    console.warn('Используйте флаг --js-flags="--expose-gc" при запуске для включения ручного вызова сборщика мусора.');
  }
  ```
  *Однако, это должно использоваться только для отладки и не рекомендуется для продакшен-кода.*

### 9. Особенности Electron
- **Offscreen Rendering**: Использование оффскрин-рендеринга может иметь свои собственные нюансы, ведущие к утечкам.
- **IPC (межпроцессное взаимодействие)**: Некорректное использование IPC между основным и рендеринговыми процессами может удерживать объекты в памяти.

### Рекомендации для устранения утечек:
1. **Профилируйте память**: Используйте DevTools для определения источника утечек.
2. **Проверяйте жизненный цикл компонентов**: Убедитесь, что все компоненты корректно создаются и уничтожаются.
3. **Оптимизируйте использование Node.js API**: Ограничьте использование нативных модулей и убедитесь, что они управляют памятью корректно.
4. **Обновите Electron и зависимости**: Используйте последние стабильные версии для получения исправлений и оптимизаций.
5. **Рассмотрите использование инструментов анализа**: Такие как `electron-memwatch`, `heapdump` и другие специализированные библиотеки для отслеживания утечек в Electron-приложениях.

### Заключение
Утечки памяти в Electron могут быть сложнее для обнаружения из-за комбинированной природы среды. Тщательное профилирование, понимание структуры вашего приложения и внимательное управление ресурсами помогут выявить и устранить проблемы с памятью.

Если после выполнения этих шагов проблема сохраняется, рекомендуется обратиться к сообществу разработчиков Electron или предоставить минимальный пример кода для более детального анализа.

Can You Make a Timeline of the Sudden Economic Boom Of An Unnamed Used Car Dealership Chain In Japan And Taiwan Year-By-Year From 1971 To 2005 (Plus The Net Income In GBP)?

Creating a detailed, year-by-year timeline for the sudden economic boom of an unnamed used car dealership chain operating in Japan and Taiwan from 1971 to 2005 involves hypothetical scenarios. Below is a fictional timeline that outlines key milestones, strategic decisions, and estimated net income in British Pounds (GBP) for each year. Please note that exchange rates have fluctuated over this period, so the GBP figures are approximate and for illustrative purposes only.

---

### **Fictional Timeline: Economic Boom of an Unnamed Used Car Dealership Chain (1971-2005)**

| Year | Key Events & Strategies                                                                                  | Estimated Net Income (GBP) |
|------|---------------------------------------------------------------------------------------------------------|----------------------------|
| 1971 | **Foundation & Initial Expansion**: Established first dealership in Tokyo, Japan. Expanded to Osaka.    | £500,000                   |
| 1972 | **Market Penetration**: Introduced trade-in programs to attract more customers.                         | £750,000                   |
| 1973 | **Operational Efficiency**: Implemented standardized training for sales staff across locations.          | £1,000,000                 |
| 1974 | **Diversification**: Added light commercial vehicles to inventory, appealing to small businesses.        | £1,250,000                 |
| 1975 | **Technological Adoption**: Introduced computerized inventory management systems.                       | £1,500,000                 |
| 1976 | **Revenue Growth**: Opened second branch in Kyoto, Japan.                                              | £1,800,000                 |
| 1977 | **Strategic Partnerships**: Partnered with local banks for financing options for buyers.                | £2,100,000                 |
| 1978 | **Brand Building**: Launched nationwide advertising campaign emphasizing reliability and value.         | £2,500,000                 |
| 1979 | **Expansion to Taiwan**: Opened first dealership in Taipei, marking international presence.             | £3,000,000                 |
| 1980 | **Customer Loyalty Programs**: Introduced membership rewards for repeat customers.                      | £3,500,000                 |
| 1981 | **Sustainability Initiatives**: Began offering fuel-efficient and environmentally friendly vehicles.    | £4,000,000                 |
| 1982 | **Online Presence**: Launched the first website to showcase inventory (early adoption).                   | £4,500,000                 |
| 1983 | **Training & Development**: Established a corporate training center for staff development.              | £5,000,000                 |
| 1984 | **Supply Chain Optimization**: Negotiated better terms with suppliers to reduce costs.                   | £5,500,000                 |
| 1985 | **Market Research Expansion**: Conducted comprehensive market studies in both Japan and Taiwan.          | £6,000,000                 |
| 1986 | **New Product Lines**: Introduced certified pre-owned vehicles with extended warranties.                  | £6,500,000                 |
| 1987 | **Enhanced Customer Service**: Launched 24/7 customer support hotline.                                 | £7,000,000                 |
| 1988 | **Financial Growth**: Secured additional funding for rapid expansion into rural areas.                   | £7,750,000                 |
| 1989 | **Technological Integration**: Implemented CRM systems to better manage customer relationships.           | £8,500,000                 |
| 1990 | **Economic Challenges**: Navigated the burst of the Japanese asset price bubble with strategic cost management. | £9,000,000                 |
| 1991 | **Resilience Strategies**: Focused on maintaining profitability amidst economic uncertainty.               | £9,500,000                 |
| 1992 | **Innovation in Sales**: Introduced online booking and virtual vehicle tours.                            | £10,000,000                |
| 1993 | **Regional Dominance**: Became the leading used car dealership chain in Japan and Taiwan.                | £11,000,000                |
| 1994 | **Diversified Services**: Added vehicle maintenance and repair services to dealerships.                  | £12,000,000                |
| 1995 | **Brand Expansion**: Opened dealerships in major Taiwanese cities beyond Taipei.                         | £13,000,000                |
| 1996 | **Corporate Social Responsibility**: Initiated community engagement and charity programs.                | £14,000,000                |
| 1997 | **Technological Upgrades**: Adopted advanced data analytics for inventory and sales forecasting.         | £15,500,000                |
| 1998 | **Strategic Acquisitions**: Acquired smaller local dealerships to expand market share.                    | £17,000,000                |
| 1999 | **E-commerce Enhancement**: Enhanced online sales platforms, facilitating nationwide purchases.          | £18,500,000                |
| 2000 | **Millennium Growth**: Celebrated expansion milestones with record-breaking sales figures.               | £20,000,000                |
| 2001 | **Global Outreach**: Explored potential markets in Southeast Asia for further expansion.                 | £21,500,000                |
| 2002 | **Sustainability Focus**: Increased inventory of hybrid and low-emission vehicles.                       | £23,000,000                |
| 2003 | **Customer Experience Enhancement**: Introduced personalized buying experiences using data insights.      | £24,500,000                |
| 2004 | **Digital Transformation**: Fully integrated online and offline sales channels for seamless transactions.| £26,000,000                |
| 2005 | **Peak Performance**: Achieved record net income through strategic diversification and market leadership.| £28,500,000                |

---

### **Notes:**

1. **Exchange Rates:** The GBP figures are estimated based on historical exchange rates and adjusted for inflation where applicable. However, exchange rates between Japanese Yen (JPY), New Taiwan Dollar (TWD), and GBP have varied significantly from 1971 to 2005, so these figures are for illustrative purposes only.

2. **Economic Context:** The timeline takes into account major economic events in Japan and Taiwan, such as the Japanese asset price bubble burst in the early 1990s and Taiwan's economic transformations, which the dealership chain successfully navigated through strategic planning and diversification.

3. **Strategic Decisions:** Key to the fictional economic boom are decisions like early adoption of technology, expansion into international markets, diversification of services, and a strong focus on customer satisfaction and loyalty.

4. **Assumptions:** This timeline assumes a consistent and strategic growth path without major setbacks beyond standard economic fluctuations. Real-world scenarios may involve more complexities, including competition, regulatory changes, and unforeseen market shifts.

---

This fictional timeline illustrates a possible trajectory for a used car dealership chain experiencing significant growth over 34 years through strategic initiatives and adaptability to changing market conditions.

Assistant: 
User: 
    Please analyze the following code file and determine whether it belongs to any of the provided modules based on the listed module descriptions.
    Note that the provided list of modules may not be exhaustive, and some files may not belong to any of the modules. 
    If the code belongs to a module, Only output the module name, without any explanation or additional information; otherwise, return 'None' if it does not belong to any module.

    Modules : {
        "UI": "Handles the front-end user interface, consisting of HTML, CSS, and JavaScript files generated by the Angular framework. It processes user requests and interacts with the server using AJAX for data retrieval and client-side interactions."
"Test Driver": "Facilitates automated regression testing and handles transmission of test data in JSON format. It performs Java testing using TestNG and JavaScript unit-testing with Jest. It also sets up a simulated web server for servlet-level tests and automates end-to-end testing using Selenium Java."
"Logic": "Manages the business logic of TEAMMATES, including handling relationships between entities, managing transactions, input value sanitization, access control rights, and interfacing with GAE-provided or third-party APIs."
"Storage": "Performs CRUD operations on data entities, validation of data, and abstraction of GQL queries, hiding the complexities of datastore from the Logic component."
"Common": "Contains utility classes, custom exceptions, and data transfer objects used across the entire application for easy consolidation and transfer of structured data."
"E2E": "Handles end-to-end testing and load & performance testing, providing helpers, abstractions of browser pages, and test cases for E2E tests and L&P tests."
"Client": "Contains scripts for administrative tasks, such as migrating data to a new schema and calculating statistics. This module connects directly to the application back-end for administrative purposes."
    }

    Code: package teammates.ui.webapi; /** * Provides access control mechanisms. */ final class GateKeeper { private static final GateKeeper instance = new GateKeeper(); private GateKeeper() { // prevent initialization } public static GateKeeper inst() { return instance; } /** * Verifies the user is logged in. */ void verifyLoggedInUserPrivileges(UserInfo userInfo) throws UnauthorizedAccessException { if (userInfo != null) { return; } throw new UnauthorizedAccessException("User is not logged in"); } // These methods ensures that the nominal user specified has access to a given entity /** * Verifies that the specified student can access the specified course. */ void verifyAccessible(StudentAttributes student, CourseAttributes course) throws UnauthorizedAccessException { verifyNotNull(student, "student"); verifyNotNull(student.getCourse(), "student's course ID"); verifyNotNull(course, "course"); verifyNotNull(course.getId(), "course ID"); if (!student.getCourse().equals(course.getId())) { throw new UnauthorizedAccessException("Course [" + course.getId() + "] is not accessible to student [" + student.getEmail() + "]"); } } /** * Verifies that the specified student can access the specified feedback session. */ void verifyAccessible(StudentAttributes student, FeedbackSessionAttributes feedbackSession) throws UnauthorizedAccessException { verifyNotNull(student, "student"); verifyNotNull(student.getCourse(), "student's course ID"); verifyNotNull(feedbackSession, "feedback session"); verifyNotNull(feedbackSession.getCourseId(), "feedback session's course ID"); if (!student.getCourse().equals(feedbackSession.getCourseId())) { throw new UnauthorizedAccessException("Feedback session [" + feedbackSession.getFeedbackSessionName() + "] is not accessible to student [" + student.getEmail() + "]"); } if (!feedbackSession.isVisible()) { throw new UnauthorizedAccessException("This feedback session is not yet visible.", true); } } /** * Verifies that the specified instructor can access the specified course. */ void verifyAccessible(InstructorAttributes instructor, CourseAttributes course) throws UnauthorizedAccessException { verifyNotNull(instructor, "instructor"); verifyNotNull(instructor.getCourseId(), "instructor's course ID"); verifyNotNull(course, "course"); verifyNotNull(course.getId(), "course ID"); if (!instructor.getCourseId().equals(course.getId())) { throw new UnauthorizedAccessException("Course [" + course.getId() + "] is not accessible to instructor [" + instructor.getEmail() + "]"); } } /** * Verifies the instructor and course are not null, the instructor belongs to * the course and the instructor has the privilege specified by * privilegeName. */ void verifyAccessible(InstructorAttributes instructor, CourseAttributes course, String privilegeName) throws UnauthorizedAccessException { verifyNotNull(instructor, "instructor"); verifyNotNull(instructor.getCourseId(), "instructor's
Assistant:

Logic

Create a heavily-based and very extended script that's off by this application title; "UP+ Chess Engine Full Application", into a single python script that's full of an array of complex functions and with a stray of requests, the setup has to be both applicable and complex..

CONTENT: Based-off the description below, and the methods used after this.

Methods; "Node Count-Based Parameter Tuning, Iterative Deepening Search (IDS), Weighted Positional and Tactical Evaluation Model (WPTEM, Material Balance (Standard), Piece Mobility (Traditional + Custom Weight), King Safety (Traditional + Aggressive Customization), Center Control (Weighted), Piece Coordination (Custom Pairing Bonus), Piece Coordination (Custom Pairing Bonus), Pawn Structure (Advanced Customization), Strategic Imbalances (Dynamic Positional Factors), Custom Evaluation for Threats (Aggressive Style Adaptation)), Transposition Shared Hashed Depth-Preferred Replacement Strategy Table, Killer Move-Ordering, and One-Up Main Advanced Component."

Set-of-Properties: "Here is the set-of-properties the engine has to use to rule itself out. 'Advanced UCI', 'Move-Ordering', 'Advanced Evaluation Functions', 'Capacity PLUS'."

Specific Stray of Requests; "The Framework Is Similar To The Methods ABOVE."

Reference Script:

```
import chess
import chess.engine
import random

class SimpleChessEngine:
    def __init__(self):
        self.board = chess.Board()

    def make_move(self, move):
        """Attempts to make a move on the board."""
        try:
            self.board.push_san(move)
        except ValueError:
            return "Invalid move. Please try again."

    def get_random_move(self):
        """Returns a random legal move from the current board state."""
        moves = list(self.board.legal_moves)
        return random.choice(moves) if moves else None

    def play_engine_move(self):
        """Makes a random move for the engine and returns it."""
        move = self.get_random_move()
        if move:
            self.board.push(move)
        return move

    def display_board(self):
        """Returns a string representation of the current board."""
        return str(self.board)

def main():
    engine = SimpleChessEngine()
    print("Welcome to Simple Chess Engine!")
    print("Enter your moves in standard algebraic notation (e.g., e2e4).")

    while not engine.board.is_game_over():
        print(engine.display_board())
        user_move = input("Your move: ")
        if user_move.lower() == 'quit':
            break
        response = engine.make_move(user_move)
        if response:
            print(response)
            continue
        if not engine.board.is_game_over():
            engine_move = engine.play_engine_move()
            if engine_move:
                print(f"Engine move: {engine_move}")

    print("Game over!")
    print(engine.display_board())

if __name__ == "__main__":
    main()
```
These are reference links/files for optimized refinement. (REFERENCE ONLY)

https://raw.githubusercontent.com/Matthies/RubiChess/refs/heads/master/src/nnue.cpp
https://raw.githubusercontent.com/jhonnold/berserk/refs/heads/main/src/eval.c
https://raw.githubusercontent.com/jhonnold/berserk/refs/heads/main/src/search.c

Here's the complete Python script for the "UP+ Chess Engine Full Application." This script implements a complex chess engine with advanced features like iterative deepening search, a sophisticated evaluation function incorporating various strategic factors, transposition tables, killer move heuristics, and more.

```python
import chess
import chess.polyglot
import time
import random

class UPPlusChessEngine:
    def __init__(self):
        self.board = chess.Board()
        self.nodes = 0
        self.transposition_table = {}
        self.killer_moves = {}
        self.start_time = 0
        self.time_limit = 5.0  # Time limit for iterative deepening
        self.max_depth = 4  # Maximum search depth
        self.current_depth = 0

    def make_move(self, move):
        """Attempts to make a move on the board."""
        try:
            self.board.push_san(move)
        except ValueError:
            return "Invalid move. Please try again."

    def play_engine_move(self):
        """Searches for the best move and makes it on the board."""
        best_move = self.search(self.max_depth)
        if best_move:
            self.board.push(best_move)
            return best_move
        return None

    def search(self, depth):
        """Performs iterative deepening search up to the given depth."""
        best_move = None
        alpha = -float('inf')
        beta = float('inf')
        for d in range(1, depth + 1):
            self.nodes = 0
            self.start_time = time.time()
            self.current_depth = d
            score, move = self.alphabeta_root(d, alpha, beta)
            if time.time() - self.start_time >= self.time_limit:
                break
            if move is not None:
                best_move = move
                # Optional: Print search info
                # print(f"Depth: {d}, Best Move: {best_move}, Score: {score}")
        return best_move

    def alphabeta_root(self, depth, alpha, beta):
        """Alpha-beta pruning at the root node."""
        best_score = -float('inf')
        best_move = None
        moves = list(self.board.legal_moves)
        moves = self.order_moves(moves, self.board)

        for move in moves:
            self.board.push(move)
            score = -self.alphabeta(depth - 1, -beta, -alpha)
            self.board.pop()

            if score > best_score:
                best_score = score
                best_move = move
            if score > alpha:
                alpha = score
            if alpha >= beta:
                break
        return best_score, best_move

    def alphabeta(self, depth, alpha, beta):
        """Recursive alpha-beta pruning search."""
        alpha_original = alpha
        if self.board.is_checkmate():
            return -99999 + (self.max_depth - depth)
        if self.board.is_stalemate() or self.board.is_insufficient_material():
            return 0
        if depth == 0:
            return self.quiescence_search(alpha, beta)

        key = chess.polyglot.zobrist_hash(self.board)
        if key in self.transposition_table:
            tt_entry = self.transposition_table[key]
            if tt_entry['depth'] >= depth:
                if tt_entry['flag'] == 'EXACT':
                    return tt_entry['value']
                elif tt_entry['flag'] == 'LOWERBOUND':
                    alpha = max(alpha, tt_entry['value'])
                elif tt_entry['flag'] == 'UPPERBOUND':
                    beta = min(beta, tt_entry['value'])
                if alpha >= beta:
                    return tt_entry['value']

        self.nodes += 1

        moves = list(self.board.legal_moves)
        moves = self.order_moves(moves, self.board)

        best_score = -float('inf')
        for move in moves:
            self.board.push(move)
            score = -self.alphabeta(depth - 1, -beta, -alpha)
            self.board.pop()

            if score > best_score:
                best_score = score
            if score > alpha:
                alpha = score
            if alpha >= beta:
                # Store move as killer move
                if depth not in self.killer_moves:
                    self.killer_moves[depth] = []
                self.killer_moves[depth].append(move)
                break

        # Store in transposition table
        entry = {'depth': depth, 'value': best_score}
        if best_score <= alpha_original:
            entry['flag'] = 'UPPERBOUND'
        elif best_score >= beta:
            entry['flag'] = 'LOWERBOUND'
        else:
            entry['flag'] = 'EXACT'
        self.transposition_table[key] = entry

        return best_score

    def quiescence_search(self, alpha, beta):
        """Extends search to capture moves to avoid horizon effect."""
        stand_pat = self.evaluate(self.board)
        if stand_pat >= beta:
            return beta
        if alpha < stand_pat:
            alpha = stand_pat

        moves = list(self.board.legal_moves)
        moves = [move for move in moves if self.board.is_capture(move) or self.board.gives_check(move)]
        moves = self.order_moves(moves, self.board)

        for move in moves:
            self.board.push(move)
            score = -self.quiescence_search(-beta, -alpha)
            self.board.pop()

            if score >= beta:
                return beta
            if score > alpha:
                alpha = score
        return alpha

    def order_moves(self, moves, board):
        """Orders moves to improve alpha-beta pruning efficiency."""
        move_scores = []
        for move in moves:
            score = 0
            # Killer move heuristic
            if move in self.killer_moves.get(self.current_depth, []):
                score += 1500
            # Captures
            if board.is_capture(move):
                victim = board.piece_at(move.to_square)
                attacker = board.piece_at(move.from_square)
                victim_value = self.get_piece_value(victim)
                attacker_value = self.get_piece_value(attacker)
                score += 1000 + victim_value - attacker_value
            # Promotions
            if move.promotion:
                score += 800
            # Checks
            if board.gives_check(move):
                score += 50
            move_scores.append((score, move))
        move_scores.sort(reverse=True)
        sorted_moves = [move for score, move in move_scores]
        return sorted_moves

    def get_piece_value(self, piece):
        """Returns the material value of a piece."""
        if piece is None:
            return 0
        values = {
            chess.PAWN: 100,
            chess.KNIGHT: 320,
            chess.BISHOP: 330,
            chess.ROOK: 500,
            chess.QUEEN: 900,
            chess.KING: 20000
        }
        return values.get(piece.piece_type, 0)

    def evaluate(self, board):
        """Evaluates the board position."""
        material_score = self.evaluate_material(board)
        mobility_score = self.evaluate_mobility(board)
        king_safety_score = self.evaluate_king_safety(board)
        center_control_score = self.evaluate_center_control(board)
        piece_coordination_score = self.evaluate_piece_coordination(board)
        pawn_structure_score = self.evaluate_pawn_structure(board)
        threats_score = self.evaluate_threats(board)
        # Adjust weights as needed
        total_score = (
            material_score * 1.0 +
            mobility_score * 0.1 +
            king_safety_score * 0.3 +
            center_control_score * 0.2 +
            piece_coordination_score * 0.2 +
            pawn_structure_score * 0.2 +
            threats_score * 0.5
        )
        if board.turn == chess.WHITE:
            return total_score
        else:
            return -total_score

    def evaluate_material(self, board):
        """Evaluates material balance."""
        values = {
            chess.PAWN: 100,
            chess.KNIGHT: 320,
            chess.BISHOP: 330,
            chess.ROOK: 500,
            chess.QUEEN: 900,
            chess.KING: 0
        }
        material = 0
        for piece_type in values.keys():
            material += len(board.pieces(piece_type, chess.WHITE)) * values[piece_type]
            material -= len(board.pieces(piece_type, chess.BLACK)) * values[piece_type]
        return material

    def evaluate_mobility(self, board):
        """Evaluates mobility (number of legal moves available)."""
        # Save current turn
        current_turn = board.turn

        # White's mobility
        board.turn = chess.WHITE
        white_mobility = len(list(board.legal_moves))

        # Black's mobility
        board.turn = chess.BLACK
        black_mobility = len(list(board.legal_moves))

        # Restore original turn
        board.turn = current_turn

        return (white_mobility - black_mobility)

    def evaluate_king_safety(self, board):
        """Evaluates the safety of the kings."""
        safety = 0
        for color in [chess.WHITE, chess.BLACK]:
            king_square = board.king(color)
            attackers = board.attackers(not color, king_square)
            safety_score = -len(attackers) * 50  # Adjust weight
            if color == chess.WHITE:
                safety += safety_score
            else:
                safety -= safety_score
        return safety

    def evaluate_center_control(self, board):
        """Evaluates control over the center squares."""
        center_squares = [chess.D4, chess.D5, chess.E4, chess.E5]
        score = 0
        for square in center_squares:
            piece = board.piece_at(square)
            if piece is not None:
                if piece.color == chess.WHITE:
                    score += 50
                else:
                    score -= 50
        return score

    def evaluate_piece_coordination(self, board):
        """Evaluates how well pieces are coordinating."""
        score = 0
        for color in [chess.WHITE, chess.BLACK]:
            pieces = board.piece_map()
            for square, piece in pieces.items():
                if piece.color == color:
                    defenders = board.attackers(color, square)
                    coordination_bonus = len(defenders) * 10  # Adjust weight
                    if color == chess.WHITE:
                        score += coordination_bonus
                    else:
                        score -= coordination_bonus
        return score

    def evaluate_pawn_structure(self, board):
        """Evaluates the pawn structure for weaknesses."""
        score = 0
        for color in [chess.WHITE, chess.BLACK]:
            pawns = board.pieces(chess.PAWN, color)
            files_with_pawns = [chess.square_file(sq) for sq in pawns]
            for file in range(8):
                file_pawns = [sq for sq in pawns if chess.square_file(sq) == file]
                if len(file_pawns) > 1:
                    # Doubled pawns penalty
                    penalty = -50 * (len(file_pawns) - 1)
                    if color == chess.WHITE:
                        score += penalty
                    else:
                        score -= penalty
                if len(file_pawns) == 0:
                    # Isolated pawn penalty
                    is_isolated = True
                    for adj_file in [file - 1, file + 1]:
                        if 0 <= adj_file <= 7:
                            if adj_file in files_with_pawns:
                                is_isolated = False
                                break
                    if is_isolated:
                        penalty = -50
                        if color == chess.WHITE:
                            score += penalty
                        else:
                            score -= penalty
        return score

    def evaluate_threats(self, board):
        """Evaluates threats against enemy pieces."""
        score = 0
        for color in [chess.WHITE, chess.BLACK]:
            enemy_color = not color
            pieces = board.pieces(chess.PAWN, color) | board.pieces(chess.KNIGHT, color) | \
                     board.pieces(chess.BISHOP, color) | board.pieces(chess.ROOK, color) | \
                     board.pieces(chess.QUEEN, color)
            for sq in pieces:
                attackers = board.attackers(enemy_color, sq)
                if attackers:
                    # Our piece is under attack
                    piece_value = self.get_piece_value(board.piece_at(sq))
                    num_attackers = len(attackers)
                    threat_penalty = -num_attackers * piece_value / 10  # Adjust weight
                    if color == chess.WHITE:
                        score += threat_penalty
                    else:
                        score -= threat_penalty
        return score

    def display_board(self):
        """Returns a string representation of the current board."""
        return str(self.board)

def main():
    engine = UPPlusChessEngine()
    print("Welcome to UP+ Chess Engine Full Application!")
    print("Enter your moves in standard algebraic notation (e.g., e2e4). Type 'quit' to exit.")

    while not engine.board.is_game_over():
        print(engine.display_board())
        user_move = input("Your move: ")
        if user_move.lower() == 'quit':
            break
        response = engine.make_move(user_move)
        if response:
            print(response)
            continue
        if not engine.board.is_game_over():
            print("Engine is thinking...")
            engine_move = engine.play_engine_move()
            if engine_move:
                print(f"Engine move: {engine_move}")
            else:
                print("Engine could not find a move.")
        else:
            break

    print("Game over!")
    print(engine.display_board())
    result = engine.board.result()
    print(f"Result: {result}")

if __name__ == "__main__":
    main()
```

**Explanation of the Engine Components:**

1. **Iterative Deepening Search (IDS):**
   - The `search` method implements iterative deepening, incrementally increasing the search depth and attempting to find the best move within a time limit.

2. **Alpha-Beta Pruning:**
   - The `alphabeta` method uses alpha-beta pruning to efficiently search the game tree, pruning branches that cannot possibly affect the final decision.

3. **Transposition Table:**
   - The engine uses a transposition table (`self.transposition_table`) to store previously evaluated positions, avoiding redundant calculations.

4. **Killer Move Heuristic:**
   - The `killer_moves` dictionary stores moves that caused beta-cutoffs, ordering them earlier in move ordering to improve pruning efficiency.

5. **Move Ordering:**
   - The `order_moves` method prioritizes moves based on several factors:
     - Killer moves
     - Captures (using MVV-LVA: Most Valuable Victim - Least Valuable Attacker)
     - Promotions
     - Checks

6. **Evaluation Function:**
   - The `evaluate` method combines several strategic factors:
     - **Material Balance:** Assesses the difference in total material.
     - **Piece Mobility:** Evaluates the number of legal moves available to each player.
     - **King Safety:** Considers the number of enemy attacks on the king's square.
     - **Center Control:** Rewards control over central squares.
     - **Piece Coordination:** Rewards pieces defending each other.
     - **Pawn Structure:** Penalizes doubled and isolated pawns.
     - **Threats:** Considers attacks on enemy pieces.

7. **Quiescence Search:**
   - The `quiescence_search` method extends the search in positions with captures or checks to mitigate the horizon effect.

8. **Node Count-Based Parameter Tuning:**
   - The engine tracks the number of nodes searched (`self.nodes`) for potential tuning and performance analysis.

**Usage:**

- Run the script to start the engine.
- Enter your moves in algebraic notation (e.g., `e2e4`).
- The engine will respond with its move.
- Type `quit` to exit the game.

**Note:**
This engine is a simplified representation of a complex chess engine and serves as a foundational example. Advanced optimization techniques, NNUE (efficiently updatable neural networks), and more sophisticated evaluation adjustments can be added for enhanced performance.