diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6ea8874 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +models/ \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 6c16806..e772658 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -25,6 +25,7 @@ set(SOURCES xenith/preprocessing/tokenizer.cpp ollama_api/test.cpp xenith/converter.cpp + help.h ) # Заголовочные файлы (для удобства в IDE) diff --git a/README.md b/README.md index b8e8f32..050776f 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,9 @@ # Xenith +[![Platform](https://img.shields.io/badge/platform-Linux-blue)]() +[![C++](https://img.shields.io/badge/C++-20-blue)]() +[![Лицензия](https://img.shields.io/badge/license-MIT-green)]() + Трансформер на чистом C++: обучение и генерация текста на CPU, без внешних зависимостей. Всё в одном бинарнике. @@ -52,6 +56,7 @@ --rope N база RoPE (10000) --seed N зерно инициализации (1337) --untied отдельная матрица выхода вместо связанной с эмбеддингом +--view-vocab вывести словарь нейросети ``` Словарь двухуровневый: частые слова берутся целиком, остальное режется на @@ -97,6 +102,15 @@ --show-tokens показать id токенов ``` +### ollama — сгенерировать + +``` +--port PORT порт сервера (по умолчанию 11434) +--conf NAME.conf конфиг с настройками и списком моделей +``` + +### update - проверка обновления + ### info / gradcheck / bench ```bash diff --git a/bin/Xenith b/bin/Xenith index 32ac0c5..e2a6fe4 100755 Binary files a/bin/Xenith and b/bin/Xenith differ diff --git a/corpus/demo.txt b/corpus/demo.txt deleted file mode 100644 index 5455f11..0000000 --- a/corpus/demo.txt +++ /dev/null @@ -1,4000 +0,0 @@ -старый данные возвращает в системы -быстрый код записывает в алгоритма -медленный программа создаёт в кода -новый компьютер записывает в алгоритма -старый код записывает в компьютера -простой данные читает в кода -новый компьютер работает в системы -новый переменная читает в программы -новый переменная считает в данных -хороший память создаёт в памяти -медленный функция создаёт в памяти -хороший переменная создаёт в программы -новый программа меняет в программы -сложный компьютер работает в программы -медленный данные хранит в алгоритма -сложный функция записывает в компьютера -сложный код считает в памяти -медленный программа возвращает в программы -простой программа считает в компьютера -хороший данные меняет в данных -новый переменная хранит в функции -сложный память хранит в кода -новый код хранит в кода -медленный компьютер работает в алгоритма -старый память возвращает в программы -новый алгоритм создаёт в программы -старый система возвращает в функции -сложный алгоритм работает в алгоритма -сложный переменная работает в компьютера -быстрый компьютер меняет в данных -старый код возвращает в программы -новый память читает в компьютера -хороший компьютер хранит в компьютера -быстрый память работает в алгоритма -новый функция считает в алгоритма -медленный алгоритм записывает в алгоритма -быстрый данные создаёт в алгоритма -хороший алгоритм меняет в памяти -хороший алгоритм работает в памяти -медленный данные возвращает в системы -новый данные хранит в системы -хороший компьютер возвращает в памяти -хороший переменная считает в данных -простой компьютер записывает в алгоритма -новый код считает в кода -сложный память возвращает в функции -новый программа возвращает в функции -новый память создаёт в памяти -сложный код читает в кода -новый программа работает в функции -новый код работает в программы -быстрый функция хранит в алгоритма -быстрый указатель создаёт в функции -старый указатель меняет в программы -сложный функция меняет в памяти -сложный функция работает в функции -новый память хранит в алгоритма -сложный функция считает в памяти -старый код создаёт в функции -хороший указатель записывает в алгоритма -быстрый указатель записывает в памяти -старый алгоритм меняет в компьютера -быстрый код работает в алгоритма -старый система хранит в функции -новый компьютер возвращает в кода -сложный система читает в памяти -новый функция меняет в данных -новый компьютер возвращает в функции -новый компьютер хранит в функции -медленный программа возвращает в программы -медленный компьютер читает в функции -старый код считает в памяти -быстрый данные работает в памяти -хороший программа возвращает в алгоритма -новый система создаёт в программы -быстрый код возвращает в кода -медленный компьютер записывает в функции -сложный память меняет в программы -хороший переменная возвращает в функции -простой компьютер возвращает в алгоритма -новый данные меняет в программы -медленный программа хранит в системы -хороший данные возвращает в алгоритма -простой компьютер считает в программы -сложный компьютер меняет в памяти -простой система хранит в компьютера -медленный указатель записывает в системы -быстрый указатель меняет в компьютера -простой память читает в компьютера -хороший программа меняет в алгоритма -сложный программа меняет в системы -простой система считает в компьютера -сложный программа записывает в функции -быстрый код записывает в алгоритма -хороший функция создаёт в функции -сложный система считает в компьютера -медленный данные возвращает в системы -новый функция считает в алгоритма -медленный система считает в алгоритма -быстрый функция хранит в алгоритма -медленный память создаёт в памяти -сложный функция меняет в памяти -быстрый данные меняет в памяти -новый память считает в данных -старый алгоритм возвращает в данных -сложный память создаёт в системы -медленный указатель меняет в функции -медленный система возвращает в кода -старый данные работает в данных -старый код возвращает в программы -новый данные возвращает в данных -новый программа возвращает в памяти -новый указатель меняет в компьютера -простой алгоритм создаёт в системы -быстрый код читает в компьютера -новый переменная работает в алгоритма -медленный функция создаёт в памяти -сложный функция считает в памяти -старый алгоритм меняет в компьютера -сложный память меняет в программы -простой алгоритм работает в алгоритма -новый система создаёт в программы -новый функция хранит в алгоритма -хороший переменная записывает в алгоритма -быстрый компьютер работает в компьютера -новый данные создаёт в компьютера -новый алгоритм возвращает в данных -старый указатель меняет в программы -новый указатель считает в функции -старый переменная считает в программы -быстрый компьютер записывает в функции -сложный данные работает в программы -новый алгоритм считает в кода -новый система считает в системы -новый система записывает в кода -новый алгоритм записывает в данных -быстрый память читает в кода -новый указатель читает в программы -новый код меняет в алгоритма -медленный указатель создаёт в функции -старый переменная записывает в кода -быстрый функция хранит в алгоритма -новый данные считает в памяти -новый программа читает в системы -новый программа хранит в данных -новый переменная читает в программы -медленный данные хранит в алгоритма -сложный функция считает в памяти -простой память меняет в кода -сложный память считает в данных -хороший код возвращает в данных -хороший данные возвращает в алгоритма -новый функция меняет в данных -быстрый система работает в компьютера -сложный указатель работает в данных -сложный функция хранит в алгоритма -сложный переменная считает в компьютера -сложный код меняет в алгоритма -новый указатель записывает в системы -медленный система хранит в данных -медленный система работает в программы -сложный код хранит в кода -старый переменная работает в кода -новый компьютер работает в программы -быстрый алгоритм меняет в системы -простой переменная записывает в системы -простой переменная записывает в системы -простой указатель возвращает в алгоритма -простой память возвращает в компьютера -быстрый функция меняет в памяти -старый память читает в алгоритма -медленный указатель записывает в системы -медленный алгоритм создаёт в кода -быстрый программа работает в компьютера -медленный система возвращает в кода -новый программа работает в кода -простой память создаёт в данных -медленный переменная хранит в компьютера -сложный функция считает в памяти -хороший программа считает в функции -новый алгоритм работает в компьютера -быстрый память хранит в памяти -простой память работает в программы -новый код записывает в функции -старый переменная записывает в кода -сложный алгоритм работает в алгоритма -быстрый память работает в алгоритма -хороший данные работает в функции -медленный программа хранит в системы -хороший компьютер записывает в кода -новый переменная хранит в функции -старый переменная возвращает в функции -быстрый память читает в кода -хороший функция создаёт в функции -сложный функция меняет в памяти -быстрый программа хранит в алгоритма -новый данные возвращает в данных -старый код возвращает в программы -хороший данные меняет в данных -хороший память считает в системы -медленный данные хранит в алгоритма -простой память возвращает в компьютера -хороший программа работает в памяти -хороший система работает в программы -хороший компьютер возвращает в памяти -сложный программа возвращает в системы -старый программа хранит в системы -хороший память работает в компьютера -быстрый функция читает в компьютера -новый программа читает в функции -сложный компьютер работает в программы -хороший компьютер работает в функции -хороший код считает в компьютера -простой программа записывает в программы -простой переменная хранит в компьютера -новый функция работает в данных -старый переменная возвращает в функции -быстрый функция возвращает в системы -новый данные считает в памяти -быстрый код читает в компьютера -старый компьютер возвращает в системы -медленный программа хранит в системы -медленный компьютер хранит в памяти -новый код меняет в алгоритма -быстрый функция работает в программы -простой переменная записывает в системы -новый система хранит в кода -хороший переменная работает в функции -новый функция возвращает в системы -быстрый программа хранит в алгоритма -медленный компьютер считает в системы -новый алгоритм возвращает в данных -быстрый данные записывает в компьютера -медленный программа работает в функции -новый система меняет в системы -новый функция возвращает в системы -быстрый данные работает в памяти -простой компьютер записывает в алгоритма -медленный компьютер читает в функции -медленный функция создаёт в памяти -старый указатель считает в алгоритма -старый код создаёт в функции -старый переменная создаёт в системы -хороший данные читает в кода -простой программа записывает в программы -хороший алгоритм считает в данных -новый алгоритм работает в кода -быстрый память записывает в системы -новый компьютер возвращает в функции -быстрый данные записывает в компьютера -сложный данные создаёт в кода -медленный код меняет в программы -быстрый функция меняет в памяти -медленный данные читает в алгоритма -сложный код возвращает в системы -медленный компьютер считает в системы -новый программа считает в кода -старый алгоритм считает в функции -старый алгоритм возвращает в данных -хороший память считает в системы -хороший программа меняет в алгоритма -простой код меняет в компьютера -новый указатель меняет в компьютера -новый программа меняет в программы -старый указатель работает в функции -простой код создаёт в программы -хороший компьютер работает в функции -новый переменная создаёт в функции -быстрый алгоритм создаёт в данных -новый функция считает в компьютера -новый функция меняет в данных -сложный переменная записывает в компьютера -быстрый компьютер читает в памяти -новый программа читает в системы -новый система хранит в кода -хороший алгоритм меняет в памяти -сложный переменная читает в памяти -новый функция меняет в данных -быстрый алгоритм работает в алгоритма -хороший алгоритм считает в данных -хороший данные меняет в данных -хороший система считает в кода -старый память создаёт в памяти -хороший система работает в программы -медленный память создаёт в памяти -старый система читает в памяти -быстрый переменная считает в кода -простой программа меняет в кода -новый функция создаёт в кода -хороший алгоритм работает в памяти -медленный компьютер хранит в памяти -простой алгоритм работает в алгоритма -старый указатель создаёт в кода -новый переменная работает в системы -быстрый система считает в системы -медленный система работает в программы -хороший код возвращает в данных -новый алгоритм меняет в данных -простой алгоритм меняет в компьютера -старый переменная читает в программы -простой код записывает в компьютера -сложный данные возвращает в данных -хороший алгоритм меняет в памяти -старый компьютер меняет в системы -быстрый переменная возвращает в кода -новый переменная считает в системы -новый память работает в кода -хороший память считает в системы -быстрый указатель работает в памяти -сложный переменная работает в компьютера -старый система читает в памяти -старый алгоритм меняет в компьютера -новый код меняет в программы -новый данные хранит в системы -старый функция читает в функции -сложный система меняет в программы -медленный система меняет в данных -быстрый указатель хранит в данных -старый данные хранит в компьютера -простой данные создаёт в функции -хороший система работает в программы -старый память возвращает в программы -простой указатель возвращает в алгоритма -новый указатель считает в программы -сложный компьютер хранит в кода -новый система работает в системы -простой программа возвращает в компьютера -простой система работает в данных -хороший функция хранит в программы -быстрый память считает в программы -новый система меняет в программы -хороший система меняет в кода -простой функция хранит в системы -новый указатель читает в данных -новый алгоритм считает в кода -простой код считает в компьютера -сложный память работает в данных -медленный алгоритм считает в данных -хороший программа работает в памяти -новый указатель возвращает в функции -старый компьютер считает в компьютера -быстрый данные записывает в компьютера -быстрый память считает в программы -новый система меняет в системы -новый компьютер читает в компьютера -сложный данные создаёт в кода -быстрый указатель создаёт в функции -простой функция создаёт в системы -простой программа работает в компьютера -сложный функция считает в памяти -простой код создаёт в программы -сложный компьютер хранит в кода -хороший указатель возвращает в компьютера -медленный данные считает в памяти -сложный алгоритм работает в алгоритма -медленный данные возвращает в системы -новый данные читает в программы -новый алгоритм читает в кода -быстрый данные создаёт в алгоритма -быстрый компьютер считает в кода -хороший система читает в памяти -быстрый переменная возвращает в кода -новый система считает в алгоритма -быстрый программа записывает в функции -быстрый компьютер создаёт в алгоритма -новый данные возвращает в кода -новый переменная работает в алгоритма -медленный указатель работает в данных -быстрый алгоритм меняет в системы -хороший функция считает в данных -медленный переменная хранит в компьютера -хороший переменная хранит в памяти -простой указатель меняет в системы -новый функция считает в компьютера -новый данные хранит в системы -новый система читает в функции -старый алгоритм создаёт в кода -быстрый переменная возвращает в кода -простой система возвращает в памяти -новый код меняет в программы -сложный указатель работает в данных -новый система меняет в системы -хороший система считает в кода -новый система возвращает в кода -сложный память создаёт в системы -сложный алгоритм работает в алгоритма -старый переменная записывает в кода -новый переменная возвращает в компьютера -сложный алгоритм возвращает в системы -старый компьютер считает в компьютера -быстрый функция записывает в программы -сложный программа считает в данных -новый компьютер записывает в компьютера -хороший память читает в системы -новый переменная работает в системы -быстрый программа хранит в алгоритма -новый функция работает в данных -новый функция создаёт в кода -простой компьютер читает в кода -быстрый алгоритм работает в алгоритма -сложный код возвращает в системы -старый переменная хранит в алгоритма -хороший переменная хранит в памяти -старый переменная записывает в кода -старый алгоритм работает в системы -новый данные записывает в данных -хороший указатель работает в функции -медленный программа хранит в системы -старый функция возвращает в кода -быстрый алгоритм создаёт в данных -новый программа считает в кода -новый компьютер считает в системы -хороший алгоритм записывает в данных -новый алгоритм возвращает в данных -старый алгоритм работает в системы -новый функция записывает в системы -быстрый система хранит в данных -медленный указатель создаёт в функции -сложный компьютер хранит в кода -простой код создаёт в программы -старый код хранит в компьютера -сложный алгоритм хранит в компьютера -новый алгоритм создаёт в программы -старый алгоритм работает в системы -сложный программа считает в данных -новый переменная работает в системы -сложный функция работает в функции -новый код возвращает в функции -хороший память возвращает в алгоритма -простой функция работает в системы -новый компьютер хранит в памяти -хороший данные возвращает в алгоритма -медленный данные возвращает в системы -быстрый компьютер хранит в кода -старый программа возвращает в алгоритма -хороший программа создаёт в кода -новый алгоритм хранит в программы -простой система считает в компьютера -старый программа создаёт в кода -сложный алгоритм работает в алгоритма -медленный указатель создаёт в функции -новый указатель читает в программы -старый данные меняет в функции -новый переменная работает в системы -сложный компьютер создаёт в кода -медленный код считает в программы -новый алгоритм записывает в данных -быстрый память хранит в памяти -сложный код хранит в кода -новый указатель считает в программы -медленный система создаёт в программы -новый память считает в данных -хороший функция возвращает в алгоритма -простой указатель меняет в системы -медленный код возвращает в алгоритма -простой алгоритм работает в алгоритма -хороший указатель создаёт в данных -старый компьютер записывает в данных -сложный система меняет в программы -новый данные работает в программы -медленный функция создаёт в памяти -старый система работает в памяти -простой система работает в данных -хороший программа считает в функции -старый память считает в памяти -быстрый код возвращает в кода -новый переменная создаёт в функции -сложный память считает в данных -медленный компьютер считает в системы -сложный функция создаёт в алгоритма -новый функция создаёт в системы -быстрый функция создаёт в памяти -медленный память считает в компьютера -старый переменная работает в кода -быстрый указатель меняет в компьютера -новый функция хранит в программы -сложный компьютер меняет в памяти -быстрый память работает в алгоритма -хороший программа считает в функции -медленный данные создаёт в программы -старый функция записывает в компьютера -быстрый данные меняет в памяти -хороший память считает в системы -быстрый переменная хранит в компьютера -новый программа создаёт в памяти -старый компьютер хранит в данных -новый данные работает в памяти -хороший указатель хранит в данных -простой программа работает в компьютера -хороший компьютер читает в алгоритма -медленный система хранит в данных -простой алгоритм хранит в алгоритма -старый код считает в памяти -новый данные читает в алгоритма -старый указатель работает в функции -новый данные читает в программы -медленный программа читает в данных -хороший данные записывает в алгоритма -сложный программа считает в данных -медленный функция записывает в функции -новый программа записывает в алгоритма -медленный система создаёт в программы -хороший память хранит в кода -новый компьютер считает в системы -старый программа меняет в алгоритма -новый алгоритм возвращает в данных -новый система меняет в системы -быстрый система считает в системы -старый данные создаёт в программы -хороший память хранит в кода -медленный программа считает в компьютера -медленный код записывает в программы -новый переменная считает в системы -новый данные хранит в системы -простой данные записывает в данных -сложный функция возвращает в памяти -новый программа читает в системы -медленный система меняет в данных -быстрый код работает в алгоритма -новый данные записывает в данных -хороший система читает в памяти -медленный программа считает в компьютера -быстрый данные считает в компьютера -быстрый код создаёт в алгоритма -хороший код возвращает в данных -быстрый программа хранит в алгоритма -старый код меняет в функции -новый система считает в алгоритма -медленный компьютер записывает в функции -сложный код записывает в системы -быстрый алгоритм записывает в компьютера -хороший данные работает в функции -старый указатель читает в алгоритма -старый код читает в системы -медленный функция хранит в программы -простой переменная записывает в системы -медленный переменная считает в памяти -новый алгоритм читает в кода -хороший переменная возвращает в функции -быстрый код возвращает в кода -быстрый алгоритм возвращает в функции -сложный программа хранит в кода -простой данные хранит в системы -старый компьютер читает в данных -хороший компьютер записывает в кода -сложный код возвращает в системы -медленный функция считает в системы -сложный указатель создаёт в алгоритма -старый алгоритм возвращает в данных -новый функция работает в данных -простой память создаёт в данных -новый функция создаёт в системы -медленный память возвращает в функции -медленный код считает в программы -простой код меняет в компьютера -старый компьютер меняет в системы -быстрый программа хранит в алгоритма -старый система записывает в функции -хороший алгоритм создаёт в компьютера -медленный указатель меняет в функции -сложный переменная считает в компьютера -медленный данные меняет в кода -быстрый переменная работает в памяти -новый память меняет в компьютера -новый программа меняет в программы -быстрый переменная хранит в компьютера -старый переменная записывает в кода -новый система хранит в программы -хороший указатель хранит в данных -быстрый система меняет в компьютера -медленный данные записывает в программы -простой код читает в программы -медленный память читает в данных -хороший система меняет в кода -новый код создаёт в функции -быстрый данные читает в памяти -новый алгоритм считает в кода -сложный компьютер работает в программы -сложный компьютер работает в программы -быстрый код работает в алгоритма -новый память записывает в памяти -хороший данные хранит в функции -медленный программа создаёт в кода -хороший функция возвращает в алгоритма -новый алгоритм записывает в данных -сложный код создаёт в кода -новый алгоритм читает в кода -простой указатель работает в системы -хороший программа хранит в компьютера -сложный память работает в данных -хороший код хранит в памяти -новый данные меняет в функции -хороший код читает в программы -старый код считает в памяти -сложный данные возвращает в данных -старый память меняет в системы -сложный компьютер меняет в памяти -медленный код работает в компьютера -простой функция меняет в системы -сложный компьютер создаёт в кода -медленный алгоритм создаёт в кода -сложный алгоритм работает в алгоритма -простой программа читает в памяти -новый данные возвращает в кода -быстрый компьютер возвращает в данных -новый переменная меняет в памяти -сложный алгоритм считает в данных -быстрый указатель записывает в памяти -новый компьютер считает в кода -простой программа записывает в программы -сложный алгоритм меняет в программы -медленный программа считает в компьютера -медленный переменная хранит в компьютера -новый система считает в алгоритма -хороший код считает в компьютера -старый данные записывает в функции -сложный код меняет в алгоритма -сложный алгоритм хранит в компьютера -простой данные возвращает в данных -простой компьютер хранит в кода -простой функция работает в системы -сложный программа хранит в кода -новый переменная хранит в функции -хороший компьютер хранит в компьютера -простой компьютер работает в функции -новый алгоритм читает в системы -сложный программа считает в данных -новый указатель хранит в компьютера -хороший код возвращает в данных -простой функция создаёт в системы -быстрый указатель создаёт в функции -новый переменная возвращает в компьютера -простой компьютер создаёт в памяти -быстрый указатель работает в памяти -сложный указатель меняет в компьютера -сложный функция меняет в памяти -новый указатель работает в кода -сложный система создаёт в данных -хороший указатель меняет в программы -сложный код меняет в алгоритма -медленный переменная хранит в компьютера -старый переменная считает в программы -быстрый компьютер меняет в данных -хороший переменная работает в функции -медленный система записывает в компьютера -хороший система считает в кода -старый данные меняет в функции -простой функция меняет в системы -старый память меняет в системы -простой алгоритм считает в компьютера -старый система считает в данных -сложный переменная записывает в компьютера -хороший алгоритм читает в данных -хороший переменная считает в данных -медленный система считает в алгоритма -быстрый код создаёт в алгоритма -простой компьютер считает в программы -простой алгоритм хранит в алгоритма -новый указатель считает в функции -медленный программа считает в компьютера -новый система хранит в программы -старый указатель считает в алгоритма -простой алгоритм создаёт в системы -сложный данные создаёт в кода -новый компьютер хранит в функции -хороший память читает в системы -старый указатель читает в алгоритма -хороший данные создаёт в памяти -простой память создаёт в данных -новый память создаёт в памяти -новый компьютер меняет в программы -сложный переменная записывает в компьютера -хороший указатель читает в компьютера -новый программа работает в кода -новый алгоритм возвращает в данных -новый данные считает в памяти -новый память меняет в программы -старый код возвращает в программы -простой функция возвращает в функции -сложный алгоритм записывает в алгоритма -старый алгоритм работает в системы -старый память записывает в кода -быстрый переменная создаёт в алгоритма -новый компьютер возвращает в функции -сложный указатель возвращает в компьютера -сложный указатель считает в компьютера -сложный функция записывает в компьютера -новый указатель хранит в памяти -простой функция работает в системы -старый функция создаёт в алгоритма -простой указатель создаёт в алгоритма -новый указатель работает в кода -хороший указатель работает в функции -старый программа меняет в алгоритма -старый компьютер создаёт в компьютера -сложный память возвращает в функции -сложный память меняет в программы -хороший компьютер считает в компьютера -быстрый память читает в кода -новый указатель возвращает в функции -новый алгоритм хранит в компьютера -новый переменная хранит в функции -медленный алгоритм считает в данных -новый указатель работает в компьютера -сложный код записывает в системы -новый программа создаёт в памяти -новый функция записывает в компьютера -быстрый программа меняет в функции -быстрый система хранит в данных -быстрый компьютер работает в компьютера -новый функция создаёт в кода -медленный компьютер записывает в функции -старый функция меняет в кода -старый переменная создаёт в системы -новый компьютер читает в компьютера -старый данные работает в данных -старый функция хранит в системы -медленный данные хранит в алгоритма -старый указатель читает в алгоритма -хороший переменная возвращает в функции -старый программа хранит в системы -хороший данные создаёт в памяти -быстрый указатель считает в функции -простой переменная создаёт в кода -новый система меняет в системы -простой память записывает в функции -простой код хранит в системы -новый система меняет в программы -сложный данные возвращает в данных -старый код возвращает в программы -старый алгоритм читает в памяти -хороший алгоритм хранит в компьютера -сложный переменная возвращает в программы -медленный код читает в функции -хороший данные создаёт в памяти -новый функция читает в компьютера -старый память работает в системы -старый указатель считает в алгоритма -новый код меняет в алгоритма -хороший код работает в компьютера -простой функция считает в алгоритма -старый переменная работает в кода -новый программа работает в функции -простой программа читает в памяти -быстрый система считает в системы -простой данные считает в компьютера -хороший система считает в кода -новый переменная записывает в алгоритма -быстрый переменная считает в кода -простой алгоритм считает в компьютера -простой память записывает в функции -быстрый функция работает в программы -медленный память хранит в системы -новый указатель возвращает в функции -простой переменная меняет в памяти -новый указатель работает в кода -новый память создаёт в памяти -сложный программа записывает в функции -сложный алгоритм работает в алгоритма -быстрый данные создаёт в алгоритма -быстрый память хранит в памяти -хороший функция возвращает в алгоритма -сложный переменная возвращает в программы -старый алгоритм хранит в алгоритма -новый система считает в алгоритма -новый память хранит в компьютера -хороший данные меняет в данных -медленный система создаёт в программы -сложный память хранит в кода -новый алгоритм возвращает в данных -быстрый компьютер меняет в данных -простой переменная хранит в компьютера -старый переменная меняет в программы -медленный программа работает в функции -простой данные работает в компьютера -новый компьютер записывает в компьютера -новый память читает в компьютера -простой данные записывает в данных -простой код записывает в компьютера -медленный код читает в функции -простой компьютер записывает в алгоритма -старый система работает в памяти -новый алгоритм меняет в кода -сложный данные возвращает в данных -медленный память считает в компьютера -быстрый алгоритм хранит в функции -простой система работает в данных -новый функция читает в компьютера -медленный указатель создаёт в функции -простой переменная создаёт в кода -новый система записывает в системы -старый программа меняет в алгоритма -сложный код работает в программы -быстрый переменная хранит в компьютера -старый указатель считает в алгоритма -новый указатель хранит в памяти -новый система считает в системы -старый система создаёт в памяти -новый переменная меняет в памяти -сложный память работает в данных -медленный данные считает в памяти -простой данные возвращает в данных -простой программа возвращает в компьютера -старый память меняет в системы -хороший система создаёт в компьютера -сложный система записывает в данных -сложный указатель меняет в компьютера -новый система записывает в системы -простой алгоритм создаёт в системы -хороший память читает в системы -новый компьютер возвращает в функции -быстрый указатель хранит в данных -новый память возвращает в компьютера -простой программа работает в компьютера -простой переменная работает в кода -новый память меняет в компьютера -простой система работает в данных -быстрый указатель считает в функции -простой программа создаёт в данных -медленный система меняет в данных -старый компьютер считает в компьютера -сложный память читает в алгоритма -новый переменная меняет в памяти -старый память считает в памяти -медленный указатель меняет в функции -новый функция возвращает в системы -хороший программа считает в функции -простой программа создаёт в данных -быстрый данные хранит в данных -медленный компьютер меняет в системы -простой компьютер возвращает в алгоритма -новый компьютер работает в программы -новый память хранит в компьютера -медленный переменная хранит в компьютера -сложный переменная читает в памяти -новый указатель создаёт в функции -медленный функция записывает в функции -старый алгоритм возвращает в данных -старый указатель работает в функции -новый переменная записывает в кода -простой система записывает в компьютера -старый функция хранит в системы -простой компьютер работает в функции -старый указатель работает в функции -быстрый программа читает в системы -медленный память работает в данных -простой переменная работает в кода -быстрый система хранит в данных -старый функция хранит в системы -простой система работает в данных -быстрый код читает в компьютера -новый система считает в алгоритма -сложный код считает в памяти -медленный переменная хранит в компьютера -медленный переменная работает в системы -медленный программа создаёт в кода -медленный переменная хранит в компьютера -быстрый программа считает в программы -старый алгоритм возвращает в данных -новый память возвращает в компьютера -быстрый код считает в памяти -новый данные считает в данных -быстрый код читает в компьютера -простой алгоритм считает в компьютера -старый память возвращает в программы -сложный переменная хранит в кода -сложный алгоритм возвращает в системы -новый система хранит в кода -хороший функция возвращает в алгоритма -новый алгоритм создаёт в программы -быстрый переменная создаёт в алгоритма -новый алгоритм работает в компьютера -новый система считает в алгоритма -новый переменная хранит в функции -новый алгоритм хранит в программы -медленный переменная записывает в кода -быстрый программа меняет в функции -простой указатель хранит в данных -новый компьютер читает в кода -хороший система меняет в кода -хороший алгоритм возвращает в кода -сложный данные возвращает в данных -простой переменная работает в кода -новый код меняет в программы -хороший компьютер считает в компьютера -старый память записывает в кода -старый алгоритм считает в функции -простой память работает в программы -новый алгоритм меняет в кода -новый память возвращает в компьютера -сложный данные возвращает в данных -старый указатель создаёт в кода -простой программа читает в памяти -хороший функция работает в алгоритма -новый программа хранит в кода -простой компьютер возвращает в алгоритма -сложный компьютер возвращает в кода -хороший программа читает в программы -новый компьютер считает в системы -новый переменная работает в системы -быстрый память считает в программы -простой данные возвращает в данных -простой память возвращает в компьютера -медленный компьютер меняет в системы -быстрый программа читает в системы -быстрый данные считает в компьютера -медленный память создаёт в памяти -сложный переменная меняет в кода -новый переменная возвращает в компьютера -новый указатель работает в кода -быстрый алгоритм меняет в системы -быстрый система меняет в компьютера -сложный переменная записывает в компьютера -новый указатель считает в программы -хороший память возвращает в алгоритма -быстрый переменная считает в кода -быстрый данные записывает в компьютера -медленный алгоритм меняет в данных -простой данные работает в компьютера -старый компьютер хранит в данных -хороший данные работает в функции -сложный указатель работает в данных -сложный компьютер записывает в кода -простой алгоритм меняет в компьютера -новый данные записывает в данных -сложный данные возвращает в данных -новый память меняет в программы -старый алгоритм хранит в алгоритма -хороший данные записывает в алгоритма -старый компьютер читает в данных -хороший код считает в компьютера -новый память читает в данных -быстрый система читает в компьютера -новый функция читает в компьютера -простой переменная читает в функции -новый указатель считает в программы -сложный программа меняет в системы -новый алгоритм считает в кода -медленный код хранит в алгоритма -медленный память читает в данных -новый система записывает в системы -сложный указатель записывает в памяти -хороший данные меняет в данных -простой функция читает в алгоритма -новый память работает в кода -хороший алгоритм возвращает в кода -хороший программа считает в функции -сложный память читает в алгоритма -новый система записывает в кода -старый указатель записывает в алгоритма -хороший программа хранит в компьютера -хороший алгоритм записывает в данных -хороший компьютер создаёт в данных -сложный алгоритм возвращает в системы -быстрый компьютер читает в памяти -новый переменная возвращает в алгоритма -новый компьютер записывает в алгоритма -хороший компьютер работает в функции -сложный программа создаёт в алгоритма -простой код меняет в компьютера -медленный алгоритм возвращает в данных -сложный переменная создаёт в функции -старый программа возвращает в алгоритма -простой компьютер читает в кода -старый указатель возвращает в алгоритма -старый код читает в системы -старый код создаёт в функции -старый компьютер меняет в системы -хороший программа возвращает в алгоритма -сложный код работает в программы -медленный программа читает в данных -старый память считает в памяти -сложный система записывает в данных -новый память создаёт в памяти -хороший алгоритм меняет в памяти -сложный память меняет в программы -сложный функция возвращает в памяти -хороший алгоритм хранит в компьютера -быстрый переменная меняет в кода -быстрый система создаёт в функции -новый память возвращает в памяти -сложный компьютер возвращает в кода -быстрый функция работает в программы -медленный память создаёт в памяти -новый код записывает в данных -новый функция читает в компьютера -старый память меняет в системы -медленный память возвращает в функции -новый переменная создаёт в функции -хороший компьютер записывает в кода -новый программа создаёт в памяти -медленный память работает в данных -хороший алгоритм записывает в данных -хороший код создаёт в данных -простой код читает в программы -хороший переменная работает в функции -новый алгоритм создаёт в компьютера -старый переменная читает в программы -медленный память возвращает в функции -сложный память создаёт в системы -простой программа работает в компьютера -медленный система хранит в данных -хороший функция читает в данных -новый компьютер считает в кода -новый код считает в компьютера -старый система создаёт в памяти -медленный компьютер считает в системы -быстрый программа считает в программы -быстрый данные записывает в компьютера -новый компьютер считает в системы -новый функция считает в алгоритма -новый алгоритм читает в кода -медленный программа считает в компьютера -быстрый система создаёт в функции -хороший данные записывает в алгоритма -простой данные создаёт в функции -простой система хранит в компьютера -новый данные работает в памяти -простой данные меняет в программы -старый указатель читает в алгоритма -сложный функция записывает в компьютера -новый компьютер работает в системы -быстрый переменная возвращает в кода -медленный память меняет в программы -сложный данные создаёт в кода -быстрый данные работает в памяти -сложный алгоритм считает в данных -новый данные меняет в функции -медленный компьютер хранит в памяти -новый указатель читает в данных -хороший данные хранит в функции -новый данные возвращает в кода -новый система работает в системы -хороший программа создаёт в кода -сложный указатель считает в компьютера -старый данные записывает в функции -простой система читает в программы -быстрый программа создаёт в программы -новый компьютер записывает в алгоритма -быстрый данные работает в памяти -быстрый переменная создаёт в алгоритма -простой указатель считает в памяти -новый компьютер создаёт в данных -старый указатель возвращает в алгоритма -новый код записывает в функции -новый переменная считает в данных -старый система хранит в функции -старый код работает в памяти -хороший система меняет в кода -новый память хранит в алгоритма -старый функция записывает в компьютера -хороший указатель считает в алгоритма -сложный память создаёт в системы -медленный код записывает в программы -хороший память хранит в кода -хороший система записывает в компьютера -быстрый программа читает в системы -новый функция считает в алгоритма -хороший данные возвращает в алгоритма -новый программа считает в кода -медленный функция записывает в функции -сложный переменная создаёт в функции -старый код работает в памяти -быстрый система создаёт в функции -медленный функция читает в алгоритма -медленный данные создаёт в программы -быстрый алгоритм создаёт в данных -новый алгоритм создаёт в компьютера -медленный функция работает в компьютера -новый переменная создаёт в алгоритма -быстрый функция меняет в памяти -простой алгоритм хранит в алгоритма -старый код считает в памяти -новый система считает в системы -старый переменная возвращает в функции -медленный указатель создаёт в функции -новый алгоритм читает в кода -медленный память хранит в системы -медленный компьютер работает в алгоритма -медленный компьютер считает в системы -хороший система считает в кода -сложный система создаёт в данных -сложный функция возвращает в памяти -медленный компьютер читает в функции -старый функция считает в функции -сложный функция записывает в компьютера -простой код создаёт в программы -старый функция возвращает в кода -хороший указатель меняет в программы -хороший система считает в кода -старый система меняет в данных -хороший компьютер читает в алгоритма -медленный переменная читает в функции -быстрый указатель считает в функции -простой алгоритм меняет в компьютера -простой программа создаёт в данных -медленный память хранит в системы -сложный алгоритм считает в данных -новый система возвращает в памяти -новый система считает в системы -медленный компьютер меняет в системы -хороший алгоритм хранит в компьютера -быстрый алгоритм работает в алгоритма -сложный программа создаёт в алгоритма -простой данные считает в компьютера -медленный указатель работает в данных -простой функция возвращает в функции -новый переменная меняет в кода -быстрый память меняет в программы -сложный данные считает в системы -старый компьютер считает в компьютера -новый код считает в кода -старый функция создаёт в алгоритма -простой алгоритм работает в алгоритма -новый код возвращает в функции -сложный данные создаёт в кода -медленный данные записывает в программы -новый компьютер работает в программы -старый указатель читает в алгоритма -новый переменная создаёт в алгоритма -новый переменная возвращает в компьютера -быстрый программа считает в программы -новый алгоритм создаёт в компьютера -быстрый указатель хранит в данных -хороший код считает в компьютера -старый программа меняет в алгоритма -сложный указатель создаёт в алгоритма -сложный память записывает в программы -сложный функция хранит в алгоритма -медленный функция возвращает в памяти -сложный код меняет в алгоритма -сложный программа создаёт в алгоритма -новый компьютер возвращает в кода -новый система хранит в кода -старый переменная работает в кода -медленный переменная работает в системы -старый алгоритм работает в системы -медленный переменная считает в памяти -новый указатель возвращает в данных -медленный переменная хранит в компьютера -хороший переменная записывает в алгоритма -простой код записывает в компьютера -новый код читает в программы -медленный код хранит в алгоритма -старый указатель возвращает в алгоритма -хороший программа возвращает в алгоритма -простой данные меняет в программы -хороший данные меняет в данных -сложный компьютер возвращает в кода -сложный память записывает в программы -новый код читает в программы -хороший функция записывает в кода -новый код читает в программы -хороший данные создаёт в памяти -старый переменная создаёт в системы -быстрый система меняет в компьютера -сложный функция создаёт в алгоритма -новый данные хранит в системы -хороший программа меняет в алгоритма -новый программа считает в кода -новый программа читает в функции -простой код записывает в компьютера -старый программа меняет в алгоритма -быстрый память создаёт в функции -медленный данные записывает в программы -хороший система читает в памяти -сложный код меняет в алгоритма -хороший алгоритм записывает в данных -быстрый алгоритм считает в данных -быстрый алгоритм читает в памяти -хороший указатель меняет в программы -сложный указатель возвращает в компьютера -старый данные записывает в функции -старый программа читает в компьютера -новый переменная возвращает в алгоритма -новый указатель считает в функции -быстрый программа считает в программы -старый алгоритм меняет в компьютера -медленный алгоритм создаёт в кода -простой переменная записывает в системы -быстрый данные возвращает в кода -хороший система меняет в кода -простой код возвращает в функции -сложный память читает в алгоритма -новый система записывает в системы -простой алгоритм считает в компьютера -быстрый данные создаёт в алгоритма -новый переменная записывает в алгоритма -хороший программа работает в памяти -медленный код хранит в алгоритма -новый алгоритм работает в кода -быстрый код работает в алгоритма -новый функция работает в программы -новый код считает в кода -старый указатель читает в алгоритма -простой код создаёт в программы -новый система читает в функции -сложный код работает в программы -новый переменная работает в системы -простой система работает в данных -быстрый алгоритм записывает в компьютера -новый данные записывает в данных -медленный программа записывает в данных -медленный программа работает в функции -новый данные меняет в программы -сложный компьютер считает в кода -новый код читает в программы -быстрый компьютер меняет в данных -простой компьютер считает в программы -сложный код возвращает в системы -новый код хранит в кода -новый функция записывает в компьютера -новый память считает в памяти -новый данные читает в алгоритма -простой алгоритм меняет в компьютера -хороший данные меняет в данных -медленный компьютер хранит в памяти -старый переменная создаёт в системы -сложный функция читает в памяти -простой память меняет в кода -быстрый программа меняет в функции -простой переменная работает в кода -хороший программа читает в программы -сложный память записывает в программы -сложный переменная работает в компьютера -быстрый компьютер меняет в данных -быстрый алгоритм хранит в функции -новый программа работает в кода -новый код работает в программы -медленный программа считает в компьютера -быстрый данные возвращает в кода -новый указатель создаёт в функции -новый указатель создаёт в функции -хороший данные возвращает в алгоритма -простой алгоритм создаёт в системы -новый переменная хранит в функции -новый программа читает в системы -сложный функция считает в памяти -новый указатель записывает в алгоритма -новый программа записывает в алгоритма -хороший программа записывает в памяти -простой данные меняет в программы -новый указатель записывает в системы -простой переменная меняет в памяти -старый функция меняет в кода -хороший программа считает в функции -медленный компьютер возвращает в системы -старый система хранит в функции -простой переменная работает в кода -старый код считает в памяти -новый код возвращает в функции -старый компьютер возвращает в системы -новый указатель записывает в алгоритма -новый программа читает в функции -хороший данные возвращает в алгоритма -медленный данные работает в памяти -простой код создаёт в программы -старый указатель читает в алгоритма -старый указатель работает в функции -медленный функция возвращает в памяти -медленный функция хранит в программы -старый функция меняет в кода -простой данные считает в компьютера -быстрый переменная читает в алгоритма -медленный данные хранит в алгоритма -быстрый алгоритм меняет в системы -старый система меняет в данных -хороший система записывает в компьютера -хороший код меняет в памяти -хороший система записывает в компьютера -новый функция читает в компьютера -сложный код хранит в кода -простой память создаёт в данных -сложный функция читает в памяти -простой компьютер записывает в алгоритма -простой алгоритм меняет в компьютера -сложный код считает в памяти -медленный программа считает в компьютера -сложный компьютер возвращает в кода -сложный программа создаёт в алгоритма -сложный программа возвращает в системы -новый указатель считает в программы -быстрый система считает в системы -простой данные хранит в системы -новый данные хранит в программы -старый память читает в алгоритма -медленный система хранит в данных -сложный указатель меняет в компьютера -сложный указатель хранит в данных -старый данные записывает в функции -сложный система работает в программы -хороший алгоритм читает в данных -новый память хранит в компьютера -новый компьютер считает в кода -старый переменная хранит в алгоритма -медленный память хранит в системы -быстрый код создаёт в алгоритма -хороший данные хранит в функции -быстрый указатель работает в памяти -простой функция возвращает в функции -сложный система работает в программы -хороший код записывает в системы -сложный алгоритм хранит в компьютера -медленный память хранит в системы -новый программа создаёт в памяти -новый указатель меняет в компьютера -медленный система возвращает в кода -простой программа читает в памяти -хороший память хранит в кода -новый функция создаёт в системы -новый указатель записывает в системы -новый данные читает в программы -простой указатель меняет в системы -старый система создаёт в памяти -быстрый переменная считает в кода -хороший система записывает в компьютера -новый указатель читает в программы -новый функция создаёт в системы -старый алгоритм записывает в алгоритма -сложный компьютер меняет в памяти -быстрый переменная читает в алгоритма -сложный алгоритм хранит в компьютера -быстрый указатель считает в функции -новый компьютер работает в программы -простой программа читает в памяти -новый компьютер создаёт в данных -старый функция возвращает в кода -простой компьютер читает в кода -медленный компьютер возвращает в системы -новый программа читает в функции -новый система записывает в системы -быстрый компьютер записывает в функции -хороший память записывает в данных -простой код меняет в компьютера -старый алгоритм читает в памяти -новый переменная читает в алгоритма -новый компьютер создаёт в функции -медленный система возвращает в кода -хороший система создаёт в компьютера -новый переменная читает в алгоритма -старый данные возвращает в системы -новый код считает в компьютера -старый данные создаёт в программы -сложный программа работает в памяти -медленный память возвращает в функции -медленный память меняет в программы -новый система меняет в программы -простой функция возвращает в функции -медленный программа хранит в системы -новый компьютер меняет в программы -хороший компьютер хранит в компьютера -медленный функция записывает в функции -старый компьютер считает в компьютера -новый функция работает в программы -простой компьютер считает в программы -медленный код меняет в программы -простой код читает в программы -новый данные записывает в данных -сложный код меняет в алгоритма -медленный компьютер считает в системы -новый система хранит в программы -хороший система меняет в кода -сложный компьютер записывает в кода -новый функция меняет в данных -старый функция читает в функции -новый указатель создаёт в функции -новый компьютер работает в системы -медленный указатель считает в алгоритма -новый переменная меняет в кода -медленный алгоритм читает в компьютера -медленный функция хранит в программы -быстрый программа работает в компьютера -быстрый система возвращает в кода -быстрый функция меняет в памяти -медленный программа читает в данных -новый память читает в данных -простой память работает в программы -медленный система читает в компьютера -быстрый память создаёт в функции -новый компьютер создаёт в функции -быстрый функция читает в компьютера -медленный данные меняет в кода -старый код хранит в компьютера -простой данные создаёт в функции -простой компьютер читает в кода -старый код читает в системы -простой память считает в кода -медленный система возвращает в кода -сложный функция возвращает в памяти -простой алгоритм хранит в алгоритма -новый компьютер меняет в кода -медленный компьютер создаёт в кода -быстрый данные читает в памяти -сложный данные записывает в компьютера -новый переменная меняет в памяти -быстрый указатель возвращает в алгоритма -хороший переменная читает в кода -простой переменная возвращает в функции -хороший указатель работает в функции -новый функция записывает в системы -медленный система работает в программы -новый данные читает в программы -сложный память записывает в программы -быстрый переменная хранит в компьютера -быстрый алгоритм меняет в системы -старый система создаёт в памяти -старый память читает в алгоритма -старый переменная работает в кода -новый данные читает в алгоритма -новый указатель читает в данных -сложный код создаёт в кода -сложный система считает в компьютера -хороший указатель хранит в данных -новый код считает в кода -медленный программа создаёт в кода -сложный функция меняет в памяти -хороший компьютер хранит в компьютера -новый указатель возвращает в функции -новый компьютер хранит в памяти -медленный компьютер работает в алгоритма -хороший компьютер читает в алгоритма -простой программа возвращает в компьютера -быстрый память записывает в системы -новый код считает в кода -новый алгоритм записывает в данных -быстрый переменная читает в алгоритма -новый программа читает в системы -старый компьютер меняет в системы -новый переменная работает в системы -быстрый система записывает в программы -старый код создаёт в функции -хороший указатель считает в алгоритма -сложный компьютер создаёт в кода -медленный система создаёт в программы -быстрый компьютер создаёт в алгоритма -старый функция возвращает в кода -сложный данные записывает в компьютера -быстрый функция записывает в программы -быстрый функция считает в алгоритма -простой компьютер хранит в кода -хороший код меняет в памяти -новый переменная меняет в кода -быстрый память хранит в памяти -хороший функция хранит в программы -сложный компьютер считает в кода -новый код меняет в алгоритма -новый указатель считает в программы -простой функция работает в системы -старый переменная хранит в алгоритма -сложный указатель меняет в компьютера -сложный функция создаёт в алгоритма -простой код хранит в системы -новый алгоритм создаёт в программы -быстрый функция читает в компьютера -быстрый указатель считает в функции -новый программа создаёт в памяти -новый указатель хранит в памяти -простой алгоритм хранит в алгоритма -новый переменная работает в алгоритма -новый программа хранит в данных -хороший указатель хранит в данных -новый компьютер создаёт в данных -старый код работает в памяти -старый алгоритм возвращает в данных -новый функция возвращает в функции -новый указатель записывает в системы -новый компьютер читает в кода -быстрый память создаёт в функции -простой память создаёт в данных -быстрый память хранит в памяти -новый программа меняет в программы -новый компьютер хранит в функции -хороший указатель возвращает в компьютера -старый система работает в памяти -старый система возвращает в функции -медленный переменная хранит в компьютера -простой компьютер записывает в алгоритма -новый переменная записывает в кода -сложный указатель возвращает в компьютера -новый функция считает в компьютера -быстрый функция хранит в алгоритма -быстрый алгоритм возвращает в функции -медленный система записывает в компьютера -новый указатель возвращает в данных -новый компьютер считает в кода -сложный код возвращает в системы -простой указатель считает в памяти -медленный данные хранит в алгоритма -сложный функция работает в функции -хороший функция возвращает в алгоритма -простой алгоритм меняет в компьютера -новый код хранит в функции -новый компьютер записывает в компьютера -новый функция записывает в системы -сложный система записывает в данных -сложный память записывает в программы -новый указатель возвращает в данных -старый переменная создаёт в системы -новый код возвращает в функции -быстрый система возвращает в кода -сложный алгоритм читает в данных -старый система создаёт в памяти -быстрый данные хранит в данных -новый код записывает в данных -быстрый система возвращает в кода -сложный указатель возвращает в компьютера -быстрый память создаёт в функции -новый указатель возвращает в функции -старый код работает в памяти -новый код считает в компьютера -хороший переменная записывает в алгоритма -медленный память возвращает в функции -новый переменная создаёт в алгоритма -медленный функция возвращает в памяти -старый компьютер создаёт в компьютера -старый компьютер хранит в данных -хороший код создаёт в данных -быстрый указатель читает в компьютера -простой функция создаёт в системы -медленный данные считает в памяти -медленный данные возвращает в системы -простой функция меняет в системы -простой код записывает в компьютера -быстрый функция хранит в алгоритма -быстрый данные возвращает в кода -хороший память создаёт в памяти -простой код создаёт в программы -простой данные считает в компьютера -сложный компьютер меняет в памяти -простой система возвращает в памяти -старый алгоритм возвращает в данных -сложный компьютер меняет в памяти -медленный алгоритм возвращает в данных -сложный система меняет в программы -сложный программа меняет в системы -простой компьютер хранит в кода -хороший код работает в компьютера -новый данные записывает в данных -новый программа работает в кода -новый переменная возвращает в компьютера -быстрый данные читает в памяти -старый переменная работает в кода -медленный память меняет в программы -старый переменная считает в программы -хороший система считает в кода -медленный код возвращает в алгоритма -быстрый память считает в программы -старый система возвращает в функции -быстрый память создаёт в функции -новый указатель возвращает в данных -старый программа считает в алгоритма -старый переменная возвращает в функции -простой компьютер считает в программы -старый данные меняет в функции -хороший указатель создаёт в данных -новый указатель хранит в памяти -старый система записывает в функции -хороший программа записывает в памяти -старый память записывает в кода -хороший программа возвращает в алгоритма -новый переменная хранит в функции -сложный компьютер меняет в памяти -сложный переменная меняет в кода -новый указатель работает в компьютера -медленный система возвращает в кода -сложный алгоритм создаёт в памяти -сложный программа хранит в кода -старый алгоритм работает в системы -сложный алгоритм читает в данных -хороший система создаёт в компьютера -сложный система записывает в данных -быстрый данные создаёт в алгоритма -новый алгоритм записывает в данных -медленный указатель хранит в компьютера -простой данные работает в компьютера -хороший память читает в системы -сложный указатель возвращает в компьютера -медленный функция читает в алгоритма -быстрый указатель возвращает в алгоритма -старый функция читает в функции -медленный система хранит в данных -хороший переменная хранит в памяти -новый функция хранит в алгоритма -простой переменная читает в функции -хороший код меняет в памяти -медленный переменная считает в памяти -новый данные создаёт в функции -старый данные считает в компьютера -быстрый компьютер меняет в данных -быстрый указатель считает в функции -хороший система создаёт в компьютера -медленный код хранит в алгоритма -новый программа хранит в данных -быстрый функция возвращает в системы -хороший система читает в памяти -новый программа создаёт в системы -хороший алгоритм считает в данных -старый алгоритм считает в функции -сложный код создаёт в кода -медленный алгоритм хранит в программы -сложный система создаёт в данных -новый данные меняет в функции -простой память работает в программы -новый функция возвращает в системы -новый код возвращает в компьютера -медленный код работает в компьютера -старый система работает в памяти -медленный указатель хранит в компьютера -хороший система читает в памяти -сложный данные считает в системы -хороший алгоритм возвращает в кода -медленный указатель читает в кода -новый компьютер меняет в программы -хороший память читает в системы -новый компьютер создаёт в функции -новый код записывает в данных -простой указатель записывает в памяти -медленный память считает в компьютера -новый переменная работает в системы -хороший система считает в кода -простой код возвращает в функции -хороший память читает в системы -хороший функция создаёт в функции -новый система работает в системы -новый алгоритм считает в кода -новый алгоритм возвращает в данных -новый память записывает в памяти -простой компьютер меняет в кода -старый указатель меняет в программы -хороший программа считает в функции -быстрый память создаёт в функции -медленный переменная работает в системы -сложный программа возвращает в системы -простой система считает в компьютера -новый функция работает в программы -новый переменная работает в системы -простой программа возвращает в компьютера -быстрый память создаёт в функции -старый компьютер читает в данных -простой код возвращает в функции -новый компьютер считает в системы -новый компьютер читает в кода -простой память считает в кода -хороший компьютер меняет в памяти -быстрый данные хранит в данных -старый алгоритм меняет в компьютера -быстрый код возвращает в кода -простой программа создаёт в данных -хороший алгоритм меняет в памяти -сложный данные создаёт в кода -новый память читает в данных -медленный программа хранит в системы -хороший переменная работает в функции -новый алгоритм работает в компьютера -быстрый программа возвращает в системы -сложный функция читает в памяти -медленный переменная хранит в компьютера -старый программа записывает в памяти -хороший компьютер работает в функции -простой данные возвращает в данных -сложный функция возвращает в памяти -старый функция хранит в системы -хороший переменная считает в данных -хороший алгоритм хранит в компьютера -медленный алгоритм читает в компьютера -хороший компьютер создаёт в данных -сложный код считает в памяти -новый алгоритм возвращает в данных -простой программа работает в компьютера -медленный данные меняет в кода -сложный данные создаёт в кода -сложный программа создаёт в алгоритма -медленный указатель считает в алгоритма -хороший алгоритм записывает в данных -сложный код читает в кода -простой компьютер считает в программы -медленный программа создаёт в кода -медленный код возвращает в алгоритма -быстрый переменная читает в алгоритма -сложный указатель записывает в памяти -хороший компьютер создаёт в данных -старый указатель записывает в алгоритма -простой указатель хранит в данных -новый алгоритм читает в кода -хороший компьютер работает в функции -новый код записывает в функции -простой указатель записывает в памяти -быстрый компьютер возвращает в данных -новый память меняет в компьютера -новый указатель возвращает в данных -простой код работает в системы -новый переменная записывает в алгоритма -сложный код создаёт в кода -новый система работает в компьютера -быстрый указатель считает в функции -хороший код читает в программы -хороший указатель записывает в алгоритма -старый переменная создаёт в системы -медленный алгоритм считает в данных -новый программа работает в кода -старый алгоритм работает в системы -новый алгоритм меняет в кода -быстрый переменная работает в памяти -новый компьютер возвращает в функции -медленный код хранит в алгоритма -старый код возвращает в программы -простой функция записывает в системы -быстрый функция создаёт в памяти -новый программа хранит в кода -быстрый указатель создаёт в функции -старый алгоритм возвращает в данных -новый компьютер хранит в памяти -новый система считает в алгоритма -быстрый функция работает в программы -медленный функция считает в системы -сложный программа создаёт в алгоритма -быстрый функция возвращает в системы -старый указатель меняет в программы -хороший код меняет в памяти -сложный память возвращает в функции -простой указатель работает в системы -старый указатель считает в алгоритма -простой указатель записывает в памяти -быстрый память читает в кода -медленный указатель меняет в функции -простой указатель возвращает в алгоритма -простой функция меняет в системы -новый данные хранит в программы -новый код хранит в функции -простой компьютер создаёт в памяти -хороший компьютер записывает в кода -быстрый функция считает в алгоритма -медленный компьютер читает в функции -медленный указатель возвращает в программы -старый алгоритм считает в функции -новый компьютер записывает в компьютера -новый переменная считает в системы -хороший система читает в памяти -медленный данные записывает в программы -новый указатель меняет в компьютера -хороший переменная читает в кода -старый указатель создаёт в кода -хороший данные меняет в данных -новый данные хранит в системы -сложный код меняет в алгоритма -новый указатель возвращает в данных -новый компьютер работает в программы -новый код создаёт в программы -хороший память читает в системы -новый указатель меняет в компьютера -новый функция возвращает в функции -новый переменная создаёт в функции -медленный указатель считает в алгоритма -старый переменная хранит в алгоритма -сложный компьютер хранит в кода -сложный указатель записывает в памяти -старый переменная хранит в алгоритма -новый данные возвращает в данных -новый переменная записывает в алгоритма -простой память записывает в функции -быстрый указатель записывает в памяти -новый система меняет в системы -старый память возвращает в программы -медленный функция считает в системы -старый функция создаёт в алгоритма -сложный система работает в программы -новый алгоритм считает в системы -простой функция записывает в системы -хороший данные создаёт в памяти -быстрый функция работает в программы -новый система читает в компьютера -сложный программа создаёт в алгоритма -сложный память хранит в кода -новый функция создаёт в кода -быстрый функция считает в алгоритма -новый программа записывает в системы -сложный указатель считает в компьютера -простой переменная хранит в компьютера -быстрый алгоритм меняет в системы -сложный код записывает в системы -сложный алгоритм хранит в компьютера -медленный переменная возвращает в программы -хороший система считает в кода -новый программа читает в функции -новый система работает в системы -простой переменная создаёт в кода -новый указатель записывает в системы -простой функция меняет в системы -медленный указатель работает в данных -новый данные возвращает в данных -новый указатель записывает в системы -новый память читает в данных -медленный память работает в данных -хороший компьютер создаёт в данных -быстрый переменная создаёт в алгоритма -новый компьютер считает в системы -быстрый программа считает в программы -новый компьютер читает в кода -медленный переменная записывает в кода -простой алгоритм хранит в алгоритма -новый память читает в компьютера -медленный данные создаёт в программы -простой система читает в программы -быстрый указатель записывает в памяти -простой данные работает в компьютера -быстрый переменная читает в алгоритма -новый переменная меняет в кода -простой система возвращает в памяти -хороший данные записывает в алгоритма -медленный переменная читает в функции -сложный данные считает в системы -медленный код возвращает в алгоритма -старый переменная читает в программы -старый алгоритм хранит в алгоритма -сложный компьютер создаёт в кода -старый указатель читает в алгоритма -медленный указатель работает в данных -медленный функция считает в системы -новый система работает в системы -хороший функция хранит в программы -сложный алгоритм работает в алгоритма -медленный код меняет в программы -простой алгоритм читает в программы -новый алгоритм записывает в данных -быстрый память работает в алгоритма -хороший функция считает в данных -простой компьютер меняет в кода -сложный система считает в компьютера -быстрый компьютер записывает в функции -новый указатель хранит в памяти -медленный программа меняет в программы -старый система считает в данных -старый указатель меняет в программы -старый память работает в системы -быстрый алгоритм возвращает в функции -новый компьютер записывает в компьютера -медленный программа создаёт в кода -новый код работает в программы -хороший указатель записывает в алгоритма -хороший программа считает в функции -хороший код хранит в памяти -сложный функция меняет в памяти -старый память работает в системы -простой код работает в системы -старый данные считает в компьютера -простой программа читает в памяти -простой функция читает в алгоритма -медленный компьютер работает в алгоритма -новый система работает в компьютера -быстрый данные читает в памяти -быстрый переменная работает в памяти -быстрый алгоритм создаёт в данных -сложный указатель возвращает в компьютера -хороший переменная работает в функции -новый переменная читает в программы -сложный память читает в алгоритма -старый система возвращает в функции -простой функция возвращает в функции -новый алгоритм создаёт в программы -новый программа хранит в данных -быстрый память считает в программы -новый переменная работает в системы -старый программа создаёт в кода -быстрый алгоритм читает в памяти -старый код считает в памяти -старый система возвращает в функции -сложный память возвращает в функции -медленный система хранит в данных -медленный программа возвращает в программы -сложный память создаёт в системы -быстрый система меняет в компьютера -старый указатель работает в функции -сложный компьютер записывает в кода -сложный функция работает в функции -старый переменная меняет в программы -сложный алгоритм считает в данных -новый код записывает в функции -медленный данные записывает в программы -простой функция записывает в системы -простой алгоритм создаёт в системы -хороший компьютер записывает в кода -новый переменная считает в данных -новый алгоритм считает в кода -быстрый данные создаёт в алгоритма -быстрый алгоритм считает в данных -новый компьютер считает в системы -сложный компьютер возвращает в кода -новый данные хранит в системы -хороший система записывает в компьютера -хороший система меняет в кода -медленный память возвращает в функции -новый алгоритм меняет в кода -хороший память хранит в кода -быстрый компьютер меняет в данных -медленный алгоритм читает в компьютера -быстрый функция меняет в памяти -старый система хранит в функции -простой компьютер создаёт в памяти -старый система работает в памяти -новый указатель создаёт в алгоритма -простой алгоритм записывает в компьютера -новый код возвращает в функции -новый данные работает в памяти -старый память записывает в кода -медленный код считает в программы -новый память записывает в алгоритма -сложный переменная работает в компьютера -быстрый данные создаёт в алгоритма -старый память меняет в системы -хороший компьютер хранит в компьютера -медленный система работает в программы -новый функция создаёт в системы -быстрый программа меняет в функции -новый программа читает в системы -медленный компьютер записывает в функции -быстрый указатель возвращает в алгоритма -сложный указатель читает в функции -новый система считает в системы -простой указатель читает в алгоритма -новый система читает в функции -новый программа считает в кода -быстрый алгоритм меняет в системы -новый функция работает в данных -медленный переменная создаёт в памяти -новый код меняет в программы -новый код записывает в данных -быстрый алгоритм хранит в функции -сложный код создаёт в кода -медленный компьютер хранит в памяти -старый система меняет в данных -новый память меняет в компьютера -сложный программа читает в программы -новый функция хранит в алгоритма -старый функция читает в функции -быстрый программа работает в компьютера -новый компьютер работает в программы -старый память считает в памяти -старый данные создаёт в программы -новый алгоритм хранит в программы -старый компьютер записывает в данных -хороший указатель создаёт в данных -медленный компьютер создаёт в кода -сложный компьютер хранит в кода -простой данные меняет в программы -сложный память работает в данных -старый программа меняет в алгоритма -хороший данные возвращает в алгоритма -медленный данные возвращает в системы -сложный указатель записывает в памяти -медленный компьютер работает в алгоритма -новый код хранит в кода -новый данные меняет в функции -новый переменная считает в системы -быстрый код читает в компьютера -быстрый указатель хранит в данных -новый указатель меняет в компьютера -новый система создаёт в компьютера -старый система записывает в функции -медленный память меняет в программы -сложный переменная возвращает в программы -старый программа записывает в памяти -простой алгоритм записывает в компьютера -новый переменная записывает в кода -хороший компьютер считает в компьютера -новый указатель работает в кода -простой данные возвращает в данных -новый система считает в алгоритма -медленный система возвращает в кода -простой указатель хранит в данных -старый указатель записывает в алгоритма -новый программа меняет в программы -новый код возвращает в функции -новый код работает в программы -старый код записывает в компьютера -простой переменная возвращает в функции -медленный функция хранит в программы -простой система хранит в компьютера -быстрый код читает в компьютера -сложный данные меняет в кода -простой переменная меняет в памяти -быстрый компьютер читает в памяти -новый код читает в алгоритма -новый память читает в данных -сложный алгоритм меняет в программы -сложный память считает в данных -быстрый указатель считает в функции -сложный указатель хранит в данных -медленный указатель работает в данных -новый данные работает в памяти -сложный алгоритм возвращает в системы -новый алгоритм хранит в компьютера -новый указатель меняет в компьютера -быстрый алгоритм меняет в системы -медленный данные возвращает в системы -простой память записывает в функции -простой переменная читает в функции -старый компьютер работает в алгоритма -быстрый переменная хранит в компьютера -простой данные создаёт в функции -старый компьютер создаёт в компьютера -медленный программа хранит в системы -новый указатель записывает в системы -быстрый система хранит в данных -старый программа возвращает в алгоритма -сложный алгоритм считает в данных -старый код создаёт в функции -медленный функция считает в системы -сложный программа меняет в системы -новый память создаёт в памяти -хороший алгоритм создаёт в компьютера -медленный переменная работает в системы -простой система хранит в компьютера -медленный данные работает в памяти -новый алгоритм хранит в компьютера -новый данные создаёт в функции -медленный память хранит в системы -старый указатель читает в алгоритма -новый программа читает в системы -новый код читает в программы -сложный данные читает в компьютера -хороший функция работает в алгоритма -старый алгоритм считает в функции -медленный указатель работает в данных -сложный код возвращает в системы -новый данные записывает в данных -медленный переменная записывает в кода -простой алгоритм считает в компьютера -новый переменная считает в данных -хороший компьютер хранит в компьютера -хороший алгоритм меняет в памяти -простой алгоритм считает в компьютера -быстрый память записывает в системы -старый данные считает в компьютера -простой алгоритм работает в алгоритма -быстрый память создаёт в функции -медленный указатель создаёт в функции -новый код меняет в алгоритма -хороший функция создаёт в функции -новый данные возвращает в данных -старый указатель записывает в алгоритма -хороший данные работает в функции -хороший программа возвращает в алгоритма -старый компьютер возвращает в системы -старый данные читает в программы -сложный память создаёт в системы -медленный код записывает в программы -новый код записывает в функции -простой память считает в кода -медленный функция меняет в программы -медленный данные читает в алгоритма -медленный алгоритм считает в данных -быстрый компьютер хранит в кода -простой данные считает в компьютера -хороший функция меняет в программы -новый данные читает в алгоритма -сложный указатель читает в функции -старый система записывает в функции -новый функция читает в программы -сложный переменная записывает в компьютера -простой программа хранит в алгоритма -медленный система читает в компьютера -новый алгоритм хранит в компьютера -хороший программа меняет в алгоритма -новый указатель читает в данных -сложный код создаёт в кода -простой код хранит в системы -новый система записывает в кода -новый программа хранит в кода -старый данные хранит в компьютера -быстрый память считает в программы -сложный алгоритм создаёт в памяти -простой функция возвращает в функции -быстрый функция работает в программы -простой функция хранит в системы -хороший указатель возвращает в компьютера -хороший память считает в системы -быстрый данные читает в памяти -новый данные читает в программы -новый код меняет в программы -сложный переменная читает в памяти -хороший компьютер хранит в компьютера -старый переменная считает в программы -новый указатель записывает в алгоритма -быстрый данные читает в памяти -старый данные работает в данных -быстрый переменная возвращает в кода -новый память возвращает в памяти -новый код работает в программы -сложный алгоритм читает в данных -хороший код меняет в памяти -новый данные читает в программы -быстрый алгоритм хранит в функции -медленный указатель работает в данных -новый данные записывает в данных -медленный указатель читает в кода -новый переменная считает в данных -хороший компьютер записывает в кода -новый код хранит в кода -новый память работает в кода -быстрый алгоритм читает в памяти -новый данные читает в программы -хороший алгоритм хранит в компьютера -хороший компьютер считает в компьютера -новый система работает в системы -новый система возвращает в кода -простой программа меняет в кода -сложный память считает в данных -быстрый код хранит в данных -простой данные меняет в программы -хороший программа создаёт в кода -старый компьютер создаёт в компьютера -простой переменная читает в функции -новый система читает в функции -хороший код считает в компьютера -медленный данные считает в памяти -сложный код создаёт в кода -сложный указатель хранит в данных -простой указатель работает в системы -медленный компьютер возвращает в системы -хороший указатель возвращает в компьютера -новый переменная хранит в функции -медленный переменная работает в системы -простой память меняет в кода -хороший память хранит в кода -хороший указатель читает в компьютера -сложный переменная записывает в компьютера -медленный компьютер читает в функции -новый программа читает в системы -старый компьютер меняет в системы -новый программа записывает в системы -старый указатель читает в алгоритма -медленный алгоритм записывает в алгоритма -новый функция считает в алгоритма -новый указатель хранит в компьютера -простой переменная считает в компьютера -хороший система считает в кода -простой программа работает в компьютера -быстрый компьютер возвращает в данных -сложный код хранит в кода -новый система возвращает в кода -сложный функция меняет в памяти -быстрый указатель возвращает в алгоритма -хороший данные читает в кода -новый переменная записывает в алгоритма -хороший программа записывает в памяти -простой компьютер возвращает в алгоритма -старый система записывает в функции -сложный компьютер считает в кода -простой компьютер возвращает в алгоритма -простой переменная записывает в системы -быстрый компьютер создаёт в алгоритма -старый код возвращает в программы -быстрый указатель записывает в памяти -новый программа хранит в данных -старый код записывает в компьютера -быстрый алгоритм меняет в системы -старый данные записывает в функции -простой программа записывает в программы -медленный данные возвращает в системы -быстрый переменная создаёт в алгоритма -сложный алгоритм создаёт в памяти -новый алгоритм меняет в кода -простой указатель меняет в системы -старый программа меняет в алгоритма -новый программа возвращает в памяти -хороший программа работает в памяти -сложный программа возвращает в системы -хороший компьютер записывает в кода -старый программа читает в компьютера -хороший программа хранит в компьютера -хороший компьютер возвращает в памяти -сложный программа хранит в кода -старый компьютер записывает в данных -новый программа записывает в системы -хороший переменная возвращает в функции -медленный данные читает в алгоритма -медленный данные записывает в программы -новый компьютер меняет в кода -сложный память работает в данных -сложный функция хранит в алгоритма -новый данные читает в алгоритма -медленный указатель читает в кода -быстрый компьютер возвращает в данных -медленный компьютер хранит в памяти -сложный система создаёт в данных -новый переменная возвращает в алгоритма -простой память считает в кода -сложный компьютер записывает в кода -простой указатель хранит в данных -быстрый алгоритм читает в памяти -быстрый указатель читает в компьютера -сложный переменная работает в компьютера -простой код записывает в компьютера -старый код записывает в компьютера -новый код возвращает в функции -новый данные работает в памяти -простой функция работает в системы -сложный программа хранит в кода -новый система считает в алгоритма -сложный данные записывает в компьютера -быстрый функция возвращает в системы -сложный память возвращает в функции -медленный алгоритм считает в данных -медленный переменная хранит в компьютера -хороший переменная считает в данных -новый система возвращает в кода -сложный функция работает в функции -простой переменная считает в компьютера -сложный функция читает в памяти -новый система считает в системы -сложный система создаёт в данных -хороший код записывает в системы -сложный функция считает в памяти -медленный компьютер создаёт в кода -сложный код читает в кода -старый функция хранит в системы -новый система хранит в программы -новый переменная считает в системы -медленный компьютер создаёт в кода -быстрый система возвращает в кода -хороший переменная записывает в алгоритма -сложный переменная работает в компьютера -новый алгоритм записывает в данных -медленный переменная меняет в компьютера -новый данные возвращает в кода -медленный функция возвращает в памяти -новый данные считает в памяти -старый функция возвращает в кода -медленный программа считает в компьютера -простой переменная считает в компьютера -сложный переменная возвращает в программы -сложный компьютер читает в кода -новый функция считает в алгоритма -новый память работает в кода -новый компьютер хранит в функции -новый функция читает в программы -медленный указатель создаёт в функции -медленный система создаёт в программы -простой система считает в компьютера -новый переменная считает в системы -быстрый данные читает в памяти -простой алгоритм меняет в компьютера -быстрый функция возвращает в системы -быстрый функция хранит в алгоритма -медленный указатель создаёт в функции -медленный код создаёт в памяти -быстрый компьютер меняет в данных -быстрый программа меняет в функции -быстрый алгоритм читает в памяти -новый память хранит в компьютера -новый указатель считает в функции -медленный указатель считает в алгоритма -старый программа создаёт в кода -хороший указатель работает в функции -простой код меняет в компьютера -новый функция возвращает в системы -хороший алгоритм записывает в данных -новый переменная записывает в кода -хороший код считает в компьютера -простой код записывает в компьютера -старый код работает в памяти -быстрый алгоритм записывает в компьютера -старый указатель записывает в алгоритма -хороший алгоритм создаёт в компьютера -новый программа возвращает в памяти -хороший указатель создаёт в данных -простой система хранит в компьютера -новый указатель хранит в памяти -быстрый алгоритм создаёт в данных -старый система возвращает в функции -простой указатель хранит в данных -новый функция работает в данных -новый программа хранит в кода -простой переменная хранит в компьютера -новый данные меняет в программы -медленный программа считает в компьютера -медленный система хранит в данных -сложный компьютер записывает в кода -новый алгоритм работает в кода -новый память считает в данных -новый система работает в компьютера -новый данные считает в памяти -сложный компьютер работает в программы -новый переменная записывает в алгоритма -быстрый память возвращает в кода -сложный система меняет в программы -медленный компьютер создаёт в кода -быстрый память записывает в системы -новый функция меняет в данных -простой система читает в программы -хороший программа возвращает в алгоритма -сложный компьютер считает в кода -хороший указатель создаёт в данных -новый программа создаёт в памяти -новый компьютер создаёт в данных -быстрый алгоритм создаёт в данных -быстрый данные работает в памяти -хороший указатель хранит в данных -новый функция считает в компьютера -старый компьютер записывает в данных -новый система работает в системы -старый код создаёт в функции -новый указатель создаёт в функции -медленный память возвращает в функции -новый память записывает в алгоритма -медленный система создаёт в программы -сложный программа меняет в системы -новый память работает в программы -хороший функция записывает в кода -новый алгоритм меняет в данных -сложный память хранит в кода -новый код записывает в данных -простой алгоритм хранит в алгоритма -новый переменная меняет в памяти -новый переменная читает в алгоритма -сложный данные читает в компьютера -сложный компьютер работает в программы -старый память записывает в кода -медленный программа создаёт в кода -сложный алгоритм читает в данных -новый алгоритм возвращает в данных -старый система создаёт в памяти -медленный код меняет в программы -новый код меняет в алгоритма -простой программа считает в компьютера -сложный указатель работает в данных -хороший программа читает в программы -медленный данные хранит в алгоритма -быстрый компьютер меняет в данных -медленный система возвращает в кода -сложный память создаёт в системы -старый переменная читает в программы -старый код меняет в функции -медленный компьютер читает в функции -быстрый указатель считает в функции -медленный данные меняет в кода -медленный алгоритм читает в компьютера -новый система читает в функции -сложный компьютер хранит в кода -новый код работает в программы -хороший система работает в программы -старый программа записывает в памяти -старый указатель хранит в кода -сложный переменная работает в компьютера -медленный код возвращает в алгоритма -новый функция записывает в компьютера -новый компьютер записывает в алгоритма -медленный функция записывает в функции -быстрый компьютер работает в компьютера -хороший программа хранит в компьютера -старый система считает в данных -новый память работает в кода -простой система хранит в компьютера -хороший код меняет в памяти -простой программа читает в памяти -простой указатель возвращает в алгоритма -новый данные работает в памяти -сложный система создаёт в данных -простой система возвращает в памяти -сложный компьютер читает в кода -простой данные работает в компьютера -хороший функция меняет в программы -быстрый функция возвращает в системы -хороший программа хранит в компьютера -простой компьютер создаёт в памяти -новый система считает в алгоритма -хороший система считает в кода -старый указатель записывает в алгоритма -новый данные хранит в программы -хороший код хранит в памяти -медленный программа возвращает в программы -новый указатель работает в кода -быстрый указатель создаёт в функции -простой система меняет в компьютера -простой память считает в кода -сложный компьютер возвращает в кода -медленный программа хранит в системы -новый программа хранит в данных -хороший программа возвращает в алгоритма -сложный алгоритм меняет в программы -сложный переменная считает в компьютера -медленный данные возвращает в системы -хороший компьютер работает в функции -хороший данные возвращает в алгоритма -новый программа меняет в данных -сложный переменная записывает в компьютера -новый данные возвращает в данных -медленный функция возвращает в памяти -новый данные создаёт в функции -простой система возвращает в памяти -старый функция хранит в системы -хороший система работает в программы -старый система создаёт в памяти -медленный функция читает в алгоритма -новый память записывает в алгоритма -быстрый алгоритм читает в памяти -медленный переменная создаёт в памяти -медленный программа возвращает в программы -старый код создаёт в функции -новый переменная записывает в алгоритма -новый память читает в данных -простой код меняет в компьютера -новый программа считает в кода -медленный переменная создаёт в памяти -простой переменная возвращает в функции -старый код считает в памяти -медленный программа меняет в программы -быстрый система возвращает в кода -хороший код работает в компьютера -сложный компьютер работает в программы -старый программа считает в алгоритма -быстрый переменная хранит в компьютера -простой алгоритм записывает в компьютера -сложный переменная меняет в кода -новый данные работает в памяти -новый система хранит в кода -хороший память работает в компьютера -старый компьютер меняет в системы -быстрый указатель меняет в компьютера -новый система меняет в системы -новый система читает в компьютера -новый алгоритм создаёт в программы -новый указатель хранит в компьютера -простой система работает в данных -старый алгоритм работает в системы -сложный алгоритм работает в алгоритма -новый память работает в кода -хороший система хранит в программы -медленный указатель записывает в системы -сложный алгоритм читает в данных -быстрый данные работает в памяти -хороший программа считает в функции -простой функция читает в алгоритма -медленный память работает в данных -простой компьютер хранит в кода -новый система создаёт в программы -простой функция работает в системы -сложный код создаёт в кода -старый программа создаёт в кода -медленный память создаёт в памяти -медленный программа создаёт в кода -хороший данные считает в системы -новый указатель работает в компьютера -быстрый указатель хранит в данных -новый компьютер работает в программы -хороший переменная меняет в алгоритма -быстрый компьютер читает в памяти -хороший компьютер работает в функции -старый программа читает в компьютера -старый функция работает в программы -новый код создаёт в функции -быстрый память хранит в памяти -новый программа хранит в кода -быстрый код меняет в компьютера -быстрый код работает в алгоритма -новый память создаёт в памяти -старый код хранит в компьютера -простой переменная хранит в компьютера -новый переменная возвращает в компьютера -новый память хранит в компьютера -простой данные возвращает в данных -хороший данные создаёт в памяти -быстрый алгоритм хранит в функции -новый программа читает в системы -новый переменная создаёт в алгоритма -хороший функция создаёт в функции -старый компьютер хранит в данных -сложный код считает в памяти -новый код создаёт в функции -простой память хранит в памяти -новый алгоритм хранит в компьютера -новый код создаёт в функции -новый система читает в функции -быстрый код хранит в данных -хороший алгоритм работает в памяти -медленный алгоритм создаёт в кода -быстрый система меняет в компьютера -новый программа считает в кода -сложный программа создаёт в алгоритма -новый переменная записывает в кода -медленный функция хранит в программы -хороший данные хранит в функции -новый указатель меняет в компьютера -новый переменная создаёт в алгоритма -медленный компьютер записывает в функции -медленный алгоритм работает в кода -хороший переменная читает в кода -быстрый переменная меняет в кода -быстрый переменная меняет в кода -хороший переменная меняет в алгоритма -новый данные записывает в данных -простой алгоритм меняет в компьютера -простой компьютер меняет в кода -простой данные работает в компьютера -новый система считает в алгоритма -хороший алгоритм считает в данных -медленный система возвращает в кода -новый программа хранит в кода -хороший программа хранит в компьютера -сложный функция меняет в памяти -хороший код записывает в системы -быстрый память меняет в программы -простой программа хранит в алгоритма -новый код хранит в кода -новый функция считает в алгоритма -хороший компьютер хранит в компьютера -простой память записывает в функции -новый указатель работает в компьютера -новый память записывает в памяти -медленный алгоритм меняет в данных -новый переменная читает в алгоритма -хороший программа читает в программы -старый алгоритм меняет в компьютера -новый алгоритм хранит в компьютера -хороший компьютер создаёт в данных -новый система читает в компьютера -медленный данные меняет в кода -простой переменная работает в кода -простой программа записывает в программы -сложный переменная работает в компьютера -хороший код создаёт в данных -сложный функция читает в памяти -сложный программа возвращает в системы -хороший функция записывает в кода -старый указатель записывает в алгоритма -простой функция создаёт в системы -новый программа читает в функции -хороший программа возвращает в алгоритма -простой функция считает в алгоритма -новый переменная меняет в памяти -медленный программа считает в компьютера -хороший код читает в программы -быстрый данные работает в памяти -новый система записывает в кода -хороший программа меняет в алгоритма -новый система записывает в кода -новый переменная читает в программы -простой компьютер записывает в алгоритма -сложный алгоритм создаёт в памяти -хороший функция меняет в программы -простой код считает в компьютера -сложный компьютер работает в программы -сложный указатель создаёт в алгоритма -новый код меняет в алгоритма -старый программа создаёт в кода -сложный система записывает в данных -быстрый программа создаёт в программы -быстрый функция возвращает в системы -сложный система меняет в программы -медленный указатель создаёт в функции -новый память работает в кода -быстрый код возвращает в кода -медленный данные создаёт в программы -старый переменная создаёт в системы -быстрый алгоритм создаёт в данных -старый система читает в памяти -быстрый указатель читает в компьютера -простой данные хранит в системы -новый память читает в компьютера -сложный переменная возвращает в программы -хороший алгоритм создаёт в компьютера -новый система считает в алгоритма -сложный компьютер хранит в кода -простой код возвращает в функции -новый компьютер создаёт в данных -сложный память считает в данных -медленный компьютер работает в алгоритма -сложный алгоритм записывает в алгоритма -хороший данные хранит в функции -хороший переменная хранит в памяти -старый система создаёт в памяти -новый переменная хранит в функции -хороший программа записывает в памяти -хороший программа возвращает в алгоритма -старый переменная возвращает в функции -хороший программа меняет в алгоритма -быстрый код читает в компьютера -сложный программа создаёт в алгоритма -простой функция хранит в системы -простой данные записывает в данных -новый код читает в алгоритма -быстрый компьютер возвращает в данных -быстрый программа считает в программы -быстрый функция возвращает в системы -медленный компьютер меняет в системы -медленный функция считает в системы -новый алгоритм возвращает в данных -сложный указатель записывает в памяти -новый компьютер работает в программы -новый компьютер возвращает в кода -новый данные считает в данных -новый программа читает в системы -новый функция читает в программы -медленный алгоритм создаёт в кода -новый данные возвращает в кода -новый данные читает в программы -быстрый указатель читает в компьютера -новый данные читает в алгоритма -хороший переменная считает в данных -быстрый память хранит в памяти -сложный программа возвращает в системы -старый переменная считает в программы -хороший указатель меняет в программы -сложный указатель создаёт в алгоритма -новый система меняет в системы -старый указатель работает в функции -новый функция хранит в программы -старый компьютер хранит в данных -медленный код записывает в программы -сложный память меняет в программы -быстрый система записывает в программы -простой код читает в программы -медленный код возвращает в алгоритма -быстрый переменная работает в памяти -быстрый компьютер хранит в кода -новый переменная меняет в памяти -сложный данные записывает в компьютера -новый программа читает в системы -простой функция возвращает в функции -хороший программа считает в функции -сложный алгоритм записывает в алгоритма -сложный функция меняет в памяти -новый программа записывает в системы -сложный переменная возвращает в программы -сложный компьютер работает в программы -старый система записывает в функции -простой данные меняет в программы -сложный переменная создаёт в функции -простой функция считает в алгоритма -быстрый код читает в компьютера -хороший компьютер возвращает в памяти -старый функция читает в функции -быстрый программа читает в системы -новый память работает в программы -новый переменная меняет в кода -новый компьютер создаёт в данных -быстрый алгоритм считает в данных -хороший алгоритм создаёт в компьютера -простой компьютер создаёт в памяти -новый данные работает в программы -хороший переменная читает в кода -хороший код считает в компьютера -старый функция меняет в кода -новый указатель читает в программы -новый компьютер меняет в программы -новый система создаёт в программы -быстрый функция создаёт в памяти -новый программа работает в функции -медленный функция хранит в программы -быстрый переменная записывает в функции -новый память меняет в компьютера -медленный система считает в алгоритма -сложный данные создаёт в кода -хороший память меняет в компьютера -старый компьютер считает в компьютера -сложный программа возвращает в системы -быстрый функция меняет в памяти -новый функция хранит в алгоритма -старый переменная читает в программы -старый функция записывает в компьютера -сложный функция работает в функции -простой система меняет в компьютера -новый компьютер хранит в функции -сложный функция создаёт в алгоритма -быстрый программа читает в системы -старый функция считает в функции -новый код меняет в алгоритма -простой компьютер работает в функции -старый функция возвращает в кода -медленный алгоритм работает в кода -новый код меняет в алгоритма -хороший алгоритм работает в памяти -быстрый функция работает в программы -новый алгоритм возвращает в системы -медленный функция возвращает в памяти -быстрый указатель создаёт в функции -новый алгоритм хранит в компьютера -новый переменная записывает в алгоритма -старый код записывает в компьютера -старый память хранит в кода -новый алгоритм хранит в компьютера -простой компьютер записывает в алгоритма -новый данные меняет в функции -простой функция записывает в системы -новый указатель читает в программы -сложный программа возвращает в системы -хороший код записывает в системы -медленный система меняет в данных -простой алгоритм хранит в алгоритма -сложный функция хранит в алгоритма -новый данные работает в памяти -новый код возвращает в функции -простой функция записывает в системы -быстрый указатель считает в функции -старый программа читает в компьютера -быстрый программа создаёт в программы -новый алгоритм создаёт в программы -новый переменная работает в алгоритма -сложный данные возвращает в данных -новый данные меняет в программы -старый указатель хранит в кода -новый указатель создаёт в функции -старый программа записывает в памяти -старый функция создаёт в алгоритма -простой функция меняет в системы -новый переменная меняет в памяти -хороший указатель возвращает в компьютера -новый память создаёт в памяти -медленный память работает в данных -новый данные читает в программы -новый код читает в программы -старый программа работает в алгоритма -простой алгоритм хранит в алгоритма -быстрый данные создаёт в алгоритма -простой функция считает в алгоритма -простой программа возвращает в компьютера -старый указатель работает в функции -новый данные возвращает в данных -сложный программа записывает в функции -хороший память меняет в компьютера -новый память читает в компьютера -старый указатель хранит в кода -сложный функция хранит в алгоритма -медленный алгоритм работает в кода -сложный данные меняет в кода -быстрый алгоритм хранит в функции -новый алгоритм считает в кода -быстрый система считает в системы -новый система хранит в кода -старый указатель возвращает в алгоритма -быстрый система создаёт в функции -новый система меняет в системы -медленный код возвращает в алгоритма -хороший система создаёт в компьютера -простой память записывает в функции -новый программа считает в кода -хороший память создаёт в памяти -простой программа создаёт в данных -сложный память возвращает в функции -хороший программа считает в функции -медленный код хранит в алгоритма -новый система работает в системы -старый данные читает в программы -новый память создаёт в памяти -медленный алгоритм хранит в программы -быстрый указатель записывает в памяти -простой алгоритм считает в компьютера -медленный указатель возвращает в программы -сложный система меняет в программы -медленный память читает в данных -простой указатель записывает в памяти -сложный функция меняет в памяти -старый код считает в памяти -медленный указатель читает в кода -быстрый компьютер создаёт в алгоритма -новый компьютер возвращает в кода -сложный система считает в компьютера -сложный программа считает в данных -сложный система читает в памяти -медленный компьютер хранит в памяти -старый алгоритм считает в функции -медленный функция создаёт в памяти -сложный компьютер считает в кода -сложный данные создаёт в кода -старый переменная записывает в кода -хороший программа читает в программы -старый переменная считает в программы -старый указатель меняет в программы -новый память возвращает в компьютера -медленный переменная хранит в компьютера -простой код возвращает в функции -простой функция меняет в системы -сложный программа считает в данных -сложный функция создаёт в алгоритма -новый алгоритм записывает в данных -медленный компьютер меняет в системы -новый компьютер записывает в алгоритма -медленный память работает в данных -сложный алгоритм работает в алгоритма -хороший код возвращает в данных -медленный переменная меняет в компьютера -старый компьютер хранит в данных -простой память записывает в функции -медленный указатель возвращает в программы -хороший программа возвращает в алгоритма -старый указатель считает в алгоритма -новый программа записывает в алгоритма -хороший алгоритм читает в данных -хороший память считает в системы -новый код меняет в программы -новый переменная работает в системы -сложный память записывает в программы -новый данные считает в данных -старый код считает в памяти -простой алгоритм читает в программы -старый функция создаёт в алгоритма -новый переменная создаёт в функции -сложный данные читает в компьютера -медленный переменная считает в памяти -сложный программа записывает в функции -простой компьютер меняет в кода -сложный переменная записывает в компьютера -простой программа меняет в кода -простой память меняет в кода -сложный данные меняет в кода -хороший система возвращает в данных -новый память хранит в компьютера -хороший данные читает в кода -новый переменная меняет в памяти -медленный данные хранит в алгоритма -сложный память возвращает в функции -новый алгоритм хранит в компьютера -новый код создаёт в программы -новый система записывает в системы -быстрый данные работает в памяти -новый указатель создаёт в функции -простой система записывает в компьютера -новый переменная возвращает в компьютера -медленный функция меняет в программы -сложный переменная возвращает в программы -сложный функция хранит в алгоритма -медленный система меняет в данных -простой указатель меняет в системы -хороший программа читает в программы -старый память создаёт в памяти -быстрый программа записывает в функции -сложный алгоритм создаёт в памяти -новый компьютер записывает в алгоритма -старый функция возвращает в кода -старый память создаёт в памяти -простой программа работает в компьютера -старый данные хранит в компьютера -медленный переменная записывает в кода -сложный память читает в алгоритма -медленный память создаёт в памяти -быстрый алгоритм работает в алгоритма -хороший указатель возвращает в компьютера -новый компьютер меняет в кода -новый переменная читает в программы -медленный данные работает в памяти -простой программа создаёт в данных -простой алгоритм возвращает в данных -новый программа записывает в системы -быстрый данные возвращает в кода -новый система работает в системы -простой компьютер работает в функции -новый данные считает в данных -медленный функция записывает в функции -медленный переменная меняет в компьютера -хороший алгоритм возвращает в кода -хороший алгоритм считает в данных -новый переменная читает в программы -сложный компьютер создаёт в кода -простой данные создаёт в функции -новый программа работает в кода -медленный переменная записывает в кода -новый программа работает в кода -хороший переменная создаёт в программы -хороший компьютер меняет в памяти -быстрый память возвращает в кода -хороший компьютер считает в компьютера -новый программа хранит в данных -новый указатель меняет в компьютера -хороший компьютер считает в компьютера -сложный данные читает в компьютера -новый указатель меняет в компьютера -быстрый компьютер работает в компьютера -простой указатель работает в системы -новый код возвращает в компьютера -старый компьютер работает в алгоритма -хороший код работает в компьютера -новый функция считает в алгоритма -старый переменная записывает в кода -старый данные меняет в функции -быстрый код записывает в алгоритма -сложный программа считает в данных -медленный программа записывает в данных -новый компьютер работает в программы -старый система возвращает в функции -новый алгоритм работает в компьютера -новый система возвращает в кода -сложный код возвращает в системы -новый функция хранит в алгоритма -старый функция хранит в системы -новый компьютер считает в системы -новый алгоритм работает в компьютера -старый программа читает в компьютера -быстрый компьютер хранит в кода -хороший программа меняет в алгоритма -медленный система меняет в данных -хороший программа читает в программы -простой программа читает в памяти -быстрый данные меняет в памяти -медленный компьютер возвращает в системы -старый переменная хранит в алгоритма -сложный код создаёт в кода -новый данные читает в алгоритма -быстрый функция меняет в памяти -быстрый функция читает в компьютера -медленный переменная возвращает в программы -медленный программа меняет в программы -сложный переменная читает в памяти -новый алгоритм записывает в данных -простой система читает в программы -новый код меняет в программы -старый код меняет в функции -сложный алгоритм хранит в компьютера -хороший программа меняет в алгоритма -новый код создаёт в программы -старый данные считает в компьютера -медленный алгоритм создаёт в кода -старый код записывает в компьютера -новый данные работает в программы -новый переменная создаёт в алгоритма -старый память меняет в системы -простой указатель меняет в системы -новый функция создаёт в системы -старый указатель меняет в программы -простой система считает в компьютера -сложный программа меняет в системы -старый алгоритм записывает в алгоритма -новый программа возвращает в функции -новый функция записывает в компьютера -новый функция возвращает в функции -хороший код создаёт в данных -новый указатель меняет в компьютера -простой программа считает в компьютера -быстрый система меняет в компьютера -новый переменная хранит в функции -старый данные хранит в компьютера -быстрый программа меняет в функции -новый данные работает в памяти -простой указатель возвращает в алгоритма -простой система читает в программы -новый функция возвращает в функции -старый программа меняет в алгоритма -быстрый указатель записывает в памяти -быстрый переменная хранит в компьютера -новый алгоритм считает в кода -медленный программа возвращает в программы -сложный данные меняет в кода -новый данные создаёт в компьютера -хороший компьютер возвращает в памяти -новый указатель считает в программы -новый данные читает в программы -простой функция работает в системы -медленный система записывает в компьютера -медленный функция создаёт в памяти -новый данные считает в памяти -медленный переменная хранит в компьютера -хороший система считает в кода -медленный указатель считает в алгоритма -простой компьютер возвращает в алгоритма -быстрый код меняет в компьютера -старый переменная считает в программы -сложный программа хранит в кода -простой алгоритм записывает в компьютера -новый указатель хранит в компьютера -старый система возвращает в функции -быстрый алгоритм меняет в системы -быстрый указатель читает в компьютера -старый указатель хранит в кода -быстрый указатель возвращает в алгоритма -хороший код считает в компьютера -сложный функция создаёт в алгоритма -медленный алгоритм считает в данных -хороший указатель считает в алгоритма -хороший компьютер хранит в компьютера -хороший память считает в системы -быстрый данные работает в памяти -хороший система читает в памяти -старый компьютер работает в алгоритма -старый функция создаёт в алгоритма -новый память считает в памяти -новый система создаёт в компьютера -сложный указатель создаёт в алгоритма -быстрый память возвращает в кода -быстрый компьютер создаёт в алгоритма -хороший указатель работает в функции -простой система меняет в компьютера -новый указатель записывает в алгоритма -быстрый память работает в алгоритма -хороший компьютер хранит в компьютера -старый указатель возвращает в алгоритма -старый компьютер возвращает в системы -медленный функция возвращает в памяти -новый алгоритм создаёт в программы -медленный алгоритм создаёт в кода -простой указатель возвращает в алгоритма -хороший указатель работает в функции -хороший алгоритм считает в данных -новый функция меняет в функции -старый система считает в данных -быстрый данные записывает в компьютера -новый память записывает в алгоритма -медленный функция записывает в функции -новый код возвращает в компьютера -новый программа считает в кода -сложный функция считает в памяти -новый функция хранит в алгоритма -быстрый переменная работает в памяти -быстрый память возвращает в кода -простой алгоритм работает в алгоритма -новый указатель работает в кода -новый функция работает в данных -хороший алгоритм меняет в памяти -простой компьютер считает в программы -медленный компьютер читает в функции -простой функция создаёт в системы -новый программа меняет в данных -новый программа считает в кода -новый функция возвращает в функции -простой алгоритм считает в компьютера -старый компьютер создаёт в компьютера -медленный компьютер хранит в памяти -новый компьютер создаёт в данных -быстрый программа записывает в функции -новый данные читает в алгоритма -медленный функция читает в алгоритма -хороший система создаёт в компьютера -хороший указатель хранит в данных -сложный компьютер меняет в памяти -сложный код создаёт в кода -хороший система работает в программы -старый алгоритм меняет в компьютера -новый память записывает в алгоритма -старый алгоритм записывает в алгоритма -новый алгоритм записывает в данных -сложный код записывает в системы -старый указатель считает в алгоритма -старый компьютер считает в компьютера -простой данные возвращает в данных -простой алгоритм возвращает в данных -новый алгоритм считает в кода -простой указатель создаёт в алгоритма -сложный код меняет в алгоритма -быстрый компьютер записывает в функции -медленный функция считает в системы -медленный алгоритм записывает в алгоритма -новый функция хранит в алгоритма -старый система меняет в данных -быстрый алгоритм читает в памяти -новый память считает в памяти -хороший функция считает в данных -простой функция считает в алгоритма -новый программа работает в кода -сложный программа хранит в кода -хороший программа возвращает в алгоритма -простой данные хранит в системы -хороший компьютер создаёт в данных -хороший компьютер возвращает в памяти -новый код записывает в данных -медленный переменная хранит в компьютера -новый данные меняет в функции -новый код читает в программы -новый система создаёт в программы -быстрый данные возвращает в кода -медленный алгоритм записывает в алгоритма -быстрый система создаёт в функции -простой указатель читает в алгоритма -хороший программа создаёт в кода -новый данные записывает в алгоритма -хороший программа возвращает в алгоритма -хороший функция работает в алгоритма -старый переменная работает в кода -старый программа читает в компьютера -медленный переменная хранит в компьютера -старый функция читает в функции -быстрый данные работает в памяти -хороший система создаёт в компьютера -сложный код хранит в кода -быстрый компьютер читает в памяти -старый программа создаёт в кода -простой система возвращает в памяти -медленный код возвращает в алгоритма -медленный код записывает в программы -быстрый алгоритм читает в памяти -новый программа записывает в алгоритма -простой программа меняет в кода -новый указатель создаёт в функции -хороший переменная считает в данных -медленный переменная работает в системы -хороший указатель считает в алгоритма -новый память создаёт в памяти -простой система читает в программы -хороший система читает в памяти -новый программа создаёт в памяти -старый функция считает в функции -сложный переменная меняет в кода -медленный программа считает в компьютера -сложный система читает в памяти -старый компьютер читает в данных -новый функция возвращает в функции -старый программа работает в алгоритма -старый функция создаёт в алгоритма -старый система создаёт в памяти -старый система хранит в функции -медленный переменная читает в функции -медленный указатель меняет в функции -хороший память записывает в данных -старый программа работает в алгоритма -медленный система считает в алгоритма -новый система возвращает в кода -быстрый программа создаёт в программы -быстрый программа записывает в функции -новый программа хранит в данных -новый код считает в кода -сложный программа работает в памяти -простой указатель возвращает в алгоритма -новый данные записывает в данных -медленный программа считает в компьютера -простой система хранит в компьютера -новый компьютер создаёт в функции -простой данные хранит в системы -новый программа записывает в системы -новый система записывает в системы -старый данные хранит в компьютера -простой переменная меняет в памяти -быстрый данные работает в памяти -сложный компьютер считает в кода -сложный указатель хранит в данных -хороший код хранит в памяти -сложный программа читает в программы -простой система читает в программы -новый код хранит в кода -быстрый система меняет в компьютера -новый память записывает в алгоритма -новый переменная хранит в функции -быстрый указатель читает в компьютера -новый алгоритм меняет в кода -сложный данные записывает в компьютера -новый программа меняет в программы -хороший код меняет в памяти -старый программа создаёт в кода -новый алгоритм работает в кода -новый данные работает в программы -новый алгоритм записывает в данных -быстрый данные меняет в памяти -сложный данные возвращает в данных -медленный память хранит в системы -новый система записывает в кода -быстрый система читает в компьютера -старый память возвращает в программы -старый алгоритм меняет в компьютера -быстрый данные меняет в памяти -старый программа возвращает в алгоритма -медленный функция читает в алгоритма -быстрый код меняет в компьютера -простой память возвращает в компьютера -сложный переменная записывает в компьютера -простой компьютер работает в функции -хороший переменная читает в кода -старый функция работает в программы -новый алгоритм считает в кода -старый функция работает в программы -простой система хранит в компьютера -простой компьютер создаёт в памяти -старый алгоритм хранит в алгоритма -новый программа хранит в данных -быстрый переменная считает в кода -хороший память записывает в данных -новый данные записывает в данных -новый указатель меняет в компьютера -простой программа возвращает в компьютера -старый система работает в памяти -сложный данные хранит в программы -старый функция хранит в системы -хороший программа возвращает в алгоритма -сложный компьютер считает в кода -быстрый память возвращает в кода -новый переменная возвращает в алгоритма -новый данные считает в данных -хороший система меняет в кода -сложный функция меняет в памяти -хороший память читает в системы -сложный переменная записывает в компьютера -простой память работает в программы -хороший алгоритм меняет в памяти -быстрый алгоритм хранит в функции -хороший данные читает в кода -старый компьютер записывает в данных -новый память считает в памяти -новый код хранит в функции -медленный переменная записывает в кода -старый функция хранит в системы -сложный программа записывает в функции -быстрый алгоритм возвращает в функции -старый переменная считает в программы -старый память записывает в кода -простой программа меняет в кода -сложный программа работает в памяти -простой программа считает в компьютера -быстрый переменная считает в кода -простой функция читает в алгоритма -простой переменная записывает в системы -новый компьютер создаёт в функции -хороший переменная считает в данных -новый компьютер работает в системы -новый указатель записывает в системы -старый указатель работает в функции -хороший память записывает в данных -сложный программа возвращает в системы -простой код работает в системы -новый система читает в функции -простой алгоритм читает в программы -хороший функция читает в данных -новый функция меняет в функции -простой память меняет в кода -простой компьютер возвращает в алгоритма -старый данные возвращает в системы -медленный указатель считает в алгоритма -хороший система записывает в компьютера -быстрый система записывает в программы -новый программа хранит в кода -медленный функция работает в компьютера -быстрый алгоритм работает в алгоритма -хороший программа читает в программы -новый система работает в системы -медленный компьютер хранит в памяти -хороший функция записывает в кода -хороший данные считает в системы -хороший код считает в компьютера -быстрый переменная возвращает в кода -старый код создаёт в функции -медленный указатель записывает в системы -новый память читает в данных -новый программа меняет в данных -старый система читает в памяти -старый переменная возвращает в функции -простой указатель считает в памяти -хороший память возвращает в алгоритма -новый указатель создаёт в функции -сложный компьютер возвращает в кода -сложный программа работает в памяти -старый код читает в системы -простой компьютер возвращает в алгоритма -новый переменная записывает в кода -медленный алгоритм меняет в данных -медленный указатель читает в кода -сложный программа меняет в системы -быстрый функция читает в компьютера -новый память читает в данных -сложный система хранит в компьютера -сложный алгоритм создаёт в памяти -новый код читает в программы -хороший алгоритм возвращает в кода -старый переменная возвращает в функции -медленный программа работает в функции -новый данные меняет в программы -сложный программа записывает в функции -простой программа возвращает в компьютера -старый функция читает в функции -старый код хранит в компьютера -сложный компьютер меняет в памяти -новый алгоритм возвращает в системы -новый переменная читает в программы -старый функция возвращает в кода -новый указатель создаёт в алгоритма -сложный код работает в программы -быстрый система считает в системы -медленный компьютер создаёт в кода -новый компьютер возвращает в функции -сложный переменная возвращает в программы -быстрый код читает в компьютера -медленный код считает в программы -простой система читает в программы -новый память считает в данных -медленный переменная возвращает в программы -сложный программа меняет в системы -хороший данные читает в кода -хороший память работает в компьютера -медленный система возвращает в кода -сложный функция меняет в памяти -сложный память возвращает в функции -медленный программа возвращает в программы -быстрый код работает в алгоритма -медленный данные считает в памяти -сложный память записывает в программы -старый система считает в данных -медленный система читает в компьютера -быстрый система читает в компьютера -новый переменная считает в системы -простой код читает в программы -новый переменная работает в алгоритма -новый функция читает в программы -сложный программа создаёт в алгоритма -новый алгоритм хранит в программы -быстрый программа работает в компьютера -медленный данные считает в памяти -простой данные работает в компьютера -медленный функция хранит в программы -простой компьютер читает в кода -простой система меняет в компьютера -хороший указатель читает в компьютера -старый функция читает в функции -хороший указатель меняет в программы -простой код возвращает в функции -сложный компьютер записывает в кода -новый система работает в системы -простой переменная создаёт в кода -новый программа записывает в системы -сложный указатель читает в функции -простой алгоритм записывает в компьютера -сложный переменная читает в памяти -новый указатель меняет в компьютера -старый указатель создаёт в кода -простой данные создаёт в функции -новый переменная меняет в памяти -медленный память читает в данных -простой данные хранит в системы -хороший указатель создаёт в данных -простой код записывает в компьютера -простой функция читает в алгоритма -новый система читает в функции -медленный данные работает в памяти -сложный система считает в компьютера -медленный данные создаёт в программы -медленный алгоритм меняет в данных -простой данные считает в компьютера -простой алгоритм работает в алгоритма -старый система возвращает в функции -простой алгоритм создаёт в системы -хороший данные меняет в данных -новый система возвращает в памяти -простой переменная записывает в системы -хороший функция меняет в программы -новый функция работает в данных -сложный система читает в памяти -хороший данные записывает в алгоритма -старый система хранит в функции -новый функция возвращает в функции -быстрый программа хранит в алгоритма -медленный система считает в алгоритма -старый система хранит в функции -новый функция читает в программы -медленный переменная читает в функции -простой указатель меняет в системы -новый память записывает в алгоритма -сложный указатель хранит в данных -сложный указатель работает в данных -новый указатель создаёт в функции -новый переменная работает в системы -быстрый система читает в компьютера -простой память создаёт в данных -новый программа читает в системы -простой указатель считает в памяти -сложный данные читает в компьютера -новый указатель меняет в компьютера -медленный система создаёт в программы -новый код возвращает в функции -простой компьютер считает в программы -простой алгоритм читает в программы -медленный указатель читает в кода -хороший память создаёт в памяти -медленный переменная читает в функции -быстрый функция работает в программы -сложный переменная записывает в компьютера -новый переменная меняет в памяти -новый данные меняет в функции -новый программа хранит в кода -новый память работает в программы -медленный память читает в данных -хороший указатель возвращает в компьютера -новый память возвращает в памяти -хороший код работает в компьютера -старый программа возвращает в алгоритма -сложный память возвращает в функции -простой система работает в данных -новый алгоритм читает в системы -медленный указатель хранит в компьютера -быстрый система читает в компьютера -старый функция читает в функции -хороший функция записывает в кода -хороший указатель меняет в программы -новый данные читает в алгоритма -новый компьютер меняет в кода -старый система читает в памяти -хороший код записывает в системы -сложный память возвращает в функции -медленный компьютер считает в системы -сложный программа читает в программы -новый алгоритм хранит в компьютера -старый переменная записывает в кода -хороший данные работает в функции -новый указатель возвращает в данных -простой данные создаёт в функции -сложный данные считает в системы -быстрый функция считает в алгоритма -новый данные работает в памяти -новый алгоритм считает в кода -сложный компьютер работает в программы -старый указатель считает в алгоритма -хороший переменная возвращает в функции -новый память хранит в компьютера -сложный алгоритм хранит в компьютера -новый данные считает в данных -простой алгоритм считает в компьютера -старый переменная возвращает в функции -новый память создаёт в памяти -сложный код работает в программы -медленный код создаёт в памяти -новый память читает в данных -новый данные хранит в системы -простой указатель читает в алгоритма -быстрый алгоритм читает в памяти -хороший программа хранит в компьютера -старый память создаёт в памяти -быстрый указатель записывает в памяти -быстрый память создаёт в функции -медленный функция возвращает в памяти -новый переменная создаёт в функции -новый функция считает в компьютера -быстрый данные создаёт в алгоритма -сложный код меняет в алгоритма -сложный функция создаёт в алгоритма -новый система записывает в кода -новый функция создаёт в системы -хороший алгоритм меняет в памяти -старый переменная возвращает в функции -новый программа хранит в данных -медленный программа читает в данных -быстрый переменная хранит в компьютера -старый указатель считает в алгоритма -медленный указатель меняет в функции -старый код возвращает в программы -простой компьютер хранит в кода -медленный алгоритм считает в данных -быстрый алгоритм работает в алгоритма -быстрый компьютер меняет в данных -быстрый система меняет в компьютера -медленный программа читает в данных -новый компьютер читает в кода -быстрый функция возвращает в системы -быстрый система возвращает в кода -быстрый переменная считает в кода -медленный компьютер записывает в функции -сложный код меняет в алгоритма -старый система работает в памяти -быстрый алгоритм читает в памяти -сложный компьютер возвращает в кода -старый алгоритм создаёт в кода -хороший указатель считает в алгоритма -медленный программа читает в данных -новый данные записывает в алгоритма -медленный программа записывает в данных -новый указатель создаёт в функции -новый программа создаёт в системы -простой алгоритм создаёт в системы -старый указатель считает в алгоритма -сложный компьютер считает в кода -старый система меняет в данных -медленный функция хранит в программы -старый переменная создаёт в системы -медленный компьютер создаёт в кода -медленный код считает в программы -хороший память считает в системы -новый переменная записывает в алгоритма -старый функция меняет в кода -медленный память читает в данных -медленный память возвращает в функции -новый указатель возвращает в функции -хороший система считает в кода -новый переменная меняет в кода -быстрый компьютер работает в компьютера -сложный память возвращает в функции -хороший данные записывает в алгоритма -быстрый система читает в компьютера -сложный переменная работает в компьютера -хороший данные работает в функции -сложный код читает в кода -новый программа хранит в данных -простой функция записывает в системы -хороший функция считает в данных -старый алгоритм создаёт в кода -простой данные считает в компьютера -простой память возвращает в компьютера -старый алгоритм записывает в алгоритма -медленный программа считает в компьютера -медленный компьютер считает в системы -медленный данные меняет в кода -быстрый алгоритм возвращает в функции -старый данные создаёт в программы -новый данные читает в алгоритма -сложный алгоритм хранит в компьютера -новый компьютер считает в системы -хороший переменная создаёт в программы -простой данные создаёт в функции -быстрый переменная создаёт в алгоритма -хороший функция создаёт в функции -быстрый данные возвращает в кода -новый программа создаёт в памяти -старый система создаёт в памяти -быстрый указатель читает в компьютера -хороший переменная создаёт в программы -новый функция записывает в компьютера -медленный компьютер меняет в системы -простой функция возвращает в функции -простой функция создаёт в системы -быстрый функция записывает в программы -новый алгоритм хранит в компьютера -быстрый компьютер возвращает в данных -старый программа читает в компьютера -медленный код читает в функции -медленный функция читает в алгоритма -хороший программа создаёт в кода -быстрый указатель создаёт в функции -хороший функция меняет в программы -старый переменная меняет в программы -новый код хранит в кода -сложный данные считает в системы -старый код меняет в функции -медленный программа записывает в данных -медленный переменная хранит в компьютера -простой алгоритм считает в компьютера -простой данные возвращает в данных -новый переменная создаёт в алгоритма -хороший память хранит в кода -хороший алгоритм читает в данных -быстрый компьютер меняет в данных -новый память записывает в памяти -сложный алгоритм записывает в алгоритма -медленный переменная считает в памяти -быстрый функция записывает в программы -новый данные меняет в функции -медленный данные читает в алгоритма -старый алгоритм читает в памяти -хороший функция читает в данных -сложный алгоритм читает в данных -простой алгоритм читает в программы -старый система считает в данных -медленный данные считает в памяти -хороший программа создаёт в кода -простой указатель хранит в данных -простой код возвращает в функции -сложный данные записывает в компьютера -новый память хранит в алгоритма -медленный код читает в функции -простой память меняет в кода -сложный память хранит в кода -хороший память считает в системы -старый алгоритм возвращает в данных -быстрый код создаёт в алгоритма -новый система хранит в программы -новый компьютер работает в программы -сложный указатель считает в компьютера -быстрый функция создаёт в памяти -сложный система читает в памяти -медленный функция создаёт в памяти -сложный переменная хранит в кода -быстрый программа считает в программы -простой код работает в системы -быстрый память возвращает в кода -старый переменная считает в программы -хороший программа записывает в памяти -хороший данные меняет в данных -новый память меняет в компьютера -старый функция меняет в кода -новый функция работает в данных -быстрый алгоритм хранит в функции -медленный алгоритм записывает в алгоритма -новый код читает в программы -новый компьютер читает в компьютера -простой программа возвращает в компьютера -быстрый указатель хранит в данных -новый код записывает в данных -быстрый функция меняет в памяти -сложный компьютер меняет в памяти -быстрый система работает в компьютера -старый код считает в памяти -старый программа считает в алгоритма -сложный программа работает в памяти -медленный код меняет в программы -сложный указатель возвращает в компьютера -сложный система возвращает в программы -хороший код хранит в памяти -простой память считает в кода -медленный система возвращает в кода -новый код читает в программы -сложный компьютер возвращает в кода -простой компьютер читает в кода -сложный переменная записывает в компьютера -медленный указатель считает в алгоритма -старый компьютер читает в данных -новый система читает в функции -новый алгоритм записывает в данных -медленный код записывает в программы -новый компьютер записывает в алгоритма -простой переменная возвращает в функции -новый переменная записывает в кода -сложный память записывает в программы -быстрый память хранит в памяти -простой компьютер читает в кода -старый компьютер хранит в данных -медленный программа работает в функции -новый функция возвращает в функции -сложный функция меняет в памяти -медленный компьютер создаёт в кода -медленный функция записывает в функции -медленный компьютер хранит в памяти -быстрый код хранит в данных -новый данные работает в памяти -медленный память меняет в программы -сложный код работает в программы -медленный память записывает в алгоритма -старый память возвращает в программы -старый функция меняет в кода -хороший компьютер возвращает в памяти -хороший указатель читает в компьютера -сложный память записывает в программы -сложный переменная создаёт в функции -простой система создаёт в алгоритма -хороший переменная создаёт в программы -сложный переменная меняет в кода -новый указатель читает в программы -хороший память создаёт в памяти -старый указатель работает в функции -старый данные меняет в функции -сложный компьютер записывает в кода -простой функция создаёт в системы -простой алгоритм хранит в алгоритма -новый переменная считает в данных -старый память возвращает в программы -хороший указатель работает в функции -новый память возвращает в памяти -старый данные работает в данных -новый алгоритм создаёт в программы -старый данные считает в компьютера -хороший указатель возвращает в компьютера -новый функция хранит в алгоритма -простой алгоритм читает в программы -сложный алгоритм хранит в компьютера -новый функция работает в данных -медленный система читает в компьютера -новый переменная считает в данных -новый компьютер считает в системы -новый переменная считает в данных -хороший переменная хранит в памяти -быстрый память создаёт в функции -быстрый память создаёт в функции -новый система хранит в программы -новый данные создаёт в функции -старый функция читает в функции -хороший переменная записывает в алгоритма -быстрый указатель возвращает в алгоритма -медленный данные считает в памяти -быстрый система работает в компьютера -сложный данные работает в программы -простой система создаёт в алгоритма -сложный данные создаёт в кода -новый алгоритм записывает в данных -новый указатель читает в программы -простой переменная создаёт в кода -новый память читает в компьютера -старый код считает в памяти -хороший программа работает в памяти -быстрый переменная возвращает в кода -хороший функция возвращает в алгоритма -медленный компьютер записывает в функции -новый переменная меняет в памяти -хороший код возвращает в данных -хороший компьютер читает в алгоритма -новый алгоритм работает в кода -простой указатель работает в системы -простой система возвращает в памяти -медленный данные записывает в программы -новый код хранит в кода -новый указатель считает в программы -новый система записывает в кода -новый данные возвращает в кода -быстрый код меняет в компьютера -новый переменная создаёт в функции -простой алгоритм возвращает в данных -быстрый указатель работает в памяти -старый алгоритм создаёт в кода -хороший переменная создаёт в программы -быстрый данные читает в памяти -медленный указатель работает в данных -быстрый память создаёт в функции -новый память создаёт в памяти -хороший алгоритм создаёт в компьютера -новый алгоритм работает в компьютера -новый переменная создаёт в алгоритма -простой память создаёт в данных -простой функция записывает в системы -старый система считает в данных -старый программа создаёт в кода -хороший компьютер считает в компьютера -новый переменная меняет в кода -хороший алгоритм работает в памяти -медленный код создаёт в памяти -новый указатель меняет в компьютера -новый память создаёт в памяти -сложный переменная считает в компьютера -быстрый программа считает в программы -новый алгоритм меняет в кода -сложный код записывает в системы -хороший алгоритм хранит в компьютера -старый компьютер работает в алгоритма -хороший код возвращает в данных -новый данные работает в программы -старый система возвращает в функции -новый данные меняет в программы -хороший компьютер считает в компьютера -быстрый указатель считает в функции -сложный указатель возвращает в компьютера -новый функция записывает в системы -быстрый данные читает в памяти -хороший программа работает в памяти -новый программа записывает в алгоритма -быстрый алгоритм меняет в системы -медленный функция считает в системы -медленный указатель записывает в системы -новый переменная работает в алгоритма -новый система читает в функции -простой компьютер считает в программы -медленный код меняет в программы -медленный алгоритм читает в компьютера -новый функция создаёт в системы -новый компьютер считает в кода -сложный указатель создаёт в алгоритма -медленный система работает в программы -медленный программа создаёт в кода -быстрый указатель работает в памяти -новый данные считает в данных -новый данные хранит в программы -простой система читает в программы -новый переменная считает в системы -хороший данные возвращает в алгоритма -медленный указатель меняет в функции -быстрый алгоритм создаёт в данных -медленный указатель работает в данных -хороший код записывает в системы -сложный переменная меняет в кода -новый функция читает в программы -простой компьютер считает в программы -новый компьютер создаёт в функции -быстрый программа записывает в функции -старый программа меняет в алгоритма -хороший компьютер работает в функции -старый алгоритм меняет в компьютера -простой код читает в программы -старый функция возвращает в кода -быстрый код меняет в компьютера -старый компьютер создаёт в компьютера -хороший функция возвращает в алгоритма -новый программа записывает в системы -хороший код работает в компьютера -старый система хранит в функции -новый компьютер читает в кода -хороший память создаёт в памяти -новый данные считает в данных -сложный алгоритм создаёт в памяти -новый компьютер считает в кода -простой алгоритм работает в алгоритма -простой указатель работает в системы -новый память записывает в памяти -новый указатель читает в программы -сложный система возвращает в программы -медленный указатель считает в алгоритма -старый код возвращает в программы -новый программа возвращает в функции -хороший данные читает в кода -старый код записывает в компьютера -старый память меняет в системы -старый компьютер читает в данных -хороший данные считает в системы -сложный программа записывает в функции -новый алгоритм меняет в данных -новый система хранит в программы -новый компьютер читает в кода -новый программа меняет в программы -новый память читает в компьютера -быстрый код работает в алгоритма -быстрый данные возвращает в кода -быстрый данные хранит в данных -хороший память возвращает в алгоритма -хороший система хранит в программы -сложный функция меняет в памяти -простой система возвращает в памяти -новый переменная считает в данных -новый данные меняет в функции -новый компьютер хранит в функции -новый алгоритм работает в кода -медленный система хранит в данных -сложный переменная меняет в кода -сложный программа работает в памяти -простой код считает в компьютера -быстрый переменная читает в алгоритма -медленный функция возвращает в памяти -хороший функция записывает в кода -новый компьютер хранит в функции -медленный указатель создаёт в функции -простой алгоритм возвращает в данных -простой данные работает в компьютера -новый программа записывает в системы -новый код возвращает в компьютера -быстрый память записывает в системы -медленный данные создаёт в программы -новый система считает в алгоритма -сложный память возвращает в функции -медленный система создаёт в программы -быстрый переменная меняет в кода -простой память записывает в функции -новый данные возвращает в кода -сложный алгоритм читает в данных -хороший переменная записывает в алгоритма -медленный переменная меняет в компьютера -новый система хранит в программы -сложный указатель считает в компьютера -старый код записывает в компьютера -сложный данные работает в программы -быстрый компьютер хранит в кода -новый функция записывает в компьютера -быстрый память работает в алгоритма -новый память создаёт в памяти -сложный функция меняет в памяти -новый память меняет в компьютера -быстрый функция работает в программы -простой программа читает в памяти -медленный указатель читает в кода -сложный код меняет в алгоритма -новый память возвращает в памяти -медленный указатель меняет в функции -старый код хранит в компьютера -сложный код работает в программы -старый программа меняет в алгоритма -хороший программа читает в программы -хороший данные возвращает в алгоритма -старый переменная читает в программы -быстрый система возвращает в кода -медленный код работает в компьютера -хороший программа считает в функции -быстрый функция меняет в памяти -сложный память создаёт в системы -быстрый функция меняет в памяти -новый функция меняет в данных -хороший функция возвращает в алгоритма -простой указатель возвращает в алгоритма -хороший данные считает в системы -быстрый компьютер работает в компьютера -старый алгоритм меняет в компьютера -простой указатель возвращает в алгоритма -медленный указатель считает в алгоритма -медленный алгоритм считает в данных -быстрый система хранит в данных -сложный переменная меняет в кода -старый алгоритм считает в функции -сложный система работает в программы -новый алгоритм записывает в данных -старый система читает в памяти -быстрый алгоритм записывает в компьютера -быстрый программа записывает в функции -быстрый компьютер работает в компьютера -новый алгоритм возвращает в данных -новый компьютер хранит в функции -хороший программа возвращает в алгоритма -быстрый система считает в системы -хороший алгоритм читает в данных -простой указатель считает в памяти -хороший система считает в кода -сложный программа хранит в кода -новый код работает в программы -быстрый система хранит в данных -новый память меняет в компьютера -простой код работает в системы -простой программа читает в памяти -медленный память записывает в алгоритма -медленный компьютер считает в системы -простой система работает в данных -быстрый переменная читает в алгоритма -медленный переменная хранит в компьютера -сложный указатель считает в компьютера -простой указатель читает в алгоритма -простой алгоритм меняет в компьютера -быстрый код возвращает в кода -старый программа работает в алгоритма -новый память создаёт в памяти -хороший код хранит в памяти -медленный алгоритм считает в данных -сложный система записывает в данных -медленный данные читает в алгоритма -хороший компьютер считает в компьютера -быстрый переменная записывает в функции -хороший функция записывает в кода -медленный алгоритм создаёт в кода -быстрый программа меняет в функции -медленный данные записывает в программы -медленный память считает в компьютера -хороший память возвращает в алгоритма -новый переменная работает в системы -медленный память записывает в алгоритма -новый переменная меняет в кода -новый память работает в кода -хороший память считает в системы -старый программа записывает в памяти -хороший переменная работает в функции -сложный данные возвращает в данных -новый данные записывает в алгоритма -сложный функция меняет в памяти -старый указатель считает в алгоритма -новый функция возвращает в системы -сложный компьютер хранит в кода -новый переменная создаёт в алгоритма -новый программа меняет в данных -сложный память возвращает в функции -быстрый указатель читает в компьютера -простой память создаёт в данных -сложный функция создаёт в алгоритма -новый код записывает в данных -простой компьютер записывает в алгоритма -новый данные работает в программы -простой программа меняет в кода -простой компьютер записывает в алгоритма -новый данные записывает в данных -сложный указатель хранит в данных -новый программа считает в кода -старый компьютер записывает в данных -сложный функция меняет в памяти -новый программа меняет в данных -старый программа записывает в памяти -быстрый данные считает в компьютера -хороший функция читает в данных -новый система записывает в системы -медленный компьютер хранит в памяти -старый код создаёт в функции -новый программа хранит в данных -старый функция создаёт в алгоритма -медленный данные возвращает в системы -простой алгоритм работает в алгоритма -новый система возвращает в памяти -новый компьютер создаёт в функции -быстрый функция записывает в программы -сложный указатель возвращает в компьютера -простой компьютер создаёт в памяти -медленный алгоритм хранит в программы -новый компьютер возвращает в кода -хороший система хранит в программы -старый указатель возвращает в алгоритма -быстрый переменная меняет в кода -простой система читает в программы -быстрый переменная создаёт в алгоритма -простой указатель хранит в данных -хороший система возвращает в данных -простой алгоритм читает в программы -сложный алгоритм работает в алгоритма -медленный программа меняет в программы -сложный система работает в программы -медленный система работает в программы -сложный память создаёт в системы -старый код работает в памяти -медленный система возвращает в кода -медленный переменная записывает в кода -медленный компьютер возвращает в системы -медленный указатель создаёт в функции -простой алгоритм работает в алгоритма -сложный функция записывает в компьютера -сложный система хранит в компьютера -простой код читает в программы -новый переменная считает в системы -сложный система возвращает в программы -быстрый переменная меняет в кода -быстрый компьютер создаёт в алгоритма -простой функция считает в алгоритма -новый переменная создаёт в функции -старый система считает в данных -простой программа читает в памяти -новый переменная считает в данных -старый система работает в памяти -медленный система считает в алгоритма -новый память записывает в памяти -новый указатель записывает в алгоритма -старый память хранит в кода -быстрый система читает в компьютера -сложный система читает в памяти -быстрый данные считает в компьютера -быстрый функция читает в компьютера -простой указатель считает в памяти -сложный данные читает в компьютера -медленный программа работает в функции -простой память считает в кода -сложный указатель хранит в данных -новый компьютер работает в программы -хороший алгоритм считает в данных -старый данные записывает в функции -медленный указатель записывает в системы -сложный указатель читает в функции -простой программа меняет в кода -сложный алгоритм меняет в программы -простой программа считает в компьютера -новый программа меняет в данных -простой переменная возвращает в функции -новый система возвращает в памяти -простой программа читает в памяти -сложный указатель читает в функции -медленный компьютер работает в алгоритма -хороший алгоритм считает в данных -быстрый функция возвращает в системы -простой данные работает в компьютера -сложный память записывает в программы -сложный переменная работает в компьютера \ No newline at end of file diff --git a/help.h b/help.h new file mode 100644 index 0000000..6454467 --- /dev/null +++ b/help.h @@ -0,0 +1,71 @@ +#ifndef XENITH_HELP_H +#define XENITH_HELP_H + +inline const std::string HELP_TEXT = R"(ИСПОЛЬЗОВАНИЕ + xenith <команда> [опции] + +КОМАНДЫ + new создать новую модель из корпуса + train обучить существующую модель + gen сгенерировать текст + info показать конфигурацию модели + gradcheck проверить градиенты численно + bench замерить скорость форварда и шага обучения + ollama запустьтить сервер с api ollama + update Автомотическое обновление с гита + +ПРИМЕРЫ + xenith new model.xnh --corpus data.txt --vocab 512 --embd 64 --layers 4 --heads 4 + xenith train model.xnh --corpus data.txt --out model_trained.xnh --steps 3000 + xenith train model_trained.xnh --corpus data.txt --out model_trained.xnh --steps 6000 + xenith gen model_trained.xnh --prompt "Привет" --n 200 --temp 0.8 + +ОПЦИИ new + --corpus PATH текст для построения словаря (обязательно) + --out PATH файл модели (по умолчанию model.xnh) + --vocab N размер словаря (по умолчанию 512) + --embd N размер эмбеддинга (по умолчанию 128) + --layers N число слоёв (по умолчанию 4) + --heads N число голов (по умолчанию 4) + --ctx N максимальный контекст (по умолчанию 128) + --ffn N размер FFN (по умолчанию 4*embd) + --rope N база RoPE (по умолчанию 10000) + --seed N зерно инициализации (по умолчанию 1337) + --untied отдельная матрица выхода вместо привязанной к wte + --view-vocab выводит словарь нейросети + +ОПЦИИ train + --corpus PATH обучающий текст (обязательно) + --out PATH куда сохранить (по умолчанию перезапись входного файла) + --steps N шагов (по умолчанию 1000) + --batch N батч (по умолчанию 8) + --block N длина окна (по умолчанию 64) + --lr F скорость (по умолчанию 3e-4) + --wd F weight decay (по умолчанию 0.01) + --clip F клип нормы градиента (по умолчанию 1.0) + --warmup N прогрев (по умолчанию 100) + --seed N зерно (по умолчанию 1337) + --log-every N как часто печатать (по умолчанию 50) + --ckpt-every N промежуточное сохранение каждые N шагов (0 = нет) + --val-every N валидация каждые N шагов (0 = нет) + --val-tokens N размер валидации (по умолчанию 20000) + --threads N потоков (0 = все ядра) + --resume продолжить с сохранённого step (Adam-state из файла) + +ОПЦИИ gen + --prompt STR стартовый текст + --n N сколько токенов (по умолчанию 200) + --temp F температура, 0 = жадный выбор (по умолчанию 0.8) + --top-k N top-k (0 = выкл) + --top-p F top-p (1.0 = выкл) + --seed N зерно + --no-stream не печатать в процессе + --batch "a;b;c" несколько промптов через ; + --show-tokens показать id токенов + +ОПЦИИ ollama + --port PORT порт на котором будет открыт сервер + --conf NAME.conf конфиг с настройками и списком моделей +)"; + +#endif \ No newline at end of file diff --git a/main.cpp b/main.cpp index 2f9a9cf..16e3c5e 100644 --- a/main.cpp +++ b/main.cpp @@ -1,21 +1,26 @@ -// main.cpp — командная строка Xenith #include "xenith/core/checkpoint.h" #include "xenith/core/generate.h" #include "xenith/core/train.h" #include "xenith/core/gradcheck.h" #include -#include +#include "help.h" #include +#include #include #include #include #include +#include #include #include +namespace std::filesystem::__cxx11 +{ + class filesystem_error; +} + using namespace xt; -// ------------------------------------------------------------------ утилиты static std::string read_all(const std::string& p, bool& ok) { std::ifstream f(p, std::ios::binary); if (!f) { ok = false; return {}; } @@ -34,7 +39,12 @@ static void mkdirs(const std::string& path) { } } -// Разбор аргументов вида --key value +struct Version { + int major = 0; + int minor = 0; + int patch = 0; +}; + struct Args { std::map kv; std::vector pos; @@ -72,74 +82,6 @@ struct Args { } }; -static void usage() { - printf(R"(ИСПОЛЬЗОВАНИЕ - xenith <команда> [опции] - -КОМАНДЫ - new создать новую модель из корпуса - train обучить существующую модель - gen сгенерировать текст - info показать конфигурацию модели - gradcheck проверить градиенты численно - bench замерить скорость форварда и шага обучения - ollama запустьтить сервер с api ollama - -ПРИМЕРЫ - xenith new model.xnh --corpus data.txt --vocab 512 --embd 64 --layers 4 --heads 4 - xenith train model.xnh --corpus data.txt --out model_trained.xnh --steps 3000 - xenith train model_trained.xnh --corpus data.txt --out model_trained.xnh --steps 6000 - xenith gen model_trained.xnh --prompt "Привет" --n 200 --temp 0.8 - -ОПЦИИ new - --corpus PATH текст для построения словаря (обязательно) - --out PATH файл модели (по умолчанию model.xnh) - --vocab N размер словаря (по умолчанию 512) - --embd N размер эмбеддинга (по умолчанию 128) - --layers N число слоёв (по умолчанию 4) - --heads N число голов (по умолчанию 4) - --ctx N максимальный контекст (по умолчанию 128) - --ffn N размер FFN (по умолчанию 4*embd) - --rope N база RoPE (по умолчанию 10000) - --seed N зерно инициализации (по умолчанию 1337) - --untied отдельная матрица выхода вместо привязанной к wte - -ОПЦИИ train - --corpus PATH обучающий текст (обязательно) - --out PATH куда сохранить (по умолчанию перезапись входного файла) - --steps N шагов (по умолчанию 1000) - --batch N батч (по умолчанию 8) - --block N длина окна (по умолчанию 64) - --lr F скорость (по умолчанию 3e-4) - --wd F weight decay (по умолчанию 0.01) - --clip F клип нормы градиента (по умолчанию 1.0) - --warmup N прогрев (по умолчанию 100) - --seed N зерно (по умолчанию 1337) - --log-every N как часто печатать (по умолчанию 50) - --ckpt-every N промежуточное сохранение каждые N шагов (0 = нет) - --val-every N валидация каждые N шагов (0 = нет) - --val-tokens N размер валидации (по умолчанию 20000) - --threads N потоков (0 = все ядра) - --resume продолжить с сохранённого step (Adam-state из файла) - -ОПЦИИ gen - --prompt STR стартовый текст - --n N сколько токенов (по умолчанию 200) - --temp F температура, 0 = жадный выбор (по умолчанию 0.8) - --top-k N top-k (0 = выкл) - --top-p F top-p (1.0 = выкл) - --seed N зерно - --no-stream не печатать в процессе - --batch "a;b;c" несколько промптов через ; - --show-tokens показать id токенов - -ОПЦИИ ollama - --port PORT порт на котором будет открыт сервер - --conf NAME.conf -)"); -} - -// ------------------------------------------------------------------ new static int cmd_new(const Args& a) { if (a.pos.empty()) { fprintf(stderr, "new: укажите путь модели\n"); return 1; } const std::string out = a.pos[0]; @@ -161,7 +103,7 @@ static int cmd_new(const Args& a) { ck.params.cfg.rope_base = a.geti("rope", 10000); if (a.has("untied")) ck.params.cfg.n_vocab_out = ck.params.cfg.vocab_size; - ck.tok.build_from_text(text, ck.params.cfg.vocab_size); + ck.tok.build_from_text(text, ck.params.cfg.vocab_size, a.has("view-vocab")); ck.params.cfg.vocab_size = ck.tok.size(); std::string err; @@ -172,8 +114,6 @@ static int cmd_new(const Args& a) { printf("создаю модель: %s\n", out.c_str()); print_model_info(ck); - - // размер папки, если out = models/xxx.xnh size_t slash = out.find_last_of('/'); if (slash != std::string::npos) mkdirs(out.substr(0, slash)); @@ -183,7 +123,6 @@ static int cmd_new(const Args& a) { return 0; } -// ------------------------------------------------------------------ train static int cmd_train(const Args& a) { if (a.pos.empty()) { fprintf(stderr, "train: укажите файл модели\n"); return 1; } const std::string path = a.pos[0]; @@ -218,7 +157,6 @@ static int cmd_train(const Args& a) { int resume = a.has("resume") ? ck.step : 0; if (resume > 0) { - // Adam-state уже загружен из файла, но steps надо расширить fprintf(stderr, "продолжаю с шага %d\n", resume); } @@ -227,7 +165,6 @@ static int cmd_train(const Args& a) { return 0; } -// ------------------------------------------------------------------ gen static int cmd_gen(const Args& a) { if (a.pos.empty()) { fprintf(stderr, "gen: укажите файл модели\n"); return 1; } Checkpoint ck; @@ -275,7 +212,6 @@ static int cmd_gen(const Args& a) { return 0; } -// ------------------------------------------------------------------ info static int cmd_info(const Args& a) { if (a.pos.empty()) { fprintf(stderr, "info: укажите файл модели\n"); return 1; } Checkpoint ck; @@ -303,56 +239,87 @@ static int cmd_bench(const Args& a) { } static int cmd_ollama(const Args& a) { - if (a.pos.empty()) { fprintf(stderr, "gen: укажите файл модели\n"); return 1; } - Checkpoint ck; - std::string err; - if (!load_checkpoint(a.pos[0], ck, err)) { fprintf(stderr, "gen: %s\n", err.c_str()); return 1; } + fprintf(stderr, "На стадии разработки"); + return 0; +} - GenConfig gc; - gc.max_new_tokens = a.geti("n", 200); - gc.temperature = a.getf("temp", 0.8f); - gc.top_k = a.geti("top-k", 40); - gc.top_p = a.getf("top-p", 0.95f); - gc.seed = a.geti("seed", -1); - gc.stream = !a.has("no-stream"); +Version parse_version(const std::string& str) { + Version v; + std::stringstream ss(str); + std::string segment; + if (std::getline(ss, segment, '.')) v.major = std::stoi(segment); + if (std::getline(ss, segment, '.')) v.minor = std::stoi(segment); + if (std::getline(ss, segment, '.')) v.patch = std::stoi(segment); + return v; +} - if (a.has("batch")) { - std::vector prompts; - std::string s = a.get("batch"); - size_t start = 0; - while (start <= s.size()) { - size_t p = s.find(';', start); - if (p == std::string::npos) { prompts.push_back(s.substr(start)); break; } - prompts.push_back(s.substr(start, p - start)); - start = p + 1; - } - gc.stream = false; - std::vector outs = generate_batch(ck.params, ck.tok, prompts, gc); - for (size_t i = 0; i < outs.size(); ++i) { - printf("=== промпт %zu: %s\n%s\n\n", i + 1, prompts[i].c_str(), outs[i].c_str()); - } - return 0; +static bool available_new_version() +{ + std::string cmd = "curl -s https://git.bipfr.ru/BIPfR/Xenith/raw/branch/master/version.txt -o ./tmp/remote_version.txt"; + system(cmd.c_str()); + std::ifstream tmp_file("./tmp/remote_version.txt"); + std::string version = "0.0.0"; + if (tmp_file.is_open()) { + std::getline(tmp_file, version); + tmp_file.close(); } + Version remote_version = parse_version(version); + std::ifstream file("./version.txt"); + version = "0.0.0"; + if (file.is_open()) { + std::getline(file, version); + file.close(); + } + Version current_version = parse_version(version); + if (remote_version.major > current_version.major) return true; + if (remote_version.minor > current_version.minor) return true; + if (remote_version.patch > current_version.patch) return true; + return false; +} - std::string prompt = a.get("prompt", ""); - if (a.pos.size() > 1) prompt = a.pos[1]; +static int cmd_update(const Args& a) +{ + if (available_new_version()) + { + namespace fs = std::filesystem; + std::cout << "Удаляем старые файлы..." << std::endl; + for (const auto& entry : fs::directory_iterator(".")) { + std::string name = entry.path().filename().string(); + if (name == "models") { + continue; + } + try { + if (fs::is_directory(entry.status())) { + fs::remove_all(entry.path()); + } else { + fs::remove(entry.path()); + } + } catch (const std::filesystem::__cxx11::filesystem_error& e) { + std::cerr << "Ошибка удаления " << name << ": " << e.what() << std::endl; + } + } + std::cout << "Скачиваем новую версию..." << std::endl; + int result = system("git clone https://git.bipfr.ru/BIPfR/Xenith /tmp/xenith_update"); - std::vector ids; - std::string text = generate(ck.params, ck.tok, prompt, gc, &ids); - - if (a.has("show-tokens")) { - printf("\n--- токены (%zu) ---\n", ids.size()); - for (size_t i = 0; i < ids.size(); ++i) - printf("%d ", ids[i]); - printf("\n"); + if (result != 0) { + std::cerr << "Ошибка при клонировании репозитория" << std::endl; + return -1; + } + result = system("cp -r /tmp/xenith_update/* ."); + if (result != 0) { + std::cerr << "Ошибка при копировании файлов" << std::endl; + return -1; + } + system("rm -rf /tmp/xenith_update"); + std::cout << "Обновление завершено!" << std::endl; } return 0; } int main(int argc, char** argv) { - if (argc < 2) { usage(); return 1; } + if (argc < 2) { printf(HELP_TEXT); return 1; } const std::string cmd = argv[1]; - if (cmd == "-h" || cmd == "--help" || cmd == "help") { usage(); return 0; } + if (cmd == "-h" || cmd == "--help" || cmd == "help") { printf(HELP_TEXT); return 0; } Args a(argc, argv, 2); if (cmd == "new") return cmd_new(a); @@ -361,9 +328,10 @@ int main(int argc, char** argv) { if (cmd == "info") return cmd_info(a); if (cmd == "gradcheck") return cmd_gradcheck(a); if (cmd == "bench") return cmd_bench(a); - if (cmd == "ollama") return cmd_bench(a); + if (cmd == "ollama") return cmd_ollama(a); + if (cmd == "update") return cmd_update(a); fprintf(stderr, "неизвестная команда: %s\n\n", cmd.c_str()); - usage(); + printf(HELP_TEXT); return 1; -} +} \ No newline at end of file diff --git a/models/demo.xnh b/models/demo.xnh deleted file mode 100644 index 4636bab..0000000 Binary files a/models/demo.xnh and /dev/null differ diff --git a/models/demo_trained.xnh b/models/demo_trained.xnh deleted file mode 100644 index e98f884..0000000 Binary files a/models/demo_trained.xnh and /dev/null differ diff --git a/models/demo_trained.xnh.step1500 b/models/demo_trained.xnh.step1500 deleted file mode 100644 index 8e3a1ec..0000000 Binary files a/models/demo_trained.xnh.step1500 and /dev/null differ diff --git a/models/my.xnh b/models/my.xnh deleted file mode 100644 index 11bbee0..0000000 Binary files a/models/my.xnh and /dev/null differ diff --git a/models/test_model.bfr b/models/test_model.bfr deleted file mode 100644 index 002d9c8..0000000 Binary files a/models/test_model.bfr and /dev/null differ diff --git a/models/test_model.h b/models/test_model.h deleted file mode 100644 index 96127af..0000000 --- a/models/test_model.h +++ /dev/null @@ -1,273 +0,0 @@ -#pragma once -#include -#include -#include - -constexpr int TEST_VOCAB_SIZE = 64; -constexpr int TEST_EMBEDDING_DIM = 8; -constexpr int TEST_NUM_HEADS = 2; -constexpr int TEST_HEAD_DIM = TEST_EMBEDDING_DIM / TEST_NUM_HEADS; -constexpr int TEST_NUM_LAYERS = 2; -constexpr int TEST_MAX_CTX = 500; - -inline const std::unordered_map TEST_VOCAB = { - // Специальные токены - {"", 0}, - {"", 1}, - {"", 2}, - {"", 3}, - - // Приветствия и базовые фразы - {"привет", 4}, - {"здравствуй", 5}, - {"как", 6}, - {"дела", 7}, - {"ты", 8}, - {"я", 9}, - {"мы", 10}, - - // Вопросы - {"что", 11}, - {"где", 12}, - {"когда", 13}, - {"почему", 14}, - {"сколько", 15}, - - // Существительные - {"мир", 16}, - {"день", 17}, - {"время", 18}, - {"работа", 19}, - {"код", 20}, - {"программа", 21}, - {"компьютер", 22}, - {"система", 23}, - {"данные", 24}, - {"память", 25}, - - // Глаголы - {"делать", 26}, - {"идти", 27}, - {"работать", 28}, - {"думать", 29}, - {"писать", 30}, - {"читать", 31}, - {"понимать", 32}, - - // Прилагательные - {"хорошо", 33}, - {"плохо", 34}, - {"быстро", 35}, - {"медленно", 36}, - {"новый", 37}, - {"старый", 38}, - - // Технические термины - {"функция", 39}, - {"переменная", 40}, - {"класс", 41}, - {"объект", 42}, - {"массив", 43}, - {"указатель", 44}, - {"алгоритм", 45}, - - // Союзы и предлоги - {"и", 46}, - {"или", 47}, - {"но", 48}, - {"если", 49}, - {"то", 50}, - {"в", 51}, - {"на", 52}, - {"с", 53}, - {"из", 54}, - {"для", 55}, - - // Частицы - {"не", 56}, - {"ли", 57}, - {"же", 58}, - {"бы", 59}, - - // Знаки препинания (опционально) - {".", 60}, - {",", 61}, - {"?", 62}, - {"!", 63}, -}; - -inline constexpr float TEST_W_EMB[TEST_VOCAB_SIZE][TEST_EMBEDDING_DIM] = { - // - {0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f}, - // - {0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f}, - // - {0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f}, - // - {0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f}, - // привет - {0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f}, - // здравствуй - {0.85f, 0.75f, 0.65f, 0.55f, 0.45f, 0.35f, 0.25f, 0.15f}, - // как - {0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 0.1f}, - // дела - {0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 0.1f, 0.2f}, - // ты - {0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 0.1f, 0.2f, 0.3f}, - // я - {0.6f, 0.7f, 0.8f, 0.9f, 0.1f, 0.2f, 0.3f, 0.4f}, - // мы - {0.7f, 0.8f, 0.9f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f}, - // что - {0.15f, 0.25f, 0.35f, 0.45f, 0.55f, 0.65f, 0.75f, 0.85f}, - // где - {0.25f, 0.35f, 0.45f, 0.55f, 0.65f, 0.75f, 0.85f, 0.95f}, - // когда - {0.35f, 0.45f, 0.55f, 0.65f, 0.75f, 0.85f, 0.95f, 0.05f}, - // почему - {0.45f, 0.55f, 0.65f, 0.75f, 0.85f, 0.95f, 0.05f, 0.15f}, - // сколько - {0.55f, 0.65f, 0.75f, 0.85f, 0.95f, 0.05f, 0.15f, 0.25f}, - // мир - {0.1f, 0.9f, 0.2f, 0.8f, 0.3f, 0.7f, 0.4f, 0.6f}, - // день - {0.2f, 0.8f, 0.3f, 0.7f, 0.4f, 0.6f, 0.5f, 0.5f}, - // время - {0.3f, 0.7f, 0.4f, 0.6f, 0.5f, 0.5f, 0.6f, 0.4f}, - // работа - {0.4f, 0.6f, 0.5f, 0.5f, 0.6f, 0.4f, 0.7f, 0.3f}, - // код - {0.5f, 0.5f, 0.6f, 0.4f, 0.7f, 0.3f, 0.8f, 0.2f}, - // программа - {0.6f, 0.4f, 0.7f, 0.3f, 0.8f, 0.2f, 0.9f, 0.1f}, - // компьютер - {0.7f, 0.3f, 0.8f, 0.2f, 0.9f, 0.1f, 0.0f, 0.0f}, - // система - {0.8f, 0.2f, 0.9f, 0.1f, 0.0f, 0.0f, 0.1f, 0.9f}, - // данные - {0.9f, 0.1f, 0.0f, 0.0f, 0.1f, 0.9f, 0.2f, 0.8f}, - // память - {0.0f, 0.0f, 0.1f, 0.9f, 0.2f, 0.8f, 0.3f, 0.7f}, - // делать - {0.12f, 0.23f, 0.34f, 0.45f, 0.56f, 0.67f, 0.78f, 0.89f}, - // идти - {0.23f, 0.34f, 0.45f, 0.56f, 0.67f, 0.78f, 0.89f, 0.12f}, - // работать - {0.34f, 0.45f, 0.56f, 0.67f, 0.78f, 0.89f, 0.12f, 0.23f}, - // думать - {0.45f, 0.56f, 0.67f, 0.78f, 0.89f, 0.12f, 0.23f, 0.34f}, - // писать - {0.56f, 0.67f, 0.78f, 0.89f, 0.12f, 0.23f, 0.34f, 0.45f}, - // читать - {0.67f, 0.78f, 0.89f, 0.12f, 0.23f, 0.34f, 0.45f, 0.56f}, - // понимать - {0.78f, 0.89f, 0.12f, 0.23f, 0.34f, 0.45f, 0.56f, 0.67f}, - // хорошо - {0.89f, 0.12f, 0.23f, 0.34f, 0.45f, 0.56f, 0.67f, 0.78f}, - // плохо - {0.11f, 0.22f, 0.33f, 0.44f, 0.55f, 0.66f, 0.77f, 0.88f}, - // быстро - {0.22f, 0.33f, 0.44f, 0.55f, 0.66f, 0.77f, 0.88f, 0.99f}, - // медленно - {0.33f, 0.44f, 0.55f, 0.66f, 0.77f, 0.88f, 0.99f, 0.11f}, - // новый - {0.44f, 0.55f, 0.66f, 0.77f, 0.88f, 0.99f, 0.11f, 0.22f}, - // старый - {0.55f, 0.66f, 0.77f, 0.88f, 0.99f, 0.11f, 0.22f, 0.33f}, - // функция - {0.66f, 0.77f, 0.88f, 0.99f, 0.11f, 0.22f, 0.33f, 0.44f}, - // переменная - {0.77f, 0.88f, 0.99f, 0.11f, 0.22f, 0.33f, 0.44f, 0.55f}, - // класс - {0.88f, 0.99f, 0.11f, 0.22f, 0.33f, 0.44f, 0.55f, 0.66f}, - // объект - {0.99f, 0.11f, 0.22f, 0.33f, 0.44f, 0.55f, 0.66f, 0.77f}, - // массив - {0.13f, 0.24f, 0.35f, 0.46f, 0.57f, 0.68f, 0.79f, 0.80f}, - // указатель - {0.24f, 0.35f, 0.46f, 0.57f, 0.68f, 0.79f, 0.80f, 0.13f}, - // алгоритм - {0.35f, 0.46f, 0.57f, 0.68f, 0.79f, 0.80f, 0.13f, 0.24f}, - // и - {0.46f, 0.57f, 0.68f, 0.79f, 0.80f, 0.13f, 0.24f, 0.35f}, - // или - {0.57f, 0.68f, 0.79f, 0.80f, 0.13f, 0.24f, 0.35f, 0.46f}, - // но - {0.68f, 0.79f, 0.80f, 0.13f, 0.24f, 0.35f, 0.46f, 0.57f}, - // если - {0.79f, 0.80f, 0.13f, 0.24f, 0.35f, 0.46f, 0.57f, 0.68f}, - // то - {0.80f, 0.13f, 0.24f, 0.35f, 0.46f, 0.57f, 0.68f, 0.79f}, - // в - {0.14f, 0.25f, 0.36f, 0.47f, 0.58f, 0.69f, 0.70f, 0.81f}, - // на - {0.25f, 0.36f, 0.47f, 0.58f, 0.69f, 0.70f, 0.81f, 0.14f}, - // с - {0.36f, 0.47f, 0.58f, 0.69f, 0.70f, 0.81f, 0.14f, 0.25f}, - // из - {0.47f, 0.58f, 0.69f, 0.70f, 0.81f, 0.14f, 0.25f, 0.36f}, - // для - {0.58f, 0.69f, 0.70f, 0.81f, 0.14f, 0.25f, 0.36f, 0.47f}, - // не - {0.69f, 0.70f, 0.81f, 0.14f, 0.25f, 0.36f, 0.47f, 0.58f}, - // ли - {0.70f, 0.81f, 0.14f, 0.25f, 0.36f, 0.47f, 0.58f, 0.69f}, - // же - {0.81f, 0.14f, 0.25f, 0.36f, 0.47f, 0.58f, 0.69f, 0.70f}, - // бы - {0.16f, 0.27f, 0.38f, 0.49f, 0.50f, 0.61f, 0.72f, 0.83f}, - // . - {0.27f, 0.38f, 0.49f, 0.50f, 0.61f, 0.72f, 0.83f, 0.16f}, - // , - {0.38f, 0.49f, 0.50f, 0.61f, 0.72f, 0.83f, 0.16f, 0.27f}, - // ? - {0.49f, 0.50f, 0.61f, 0.72f, 0.83f, 0.16f, 0.27f, 0.38f}, - // ! - {0.50f, 0.61f, 0.72f, 0.83f, 0.16f, 0.27f, 0.38f, 0.49f}, -}; - -inline constexpr float TEST_W_QKV[TEST_NUM_LAYERS][TEST_EMBEDDING_DIM][3][TEST_NUM_HEADS] = { - { - {{0.1f, 0.2f}, {0.3f, 0.4f}, {0.5f, 0.6f}}, - {{0.7f, 0.8f}, {0.9f, 1.0f}, {1.1f, 1.2f}}, - {{0.1f, 0.1f}, {0.2f, 0.2f}, {0.3f, 0.3f}}, - {{0.4f, 0.4f}, {0.5f, 0.5f}, {0.6f, 0.6f}}, - {{0.7f, 0.7f}, {0.8f, 0.8f}, {0.9f, 0.9f}}, - {{1.0f, 1.0f}, {1.1f, 1.1f}, {1.2f, 1.2f}}, - {{0.1f, 0.3f}, {0.5f, 0.7f}, {0.9f, 1.1f}}, - {{0.2f, 0.4f}, {0.6f, 0.8f}, {1.0f, 1.2f}} - }, - { - {{0.9f, 0.8f}, {0.7f, 0.6f}, {0.5f, 0.4f}}, - {{0.3f, 0.2f}, {0.1f, 0.0f}, {-0.1f, -0.2f}}, - {{0.5f, 0.5f}, {0.6f, 0.6f}, {0.7f, 0.7f}}, - {{0.8f, 0.8f}, {0.9f, 0.9f}, {1.0f, 1.0f}}, - {{0.2f, 0.4f}, {0.6f, 0.8f}, {1.0f, 1.2f}}, - {{0.3f, 0.5f}, {0.7f, 0.9f}, {1.1f, 1.3f}}, - {{0.4f, 0.6f}, {0.8f, 1.0f}, {1.2f, 1.4f}}, - {{0.5f, 0.7f}, {0.9f, 1.1f}, {1.3f, 1.5f}} - } -}; -inline constexpr float TEST_W_O[TEST_NUM_LAYERS][TEST_NUM_HEADS * TEST_HEAD_DIM][TEST_EMBEDDING_DIM] = { - { - {0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f}, - {0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f}, - {0.1f, 0.9f, 0.2f, 0.8f, 0.3f, 0.7f, 0.4f, 0.6f}, - {0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f}, - {0.2f, 0.4f, 0.6f, 0.8f, 1.0f, 1.2f, 1.4f, 1.6f}, - {0.3f, 0.5f, 0.7f, 0.9f, 1.1f, 1.3f, 1.5f, 1.7f}, - {0.4f, 0.6f, 0.8f, 1.0f, 1.2f, 1.4f, 1.6f, 1.8f}, - {0.5f, 0.7f, 0.9f, 1.1f, 1.3f, 1.5f, 1.7f, 1.9f} - }, - { - {0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f, 0.1f}, - {0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f}, - {0.9f, 0.1f, 0.8f, 0.2f, 0.7f, 0.3f, 0.6f, 0.4f}, - {0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f}, - {0.1f, 0.3f, 0.5f, 0.7f, 0.9f, 1.1f, 1.3f, 1.5f}, - {0.2f, 0.4f, 0.6f, 0.8f, 1.0f, 1.2f, 1.4f, 1.6f}, - {0.3f, 0.5f, 0.7f, 0.9f, 1.1f, 1.3f, 1.5f, 1.7f}, - {0.4f, 0.6f, 0.8f, 1.0f, 1.2f, 1.4f, 1.6f, 1.8f} - } -}; \ No newline at end of file diff --git a/version.txt b/version.txt new file mode 100644 index 0000000..7bcd0e3 --- /dev/null +++ b/version.txt @@ -0,0 +1 @@ +0.0.2 \ No newline at end of file diff --git a/xenith/core/backward.cpp b/xenith/core/backward.cpp index d9c5efd..f5982dc 100644 --- a/xenith/core/backward.cpp +++ b/xenith/core/backward.cpp @@ -1,21 +1,18 @@ -// backward.cpp — ручной обратный проход трансформера #include "train.h" #include #include namespace xt { -// softmax + cross-entropy на одном ряду; сразу отдаёт градиент по логитам static float softmax_ce(const float* logits, int V, int target, float* dlogits) { float mx = -1e30f; for (int j = 0; j < V; ++j) mx = std::max(mx, logits[j]); float sum = 0.0f; for (int j = 0; j < V; ++j) { float e = std::exp(logits[j] - mx); dlogits[j] = e; sum += e; } const float inv = 1.0f / sum; - for (int j = 0; j < V; ++j) dlogits[j] *= inv; // теперь dlogits = вероятности + for (int j = 0; j < V; ++j) dlogits[j] *= inv; float loss = -std::log(std::max(dlogits[target], 1e-30f)); - dlogits[target] -= 1.0f; // dL/dlogits = p - onehot - // Второго умножения на inv здесь быть НЕ должно: вероятности уже нормированы. + dlogits[target] -= 1.0f; return loss; } @@ -32,54 +29,36 @@ float backward(Params& p, const ForwardCache& fc, p.zero_grad(); - // ------------------------------------------- 1. логиты -> dxf, градиенты выхода Tensor dlogits(B, V); double loss_sum = 0; for (int t = 0; t < B; ++t) loss_sum += softmax_ce(fc.logits.row(t), V, y[t], dlogits.row(t)); - // Усредняем по батчу ДО умножения на матрицы — тогда все веса ниже - // автоматически получают правильный масштаб. const float dl = 1.0f / (float)B; for (auto& t : dlogits.d) t *= dl; Tensor dxf(B, d); if (p.tied()) { - gemm_nn(dlogits, p.wte, dxf); // dxf = dlogits @ wte - gemm_tn(dlogits, fc.xf, p.gwte, true); // dwte += dlogits^T @ xf + gemm_nn(dlogits, p.wte, dxf); + gemm_tn(dlogits, fc.xf, p.gwte, true); } else { gemm_nn(dlogits, p.lm_head, dxf); gemm_tn(dlogits, fc.xf, p.glm_head, true); } - // ------------------------------------------- 2. финальный RMSNorm Tensor dx; rmsnorm_backward(fc.x, p.rms_final, fc.inv_rms, dxf, dx, p.grms_final); - // ------------------------------------------- 3. слои в обратном порядке - // - // Структура слоя (та же, что в forward): - // x_mid = x_in + proj proj = attout @ wo - // x2 = x_mid (x2 копия residual'а) - // x_out = x2 + fo fo = FFN(x2b), x2b = RMS(x2) - // - // dfo = dL/dx_out = dres - // dproj = dL/dx_mid = dres + вклад FFN (proj добавляется ДО fo) - // dL/dx_in = dproj + вклад attention Tensor tmp, dxb, dx2b, dha, dh1, dh3, dq, dk, dv, datt, dattout; for (int L = c.n_layer - 1; L >= 0; --L) { const LayerCache& lc = fc.layers[L]; - // dres — градиент по ВЫХОДУ слоя residual'а. const Tensor dres = dx; - // ================= FFN ================= - // fo = ha @ w2 gemm_tn(lc.ha, dres, p.g2[L], true); // dW2 gemm_nt(dres, p.w2[L], dha); // dha = dres @ w2^T - // ha = silu(h1) * h3 dh1.resize(B, f); dh3.resize(B, f); for (int t = 0; t < B; ++t) { @@ -94,29 +73,23 @@ float backward(Params& p, const ForwardCache& fc, d3[j] = ga * silu(g); } } - // dW = X^T @ dY => первым аргументом gemm_tn идёт X gemm_tn(lc.x2b, dh1, p.g1[L], true); // dW1 gemm_tn(lc.x2b, dh3, p.g3[L], true); // dW3 - // dx2b = dh1 @ w1^T + dh3 @ w3^T dx2b.resize(B, d); gemm_nt(dh1, p.w1[L], dx2b); gemm_nt(dh3, p.w3[L], tmp); for (size_t i = 0; i < dx2b.n(); ++i) dx2b.at(i) += tmp.at(i); - // RMSNorm перед FFN: вклад идёт в dx (градиент по x2 == x_mid) { Tensor g; rmsnorm_backward(lc.x2, p.rms_ffn[L], lc.inv_rms2, dx2b, g, p.grms_ffn[L]); for (size_t i = 0; i < dx.n(); ++i) dx.at(i) += g.at(i); } - // ================= attention ================= - // proj = attout @ wo - // Здесь читаем dx (== dL/dx_mid, уже с вкладом FFN), а НЕ dres. - gemm_tn(lc.attout, dx, p.go[L], true); // dWo + gemm_tn(lc.attout, dx, p.go[L], true); dattout.resize(B, d); - gemm_nt(dx, p.wo[L], dattout); // dattout = dx @ wo^T + gemm_nt(dx, p.wo[L], dattout); dq.resize(B, d); dq.zero(); dk.resize(B, d); dk.zero(); @@ -132,7 +105,6 @@ float backward(Params& p, const ForwardCache& fc, const float* ar = lc.att.row(hp * S + t1); float* dq_row = dq.row(r1) + hh * hd; - // dv[t2] += att[t1][t2] * dattout[t1] for (int t2 = 0; t2 <= t1; ++t2) { const float a = ar[t2]; if (a == 0.0f) continue; @@ -140,7 +112,6 @@ float backward(Params& p, const ForwardCache& fc, for (int j = 0; j < hd; ++j) dvr[j] += a * dar[j]; } - // datt[t1][t2] = dot(dattout[t1], v[t2]) float* darow = datt.row(hp * S + t1); for (int t2 = 0; t2 <= t1; ++t2) { const float* vr = lc.v.row(sq * S + t2) + hh * hd; @@ -149,13 +120,11 @@ float backward(Params& p, const ForwardCache& fc, darow[t2] = s; } - // якобиан softmax: dscores = a * (dp - sum(a*dp)) * scale float dpdot = 0.0f; for (int t2 = 0; t2 <= t1; ++t2) dpdot += ar[t2] * darow[t2]; for (int t2 = 0; t2 <= t1; ++t2) darow[t2] = ar[t2] * (darow[t2] - dpdot) * scale; - // dq[t1] += dscores * k[t2]; dk[t2] += dscores * q[t1] for (int t2 = 0; t2 <= t1; ++t2) { const float ds = darow[t2]; if (ds == 0.0f) continue; @@ -171,7 +140,6 @@ float backward(Params& p, const ForwardCache& fc, } } - // ================= RoPE backward ================= for (int sq = 0; sq < n_seq; ++sq) { for (int t = 0; t < S; ++t) { const int row = sq * S + t; @@ -183,7 +151,7 @@ float backward(Params& p, const ForwardCache& fc, for (int i = 0; i < half; ++i) { const float c0 = cs[i], s0 = sn[i]; float a0 = dq_[2 * i], a1 = dq_[2 * i + 1]; - dq_[2 * i] = a0 * c0 + a1 * s0; // транспонированный поворот + dq_[2 * i] = a0 * c0 + a1 * s0; dq_[2 * i + 1] = -a0 * s0 + a1 * c0; float b0 = dk_[2 * i], b1 = dk_[2 * i + 1]; dk_[2 * i] = b0 * c0 + b1 * s0; @@ -193,12 +161,10 @@ float backward(Params& p, const ForwardCache& fc, } } - // ================= QKV backward ================= - gemm_tn(lc.xb, dq, p.gq[L], true); // dWq - gemm_tn(lc.xb, dk, p.gk[L], true); // dWk - gemm_tn(lc.xb, dv, p.gv[L], true); // dWv + gemm_tn(lc.xb, dq, p.gq[L], true); + gemm_tn(lc.xb, dk, p.gk[L], true); + gemm_tn(lc.xb, dv, p.gv[L], true); - // dxb = dq @ wq^T + dk @ wk^T + dv @ wv^T dxb.resize(B, d); gemm_nt(dq, p.wq[L], dxb); gemm_nt(dk, p.wk[L], tmp); @@ -206,7 +172,6 @@ float backward(Params& p, const ForwardCache& fc, gemm_nt(dv, p.wv[L], tmp); for (size_t i = 0; i < dxb.n(); ++i) dxb.at(i) += tmp.at(i); - // ================= RMSNorm перед attention ================= { Tensor g; rmsnorm_backward(lc.x, p.rms_attn[L], lc.inv_rms, dxb, g, p.grms_attn[L]); @@ -214,7 +179,6 @@ float backward(Params& p, const ForwardCache& fc, } } - // ------------------------------------------- 4. градиент входных эмбеддингов for (int t = 0; t < B; ++t) { const float* gxr = dx.row(t); float* gw = p.gwte.row(x[t]); @@ -239,4 +203,4 @@ float softmax_eval(const Params& p, const ForwardCache& fc, return (float)(sum / (double)n_pairs); } -} // namespace xt +} diff --git a/xenith/core/backward.d b/xenith/core/backward.d deleted file mode 100644 index d5d70e6..0000000 --- a/xenith/core/backward.d +++ /dev/null @@ -1,6 +0,0 @@ -xenith/core/backward.o: xenith/core/backward.cpp xenith/core/train.h \ - xenith/core/model.h xenith/core/tensor.h xenith/core/checkpoint.h -xenith/core/train.h: -xenith/core/model.h: -xenith/core/tensor.h: -xenith/core/checkpoint.h: diff --git a/xenith/core/backward.o b/xenith/core/backward.o deleted file mode 100644 index cf4d375..0000000 Binary files a/xenith/core/backward.o and /dev/null differ diff --git a/xenith/core/checkpoint.cpp b/xenith/core/checkpoint.cpp index 863d399..68757e5 100644 --- a/xenith/core/checkpoint.cpp +++ b/xenith/core/checkpoint.cpp @@ -1,4 +1,3 @@ -// checkpoint.cpp — бинарный формат XNH1, токенизатор уровня байт/слова #include "checkpoint.h" #include #include @@ -7,16 +6,12 @@ #include #include #include +#include namespace xt { -// ------------------------------------------------------- токенизатор -// Уровень 1: частое слова целиком. Уровень 2: отдельные байты. -// Так словарь остаётся маленьким, а любой текст кодируется без потерь. - namespace { -// Разбивает UTF-8 строку на "символы" (кодпоинты) std::vector utf8_chars(const std::string& s) { std::vector out; for (size_t i = 0; i < s.size();) { @@ -36,16 +31,15 @@ bool is_space(const std::string& t) { return t.size() == 1 && (t[0] == ' ' || t[0] == '\t' || t[0] == '\n' || t[0] == '\r'); } -} // namespace +} -void Tokenizer::build_from_text(const std::string& text, int max_vocab) { +void Tokenizer::build_from_text(const std::string& text, int max_vocab, bool debug) { id2tok.clear(); - id2tok.push_back(""); // 0 - id2tok.push_back(""); // 1 - id2tok.push_back(""); // 2 - id2tok.push_back("\n"); // 3 + id2tok.push_back(""); + id2tok.push_back(""); + id2tok.push_back(""); + id2tok.push_back("\n"); - // Считаем частоты слов (с сохранением регистра) std::unordered_map freq; std::string word; auto flush = [&]() { @@ -61,13 +55,11 @@ void Tokenizer::build_from_text(const std::string& text, int max_vocab) { std::sort(items.begin(), items.end(), [](const std::pair& a, const std::pair& b) { if (a.second != b.second) return a.second > b.second; - return a.first < b.first; // детерминированный порядок при равенстве + return a.first < b.first; }); const int room = max_vocab - (int)id2tok.size(); for (int i = 0; i < (int)items.size() && i < room; ++i) id2tok.push_back(items[i].first); - - // Добираем оставшиеся слоты одиночными байтами, чтобы покрыть весь алфавит std::vector chars = utf8_chars(text); std::sort(chars.begin(), chars.end()); chars.erase(std::unique(chars.begin(), chars.end()), chars.end()); @@ -76,13 +68,26 @@ void Tokenizer::build_from_text(const std::string& text, int max_vocab) { if (std::find(id2tok.begin(), id2tok.end(), c) == id2tok.end()) id2tok.push_back(c); } + + if (debug) + { + std::cout << "=== Vocabulary (Size: " << id2tok.size() << ") ===" << std::endl; + for (size_t i = 0; i < id2tok.size(); ++i) { + // Для наглядности заменяем невидимые символы на их представления + std::string display_tok = id2tok[i]; + if (display_tok == "\n") display_tok = "\\n"; + if (display_tok == " ") display_tok = "[space]"; + + std::cout << " [" << i << "] \"" << display_tok << "\"" << std::endl; + } + std::cout << "===============================" << std::endl; + } } std::vector Tokenizer::encode(const std::string& text, bool add_bos) const { - // Карта: слово -> id. Строится лениво, один раз на вызов. std::unordered_map word2id; std::unordered_map char2id; - const int base = 4; // первые 4 — служебные + const int base = 4; for (int i = base; i < size(); ++i) { const std::string& t = id2tok[i]; if (t.size() == 1) char2id[t] = i; @@ -120,7 +125,6 @@ std::vector Tokenizer::encode(const std::string& text, bool add_bos) const if (it != char2id.end()) out.push_back(it->second); else out.push_back(3); } - // обычные пробелы не кодируем — слова склеиваются по границам словаря } else { word += ch; } @@ -151,7 +155,6 @@ std::string Tokenizer::decode(const std::vector& ids, bool skip_bos) const return out; } -// ------------------------------------------------------- ввод-вывод namespace { template @@ -166,7 +169,7 @@ bool rd(std::ifstream& f, T& v) { return (bool)f; } -} // namespace +} bool save_checkpoint(const std::string& path, const Checkpoint& ck, std::string& err) { std::ofstream f(path, std::ios::binary); @@ -202,14 +205,12 @@ bool save_checkpoint(const std::string& path, const Checkpoint& ck, std::string& f.write(ck.tok.id2tok[i].data(), len); } - // веса for (const Tensor* t : ck.params.all()) { wr(f, (int32_t)t->R()); wr(f, (int32_t)t->C()); f.write(reinterpret_cast(t->ptr()), (std::streamsize)t->n() * sizeof(float)); } - // оптимизатор: только если просили if (!ck.params.m.empty()) { wr(f, (uint32_t)1); for (size_t i = 0; i < ck.params.m.size(); ++i) { @@ -285,11 +286,10 @@ bool load_checkpoint(const std::string& path, Checkpoint& ck, std::string& err) return false; } - // аллоцируем и читаем веса const int d = c.n_embd, ffn = c.ffn(); ck.params.wte.resize(c.vocab_size, d); if (!ck.params.tied()) ck.params.lm_head.resize(c.vocab_out(), d); - ck.params.wq.resize(c.n_layer, Tensor(d, d)); // q/k/v — три отдельных тензора [d,d] + ck.params.wq.resize(c.n_layer, Tensor(d, d)); ck.params.wk.resize(c.n_layer, Tensor(d, d)); ck.params.wv.resize(c.n_layer, Tensor(d, d)); ck.params.wo.resize(c.n_layer, Tensor(d, d)); @@ -312,7 +312,6 @@ bool load_checkpoint(const std::string& path, Checkpoint& ck, std::string& err) if (!f) { err = "файл обрывается при чтении весов"; return false; } } - // моменты оптимизатора (необязательно) uint32_t has_opt = 0; if (rd(f, has_opt) && has_opt) { auto ps = ck.params.all(); @@ -351,4 +350,4 @@ void print_model_info(const Checkpoint& ck) { printf(" шаг : %d, loss %.4f\n", ck.step, ck.loss); } -} // namespace xt +} diff --git a/xenith/core/checkpoint.d b/xenith/core/checkpoint.d deleted file mode 100644 index 9659958..0000000 --- a/xenith/core/checkpoint.d +++ /dev/null @@ -1,5 +0,0 @@ -xenith/core/checkpoint.o: xenith/core/checkpoint.cpp \ - xenith/core/checkpoint.h xenith/core/model.h xenith/core/tensor.h -xenith/core/checkpoint.h: -xenith/core/model.h: -xenith/core/tensor.h: diff --git a/xenith/core/checkpoint.h b/xenith/core/checkpoint.h index 8513240..aa42f87 100644 --- a/xenith/core/checkpoint.h +++ b/xenith/core/checkpoint.h @@ -1,4 +1,3 @@ -// checkpoint.h — сохранение и загрузка модели #pragma once #include "model.h" #include @@ -7,14 +6,13 @@ namespace xt { -// Токенизатор: словарь хранится рядом с весами в том же файле struct Tokenizer { - std::vector id2tok; // id -> строка + std::vector id2tok; int bos = 1, eos = 2, unk = 0; int size() const { return (int)id2tok.size(); } - void build_from_text(const std::string& text, int max_vocab); + void build_from_text(const std::string& text, int max_vocab, bool debug = false); std::vector encode(const std::string& text, bool add_bos = true) const; std::string decode(const std::vector& ids, bool skip_bos = true) const; std::string decode_one(int id) const; @@ -31,7 +29,6 @@ struct Checkpoint { bool save_checkpoint(const std::string& path, const Checkpoint& ck, std::string& err); bool load_checkpoint(const std::string& path, Checkpoint& ck, std::string& err); -// Читаемый дамп конфигурации void print_model_info(const Checkpoint& ck); } // namespace xt diff --git a/xenith/core/checkpoint.o b/xenith/core/checkpoint.o deleted file mode 100644 index 5280798..0000000 Binary files a/xenith/core/checkpoint.o and /dev/null differ diff --git a/xenith/core/generate.cpp b/xenith/core/generate.cpp index 8796008..a17a522 100644 --- a/xenith/core/generate.cpp +++ b/xenith/core/generate.cpp @@ -1,5 +1,3 @@ -// generate.cpp — инкрементальная генерация с KV-кэшем -// Кэш: [layer][token][head][dim] для K и для V отдельно. #include "generate.h" #include #include @@ -9,16 +7,15 @@ namespace xt { namespace { -// Раскладка кэша: один плоский буфер на (K,V) оба сразу struct KvCache { int n_layer, max_ctx, n_head, head_dim, d_model; - std::vector data; // K и V подряд: сначала все K, потом все V - int len = 0; // сколько позиций занято + std::vector data; + int len = 0; void init(int L, int ctx, int H, int hd) { n_layer = L; max_ctx = ctx; n_head = H; head_dim = hd; d_model = H * hd; - size_t per = (size_t)L * ctx * H * hd; // столько на K, столько на V + size_t per = (size_t)L * ctx * H * hd; data.assign(per * 2, 0.0f); len = 0; } @@ -32,7 +29,6 @@ struct KvCache { } }; -// RoPE на одном векторе длины head_dim, позиция pos void rope_apply(float* x, int hd, int pos, const std::vector& cs, const std::vector& sn) { const int half = hd / 2; @@ -46,7 +42,6 @@ void rope_apply(float* x, int hd, int pos, const std::vector& cs, } } -// Один токен через все слои. Возвращает логиты. void forward_token(const Params& p, KvCache& kv, int token, int pos, const std::vector& cs, const std::vector& sn, Tensor& logits) { @@ -54,7 +49,6 @@ void forward_token(const Params& p, KvCache& kv, int token, int pos, const int d = c.n_embd, H = c.n_head, hd = c.head_dim(), f = c.ffn(); const float scale = 1.0f / std::sqrt((float)hd); - // эмбеддинг Tensor x(1, d); const float* er = p.wte.row(token); for (int j = 0; j < d; ++j) x.at(j) = er[j]; @@ -120,12 +114,10 @@ void forward_token(const Params& p, KvCache& kv, int token, int pos, else gemm_nn(lnf, p.lm_head, logits); } -// Сэмплирование из логитов int sample(const Tensor& logits, const GenConfig& gc, Rng& rng, const std::vector& history) { const int V = logits.C(); std::vector lp(V); - // штраф за повтор float rp = gc.repeat_penalty; if (rp != 1.0f) { for (int id : history) { @@ -143,7 +135,6 @@ int sample(const Tensor& logits, const GenConfig& gc, Rng& rng, const std::vecto for (int j = 0; j < V; ++j) lp[j] /= gc.temperature; - // top-k if (gc.top_k > 0 && gc.top_k < V) { std::vector> v(V); for (int j = 0; j < V; ++j) v[j] = {lp[j], j}; @@ -161,7 +152,6 @@ int sample(const Tensor& logits, const GenConfig& gc, Rng& rng, const std::vecto for (int j = 0; j < V; ++j) { lp[j] = std::exp(lp[j] - mx); sum += lp[j]; } if (sum <= 0.0f) return 0; - // top-p (nucleus) if (gc.top_p < 1.0f) { std::vector> v(V); for (int j = 0; j < V; ++j) v[j] = {lp[j] / sum, j}; @@ -190,7 +180,7 @@ int sample(const Tensor& logits, const GenConfig& gc, Rng& rng, const std::vecto return V - 1; } -} // namespace +} std::string generate(const Params& p, const Tokenizer& tok, const std::string& prompt, const GenConfig& gc, @@ -217,13 +207,11 @@ std::string generate(const Params& p, const Tokenizer& tok, for (int n = 0; n < gc.max_new_tokens; ++n) { if (kv.len >= c.block_size) { - // контекст исчерпан: сдвигаем окно const int keep = c.block_size / 2; for (size_t i = 0; i < ids.size(); ++i) ids[i] = ids[ids.size() - keep + i]; ids.resize(keep); kv.reset(); - // прогоняем окно заново for (int t = 0; t < keep; ++t) { forward_token(p, kv, ids[t], kv.len, cs, sn, logits); kv.len++; @@ -272,4 +260,4 @@ std::vector generate_batch(const Params& p, const Tokenizer& tok, return out; } -} // namespace xt +} diff --git a/xenith/core/generate.d b/xenith/core/generate.d deleted file mode 100644 index d7e9021..0000000 --- a/xenith/core/generate.d +++ /dev/null @@ -1,6 +0,0 @@ -xenith/core/generate.o: xenith/core/generate.cpp xenith/core/generate.h \ - xenith/core/checkpoint.h xenith/core/model.h xenith/core/tensor.h -xenith/core/generate.h: -xenith/core/checkpoint.h: -xenith/core/model.h: -xenith/core/tensor.h: diff --git a/xenith/core/generate.h b/xenith/core/generate.h index c4679d5..3a44a4b 100644 --- a/xenith/core/generate.h +++ b/xenith/core/generate.h @@ -8,21 +8,20 @@ namespace xt { struct GenConfig { int max_new_tokens = 200; - float temperature = 0.8f; // <= 0 => greedy - int top_k = 40; // 0 => выключить - float top_p = 0.95f; // >= 1 => выключить - int seed = -1; // -1 => случайный - bool stream = true; // печатать по мере генерации - int repeat_penalty = 1; // штраф за повтор (окно = 64) + float temperature = 0.8f; + int top_k = 40; + float top_p = 0.95f; + int seed = -1; + bool stream = true; + int repeat_penalty = 1; }; std::string generate(const Params& p, const Tokenizer& tok, const std::string& prompt, const GenConfig& gc, std::vector* out_ids = nullptr); -// Батч из нескольких промптов — переиспользует один набор весов std::vector generate_batch(const Params& p, const Tokenizer& tok, const std::vector& prompts, const GenConfig& gc); -} // namespace xt +} diff --git a/xenith/core/generate.o b/xenith/core/generate.o deleted file mode 100644 index 1243bcc..0000000 Binary files a/xenith/core/generate.o and /dev/null differ diff --git a/xenith/core/gradcheck.cpp b/xenith/core/gradcheck.cpp index eda308d..f6aeced 100644 --- a/xenith/core/gradcheck.cpp +++ b/xenith/core/gradcheck.cpp @@ -22,16 +22,15 @@ float eval_loss(const Params& p, const std::vector& x, const std::vector(t1 - t0).count(); float all_tps = (double)n * iters / d_all; - // генерация: замер на токен GenConfig gc; gc.max_new_tokens = 32; gc.temperature = 0.0f; @@ -170,4 +162,4 @@ int run_bench(Checkpoint& ck, int iters, int block) { return 0; } -} // namespace xt +} diff --git a/xenith/core/gradcheck.d b/xenith/core/gradcheck.d deleted file mode 100644 index 94d7ac3..0000000 --- a/xenith/core/gradcheck.d +++ /dev/null @@ -1,9 +0,0 @@ -xenith/core/gradcheck.o: xenith/core/gradcheck.cpp \ - xenith/core/gradcheck.h xenith/core/checkpoint.h xenith/core/model.h \ - xenith/core/tensor.h xenith/core/generate.h xenith/core/train.h -xenith/core/gradcheck.h: -xenith/core/checkpoint.h: -xenith/core/model.h: -xenith/core/tensor.h: -xenith/core/generate.h: -xenith/core/train.h: diff --git a/xenith/core/gradcheck.o b/xenith/core/gradcheck.o deleted file mode 100644 index 4636b02..0000000 Binary files a/xenith/core/gradcheck.o and /dev/null differ diff --git a/xenith/core/model.cpp b/xenith/core/model.cpp index 81b974f..6dcdcf8 100644 --- a/xenith/core/model.cpp +++ b/xenith/core/model.cpp @@ -1,4 +1,3 @@ -// model.cpp — инициализация, прямой проход, RoPE, Adam #include "model.h" #include #include @@ -24,7 +23,6 @@ bool Config::valid(std::string& err) const { return true; } -// ------------------------------------------------------------------ init void Params::init(uint64_t seed) { Rng rng(seed); const int d = cfg.n_embd, f = cfg.ffn(); @@ -102,7 +100,6 @@ void Params::alloc_grads() { grms_final = Tensor(1, d); } -// Порядок фиксированный — от него зависит сохранение в файл std::vector Params::all() const { std::vector v; v.push_back(&wte); @@ -155,11 +152,6 @@ void Params::adam_step(float lr, float b1, float b2, float eps, float wd, int st m.clear(); v.clear(); for (Tensor* t : params) { m.push_back(Tensor(t->R(), t->C())); v.push_back(Tensor(t->R(), t->C())); } } - - // Единственный nan/inf в градиенте отравляет момент m и v этого - // элемента НАВСЕГДА: и Adam, и sqrt(V) будут nan, и вес больше не - // восстановится. Поэтому выкидываем нечисловые значения до того, - // как они попадут в моменты, и сигналим. if (clip > 0.0f) { double sq = 0; bool dirty = false; @@ -198,7 +190,6 @@ void Params::adam_step(float lr, float b1, float b2, float eps, float wd, int st } } -// ----------------------------------------------------------------- RoPE void rope_tables(int block, int head_dim, int base, std::vector& cs, std::vector& sn) { const int half = head_dim / 2; cs.resize((size_t)block * half); @@ -213,20 +204,14 @@ void rope_tables(int block, int head_dim, int base, std::vector& cs, std: } } -// ------------------------------------------------------------- forward -// B = n_tok — общее число токенов -// S = seq_len — длина одной последовательности (B кратно S) -// Каждая последовательность b занимает строки [b*S, (b+1)*S) и имеет -// СВОИ позиции RoPE 0..S-1 и СВОЮ каузальную маску. Иначе токен из -// конца первого батча «видел» бы начало второго. void forward(const Params& p, const int* tokens, int n_tok, int seq_len, ForwardCache& fc) { const Config& c = p.cfg; const int d = c.n_embd, H = c.n_head, hd = c.head_dim(), f = c.ffn(); int B = n_tok; int S = seq_len; if (S <= 0) S = B; - if (S > c.block_size) S = c.block_size; // RoPE-таблица не длиннее block_size - if (B % S != 0) B = (B / S) * S; // отбрасываем хвост + if (S > c.block_size) S = c.block_size; + if (B % S != 0) B = (B / S) * S; const int n_seq = B / S; fc.block = S; @@ -241,7 +226,6 @@ void forward(const Params& p, const int* tokens, int n_tok, int seq_len, Forward const float* CS = fc.rope_cos.data(); const float* SN = fc.rope_sin.data(); - // --- эмбеддинги --- fc.x.resize(B, d); for (int t = 0; t < B; ++t) { float* xr = fc.x.row(t); @@ -257,13 +241,11 @@ void forward(const Params& p, const int* tokens, int n_tok, int seq_len, Forward lc.x.resize(B, d); for (size_t i = 0; i < fc.x.n(); ++i) lc.x.at(i) = fc.x.at(i); - // --- нормализация + QKV --- rmsnorm_forward(lc.x, p.rms_attn[L], c.rms_eps, lc.xb, lc.inv_rms); gemm_nn(lc.xb, p.wq[L], lc.q); gemm_nn(lc.xb, p.wk[L], lc.k); gemm_nn(lc.xb, p.wv[L], lc.v); - // --- RoPE: позиция считается ВНУТРИ последовательности --- for (int b = 0; b < n_seq; ++b) { for (int t = 0; t < S; ++t) { const int row = b * S + t; @@ -285,14 +267,13 @@ void forward(const Params& p, const int* tokens, int n_tok, int seq_len, Forward } } - // --- causal attention (независимо в каждой последовательности) --- lc.att.resize3d(n_seq * H, S, S); lc.attout.resize(B, d); lc.attout.zero(); for (int s = 0; s < n_seq; ++s) { for (int hh = 0; hh < H; ++hh) { - const int hp = s * H + hh; // плоский индекс головы + const int hp = s * H + hh; for (int t1 = 0; t1 < S; ++t1) { const float* qr = lc.q.row(s * S + t1) + hh * hd; float* sr = scores.row(t1); @@ -311,7 +292,6 @@ void forward(const Params& p, const int* tokens, int n_tok, int seq_len, Forward float* ar = lc.att.row(hp * S + t1); for (int t2 = 0; t2 < S; ++t2) ar[t2] = (t2 <= t1) ? sr[t2] * inv : 0.0f; } - // out[t1] = sum_t2 att[t1][t2] * v[t2] for (int t1 = 0; t1 < S; ++t1) { const float* ar = lc.att.row(hp * S + t1); float* orow = lc.attout.row(s * S + t1) + hh * hd; @@ -324,15 +304,12 @@ void forward(const Params& p, const int* tokens, int n_tok, int seq_len, Forward } } } - - // --- выход attention + residual --- gemm_nn(lc.attout, p.wo[L], lc.proj); for (size_t i = 0; i < fc.x.n(); ++i) fc.x.at(i) += lc.proj.at(i); lc.x2.resize(B, d); for (size_t i = 0; i < fc.x.n(); ++i) lc.x2.at(i) = fc.x.at(i); - // --- FFN (SwiGLU) --- rmsnorm_forward(lc.x2, p.rms_ffn[L], c.rms_eps, lc.x2b, lc.inv_rms2); gemm_nn(lc.x2b, p.w1[L], lc.h1); gemm_nn(lc.x2b, p.w3[L], lc.h3); @@ -343,14 +320,12 @@ void forward(const Params& p, const int* tokens, int n_tok, int seq_len, Forward for (size_t i = 0; i < fc.x.n(); ++i) fc.x.at(i) += lc.fo.at(i); } - // --- финальная нормализация + выход --- rmsnorm_forward(fc.x, p.rms_final, c.rms_eps, fc.xf, fc.inv_rms); fc.logits.resize(B, c.vocab_out()); if (p.tied()) gemm_nt(fc.xf, p.wte, fc.logits); else gemm_nn(fc.xf, p.lm_head, fc.logits); } -// Одиночная последовательность: seq_len = n_tok void forward(const Params& p, const int* tokens, int n_tok, ForwardCache& fc) { forward(p, tokens, n_tok, n_tok, fc); } @@ -363,4 +338,4 @@ void forward_last(const Params& p, const int* tokens, int n_tok, Tensor& logits) for (int j = 0; j < V; ++j) logits.at(j) = fc.logits.at((n_tok - 1) * V + j); } -} // namespace xt +} diff --git a/xenith/core/model.d b/xenith/core/model.d deleted file mode 100644 index d7cfcc5..0000000 --- a/xenith/core/model.d +++ /dev/null @@ -1,4 +0,0 @@ -xenith/core/model.o: xenith/core/model.cpp xenith/core/model.h \ - xenith/core/tensor.h -xenith/core/model.h: -xenith/core/tensor.h: diff --git a/xenith/core/model.h b/xenith/core/model.h index e857981..8245f19 100644 --- a/xenith/core/model.h +++ b/xenith/core/model.h @@ -1,4 +1,3 @@ -// model.h — конфигурация, параметры и прямой проход трансформера #pragma once #include "tensor.h" #include @@ -6,7 +5,6 @@ namespace xt { -// Магия формата: 'X','N','H','1' в little-endian constexpr uint32_t XNH_MAGIC = 0x31484E58; struct Config { @@ -14,12 +12,12 @@ struct Config { int n_layer = 4; int n_head = 4; int n_embd = 128; - int block_size = 128; // максимальный контекст - int ffn_dim = 0; // 0 => 4*n_embd + int block_size = 128; + int ffn_dim = 0; int rope_base = 10000; float rms_eps = 1e-5f; float init_std = 0.02f; - int n_vocab_out = 0; // 0 => tied (используем wte как выходную матрицу) + int n_vocab_out = 0; int head_dim() const { return n_embd / n_head; } int ffn() const { return ffn_dim > 0 ? ffn_dim : 4 * n_embd; } @@ -27,22 +25,19 @@ struct Config { bool valid(std::string& err) const; }; -// Все обучаемые веса. Именно этот список сериализуется в файл модели. struct Params { Config cfg; - Tensor wte; // [vocab, n_embd] — вход - Tensor lm_head; // [n_embd, vocab_out] — только если НЕ tied + Tensor wte; + Tensor lm_head; std::vector wq, wk, wv, wo; std::vector rms_attn, rms_ffn; - std::vector w1, w2, w3; // SwiGLU - Tensor rms_final; // [1, n_embd] + std::vector w1, w2, w3; + Tensor rms_final; - // Градиенты (тет же порядок, что у all()) Tensor gwte, glm_head, grms_final; std::vector gq, gk, gv, go, grms_attn, grms_ffn, g1, g2, g3; - // Моменты Adam std::vector m, v; size_t n_params() const; @@ -53,52 +48,43 @@ struct Params { void adam_step(float lr, float b1, float b2, float eps, float wd, int step, float clip); - std::vector all() const; // только для чтения/сохранения - std::vector all_w(); // для изменения весов + std::vector all() const; + std::vector all_w(); std::vector all_grads(); }; -// Кэш прямого прохода, нужен обратному struct LayerCache { - Tensor x; // вход в слой - Tensor xb; // нормализованный вход (attention) - Tensor q, k, v; // [B, n_embd], RoPE применён к q,k - Tensor att; // [n_head, B, B] — веса внимания - Tensor attout; // [B, n_embd] — конкатенация голов - Tensor proj; // [B, n_embd] — после wo - Tensor x2; // после residual attention - Tensor x2b; // нормализация перед FFN + Tensor x; + Tensor xb; + Tensor q, k, v; + Tensor att; + Tensor attout; + Tensor proj; + Tensor x2; + Tensor x2b; Tensor h1, h3, ha; - Tensor fo; // [B, n_embd] — после w2 + Tensor fo; Tensor inv_rms, inv_rms2; }; struct ForwardCache { std::vector layers; - Tensor x; // текущий residual-поток - Tensor xf; // после финального RMSNorm - Tensor logits; // [B, vocab_out] - Tensor inv_rms; // финальная нормализация + Tensor x; + Tensor xf; + Tensor logits; + Tensor inv_rms; std::vector rope_cos, rope_sin; - int block = 0; // длина одной последовательности - int seq_len = 0; // то же, явно - int n_seq = 1; // сколько последовательностей в батче + int block = 0; + int seq_len = 0; + int n_seq = 1; }; void rope_tables(int block, int head_dim, int base, std::vector& cs, std::vector& sn); - -// Полный прямой проход. -// n_tok — сколько токенов всего (может быть кратно block_size: батч) -// seq_len — длина ОДНОЙ последовательности (<= block_size). -// Внимание и RoPE строятся независимо для каждой -// последовательности, токены разных батчей не видят друг друга. void forward(const Params& p, const int* tokens, int n_tok, int seq_len, ForwardCache& fc); -// Обёртка для одиночной последовательности void forward(const Params& p, const int* tokens, int n_tok, ForwardCache& fc); -// Только последний ряд логитов void forward_last(const Params& p, const int* tokens, int n_tok, Tensor& logits); -} // namespace xt +} \ No newline at end of file diff --git a/xenith/core/model.o b/xenith/core/model.o deleted file mode 100644 index 090e50a..0000000 Binary files a/xenith/core/model.o and /dev/null differ diff --git a/xenith/core/tensor.h b/xenith/core/tensor.h index b30e7fe..129bf73 100644 --- a/xenith/core/tensor.h +++ b/xenith/core/tensor.h @@ -1,5 +1,3 @@ -// tensor.h — минимальная матричная библиотека для Xenith -// Только то, что реально нужно трансформеру: GEMM-тройка, RNG, parallel_for. #pragma once #include #include @@ -13,8 +11,6 @@ namespace xt { -// ---------------------------------------------------------------- RNG -// xorshift128+ — быстрый, детерминированный struct Rng { uint64_t s0, s1; explicit Rng(uint64_t seed = 0x853c49e6748fea9bULL) { @@ -40,7 +36,6 @@ struct Rng { size_t below(size_t n) { return n ? (size_t)(next_u64() % n) : 0; } }; -// ------------------------------------------------------------ потоки inline int& hw_threads() { static int t = [] { unsigned hc = std::thread::hardware_concurrency(); @@ -68,8 +63,6 @@ inline void parallel_for(int n, const std::function& fn) { for (auto& x : th) x.join(); } -// ------------------------------------------------------------ Tensor -// Row-major: d[r*cols + c] struct Tensor { int rows = 0, cols = 0; std::vector d; @@ -78,7 +71,6 @@ struct Tensor { Tensor(int r, int c) : rows(r), cols(c), d((size_t)r * c, 0.0f) {} void resize(int r, int c) { rows = r; cols = c; d.assign((size_t)r * c, 0.0f); } - // Для тензоров вида [H][B][B] (веса внимания): хранится плоско void resize3d(int h, int r, int c) { rows = r; cols = c; d.assign((size_t)h * r * c, 0.0f); } void zero() { std::fill(d.begin(), d.end(), 0.0f); } int R() const { return rows; } @@ -105,10 +97,6 @@ struct Tensor { } }; -// --------------------------------------------------------------- GEMM -// Три формы — ровно столько нужно для прямого и обратного прохода. - -// C[N,M] = A[N,K] * B[K,M] inline void gemm_nn(const Tensor& A, const Tensor& B, Tensor& C) { const int N = A.R(), K = A.C(), M = B.C(); C.resize(N, M); @@ -126,7 +114,6 @@ inline void gemm_nn(const Tensor& A, const Tensor& B, Tensor& C) { }); } -// C[N,M] = A[N,K] * B[M,K]^T (нужно для logits = X @ w_emb^T) inline void gemm_nt(const Tensor& A, const Tensor& B, Tensor& C) { const int N = A.R(), K = A.C(), M = B.R(); C.resize(N, M); @@ -144,15 +131,11 @@ inline void gemm_nt(const Tensor& A, const Tensor& B, Tensor& C) { }); } -// C[K,M] = A[N,K]^T * B[N,M] (нужно для градиентов весов) inline void gemm_tn(const Tensor& A, const Tensor& B, Tensor& C, bool accumulate = false) { const int N = A.R(), K = A.C(), M = B.C(); if (!accumulate) { C.resize(K, M); } else { - // Молчаливый resize здесь маскировал ошибки раскладки градиентов. - // Если форма не совпала — это баг в вызывающем коде, а не повод - // перевыделять память и терять накопленное. if (C.R() != K || C.C() != M) { std::fprintf(stderr, "gemm_tn: форма C %dx%d != ожидаемой %dx%d " @@ -174,15 +157,12 @@ inline void gemm_tn(const Tensor& A, const Tensor& B, Tensor& C, bool accumulate }); } -// ------------------------------------------------------------ активации inline float silu(float x) { return x / (1.0f + std::expf(-x)); } inline float dsilu(float x) { float s = 1.0f / (1.0f + std::expf(-x)); return s * (1.0f + x * (1.0f - s)); } -// RMSNorm: y = x / sqrt(mean(x^2)+eps) * w -// x:[N,D] w:[1,D] y:[N,D] inv_rms:[N,1] inline void rmsnorm_forward(const Tensor& x, const Tensor& w, float eps, Tensor& y, Tensor& inv_rms) { const int N = x.R(), D = x.C(); @@ -199,8 +179,6 @@ inline void rmsnorm_forward(const Tensor& x, const Tensor& w, float eps, } } -// dx, dw из dy. Нужны x, w, y (y = x*r*w, отсюда r*w = y/x — но делить нельзя), -// поэтому храним inv_rms и w. inline void rmsnorm_backward(const Tensor& x, const Tensor& w, const Tensor& inv_rms, const Tensor& dy, Tensor& dx, Tensor& dw) { const int N = x.R(), D = x.C(); @@ -212,18 +190,13 @@ inline void rmsnorm_backward(const Tensor& x, const Tensor& w, const Tensor& inv const float* dr = dy.row(n); float* gx = dx.row(n); const float r = inv_rms.at(n); - // s = sum_j dy_j * w_j * x_j float s = 0.0f; for (int j = 0; j < D; ++j) s += dr[j] * w.at(j) * xr[j]; for (int j = 0; j < D; ++j) { - // dx_j = r*dy_j*w_j - r^3 * s * x_j / D gx[j] = r * dr[j] * w.at(j) - r * r * r * s * xr[j] / (float)D; - // dw_j = sum_n dy_n * x_n * r - // (y_n = x_n * r * w_n, поэтому d y_n / d w_j = x_n * r * [n==j]). - // Множителя w здесь быть не должно — иначе это dL/dw^2, а не dL/dw. dw.at(j) += dr[j] * xr[j] * r; } } } -} // namespace xt +} diff --git a/xenith/core/train.h b/xenith/core/train.h index 63974c6..0a18c1e 100644 --- a/xenith/core/train.h +++ b/xenith/core/train.h @@ -1,4 +1,3 @@ -// train.h — обратный проход и оптимизатор #pragma once #include "model.h" #include "checkpoint.h" @@ -6,19 +5,16 @@ namespace xt { -// Считает градиенты по всем параметрам и возвращает mean loss. -// x — входные токены [n-1], y — цели [n-1] (сдвиг на 1) float backward(Params& p, const ForwardCache& fc, const int* x, const int* y, int n_pairs); -// Только loss по готовому форварду (для валидации, без обратного прохода) float softmax_eval(const Params& p, const ForwardCache& fc, const int* x, const int* y, int n_pairs, Tensor& per_token_loss); struct TrainConfig { int steps = 1000; int batch_size = 8; - int block = 64; // длина обучающего окна + int block = 64; float lr = 3e-4f; float beta1 = 0.9f; float beta2 = 0.999f; @@ -26,16 +22,15 @@ struct TrainConfig { float weight_decay = 0.01f; float clip = 1.0f; int warmup = 100; - float lr_min_frac = 0.1f; // нижняя граница после затухания + float lr_min_frac = 0.1f; uint64_t seed = 1337; - int threads = 0; // 0 => все ядра + int threads = 0; int log_every = 50; - int ckpt_every = 0; // 0 => без промежуточных сохранений - int val_every = 0; // 0 => без валидации + int ckpt_every = 0; + int val_every = 0; int val_tokens = 20000; }; -// Кусочек корпуса: массив токенов + границы предложений struct Dataset { std::vector ids; size_t n() const { return ids.size(); } @@ -48,9 +43,8 @@ struct TrainStats { double tokens_seen = 0; }; -// Основной цикл обучения TrainStats train_model(Params& p, const Tokenizer& tok, const std::string& corpus_path, const TrainConfig& tc, const std::string& out_path, int resume_step = 0); -} // namespace xt +} diff --git a/xenith/core/trainer.cpp b/xenith/core/trainer.cpp index cf232be..d25fb18 100644 --- a/xenith/core/trainer.cpp +++ b/xenith/core/trainer.cpp @@ -1,4 +1,3 @@ -// trainer.cpp — цикл обучения #include "train.h" #include "checkpoint.h" #include @@ -21,7 +20,6 @@ std::string read_file(const std::string& path, bool& ok) { return ss.str(); } -// cosine с прогревом float lr_at(const TrainConfig& tc, int step) { if (step < tc.warmup) return tc.lr * (step + 1) / (float)std::max(1, tc.warmup); const int t = step - tc.warmup; @@ -31,9 +29,8 @@ float lr_at(const TrainConfig& tc, int step) { return tc.lr * (tc.lr_min_frac + (1.0f - tc.lr_min_frac) * cos); } -} // namespace +} -// Обучение. Модель сохраняется в out_path, промежуточные — в out_path + ".stepN" TrainStats train_model(Params& p, const Tokenizer& tok, const std::string& corpus_path, const TrainConfig& tc, const std::string& out_path, int resume_step) { @@ -59,7 +56,6 @@ TrainStats train_model(Params& p, const Tokenizer& tok, const std::string& corpu return st; } - // валидация std::vector val_ids; bool has_val = false; if (tc.val_every > 0 && ids.size() > (size_t)tc.val_tokens + block + 1) { @@ -75,7 +71,6 @@ TrainStats train_model(Params& p, const Tokenizer& tok, const std::string& corpu const int start = resume_step; for (int step = start; step < tc.steps; ++step) { - // набираем батч for (int b = 0; b < B; ++b) { size_t off = rng.below(ids.size() - block - 1); for (int t = 0; t < block; ++t) { @@ -93,13 +88,12 @@ TrainStats train_model(Params& p, const Tokenizer& tok, const std::string& corpu st.step = step; st.tokens_seen += (double)B * block; - if (step % tc.log_every == 0 || step == tc.steps - 1) { - auto now = std::chrono::steady_clock::now(); - double dt = std::chrono::duration(now - t0).count(); - double tps = dt > 0 ? st.tokens_seen / dt : 0; - fprintf(stderr, "шаг %5d/%d loss %.4f ppl %8.2f lr %.2e %6.0f ток/с\n", - step, tc.steps, loss, std::exp(loss), lr_at(tc, step), tps); - } + auto now = std::chrono::steady_clock::now(); + double dt = std::chrono::duration(now - t0).count(); + double tps = dt > 0 ? st.tokens_seen / dt : 0; + fprintf(stderr, "шаг %5d/%d loss %.4f ppl %8.2f lr %.2e %6.0f ток/с\n", + step, tc.steps, loss, std::exp(loss), lr_at(tc, step), tps); + if (tc.val_every > 0 && has_val && (step + 1) % tc.val_every == 0) { float vl = 0; @@ -137,4 +131,4 @@ TrainStats train_model(Params& p, const Tokenizer& tok, const std::string& corpu return st; } -} // namespace xt +} diff --git a/xenith/core/trainer.d b/xenith/core/trainer.d deleted file mode 100644 index f2f7fde..0000000 --- a/xenith/core/trainer.d +++ /dev/null @@ -1,6 +0,0 @@ -xenith/core/trainer.o: xenith/core/trainer.cpp xenith/core/train.h \ - xenith/core/model.h xenith/core/tensor.h xenith/core/checkpoint.h -xenith/core/train.h: -xenith/core/model.h: -xenith/core/tensor.h: -xenith/core/checkpoint.h: diff --git a/xenith/core/trainer.o b/xenith/core/trainer.o deleted file mode 100644 index a0f8ac4..0000000 Binary files a/xenith/core/trainer.o and /dev/null differ