исправь ошибки логики и подходов, добавь много поточность и эмуляцию ядер 
class CPU {
    constructor(logElement, instructionListElement, memoryElement, registerListElement) {
        this.registers = {}; // Динамические регистры
        this.memory = {}; // Оперативная память, адреса: значения
        this.instructions = [];
        this.labels = {}; // Маппинг меток на индексы инструкций
        this.running = false;
        this.logElement = logElement;
        this.instructionListElement = instructionListElement;
        this.memoryElement = memoryElement;
        this.registerListElement = registerListElement;
        this.maxMemory = 512; // Макс. адрес памяти
        this.initMemory();
        this.flags = {
            ZF: false, // Zero Flag
            GT: false, // Greater Than
            LT: false, // Less Than
            EQ: false  // Equal
        };
    }

    // Инициализация памяти
    initMemory() {
        for (let i = 0; i < this.maxMemory; i++) {
            this.memory[i] = 0;
            this.renderMemoryCell(i);
        }
    }

    // Рендер одной ячейки памяти
    renderMemoryCell(address) {
        const cell = document.createElement('div');
        cell.classList.add('memory-cell');
        cell.id = `mem-${address}`;
        cell.innerHTML = `<span class="mem-address">${address}</span><span class="mem-value">${this.memory[address]}</span>`;
        this.memoryElement.appendChild(cell);
    }

    // Обновление отображения ячейки памяти
    updateMemoryUI(address) {
        const memValueElement = document.querySelector(`#mem-${address} .mem-value`);
        memValueElement.textContent = this.memory[address];
        this.highlightElement(memValueElement);
    }

    // Добавление или обновление регистра в UI
    updateRegisterUI(register) {
        let regElement = document.getElementById(register);
        if (!regElement) {
            // Создание нового регистра в UI
            const regDiv = document.createElement('div');
            regDiv.classList.add('register');
            regDiv.innerHTML = `<span class="reg-name">${register}:</span><span id="${register}" class="reg-value">0</span>`;
            this.registerListElement.appendChild(regDiv);
        }
        // Обновление значения
        if (this.registers.hasOwnProperty(register)) {
            document.getElementById(register).textContent = this.registers[register];
        }
    }

    // Загружает программу, маппит метки
    loadProgram(programText) {
        const lines = programText.split('\n');
        this.instructions = [];
        this.labels = {};

        // Первый проход: маппинг меток
        lines.forEach((line, index) => {
            const cleanLine = line.trim();
            if (cleanLine === '' || cleanLine.startsWith('//')) {
                return; // Игнорировать пустые строки и комментарии
            }
            if (cleanLine.endsWith(':')) {
                const label = cleanLine.slice(0, -1).trim();
                if (this.labels.hasOwnProperty(label)) {
                    throw new Error(`Метка ${label} определена несколько раз.`);
                }
                this.labels[label] = this.instructions.length;
            } else {
                this.instructions.push(cleanLine);
            }
        });

        // Сброс регистров и флагов
        this.reset(false);
        this.log("Программа загружена.");
        this.updateUI();
        this.renderInstructionList();
    }

    // Сброс регистров и памяти
    reset(clearRegisters = false) {
        if (clearRegisters) {
            this.registers = {};
            this.registerListElement.innerHTML = '';
        }
        // Сброс памяти
        for (let addr in this.memory) {
            this.memory[addr] = 0;
            this.updateMemoryUI(addr);
        }
        // Сброс указателя и флагов
        if (clearRegisters) {
            this.registers['IP'] = 0;
        } else {
            this.registers['IP'] = this.registers['IP'] || 0;
        }
        this.flags = {
            ZF: false,
            GT: false,
            LT: false,
            EQ: false
        };
        this.running = false;
        this.log("Состояние сброшено.");
        this.updateUI();
        this.renderInstructionList();
    }

    // Воспроизведение одной инструкции
    async step() {
        if (this.registers['IP'] >= this.instructions.length) {
            this.log("Программа завершена.");
            this.running = false;
            return;
        }

        const instructionLine = this.instructions[this.registers['IP']];
        this.log(`Выполнение: ${instructionLine}`);
        const { opcode, args } = this.parseInstruction(instructionLine);

        // Обработка команды
        try {
            switch (opcode) {
                case 'LOAD':
                    this.load(args[0], args[1]);
                    break;
                case 'LOADM':
                    this.loadMemory(args[0], args[1]);
                    break;
                case 'STORE':
                    this.store(args[0], args[1]);
                    break;
                case 'STOREM':
                    this.storeMemory(args[0], args[1]);
                    break;
                case 'ADD':
                    this.add(args[0], args[1]);
                    break;
                case 'SUB':
                    this.sub(args[0], args[1]);
                    break;
                case 'MUL':
                    this.mul(args[0], args[1]);
                    break;
                case 'DIV':
                    this.div(args[0], args[1]);
                    break;
                case 'AND':
                    this.and(args[0], args[1]);
                    break;
                case 'OR':
                    this.or(args[0], args[1]);
                    break;
                case 'XOR':
                    this.xor(args[0], args[1]);
                    break;
                case 'CMP':
                    this.cmp(args[0], args[1]);
                    break;
                case 'JLT':
                    this.jlt(args[0]);
                    break;
                case 'JGT':
                    this.jgt(args[0]);
                    break;
                case 'JE':
                    this.je(args[0]);
                    break;
                case 'JMP':
                    this.jmp(args[0]);
                    break;
                default:
                    throw new Error(`Неизвестная инструкция: ${opcode}`);
            }

            this.registers['IP'] += 1;
            this.updateUI();
            this.renderInstructionList();
        } catch (error) {
            this.log(`Ошибка: ${error.message}`);
            this.running = false;
        }
    }

    // Запуск программы
    run() {
        if (this.running) return;
        this.running = true;
        const interval = setInterval(async () => {
            if (!this.running) {
                clearInterval(interval);
                return;
            }
            if (this.registers['IP'] >= this.instructions.length) {
                this.log("Программа завершена.");
                this.running = false;
                clearInterval(interval);
                return;
            }
            await this.step();
        }, 500);
    }

    // Парсинг инструкции
    parseInstruction(instructionLine) {
        const tokens = instructionLine.split(' ');
        const opcode = tokens[0].toUpperCase();
        const argsPart = tokens.slice(1).join(' ');
        // Разделение аргументов на основе запятых, учитывая возможные выражения
        const args = this.splitArgs(argsPart);
        return { opcode, args };
    }

    // Разделение аргументов, учитывая выражения с запятыми внутри
    splitArgs(argsStr) {
        const args = [];
        let currentArg = '';
        let parentheses = 0;
        for (let i = 0; i < argsStr.length; i++) {
            const char = argsStr[i];
            if (char === '(') {
                parentheses++;
                currentArg += char;
            } else if (char === ')') {
                parentheses--;
                currentArg += char;
            } else if (char === ',' && parentheses === 0) {
                args.push(currentArg.trim());
                currentArg = '';
            } else {
                currentArg += char;
            }
        }
        if (currentArg.trim() !== '') {
            args.push(currentArg.trim());
        }
        return args;
    }

    // Методы инструкций

    load(register, operand) {
        this.ensureRegister(register);
        const value = this.evaluateOperand(operand);
        this.registers[register] = value;
        this.log(`Загружено значение ${value} в регистр ${register}.`);
        this.updateRegisterUI(register);
    }

    loadMemory(register, expression) {
        this.ensureRegister(register);
        const address = this.evaluateExpression(expression);
        this.validateMemoryAddress(address);
        this.registers[register] = this.memory[address];
        this.log(`Загружено значение из памяти (${address}) в регистр ${register}: ${this.memory[address]}.`);
        this.updateRegisterUI(register);
    }

    store(register, expression) {
        this.ensureRegister(register);
        const address = this.evaluateExpression(expression);
        this.validateMemoryAddress(address);
        this.memory[address] = this.registers[register];
        this.log(`Сохранено значение регистра ${register} (${this.registers[register]}) в память (${address}).`);
        this.updateMemoryUI(address);
    }

    storeMemory(register, expression) {
        this.ensureRegister(register);
        const address = this.evaluateExpression(expression);
        this.validateMemoryAddress(address);
        this.memory[address] = this.registers[register];
        this.log(`Сохранено значение регистра ${register} (${this.registers[register]}) в память (${address}).`);
        this.updateMemoryUI(address);
    }

    add(register, operand) {
        this.ensureRegister(register);
        const value = this.evaluateOperand(operand);
        this.ensureRegister('ACC'); // ACC должен существовать для операций
        this.registers['ACC'] += this.registers[register] + value;
        this.log(`ACC увеличен на (${register}=${this.registers[register]}) + ${value} = ${this.registers[register] + value}. Новое значение ACC: ${this.registers['ACC']}.`);
        this.updateRegisterUI('ACC');
    }

    sub(register, operand) {
        this.ensureRegister(register);
        const value = this.evaluateOperand(operand);
        this.ensureRegister('ACC');
        this.registers['ACC'] -= this.registers[register] + value;
        this.log(`ACC уменьшен на (${register}=${this.registers[register]}) + ${value} = ${this.registers[register] + value}. Новое значение ACC: ${this.registers['ACC']}.`);
        this.updateRegisterUI('ACC');
    }

    mul(register, operand) {
        this.ensureRegister(register);
        const value = this.evaluateOperand(operand);
        this.ensureRegister('ACC');
        const multiplier = this.registers[register] * value;
        this.registers['ACC'] *= multiplier;
        this.log(`ACC умножен на (${register}=${this.registers[register]}) * ${value} = ${multiplier}. Новое значение ACC: ${this.registers['ACC']}.`);
        this.updateRegisterUI('ACC');
    }

    div(register, operand) {
        this.ensureRegister(register);
        const value = this.evaluateOperand(operand);
        this.ensureRegister('ACC');
        const divisor = this.registers[register] * value;
        if (divisor === 0) {
            throw new Error("Деление на ноль.");
        }
        this.registers['ACC'] /= divisor;
        this.log(`ACC разделён на (${register}=${this.registers[register]}) * ${value} = ${divisor}. Новое значение ACC: ${this.registers['ACC']}.`);
        this.updateRegisterUI('ACC');
    }

    and(register, operand) {
        this.ensureRegister(register);
        const value = this.evaluateOperand(operand);
        this.ensureRegister('ACC');
        this.registers['ACC'] = this.registers['ACC'] & value;
        this.log(`ACC подвергся операции AND с ${value}. Новое значение ACC: ${this.registers['ACC']}.`);
        this.updateRegisterUI('ACC');
    }

    or(register, operand) {
        this.ensureRegister(register);
        const value = this.evaluateOperand(operand);
        this.ensureRegister('ACC');
        this.registers['ACC'] = this.registers['ACC'] | value;
        this.log(`ACC подвергся операции OR с ${value}. Новое значение ACC: ${this.registers['ACC']}.`);
        this.updateRegisterUI('ACC');
    }

    xor(register, operand) {
        this.ensureRegister(register);
        const value = this.evaluateOperand(operand);
        this.ensureRegister('ACC');
        this.registers['ACC'] = this.registers['ACC'] ^ value;
        this.log(`ACC подвергся операции XOR с ${value}. Новое значение ACC: ${this.registers['ACC']}.`);
        this.updateRegisterUI('ACC');
    }

    cmp(register, operand) {
        this.ensureRegister(register);
        const value = this.evaluateOperand(operand);
        if (this.registers[register] > value) {
            this.flags.GT = true;
            this.flags.LT = false;
            this.flags.EQ = false;
        } else if (this.registers[register] < value) {
            this.flags.GT = false;
            this.flags.LT = true;
            this.flags.EQ = false;
        } else {
            this.flags.GT = false;
            this.flags.LT = false;
            this.flags.EQ = true;
        }
        this.log(`Сравнение: ${register} (${this.registers[register]}) с ${value}. Флаги: GT=${this.flags.GT}, LT=${this.flags.LT}, EQ=${this.flags.EQ}.`);
    }

    jlt(label) {
        if (this.flags.LT) {
            this.jumpToLabel(label);
        }
    }

    jgt(label) {
        if (this.flags.GT) {
            this.jumpToLabel(label);
        }
    }

    je(label) {
        if (this.flags.EQ) {
            this.jumpToLabel(label);
        }
    }

    jmp(label) {
        this.jumpToLabel(label);
    }

    // Переход к метке
    jumpToLabel(label) {
        if (this.labels.hasOwnProperty(label)) {
            this.registers['IP'] = this.labels[label] - 1; // -1, так как он будет увеличен после шага
            this.log(`Переход к метке: ${label} (инструкция ${this.labels[label]})`);
        } else {
            throw new Error(`Метка ${label} не найдена.`);
        }
    }

    // Проверка и создание регистра
    ensureRegister(register) {
        if (!this.registers.hasOwnProperty(register)) {
            this.registers[register] = 0;
            this.updateRegisterUI(register);
        }
    }

    // Оценка операнда (регистр, число или выражение)
    evaluateOperand(operand) {
        operand = operand.trim();
        if (this.registers.hasOwnProperty(operand)) {
            return this.registers[operand];
        } else {
            const value = parseInt(operand, 10);
            if (isNaN(value)) {
                throw new Error(`Невозможно распознать операнд: ${operand}`);
            }
            return value;
        }
    }

    // Оценка арифметического выражения
    evaluateExpression(expression) {
        // Заменяем регистры их значениями
        const exprWithValues = expression.replace(/[A-Za-z]+/g, (match) => {
            if (this.registers.hasOwnProperty(match)) {
                return this.registers[match];
            } else {
                throw new Error(`Регистро ${match} не существует.`);
            }
        });
        // Оцениваем выражение
        try {
            // Используем Function для безопасного вычисления
            // eslint-disable-next-line no-new-func
            const func = new Function(`return (${exprWithValues});`);
            const result = func();
            if (isNaN(result)) {
                throw new Error(`Некорректное арифметическое выражение: ${expression}`);
            }
            return result;
        } catch (error) {
            throw new Error(`Ошибка при оценке выражения "${expression}": ${error.message}`);
        }
    }

    // Валидация адреса памяти
    validateMemoryAddress(address) {
        if (address < 0 || address >= this.maxMemory) {
            throw new Error(`Адрес памяти ${address} выходит за пределы допустимого диапазона.`);
        }
    }

    // Логирование сообщений
    log(message) {
        const p = document.createElement('p');
        p.textContent = message;
        this.logElement.appendChild(p);
        // Прокрутка вниз
        this.logElement.parentElement.scrollTop = this.logElement.parentElement.scrollHeight;
    }

    // Обновление отображения регистров
    updateUI() {
        for (let reg in this.registers) {
            this.updateRegisterUI(reg);
        }
    }

    // Подсветка элемента
    highlightElement(element) {
        element.classList.add('highlight');
        setTimeout(() => {
            element.classList.remove('highlight');
        }, 500);
    }

    // Рендер списка инструкций с выделением текущей
    renderInstructionList() {
        this.instructionListElement.innerHTML = '';
        this.instructions.forEach((instr, index) => {
            const item = document.createElement('div');
            item.classList.add('instruction-item');
            if (index === this.registers['IP']) {
                item.classList.add('current');
            }
            item.textContent = `${index}: ${instr}`;
            this.instructionListElement.appendChild(item);
        });
    }
}

// Инициализация при загрузке страницы
document.addEventListener('DOMContentLoaded', () => {
    const logElement = document.getElementById('log');
    const instructionListElement = document.getElementById('instructionList');
    const memoryElement = document.getElementById('memory');
    const registerListElement = document.getElementById('registerList');
    const cpu = new CPU(logElement, instructionListElement, memoryElement, registerListElement);

    const stepButton = document.getElementById('stepButton');
    const runButton = document.getElementById('runButton');
    const resetButton = document.getElementById('resetButton');
    const saveButton = document.getElementById('saveButton');
    const loadButton = document.getElementById('loadButton');
    const programArea = document.getElementById('program');

    // Модальное окно
    const modal = document.getElementById('modal');
    const closeModal = document.querySelector('.close');
    const fileInputModal = document.getElementById('fileInputModal');

    // Обработчики событий
    stepButton.addEventListener('click', () => {
        cpu.step();
    });

    runButton.addEventListener('click', () => {
        cpu.run();
    });

    resetButton.addEventListener('click', () => {
        cpu.reset(true);
    });

    saveButton.addEventListener('click', () => {
        const programText = programArea.value;
        const blob = new Blob([programText], { type: 'text/plain' });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        a.download = 'program.txt';
        a.click();
        URL.revokeObjectURL(url);
        cpu.log("Программа сохранена.");
    });

    loadButton.addEventListener('click', () => {
        modal.style.display = 'block';
    });

    closeModal.addEventListener('click', () => {
        modal.style.display = 'none';
    });

    window.addEventListener('click', (event) => {
        if (event.target === modal) {
            modal.style.display = 'none';
        }
    });

    fileInputModal.addEventListener('change', (event) => {
        const file = event.target.files[0];
        if (file) {
            const reader = new FileReader();
            reader.onload = (e) => {
                programArea.value = e.target.result;
                cpu.loadProgram(e.target.result);
                cpu.log("Программа загружена из файла.");
            };
            reader.readAsText(file);
            modal.style.display = 'none';
        }
    });

    // Загрузка программы при инициализации
    cpu.loadProgram(programArea.value);
});

/* Основные стили */
body {
    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
    background-color: #1e1e1e;
    color: #f0f0f0;
    margin: 0;
    padding: 0;
}

.container {
    width: 95%;
    max-width: 1400px;
    margin: 20px auto;
}

h1, h2 {
    text-align: center;
    color: #4CAF50;
}

#controls {
    text-align: center;
    margin-bottom: 20px;
}

.btn {
    background-color: #4CAF50;
    border: none;
    color: white;
    padding: 12px 20px;
    margin: 5px;
    cursor: pointer;
    font-size: 16px;
    border-radius: 5px;
    transition: background-color 0.3s, transform 0.2s;
}

.btn:hover {
    background-color: #45a049;
    transform: scale(1.05);
}

.registers, .instructions, .memory, #output {
    background-color: #2e2e2e;
    padding: 20px;
    border-radius: 10px;
    margin-bottom: 20px;
    box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);
}

.register-list, .memory-list, .instruction-list {
    display: flex;
    flex-wrap: wrap;
    justify-content: center;
}

.register, .memory-cell, .instruction-item {
    background-color: #3e3e3e;
    padding: 10px 20px;
    margin: 10px;
    border-radius: 5px;
    width: 120px;
    text-align: center;
    transition: background-color 0.3s, transform 0.3s;
}

.register:hover, .memory-cell:hover, .instruction-item:hover {
    background-color: #4CAF50;
    transform: scale(1.05);
}

.reg-name, .mem-address {
    font-weight: bold;
}

.reg-value, .mem-value {
    display: block;
    margin-top: 5px;
    font-size: 1.2em;
}

textarea#program {
    width: 100%;
    height: 500px;
    background-color: #1e1e1e;
    color: #f0f0f0;
    border: 2px solid #4CAF50;
    border-radius: 5px;
    padding: 10px;
    font-family: 'Courier New', Courier, monospace;
    resize: vertical;
    transition: border-color 0.3s;
}

textarea#program:focus {
    border-color: #45a049;
}

#output {
    height: 300px;
    overflow-y: scroll;
    background-color: #1e1e1e;
    border: 2px solid #4CAF50;
}

#log {
    padding: 10px;
    font-family: 'Courier New', Courier, monospace;
    white-space: pre-wrap;
}

/* Анимации для выделения регистров и памяти */
.highlight {
    background-color: #FFD700 !important;
    color: #000 !important;
    transition: background-color 0.5s, color 0.5s !important;
}

/* Стилизация списка инструкций */
.instruction-list {
    margin-top: 20px;
    max-height: 200px;
    overflow-y: auto;
    background-color: #1e1e1e;
    border: 1px solid #4CAF50;
    border-radius: 5px;
}

.instruction-item {
    width: 100%;
    padding: 8px;
    cursor: pointer;
    transition: background-color 0.3s;
}

.instruction-item.current {
    background-color: #FFD700;
    color: #000;
}

.instruction-item:hover {
    background-color: #4CAF50;
    color: #fff;
}

/* Модальное окно */
.modal {
    display: none; /* Скрыто по умолчанию */
    position: fixed; /* Остаётся на месте */
    z-index: 1; /* На вершине */
    left: 0;
    top: 0;
    width: 100%; /* Ширина экрана */
    height: 100%; /* Высота экрана */
    overflow: auto; /* Включить прокрутку, если нужно */
    background-color: rgba(0,0,0,0.8); /* Чёрный с прозрачностью */
}

.modal-content {
    background-color: #2e2e2e;
    margin: 10% auto; /* 10% сверху и по центру */
    padding: 20px;
    border: 1px solid #4CAF50;
    width: 50%; /* Ширина модального окна */
    border-radius: 10px;
    color: #f0f0f0;
}

.close {
    color: #aaa;
    float: right;
    font-size: 28px;
    font-weight: bold;
    cursor: pointer;
}

.close:hover,
.close:focus {
    color: #fff;
    text-decoration: none;
}

/* Память */
.memory-cell {
    width: 100px;
    padding: 10px;
}

.memory-cell .mem-address {
    font-size: 0.9em;
}
<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title>Эмуляция Процессора Pentium II</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <div class="container">
        <h1>Эмуляция Процессора Pentium II</h1>

        <div id="controls">
            <button id="stepButton" class="btn">Выполнить Шаг</button>
            <button id="runButton" class="btn">Запустить</button>
            <button id="resetButton" class="btn">Сброс</button>
            <button id="saveButton" class="btn">Сохранить Программу</button>
            <button id="loadButton" class="btn">Загрузить Программу</button>
        </div>

        <div class="registers">
            <h2>Регистры</h2>
            <div class="register-list" id="registerList">
                <!-- Регистры будут динамически добавлены здесь -->
            </div>
        </div>

        <div class="memory">
            <h2>Память</h2>
            <div class="memory-list" id="memory">
                <!-- Память будет динамически заполнена -->
            </div>
        </div>

        <div class="instructions">
            <h2>Программа</h2>
            <textarea id="program" rows="30" cols="80">
// Инициализация регистров
LOAD ACC, 10
LOAD BX, 5
LOAD CX, 0
LOAD DX, 20
LOAD EX, 15
LOAD FX, 25
LOAD GX, 30
LOAD HX, 35
LOAD IX, 40
LOAD JX, 45

// Арифметические операции
ADD BX, ACC
SUB ACC, 3
MUL ACC, 2
DIV ACC, 4
ADD CX, BX
SUB DX, EX
MUL EX, 3
DIV FX, 5
ADD GX, HX
SUB IX, JX

// Логические операции
AND ACC, 3
OR BX, 1
XOR CX, 2
AND DX, 7
OR EX, 4
XOR FX, 6
AND GX, 5
OR HX, 3
XOR IX, 9
AND JX, 2

// Хранение результатов
STORE ACC, 100
STORE BX, 101
STORE CX, 102
STORE DX, 103
STORE EX, 104
STORE FX, 105
STORE GX, 106
STORE HX, 107
STORE IX, 108
STORE JX, 109

// Загрузка из памяти
LOADM KA, 200
LOADM KB, 201
LOADM KC, 202
LOADM KD, 203
LOADM KE, 204
LOADM KF, 205
LOADM KG, 206
LOADM KH, 207
LOADM KI, 208
LOADM KJ, 209

// Арифметические операции с памятью
ADD KA, KB
SUB KC, KD
MUL KE, 4
DIV KF, 2
ADD KG, KH
SUB KI, KJ
MUL KA, 3
DIV KB, 6
ADD KC, KE
SUB KD, KF

// Логические операции с памятью
AND KA, 12
OR KB, 8
XOR KC, 5
AND KD, 3
OR KE, 1
XOR KF, 7
AND KG, 14
OR KH, 9
XOR KI, 11
AND KJ, 4

// Хранение результатов из памяти
STOREM KA, 210
STOREM KB, 211
STOREM KC, 212
STOREM KD, 213
STOREM KE, 214
STOREM KF, 215
STOREM KG, 216
STOREM KH, 217
STOREM KI, 218
STOREM KJ, 219

// Дополнительные операции
LOAD LA, 50
LOAD LB, 60
ADD LA, LB
SUB LB, LA
MUL LA, 5
DIV LB, 10
AND LA, 255
OR LB, 128
XOR LA, 64
STORE LA, 220

// Цикл 1
LOAD CX, 0
LOOP_START1:
    ADD CX, 1
    MUL CX, 2
    STOREM CX, 300 + CX
    SUB CX, 1
    ADD ACC, CX
    SUB ACC, 1
    CMP CX, 10
    JLT LOOP_START1

// Цикл 2
LOAD CX, 5
LOOP_START2:
    SUB CX, 1
    MUL CX, 3
    STOREM CX, 310 + CX
    ADD CX, 2
    DIV CX, 2
    CMP CX, 0
    JGT LOOP_START2

// Условные переходы
LOAD MA, 1000
LOAD MB, 2000
CMP MA, MB
JGT GREATER
JLT LESS
JE EQUAL

GREATER:
    ADD MA, 500
    STORE MA, 320
    JMP END_COND

LESS:
    SUB MB, 500
    STORE MB, 321
    JMP END_COND

EQUAL:
    LOAD MC, 1234
    STORE MC, 322

END_COND:

// Работа с временными регистрами
LOAD TEMP1, 50
LOAD TEMP2, 25
ADD TEMP1, TEMP2
SUB TEMP1, 10
MUL TEMP2, 2
DIV TEMP2, 5
AND TEMP1, 15
OR TEMP2, 8
XOR TEMP1, 4
STORE TEMP1, 330
STORE TEMP2, 331

// Повторные операции
LOAD ACC, 100
LOAD BX, 50
ADD ACC, BX
SUB ACC, 25
MUL ACC, 4
DIV ACC, 2
AND ACC, 7
OR BX, 3
XOR ACC, 1
STORE ACC, 340

// Работа с адресами памяти
LOADM MA, 400
LOADM MB, 401
ADD MA, MB
STOREM MA, 350
SUB MA, MB
STOREM MA, 351
MUL MB, 2
DIV MA, 3
STOREM MB, 352
ADD MA, MB
STOREM MA, 353
SUB MB, MA
STOREM MB, 354

// Завершающие операции
LOAD FINAL, 999
ADD FINAL, 1
STORE FINAL, 400
            </textarea>
            <div class="instruction-list" id="instructionList">
                <!-- Список инструкций будет динамически заполнен -->
            </div>
        </div>

        <div id="output">
            <h2>Вывод</h2>
            <div id="log"></div>
        </div>
    </div>

    <!-- Модальное окно для загрузки программ -->
    <div id="modal" class="modal">
        <div class="modal-content">
            <span class="close">&times;</span>
            <h2>Загрузить Программу</h2>
            <input type="file" id="fileInputModal" accept=".txt">
        </div>
    </div>

    <script src="cpu.js"></script>
</body>
</html>