исправь и напиши целиком код не работает <!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title>Эмуляция Многоядерного Процессора</title>
    <style>
        /* Основные стили */
        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);
        }
        
        .cpu-container {
            display: flex;
            flex-wrap: wrap;
            justify-content: center;
        }
        
        .cpu {
            background-color: #2e2e2e;
            padding: 20px;
            border-radius: 10px;
            margin: 10px;
            width: 400px;
            box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);
        }
        
        .cpu h2 {
            margin-top: 0;
        }
        
        .registers, .memory, .instruction-list {
            background-color: #3e3e3e;
            padding: 10px;
            border-radius: 5px;
            margin-bottom: 10px;
            max-height: 200px;
            overflow-y: auto;
        }
        
        .register, .memory-cell {
            background-color: #4CAF50;
            padding: 5px 10px;
            margin: 5px;
            border-radius: 3px;
            display: inline-block;
            min-width: 80px;
            text-align: center;
            transition: background-color 0.3s;
        }
        
        .register:hover, .memory-cell:hover {
            background-color: #45a049;
        }
        
        .instruction-item {
            padding: 2px 5px;
            margin: 2px 0;
            background-color: #555;
            border-radius: 3px;
            font-size: 0.9em;
        }
        
        .instruction-item.current {
            background-color: #FFD700;
            color: #000;
        }
        
        #log {
            padding: 10px;
            font-family: 'Courier New', Courier, monospace;
            white-space: pre-wrap;
            height: 300px;
            overflow-y: scroll;
            background-color: #1e1e1e;
            border: 2px solid #4CAF50;
            border-radius: 5px;
        }
        
        /* Программа */
        .instructions {
            background-color: #3e3e3e;
            padding: 20px;
            border-radius: 10px;
            margin-bottom: 20px;
            box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);
        }
        
        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;
        }
        
        /* Модальное окно */
        .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;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>Эмуляция Многоядерного Процессора</h1>

        <div id="controls">
            <button id="addCoreButton" class="btn">Добавить Ядро</button>
            <button id="removeCoreButton" class="btn">Удалить Ядро</button>
            <button id="runAllButton" class="btn">Запустить Все</button>
            <button id="stopAllButton" class="btn">Остановить Все</button>
            <button id="resetAllButton" class="btn">Сбросить Все</button>
            <button id="saveProgramButton" class="btn">Сохранить Программу</button>
            <button id="loadProgramButton" class="btn">Загрузить Программу</button>
        </div>

        <div class="cpu-container" id="cpuContainer">
            <!-- Ядра будут динамически добавлены здесь -->
        </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>

        <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>
        // ---------------------------
        // Worker-код как строка
        // ---------------------------
        const workerCode = `
        // Worker-код

        // Слушаем сообщения от основного потока
        self.onmessage = function(event) {
            const { type, data } = event.data;

            if (type === 'init') {
                // Инициализация ядра с необходимыми данными
                initializeCore(data);
            } else if (type === 'run') {
                runCore();
            } else if (type === 'stop') {
                stopCore();
            } else if (type === 'reset') {
                resetCore();
            } else if (type === 'loadProgram') {
                loadProgram(data.programText);
            }
        };

        // Переменные ядра
        let registers = {};
        let flags = {
            ZF: false,
            GT: false,
            LT: false,
            EQ: false
        };
        let instructions = [];
        let labels = {};
        let IP = 0;
        let running = false;
        let logMessages = [];
        let memory = null;
        let timer = null;
        let coreId = 0;

        // Инициализация ядра
        function initializeCore(data) {
            coreId = data.coreId;
            memory = new Int32Array(data.sharedMemory);
            // Дополнительная инициализация, если необходимо
            postLog("Ядро инициализировано.");
        }

        // Загрузка программы
        function loadProgram(programText) {
            const lines = programText.split('\\n');
            instructions = [];
            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 (labels.hasOwnProperty(label)) {
                        postLog(\`Ошибка: Метка \${label} определена несколько раз.\`);
                    } else {
                        labels[label] = instructions.length;
                    }
                } else {
                    instructions.push(cleanLine);
                }
            });

            // Сброс регистров и флагов
            resetCore(false);
            postLog("Программа загружена.");
            sendState();
        }

        // Сброс ядра
        function resetCore(clearRegisters = false) {
            if (clearRegisters) {
                registers = {};
            }
            // Сброс указателя и флагов
            IP = 0;
            flags = {
                ZF: false,
                GT: false,
                LT: false,
                EQ: false
            };
            running = false;
            postLog("Состояние сброшено.");
            sendState();
        }

        // Выполнение одной инструкции
        async function step() {
            if (IP >= instructions.length) {
                postLog("Программа завершена.");
                running = false;
                clearInterval(timer);
                sendState();
                return;
            }

            const instructionLine = instructions[IP];
            postLog(\`Выполнение: \${instructionLine}\`);
            const { opcode, args } = parseInstruction(instructionLine);

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

                IP += 1;
                sendState();
            } catch (error) {
                postLog(\`Ошибка: \${error.message}\`);
                running = false;
                clearInterval(timer);
                sendState();
            }
        }

        // Парсинг инструкции
        function parseInstruction(instructionLine) {
            const tokens = instructionLine.split(' ');
            const opcode = tokens[0].toUpperCase();
            const argsPart = tokens.slice(1).join(' ');
            const args = splitArgs(argsPart);
            return { opcode, args };
        }

        function 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;
        }

        // Методы инструкций
        function load(register, operand) {
            ensureRegister(register);
            const value = evaluateOperand(operand);
            registers[register] = value;
            postLog(\`Загружено значение \${value} в регистр \${register}.\`);
        }

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

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

        function storeMemory(register, expression) {
            store(register, expression);
        }

        function add(register, operand) {
            ensureRegister(register);
            ensureRegister('ACC');
            const value = evaluateOperand(operand);
            registers['ACC'] += registers[register] + value;
            postLog(\`ACC увеличен на (\${register}=\${registers[register]}) + \${value}. Новое значение ACC: \${registers['ACC']}.\`);
        }

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

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

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

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

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

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

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

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

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

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

        function jmp(label) {
            jumpToLabel(label);
        }

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

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

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

        // Оценка арифметического выражения
        function evaluateExpression(expression) {
            // Заменяем регистры их значениями
            const exprWithValues = expression.replace(/[A-Za-z]+/g, (match) => {
                if (registers.hasOwnProperty(match)) {
                    return 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}\`);
            }
        }

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

        // Логирование
        function postLog(message) {
            logMessages.push(message);
            sendLogs();
        }

        // Отправка логов и состояния
        function sendLogs() {
            self.postMessage({
                type: 'log',
                data: { coreId, logs: logMessages }
            });
            logMessages = [];
        }

        function sendState() {
            self.postMessage({
                type: 'state',
                data: {
                    coreId,
                    registers,
                    flags,
                    IP,
                    instructionsLength: instructions.length
                }
            });
        }

        // Запуск ядра
        function runCore() {
            if (running) return;
            running = true;
            timer = setInterval(async () => {
                if (!running) {
                    clearInterval(timer);
                    return;
                }
                if (IP >= instructions.length) {
                    postLog("Программа завершена.");
                    running = false;
                    clearInterval(timer);
                    sendState();
                    return;
                }
                await step();
            }, 500);
        }

        // Остановка ядра
        function stopCore() {
            running = false;
            clearInterval(timer);
            postLog("Выполнение остановлено.");
            sendState();
        }

        // Экспортируем функции через сообщения
        `;

        // Создание Blob URL для Worker
        const blob = new Blob([workerCode], { type: 'application/javascript' });
        const workerURL = URL.createObjectURL(blob);

        // ---------------------------
        // Класс CPU
        // ---------------------------
        class CPU {
            constructor(coreId, sharedBuffer, logCallback, stateCallback) {
                this.coreId = coreId;
                this.sharedBuffer = sharedBuffer;
                this.logCallback = logCallback;
                this.stateCallback = stateCallback;
                this.worker = new Worker(workerURL);
                this.initializeWorker();
            }

            initializeWorker() {
                this.worker.postMessage({
                    type: 'init',
                    data: { coreId: this.coreId, sharedMemory: this.sharedBuffer }
                });

                this.worker.onmessage = (event) => {
                    const { type, data } = event.data;

                    if (type === 'log') {
                        data.logs.forEach(msg => this.logCallback(`Ядро ${data.coreId}: ${msg}`));
                    } else if (type === 'state') {
                        this.stateCallback(data);
                    }
                };

                this.worker.postMessage({
                    type: 'loadProgram',
                    data: { programText: document.getElementById('program').value }
                });
            }

            run() {
                this.worker.postMessage({ type: 'run' });
            }

            stop() {
                this.worker.postMessage({ type: 'stop' });
            }

            reset() {
                this.worker.postMessage({ type: 'reset' });
            }

            loadProgram(programText) {
                this.worker.postMessage({ type: 'loadProgram', data: { programText } });
            }

            terminate() {
                this.worker.terminate();
            }
        }

        // ---------------------------
        // Основной JavaScript
        // ---------------------------
        document.addEventListener('DOMContentLoaded', () => {
            const logElement = document.getElementById('log');
            const cpuContainer = document.getElementById('cpuContainer');
            const addCoreButton = document.getElementById('addCoreButton');
            const removeCoreButton = document.getElementById('removeCoreButton');
            const runAllButton = document.getElementById('runAllButton');
            const stopAllButton = document.getElementById('stopAllButton');
            const resetAllButton = document.getElementById('resetAllButton');
            const saveProgramButton = document.getElementById('saveProgramButton');
            const loadProgramButton = document.getElementById('loadProgramButton');
            const programTextarea = document.getElementById('program');

            const modal = document.getElementById('modal');
            const closeModal = document.querySelector('.close');
            const fileInputModal = document.getElementById('fileInputModal');

            let sharedBuffer = new SharedArrayBuffer(512 * Int32Array.BYTES_PER_ELEMENT); // 512 ячеек памяти
            let memory = new Int32Array(sharedBuffer);
            // Инициализируем память нулями
            for (let i = 0; i < memory.length; i++) {
                memory[i] = 0;
            }

            let cpus = [];
            let coreCount = 0;

            // Добавление ядра
            function addCore() {
                const coreId = coreCount;
                coreCount += 1;

                // Создание элемента для ядра
                const coreDiv = document.createElement('div');
                coreDiv.classList.add('cpu');
                coreDiv.id = \`core-\${coreId}\`;

                const h2 = document.createElement('h2');
                h2.textContent = \`Ядро \${coreId}\`;
                coreDiv.appendChild(h2);

                // Разделы регистров, памяти и инструкций
                const registersDiv = document.createElement('div');
                registersDiv.classList.add('registers');
                const registersTitle = document.createElement('h3');
                registersTitle.textContent = "Регистры";
                registersDiv.appendChild(registersTitle);
                const registerList = document.createElement('div');
                registerList.classList.add('register-list');
                registersDiv.appendChild(registerList);
                coreDiv.appendChild(registersDiv);

                const instructionDiv = document.createElement('div');
                instructionDiv.classList.add('instruction-list');
                const instructionTitle = document.createElement('h3');
                instructionTitle.textContent = "Текущая Инструкция";
                instructionDiv.appendChild(instructionTitle);
                const currentInstr = document.createElement('div');
                currentInstr.classList.add('current-instruction');
                currentInstr.textContent = 'IP: 0 — Ожидание';
                instructionDiv.appendChild(currentInstr);
                coreDiv.appendChild(instructionDiv);

                cpuContainer.appendChild(coreDiv);

                // Создание и инициализация CPU
                const cpu = new CPU(coreId, sharedBuffer, appendLog, updateCoreState.bind(null, coreId));
                cpus.push(cpu);

                appendLog(\`Добавлено ядро \${coreId}.\`);
            }

            // Удаление ядра
            function removeCore() {
                if (cpus.length === 0) {
                    appendLog("Нет ядер для удаления.");
                    return;
                }
                const cpu = cpus.pop();
                cpu.terminate();
                const coreId = coreCount - 1;
                coreCount -= 1;
                const coreDiv = document.getElementById(\`core-\${coreId}\`);
                if (coreDiv) {
                    cpuContainer.removeChild(coreDiv);
                }
                appendLog(\`Удалено ядро \${coreId}.\`);
            }

            // Запуск всех ядер
            function runAllCores() {
                if (cpus.length === 0) {
                    appendLog("Нет ядер для запуска.");
                    return;
                }
                cpus.forEach(cpu => cpu.run());
                appendLog("Все ядра запущены.");
            }

            // Остановка всех ядер
            function stopAllCores() {
                if (cpus.length === 0) {
                    appendLog("Нет ядер для остановки.");
                    return;
                }
                cpus.forEach(cpu => cpu.stop());
                appendLog("Все ядра остановлены.");
            }

            // Сброс всех ядер
            function resetAllCores() {
                if (cpus.length === 0) {
                    appendLog("Нет ядер для сброса.");
                    return;
                }
                cpus.forEach(cpu => cpu.reset());
                appendLog("Все ядра сброшены.");
                // Очистка общих регистров и памяти
                for (let i = 0; i < memory.length; i++) {
                    memory[i] = 0;
                }
                updateAllCoresUI();
            }

            // Сохранение программы
            function saveProgram() {
                const programText = programTextarea.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);
                appendLog("Программа сохранена.");
            }

            // Загрузка программы
            loadProgramButton.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) => {
                        programTextarea.value = e.target.result;
                        appendLog("Программа загружена из файла.");
                        // Перезагружаем программу во все ядра
                        cpus.forEach(cpu => cpu.loadProgram(e.target.result));
                    };
                    reader.readAsText(file);
                    modal.style.display = 'none';
                }
            });

            // Добавление обработчиков кнопок
            addCoreButton.addEventListener('click', addCore);
            removeCoreButton.addEventListener('click', removeCore);
            runAllButton.addEventListener('click', runAllCores);
            stopAllButton.addEventListener('click', stopAllCores);
            resetAllButton.addEventListener('click', resetAllCores);
            saveProgramButton.addEventListener('click', saveProgram);

            // Инициализация первого ядра по умолчанию
            addCore();
        });

        // Функция логирования
        function appendLog(message) {
            const logElement = document.getElementById('log');
            const p = document.createElement('p');
            p.textContent = message;
            logElement.appendChild(p);
            // Прокрутка вниз
            logElement.scrollTop = logElement.scrollHeight;
        }

        // Обновление состояния ядра
        function updateCoreState(coreId, data) {
            const coreDiv = document.getElementById(\`core-\${coreId}\`);
            if (!coreDiv) return;

            // Обновление регистров
            const registerList = coreDiv.querySelector('.register-list');
            registerList.innerHTML = '';
            for (let reg in data.registers) {
                const regDiv = document.createElement('div');
                regDiv.classList.add('register');
                regDiv.innerHTML = \`<strong>\${reg}:</strong> \${data.registers[reg]}\`;
                registerList.appendChild(regDiv);
            }

            // Обновление текущей инструкции
            const currentInstr = coreDiv.querySelector('.current-instruction');
            if (data.IP < data.instructionsLength) {
                currentInstr.textContent = \`IP: \${data.IP} — В процессе\`;
            } else {
                currentInstr.textContent = \`IP: \${data.IP} — Завершено\`;
            }
        }

        // Обновление UI всех ядер (при сбросе и т.д.)
        function updateAllCoresUI() {
            const cpus = document.querySelectorAll('.cpu');
            cpus.forEach(coreDiv => {
                const coreId = coreDiv.id.split('-')[1];
                const registerList = coreDiv.querySelector('.register-list');
                registerList.innerHTML = '';

                const registers = ['ACC', 'BX', 'CX', 'DX', 'EX', 'FX', 'GX', 'HX', 'IX', 'JX', 'KA', 'KB', 'KC', 'KD', 'KE', 'KF', 'KG', 'KH', 'KI', 'KJ', 'LA', 'LB', 'MA', 'MB', 'MC', 'TEMP1', 'TEMP2', 'FINAL'];

                registers.forEach(reg => {
                    const regDiv = document.createElement('div');
                    regDiv.classList.add('register');
                    regDiv.innerHTML = \`<strong>\${reg}:</strong> 0\`;
                    registerList.appendChild(regDiv);
                });

                const currentInstr = coreDiv.querySelector('.current-instruction');
                currentInstr.textContent = 'IP: 0 — Ожидание';
            });
        }
    </script>
</body>
  
</html>