; ============================================================================
; io_signed.asm
;
; Модуль ввода-вывода знаковых целых чисел с двухслойной архитектурой.
; Обеспечивает безопасное чтение 16-битных чисел со знаком и вывод
; 32-битных результатов с проверкой переполнения и валидацией формата.
;
; АРХИТЕКТУРА:
;
;   СЛОЙ 1: Чистые функции парсинга
;     • parse_int16 - Парсинг строки в знаковое 16-битное число
;     • Не выполняет I/O операций, только обработка данных
;     • Возвращает коды ошибок через регистры
;
;   СЛОЙ 2: Интерактивный ввод-вывод (stdin/stdout)
;     • read_signed_input_vars, print_signed_output_var - работа через параметры
;     • read_signed_input, print_signed_output - обёртки для глобальных переменных
;     • Буферизованное чтение, форматированный вывод
;     • Обработка ошибок с диагностикой в stderr
;
; СОВМЕСТИМОСТЬ:
;   Модуль поддерживает два режима работы:
;   1. Новый интерфейс - передача адресов через параметры (rdi, rsi)
;   2. Старый интерфейс - использование глобальных переменных a, b, output
;      (через механизм weak symbols)
;
; БЕЗОПАСНОСТЬ:
;   • Проверка переполнения (диапазон int16_t: -32768..32767)
;   • Валидация формата входных данных
;   • Защита от переполнения буфера (максимум 30 символов)
;   • Детальные коды ошибок для диагностики
;
; ПРОИЗВОДИТЕЛЬНОСТЬ:
;   • Сложность парсинга: O(n), где n - количество цифр
;   • Память: O(1), используются фиксированные буферы
;   • Буферизация I/O минимизирует системные вызовы
; ============================================================================

default rel                             ; Использовать RIP-relative адресацию по умолчанию

section .data
    ; Сообщения для интерактивного ввода
    msg_a: db "Enter a value for variable 'a': "
    len_a: equ $ - msg_a
    msg_b: db "Enter a value for variable 'b': "
    len_b: equ $ - msg_b
    msg_res: db "Result = "
    len_res: equ $ - msg_res

    newline db 10                       ; Символ новой строки (LF)

    ; Сообщения об ошибках парсинга
    error_format_msg db "ERROR: Invalid number format", 10
    error_format_len equ $ - error_format_msg
    error_overflow_msg db "ERROR: Number overflow (must be -32768 to 32767)", 10
    error_overflow_len equ $ - error_overflow_msg
    error_buffer_msg db "ERROR: Input too long (max 30 characters)", 10
    error_buffer_len equ $ - error_buffer_msg

    ; Сообщение об ошибке обёртки совместимости
    err_compat db "CRITICAL ERROR: Legacy wrapper called but 'a', 'b' or 'output' not defined!", 10
    err_compat_len equ $ - err_compat

section .bss
    ; Буферы для работы всех слоёв
    parse_temp_buffer resb 64           ; Общий буфер для парсинга строк

    ; Буферы интерактивного режима (Слой 2)
    io_interactive_buffer resb 128      ; Буфер чтения из stdin
    io_interactive_pos resq 1           ; Текущая позиция чтения в буфере
    io_interactive_size resq 1          ; Количество непрочитанных байт в буфере

section .text
    ; Экспорт функций всех слоёв
    global parse_int16              ; Слой 1: чистая функция парсинга
    global read_signed_input_vars   ; Слой 2: чтение через параметры
    global print_signed_output_var  ; Слой 2: вывод через параметры
    global read_signed_input        ; Слой 2: обёртка совместимости
    global print_signed_output      ; Слой 2: обёртка совместимости

; ============================================================================
; СЛОЙ 1: ФУНКЦИИ ПАРСИНГА
; ============================================================================

; ----------------------------------------------------------------------------
; parse_int16
;
; Парсит текстовую строку в знаковое 16-битное целое число.
; Поддерживает знаки '+' и '-', ведущие и завершающие пробелы.
; Выполняет проверку на переполнение int16_t и корректность формата.
;
; АЛГОРИТМ:
;   1. Пропуск начальных пробелов
;   2. Обработка знака (+/-)
;   3. Посимвольный парсинг цифр с накоплением: result = result*10 + digit
;   4. Проверка границ: -32768 ≤ result ≤ 32767
;   5. Применение знака и валидация финального значения
;
; АВТОМАТ СОСТОЯНИЙ:
;   [START] → skip_spaces → check_sign → parse_digits → finalize
;                ↓              ↓             ↓
;           [' ',\t]       ['+','-']     ['0'-'9']
;
; ДОПУСТИМЫЙ ДИАПАЗОН: -32768 до 32767
; ДОПУСТИМЫЕ ФОРМАТЫ: [пробелы][+/-]цифры[пробел/LF/CR/null]
;
; ПРИМЕРЫ:
;   "  -12345 " → -12345 (rdx=0)
;   "32767"     → 32767  (rdx=0)
;   "32768"     → 0      (rdx=2, переполнение)
;   "abc"       → 0      (rdx=1, неверный формат)
;
; @param  rdi  Указатель на null-терминированную строку
; @return rax  Распарсенное число (знаковое расширение до 64 бит)
;         rdx  Код ошибки:
;              0 = успех
;              1 = неверный формат (нет цифр, недопустимые символы)
;              2 = переполнение (выход за границы int16_t)
;              3 = переполнение буфера (строка длиннее 30 символов)
; @uses   rbx, rcx, r14, r15
;
; @complexity O(n), где n - длина входной строки
; @memory     O(1), не использует динамическую память
; ----------------------------------------------------------------------------
parse_int16:
    push rbp
    mov rbp, rsp
    push rbx
    push r14
    push r15

    mov r15, rdi                ; r15 = указатель на текущий символ строки
    xor rbx, rbx                ; rbx = флаг знака (0 = положит., 1 = отрицат.)
    xor rax, rax                ; rax = аккумулятор результата
    xor r14, r14                ; r14 = счётчик обработанных цифр
    xor rcx, rcx                ; rcx = общий счётчик символов (защита от переполнения)

; --- Пропуск начальных пробелов ---
.skip_spaces:
    movzx rdx, byte [r15]       ; Загрузка текущего символа с нулевым расширением
    cmp dl, ' '                 ; Проверка: является ли символ пробелом?
    jne .check_sign             ; Если нет - переход к обработке знака
    inc r15                     ; Переход к следующему символу
    inc rcx                     ; Увеличение счётчика символов
    cmp rcx, 30                 ; Проверка на превышение лимита длины
    jg .error_buffer            ; Если превышено - ошибка переполнения буфера
    jmp .skip_spaces            ; Продолжение пропуска пробелов

; --- Обработка знака числа ---
.check_sign:
    cmp byte [r15], '-'         ; Проверка: минус?
    jne .check_plus             ; Если нет - проверяем плюс
    mov rbx, 1                  ; Установка флага отрицательного числа
    inc r15                     ; Переход к следующему символу
    inc rcx                     ; Увеличение счётчика символов
    jmp .parse_digits           ; Переход к парсингу цифр

.check_plus:
    cmp byte [r15], '+'         ; Проверка: плюс?
    jne .parse_digits           ; Если нет - переход к парсингу без изменения знака
    inc r15                     ; Пропуск символа '+'
    inc rcx                     ; Увеличение счётчика символов

; --- Главный цикл парсинга цифр ---
; Инвариант цикла: rax содержит частично собранное число
.parse_digits:
    movzx rdx, byte [r15]       ; Загрузка текущего символа

    ; Проверка символов окончания числа (null/newline/carriage return/пробел)
    test dl, dl                 ; Проверка: null-терминатор (0)?
    jz .finalize                ; Если да - завершение парсинга
    cmp dl, 10                  ; Проверка: LF (line feed)?
    je .finalize                ; Если да - завершение парсинга
    cmp dl, 13                  ; Проверка: CR (carriage return)?
    je .finalize                ; Если да - завершение парсинга
    cmp dl, ' '                 ; Проверка: пробел?
    je .finalize                ; Если да - завершение парсинга

    inc rcx                     ; Увеличение счётчика символов
    cmp rcx, 30                 ; Проверка на превышение лимита длины
    jg .error_buffer            ; Если превышено - ошибка переполнения буфера

    ; Валидация символа как цифры (ASCII '0'-'9')
    cmp dl, '0'                 ; Проверка: символ < '0'?
    jb .error_format            ; Если да - это не цифра, ошибка формата
    cmp dl, '9'                 ; Проверка: символ > '9'?
    ja .error_format            ; Если да - это не цифра, ошибка формата

    inc r14                     ; Увеличение счётчика обработанных цифр

    ; Предварительная проверка переполнения перед умножением
    ; Для int16_t: max/10 = 32767/10 = 3276 (остаток 7)
    ;              min/10 = 32768/10 = 3276 (остаток 8)
    cmp rax, 3276               ; Проверка граничного случая
    jg .check_last_digit        ; Если превышено - особая обработка последней цифры

    ; Вычисление: result = result * 10 + digit
    imul rax, rax, 10           ; rax = rax * 10 (сдвиг разряда)
    sub dl, '0'                 ; Преобразование ASCII ('0'-'9') в число (0-9)
    movzx rdx, dl               ; Нулевое расширение до 64 бит
    add rax, rdx                ; Добавление текущей цифры к результату

    ; Проверка границ int16_t в зависимости от знака
    test rbx, rbx               ; Проверка флага знака (0=положит., 1=отрицат.)
    jnz .check_negative_range   ; Если отрицательное - другая проверка

    ; Проверка для положительных чисел (max 32767)
    cmp rax, 32767              ; Проверка: результат превысил максимум?
    jg .error_overflow          ; Если да - ошибка переполнения
    jmp .next_char              ; Переход к следующему символу

.check_negative_range:
    ; Проверка для отрицательных чисел (допускается 32768 → -32768)
    cmp rax, 32768              ; Проверка: результат превысил |min|?
    jg .error_overflow          ; Если да - ошибка переполнения

.next_char:
    inc r15                     ; Переход к следующему символу
    jmp .parse_digits           ; Продолжение парсинга

; --- Обработка граничного случая: rax == 3276 ---
; Требуется особая обработка последней цифры для предотвращения переполнения
.check_last_digit:
    cmp rax, 3276               ; Проверка: точное равенство граничному значению?
    jne .error_overflow         ; Если больше - гарантированное переполнение

    movzx rdx, byte [r15]       ; Загрузка последней цифры
    sub dl, '0'                 ; Преобразование ASCII в числовое значение

    ; Для положительных: последняя цифра ≤ 7 (32767 = 3276*10 + 7)
    ; Для отрицательных: последняя цифра ≤ 8 (32768 = 3276*10 + 8)
    test rbx, rbx               ; Проверка флага знака
    jnz .check_negative_limit   ; Если отрицательное - другой лимит

    cmp dl, 7                   ; Проверка последней цифры для положительных
    jg .error_overflow          ; Если > 7 - переполнение (32767 max)
    jmp .do_last_digit          ; Переход к обработке последней цифры

.check_negative_limit:
    cmp dl, 8                   ; Проверка последней цифры для отрицательных
    jg .error_overflow          ; Если > 8 - переполнение (32768 max по модулю)

.do_last_digit:
    imul rax, rax, 10           ; Умножение на 10 (безопасно, т.к. проверено)
    movzx rdx, dl               ; Нулевое расширение последней цифры
    add rax, rdx                ; Добавление последней цифры
    inc r15                     ; Переход к следующему символу
    jmp .parse_digits           ; Продолжение парсинга (может быть пробел/LF)

; --- Финализация: проверка наличия хотя бы одной цифры ---
.finalize:
    test r14, r14               ; Проверка: были ли обработаны цифры?
    jz .error_format            ; Если нет - ошибка формата (пустая строка или только знак)

    ; Применение знака к результату
    test rbx, rbx               ; Проверка флага знака
    jz .success                 ; Если положительное - переход к успеху
    neg rax                     ; Применение отрицательного знака (двухкомплементное отрицание)

.success:
    movsx rax, ax               ; Знаковое расширение 16 бит до 64 бит
    xor rdx, rdx                ; Установка кода успеха (0)
    jmp .return                 ; Возврат из функции

; --- Обработка ошибок ---
.error_format:
    xor rax, rax                ; Результат = 0
    mov rdx, 1                  ; Код ошибки = 1 (неверный формат)
    jmp .return

.error_overflow:
    xor rax, rax                ; Результат = 0
    mov rdx, 2                  ; Код ошибки = 2 (переполнение)
    jmp .return

.error_buffer:
    xor rax, rax                ; Результат = 0
    mov rdx, 3                  ; Код ошибки = 3 (переполнение буфера)

.return:
    pop r15
    pop r14
    pop rbx
    pop rbp
    ret
    
; ============================================================================
; СЛОЙ 2: ИНТЕРАКТИВНЫЙ ВВОД-ВЫВОД
; ============================================================================

; ----------------------------------------------------------------------------
; read_signed_input_vars
;
; Читает два знаковых 16-битных целых числа из стандартного ввода.
; Выводит приглашения для ввода каждого значения. Использует буферизацию
; для эффективного чтения из stdin.
;
; ВЗАИМОДЕЙСТВИЕ С ПОЛЬЗОВАТЕЛЕМ:
;   1. Вывод: "Enter a value for variable 'a': "
;   2. Чтение и парсинг значения для 'a'
;   3. Вывод: "Enter a value for variable 'b': "
;   4. Чтение и парсинг значения для 'b'
;   5. При ошибке - вывод диагностики в stderr и exit(1)
;
; ДИАПАЗОН: -32768 до 32767 для каждого числа
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   C-style:
;     int16_t a, b;
;     read_signed_input_vars(&a, &b);
;     // a и b содержат введённые значения
;
;   Assembly:
;     section .bss
;       var_a resw 1
;       var_b resw 1
;     section .text
;       lea rdi, [var_a]
;       lea rsi, [var_b]
;       call read_signed_input_vars
;
; @param  rdi  Адрес первой 16-битной переменной (int16_t *a)
;         rsi  Адрес второй 16-битной переменной (int16_t *b)
; @return none (результаты сохраняются по переданным адресам)
; @uses   rax, rbx, rcx, rdx, rdi, rsi, r12, r13
; @calls  layer2_read_string_signed, parse_int16
; @exit   Код 1 при ошибке ввода (формат/переполнение/буфер)
;
; @see layer2_read_string_signed - внутренняя буферизация
; @see parse_int16 - валидация и преобразование
; ----------------------------------------------------------------------------
read_signed_input_vars:
    push rbp
    mov rbp, rsp
    push rbx
    push r12
    push r13

    mov r12, rdi                ; Сохранение адреса переменной 'a'
    mov r13, rsi                ; Сохранение адреса переменной 'b'

; --- Чтение первого числа (переменная 'a') ---
    ; Вывод приглашения
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    lea rsi, [msg_a]
    mov rdx, len_a
    syscall

    call layer2_read_string_signed ; Чтение строки в parse_temp_buffer

    lea rdi, [parse_temp_buffer]   ; Адрес строки для парсинга
    call parse_int16               ; Парсинг введённого значения

    test rdx, rdx                  ; Проверка кода ошибки (0 = успех)
    jnz .handle_error              ; Если ошибка - переход к обработке

    mov word [r12], ax             ; Сохранение значения в *a (младшие 16 бит)

; --- Чтение второго числа (переменная 'b') ---
    ; Вывод приглашения
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    lea rsi, [msg_b]
    mov rdx, len_b
    syscall

    call layer2_read_string_signed ; Чтение строки в parse_temp_buffer

    lea rdi, [parse_temp_buffer]   ; Адрес строки для парсинга
    call parse_int16               ; Парсинг введённого значения

    test rdx, rdx                  ; Проверка кода ошибки
    jnz .handle_error              ; Если ошибка - переход к обработке

    mov word [r13], ax             ; Сохранение значения в *b

    pop r13
    pop r12
    pop rbx
    pop rbp
    ret

; --- Обработка ошибок парсинга ---
.handle_error:
    push rdx                    ; Сохранение кода ошибки
    
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2

    pop rbx                     ; Восстановление кода ошибки в rbx
    cmp rbx, 1                  ; Проверка: код ошибки = 1 (неверный формат)?
    je .print_format
    cmp rbx, 2                  ; Проверка: код ошибки = 2 (переполнение)?
    je .print_overflow
    cmp rbx, 3                  ; Проверка: код ошибки = 3 (буфер)?
    je .print_buffer

.print_format:
    lea rsi, [error_format_msg]     ; Адрес сообщения об ошибке формата
    mov rdx, error_format_len       ; Длина сообщения
    jmp .do_print

.print_overflow:
    lea rsi, [error_overflow_msg]   ; Адрес сообщения о переполнении
    mov rdx, error_overflow_len     ; Длина сообщения
    jmp .do_print

.print_buffer:
    lea rsi, [error_buffer_msg]     ; Адрес сообщения о переполнении буфера
    mov rdx, error_buffer_len       ; Длина сообщения

.do_print:
    syscall
    
    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; ----------------------------------------------------------------------------
; print_signed_output_var
;
; Выводит знаковое 32-битное целое число в stdout в десятичном формате
; с префиксом "Result = " и переводом строки. Поддерживает отрицательные
; числа.
;
; АЛГОРИТМ:
;   1. Обработка специального случая (ноль)
;   2. Определение знака и взятие модуля
;   3. Конвертация справа налево: число % 10 → ASCII
;   4. Добавление знака '-' при необходимости
;   5. Вывод префикса, числа и перевода строки
;
; ДИАПАЗОН: -2147483648 до 2147483647 (int32_t)
; ФОРМАТ ВЫВОДА: "Result = <число>\n"
;
; ПРИМЕРЫ:
;   print_signed_output_var(0)      → "Result = 0\n"
;   print_signed_output_var(12345)  → "Result = 12345\n"
;   print_signed_output_var(-9876)  → "Result = -9876\n"
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   C-style:
;     int32_t result = -12345;
;     print_signed_output_var(result);
;
;   Assembly:
;     mov edi, -12345
;     call print_signed_output_var
;
; @param  edi  Значение для вывода (int32_t)
; @return none
; @uses   rax, rbx, rcx, rdx, rdi, rsi, r12, r13
;
; @complexity O(log₁₀(n)), где n - абсолютное значение числа
; @memory     O(1), использует фиксированный буфер
; ----------------------------------------------------------------------------
print_signed_output_var:
    push rbp
    mov rbp, rsp
    push rbx
    push r12
    push r13

    movsxd rax, edi             ; Знаковое расширение int32 → int64

    mov r12, 10                         ; Делитель = 10 (основание системы счисления)
    lea r13, [parse_temp_buffer + 63]   ; r13 = указатель на конец буфера
    mov byte [r13], 0                   ; Установка null-терминатора

; --- Специальная обработка нуля ---
    test rax, rax               ; Проверка: число равно нулю?
    jnz .check_sign             ; Если нет - обработка знака
    dec r13                     ; Смещение указателя назад
    mov byte [r13], '0'         ; Запись символа '0'
    jmp .print                  ; Переход к выводу

; --- Обработка знака числа ---
.check_sign:
    xor rbx, rbx                ; rbx = флаг знака (0 по умолчанию)
    test rax, rax               ; Проверка знака числа (установка флагов)
    jge .convert                ; Если >= 0 - переход к конвертации
    neg rax                     ; Взятие модуля (двухкомплементное отрицание)
    mov rbx, 1                  ; Установка флага отрицательного числа

; --- Конвертация числа в строку (справа налево) ---
; Инвариант цикла: r13 указывает на следующую позицию для записи
.convert:
    dec r13                     ; Смещение указателя назад
    xor rdx, rdx                ; Обнуление rdx перед делением
    div r12                     ; rax = rax / 10, rdx = rax % 10 (остаток - цифра)
    add dl, '0'                 ; Преобразование цифры (0-9) в ASCII ('0'-'9')
    mov [r13], dl               ; Запись ASCII-символа в буфер
    test rax, rax               ; Проверка: остались ли ещё цифры?
    jnz .convert                ; Если да - продолжение конвертации

; --- Добавление знака минус для отрицательных чисел ---
    test rbx, rbx               ; Проверка флага отрицательного числа
    jz .print                   ; Если положительное - переход к выводу
    dec r13                     ; Смещение указателя назад
    mov byte [r13], '-'         ; Запись символа минуса

; --- Вывод результата ---
.print:
    ; Вывод префикса "Result = "
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    lea rsi, [msg_res]
    mov rdx, len_res
    syscall

    ; Вывод преобразованного числа
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    mov rsi, r13                        ; Адрес начала числовой строки
    lea rdx, [parse_temp_buffer + 63]   ; Адрес конца буфера
    sub rdx, r13                        ; Вычисление длины строки (конец - начало)
    syscall

    ; Вывод символа новой строки
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    lea rsi, [newline]
    mov rdx, 1
    syscall

    pop r13
    pop r12
    pop rbx
    pop rbp
    ret
    
; ============================================================================
; ОБЁРТКИ СОВМЕСТИМОСТИ (для программ со старым интерфейсом)
; ============================================================================

; Объявление слабых внешних ссылок (weak symbols)
; Если программа не определяет эти переменные, их адрес будет 0
extern a:weak               ; int16_t - первая входная переменная
extern b:weak               ; int16_t - вторая входная переменная
extern output:weak          ; int32_t - выходная переменная для результата

; ----------------------------------------------------------------------------
; read_signed_input
;
; Обёртка совместимости для чтения во внешние глобальные переменные 'a' и 'b'.
; Проверяет наличие символов через механизм weak linking.
;
; ТРЕБОВАНИЯ:
;   Вызывающая программа должна определить:
;     global a
;     global b
;     section .bss
;       a resw 1
;       b resw 1
;
; ДИАПАЗОН: -32768 до 32767 для каждого числа
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   Old-style программа:
;     extern read_signed_input
;     global a, b
;     section .bss
;       a resw 1
;       b resw 1
;     section .text
;       call read_signed_input  ; Читает в a и b
;
; @param  none (читает в extern a, b)
; @return none
; @uses   rax, rdi, rsi (через вызов read_signed_input_vars)
; @calls  read_signed_input_vars
; @exit   Код 1 при ошибке ввода или отсутствии переменных a, b
;
; @see read_signed_input_vars - основная реализация
; ----------------------------------------------------------------------------
read_signed_input:
    push rbp
    mov rbp, rsp

; --- Проверка наличия символа 'a' ---
    mov rax, a                  ; Загрузка адреса переменной 'a'
    test rax, rax               ; Проверка: адрес равен 0? (символ не определён)
    jz .missing_symbols         ; Если да - переход к обработке ошибки

; --- Проверка наличия символа 'b' ---
    mov rax, b                  ; Загрузка адреса переменной 'b'
    test rax, rax               ; Проверка: адрес равен 0? (символ не определён)
    jz .missing_symbols         ; Если да - переход к обработке ошибки

; --- Вызов основной функции с адресами глобальных переменных ---
    lea rdi, [a]                ; Загрузка адреса переменной 'a' в rdi
    lea rsi, [b]                ; Загрузка адреса переменной 'b' в rsi
    call read_signed_input_vars ; Вызов функции чтения

    pop rbp
    ret

; --- Обработка отсутствия требуемых переменных ---
.missing_symbols:
    ; Вывод сообщения об ошибке
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2
    lea rsi, [err_compat]
    mov rdx, err_compat_len
    syscall
    
    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; ----------------------------------------------------------------------------
; print_signed_output
;
; Обёртка совместимости для вывода внешней глобальной переменной 'output'.
; Проверяет наличие символа через механизм weak linking.
;
; ТРЕБОВАНИЯ:
;   Вызывающая программа должна определить:
;     global output
;     section .bss
;       output resd 1
;
; ДИАПАЗОН: -2147483648 до 2147483647 (int32_t)
; ФОРМАТ ВЫВОДА: "Result = <число>\n"
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   Old-style программа:
;     extern print_signed_output
;     global output
;     section .bss
;       output resd 1
;     section .text
;       mov dword [output], -12345
;       call print_signed_output  ; Выводит: Result = -12345
;
; @param  none (читает из extern output)
; @return none
; @uses   rax, rdi (через вызов print_signed_output_var)
; @calls  print_signed_output_var
; @exit   Код 1 при отсутствии переменной output
;
; @see print_signed_output_var - основная реализация
; ----------------------------------------------------------------------------
print_signed_output:
    push rbp
    mov rbp, rsp

; --- Проверка наличия символа 'output' ---
    mov rax, output             ; Загрузка адреса переменной 'output'
    test rax, rax               ; Проверка: адрес равен 0? (символ не определён)
    jz .missing_symbols_out     ; Если да - переход к обработке ошибки

; --- Загрузка значения и вызов основной функции ---
    mov edi, [output]           ; Загрузка значения переменной output в edi
    call print_signed_output_var ; Вызов функции вывода

    pop rbp
    ret

; --- Обработка отсутствия переменной output ---
.missing_symbols_out:
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2
    lea rsi, [err_compat]
    mov rdx, err_compat_len
    syscall
    
    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; ----------------------------------------------------------------------------
; layer2_read_string_signed
;
; Внутренняя функция буферизованного чтения строки из stdin до символа LF.
; Использует внутреннюю буферизацию для минимизации системных вызовов.
; Результат сохраняется в parse_temp_buffer с null-терминатором.
;
; АЛГОРИТМ:
;   1. Очистка выходного буфера
;   2. Цикл чтения:
;      - Проверка наличия данных в буфере
;      - При необходимости: системный вызов read() для новой порции
;      - Копирование символа в выходной буфер
;      - Проверка на LF (конец строки)
;   3. Установка null-терминатора
;
; БУФЕРИЗАЦИЯ:
;   Внутренний буфер: 128 байт
;   Выходной буфер: 64 байта
;   Минимизирует количество syscall для повышения производительности
;
; @param  none
; @return none (результат в parse_temp_buffer)
; @uses   rax, rbx, rcx, rdx, rdi, rsi
; @exit   Код 1 при EOF без данных
;
; @complexity O(n), где n - длина строки
; @calls      syscall read(stdin)
; ----------------------------------------------------------------------------
layer2_read_string_signed:
    push rbx
    push rcx
    push rdi

; --- Очистка выходного буфера ---
    lea rdi, [parse_temp_buffer] ; Адрес буфера для очистки
    mov rcx, 64                  ; Количество байт для очистки
    xor al, al                   ; Значение для заполнения (0)
    rep stosb                    ; Повторение stosb rcx раз (заполнение нулями)

    xor rbx, rbx                 ; rbx = позиция записи в parse_temp_buffer (0)

; --- Цикл чтения символов ---
.read_char:
    ; Проверка наличия данных в буфере
    mov rax, [io_interactive_size]      ; Загрузка количества доступных байт
    test rax, rax                       ; Проверка: есть ли данные в буфере?
    jnz .has_data                       ; Если да - переход к чтению из буфера

    ; Буфер пуст - системный вызов
    ; syscall: read(stdin, buffer, count)
    xor rax, rax
    xor rdi, rdi
    lea rsi, [io_interactive_buffer]
    mov rdx, 128
    syscall

    test rax, rax                       ; Проверка результата (rax = количество прочитанных байт)
    jle .eof                            ; Если <= 0 (EOF или ошибка) - обработка

    mov [io_interactive_size], rax      ; Сохранение количества прочитанных байт
    mov qword [io_interactive_pos], 0   ; Сброс позиции чтения в начало буфера

; --- Извлечение символа из буфера ---
.has_data:
    mov rcx, [io_interactive_pos]              ; Загрузка текущей позиции чтения
    mov al, byte [io_interactive_buffer + rcx] ; Чтение символа из буфера

    inc qword [io_interactive_pos]  ; Увеличение позиции чтения
    dec qword [io_interactive_size] ; Уменьшение количества доступных байт

    ; Проверка 1: Достигнут ли лимит буфера parse_temp_buffer?
    cmp rbx, 63                 ; Проверка: буфер заполнен (осталось место для null)?
    jge .skip_write             ; Если да - НЕ записываем, но продолжаем читать

    ; Запись символа в выходной буфер (только если есть место)
    lea rdx, [parse_temp_buffer] ; Загрузка базового адреса выходного буфера
    mov byte [rdx + rbx], al     ; Запись символа по адресу [база + смещение]
    inc rbx                      ; Увеличение позиции записи

.skip_write:
    ; Проверка 2: Конец строки (LF)?
    cmp al, 10                  ; Проверка: LF (line feed)?
    je .done                    ; Если да - завершение чтения

    ; Продолжение чтения следующего символа (даже если буфер полон)
    jmp .read_char

; --- Обработка EOF без данных ---
.eof:
    test rbx, rbx               ; Проверка: были ли прочитаны данные?
    jnz .done                   ; Если да - завершение нормально (частичные данные)

    ; EOF без данных - это ошибка
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2
    lea rsi, [error_format_msg]
    mov rdx, error_format_len
    syscall

    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; --- Успешное завершение ---
.done:
    pop rdi
    pop rcx
    pop rbx
    ret

; ============================================================================
; io_unsigned.asm
;
; Модуль ввода-вывода беззнаковых целых чисел с двухслойной архитектурой.
; Обеспечивает безопасное чтение 16-битных беззнаковых чисел и вывод
; 32-битных результатов с проверкой переполнения и валидацией формата.
;
; АРХИТЕКТУРА:
;
;   СЛОЙ 1: Чистые функции парсинга
;     • parse_uint16 - Парсинг строки в беззнаковое 16-битное число
;     • Не выполняет I/O операций, только обработка данных
;     • Возвращает коды ошибок через регистры
;
;   СЛОЙ 2: Интерактивный ввод-вывод (stdin/stdout)
;     • read_unsigned_input_vars, print_unsigned_output_var - работа через параметры
;     • read_unsigned_input, print_unsigned_output - обёртки для глобальных переменных
;     • Буферизованное чтение, форматированный вывод
;     • Обработка ошибок с диагностикой в stderr
;
; СОВМЕСТИМОСТЬ:
;   Модуль поддерживает два режима работы:
;   1. Новый интерфейс - передача адресов через параметры (rdi, rsi)
;   2. Старый интерфейс - использование глобальных переменных a, b, output
;      (через механизм weak symbols)
;
; БЕЗОПАСНОСТЬ:
;   • Проверка переполнения (диапазон uint16_t: 0..65535)
;   • Валидация формата входных данных
;   • Защита от переполнения буфера (максимум 30 символов)
;   • Детальные коды ошибок для диагностики
;   • Отклонение отрицательных чисел для беззнакового типа
;
; ПРОИЗВОДИТЕЛЬНОСТЬ:
;   • Сложность парсинга: O(n), где n - количество цифр
;   • Память: O(1), используются фиксированные буферы
;   • Буферизация I/O минимизирует системные вызовы
; ============================================================================

default rel                             ; Использовать RIP-relative адресацию по умолчанию

section .data
    ; Сообщения для интерактивного ввода
    msg_a: db "Enter a value for variable 'a': "
    len_a: equ $ - msg_a
    msg_b: db "Enter a value for variable 'b': "
    len_b: equ $ - msg_b
    msg_res: db "Result = "
    len_res: equ $ - msg_res

    newline db 10                       ; Символ новой строки (LF)

    ; Сообщения об ошибках парсинга
    error_format_msg db "ERROR: Invalid number format", 10
    error_format_len equ $ - error_format_msg
    error_overflow_msg db "ERROR: Number overflow (must be 0 to 65535)", 10
    error_overflow_len equ $ - error_overflow_msg
    error_buffer_msg db "ERROR: Input too long (max 30 characters)", 10
    error_buffer_len equ $ - error_buffer_msg

    ; Сообщение об ошибке обёртки совместимости
    err_compat db "CRITICAL ERROR: Legacy wrapper called but 'a', 'b' or 'output' not defined!", 10
    err_compat_len equ $ - err_compat

section .bss
    ; Буферы для работы всех слоёв
    parse_temp_buffer resb 64           ; Общий буфер для парсинга строк

    ; Буферы интерактивного режима (Слой 2)
    io_interactive_buffer resb 128      ; Буфер чтения из stdin
    io_interactive_pos resq 1           ; Текущая позиция чтения в буфере
    io_interactive_size resq 1          ; Количество непрочитанных байт в буфере

section .text
    ; Экспорт функций всех слоёв
    global parse_uint16             ; Слой 1: чистая функция парсинга
    global read_unsigned_input_vars ; Слой 2: чтение через параметры
    global print_unsigned_output_var; Слой 2: вывод через параметры
    global read_unsigned_input      ; Слой 2: обёртка совместимости
    global print_unsigned_output    ; Слой 2: обёртка совместимости

; ============================================================================
; СЛОЙ 1: ФУНКЦИИ ПАРСИНГА
; ============================================================================

; ----------------------------------------------------------------------------
; parse_uint16
;
; Парсит текстовую строку в беззнаковое 16-битное целое число.
; Поддерживает знак '+', ведущие и завершающие пробелы.
; Выполняет проверку на переполнение uint16_t и корректность формата.
; ОТКЛОНЯЕТ отрицательные числа (знак '-').
;
; АЛГОРИТМ:
;   1. Пропуск начальных пробелов
;   2. Проверка знака ('+' допустим, '-' - ошибка формата)
;   3. Посимвольный парсинг цифр с накоплением: result = result*10 + digit
;   4. Проверка границ: 0 ≤ result ≤ 65535
;   5. Валидация финального значения
;
; АВТОМАТ СОСТОЯНИЙ:
;   [START] → skip_spaces → check_sign → parse_digits → finalize
;                ↓              ↓             ↓
;           [' ',\t]         ['+']       ['0'-'9']
;                              ↓
;                            ['-'] → ERROR
;
; ДОПУСТИМЫЙ ДИАПАЗОН: 0 до 65535
; ДОПУСТИМЫЕ ФОРМАТЫ: [пробелы][+]цифры[пробел/LF/CR/null]
;
; ПРИМЕРЫ:
;   "  12345 " → 12345 (rdx=0)
;   "65535"    → 65535 (rdx=0)
;   "65536"    → 0     (rdx=2, переполнение)
;   "-100"     → 0     (rdx=1, отрицательное недопустимо)
;   "abc"      → 0     (rdx=1, неверный формат)
;
; @param  rdi  Указатель на null-терминированную строку
; @return rax  Распарсенное число (нулевое расширение до 64 бит)
;         rdx  Код ошибки:
;              0 = успех
;              1 = неверный формат (нет цифр, недопустимые символы, минус)
;              2 = переполнение (выход за границы uint16_t)
;              3 = переполнение буфера (строка длиннее 30 символов)
; @uses   rbx, rcx, r14, r15
;
; @complexity O(n), где n - длина входной строки
; @memory     O(1), не использует динамическую память
; ----------------------------------------------------------------------------
parse_uint16:
    push rbp
    mov rbp, rsp
    push rbx
    push r14
    push r15

    mov r15, rdi                ; r15 = указатель на текущий символ строки
    xor rax, rax                ; rax = аккумулятор результата
    xor r14, r14                ; r14 = счётчик обработанных цифр
    xor rcx, rcx                ; rcx = общий счётчик символов (защита от переполнения)

; --- Пропуск начальных пробелов ---
.skip_spaces:
    movzx rdx, byte [r15]       ; Загрузка текущего символа с нулевым расширением
    cmp dl, ' '                 ; Проверка: является ли символ пробелом?
    jne .check_sign             ; Если нет - переход к проверке знака
    inc r15                     ; Переход к следующему символу
    inc rcx                     ; Увеличение счётчика символов
    cmp rcx, 30                 ; Проверка на превышение лимита длины
    jg .error_buffer            ; Если превышено - ошибка переполнения буфера
    jmp .skip_spaces            ; Продолжение пропуска пробелов

; --- Обработка знака числа ---
.check_sign:
    cmp byte [r15], '-'         ; Проверка: минус?
    je .error_format            ; Минус недопустим для беззнаковых чисел

    cmp byte [r15], '+'         ; Проверка: плюс?
    jne .parse_digits           ; Если нет - переход к парсингу без изменения
    inc r15                     ; Пропуск символа '+'
    inc rcx                     ; Увеличение счётчика символов

; --- Главный цикл парсинга цифр ---
; Инвариант цикла: rax содержит частично собранное число
.parse_digits:
    movzx rdx, byte [r15]       ; Загрузка текущего символа

    ; Проверка символов окончания числа (null/newline/carriage return/пробел)
    test dl, dl                 ; Проверка: null-терминатор (0)?
    jz .finalize                ; Если да - завершение парсинга
    cmp dl, 10                  ; Проверка: LF (line feed)?
    je .finalize                ; Если да - завершение парсинга
    cmp dl, 13                  ; Проверка: CR (carriage return)?
    je .finalize                ; Если да - завершение парсинга
    cmp dl, ' '                 ; Проверка: пробел?
    je .finalize                ; Если да - завершение парсинга

    inc rcx                     ; Увеличение счётчика символов
    cmp rcx, 30                 ; Проверка на превышение лимита длины
    jg .error_buffer            ; Если превышено - ошибка переполнения буфера

    ; Валидация символа как цифры (ASCII '0'-'9')
    cmp dl, '0'                 ; Проверка: символ < '0'?
    jb .error_format            ; Если да - это не цифра, ошибка формата
    cmp dl, '9'                 ; Проверка: символ > '9'?
    ja .error_format            ; Если да - это не цифра, ошибка формата

    inc r14                     ; Увеличение счётчика обработанных цифр

    ; Предварительная проверка переполнения перед умножением
    ; Для uint16_t: max/10 = 65535/10 = 6553 (остаток 5)
    cmp rax, 6553               ; Проверка граничного случая
    jg .check_last_digit        ; Если превышено - особая обработка последней цифры

    ; Вычисление: result = result * 10 + digit
    imul rax, rax, 10           ; rax = rax * 10 (сдвиг разряда)
    sub dl, '0'                 ; Преобразование ASCII ('0'-'9') в число (0-9)
    movzx rdx, dl               ; Нулевое расширение до 64 бит
    add rax, rdx                ; Добавление текущей цифры к результату

    ; Проверка границы uint16_t (максимум 65535)
    cmp rax, 65535              ; Проверка: результат превысил максимум?
    jg .error_overflow          ; Если да - ошибка переполнения

    inc r15                     ; Переход к следующему символу
    jmp .parse_digits           ; Продолжение парсинга

; --- Обработка граничного случая: rax == 6553 ---
; Требуется особая обработка последней цифры для предотвращения переполнения
.check_last_digit:
    cmp rax, 6553               ; Проверка: точное равенство граничному значению?
    jne .error_overflow         ; Если больше - гарантированное переполнение

    movzx rdx, byte [r15]       ; Загрузка последней цифры
    sub dl, '0'                 ; Преобразование ASCII в числовое значение

    ; Для uint16_t: последняя цифра ≤ 5 (65535 = 6553*10 + 5)
    cmp dl, 5                   ; Проверка последней цифры
    jg .error_overflow          ; Если > 5 - переполнение (65535 max)

    imul rax, rax, 10           ; Умножение на 10 (безопасно, т.к. проверено)
    movzx rdx, dl               ; Нулевое расширение последней цифры
    add rax, rdx                ; Добавление последней цифры

    ; Дополнительная проверка на всякий случай
    cmp rax, 65535              ; Проверка финального результата
    jg .error_overflow          ; Если превышено - ошибка

    inc r15                     ; Переход к следующему символу
    jmp .parse_digits           ; Продолжение парсинга (может быть пробел/LF)

; --- Финализация: проверка наличия хотя бы одной цифры ---
.finalize:
    test r14, r14               ; Проверка: были ли обработаны цифры?
    jz .error_format            ; Если нет - ошибка формата (пустая строка или только знак)

    movzx rax, ax               ; Нулевое расширение 16 бит до 64 бит
    xor rdx, rdx                ; Установка кода успеха (0)
    jmp .return                 ; Возврат из функции

; --- Обработка ошибок ---
.error_format:
    xor rax, rax                ; Результат = 0
    mov rdx, 1                  ; Код ошибки = 1 (неверный формат)
    jmp .return

.error_overflow:
    xor rax, rax                ; Результат = 0
    mov rdx, 2                  ; Код ошибки = 2 (переполнение)
    jmp .return

.error_buffer:
    xor rax, rax                ; Результат = 0
    mov rdx, 3                  ; Код ошибки = 3 (переполнение буфера)

.return:
    pop r15
    pop r14
    pop rbx
    pop rbp
    ret

; ============================================================================
; СЛОЙ 2: ИНТЕРАКТИВНЫЙ ВВОД-ВЫВОД
; ============================================================================

; ----------------------------------------------------------------------------
; read_unsigned_input_vars
;
; Читает два беззнаковых 16-битных целых числа из стандартного ввода.
; Выводит приглашения для ввода каждого значения. Использует буферизацию
; для эффективного чтения из stdin.
;
; ВЗАИМОДЕЙСТВИЕ С ПОЛЬЗОВАТЕЛЕМ:
;   1. Вывод: "Enter a value for variable 'a': "
;   2. Чтение и парсинг значения для 'a'
;   3. Вывод: "Enter a value for variable 'b': "
;   4. Чтение и парсинг значения для 'b'
;   5. При ошибке - вывод диагностики в stderr и exit(1)
;
; ДИАПАЗОН: 0 до 65535 для каждого числа
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   C-style:
;     uint16_t a, b;
;     read_unsigned_input_vars(&a, &b);
;     // a и b содержат введённые значения
;
;   Assembly:
;     section .bss
;       var_a resw 1
;       var_b resw 1
;     section .text
;       lea rdi, [var_a]
;       lea rsi, [var_b]
;       call read_unsigned_input_vars
;
; @param  rdi  Адрес первой 16-битной переменной (uint16_t *a)
;         rsi  Адрес второй 16-битной переменной (uint16_t *b)
; @return none (результаты сохраняются по переданным адресам)
; @uses   rax, rbx, rcx, rdx, rdi, rsi, r12, r13
; @calls  layer2_read_string_unsigned, parse_uint16
; @exit   Код 1 при ошибке ввода (формат/переполнение/буфер)
;
; @see layer2_read_string_unsigned - внутренняя буферизация
; @see parse_uint16 - валидация и преобразование
; ----------------------------------------------------------------------------
read_unsigned_input_vars:
    push rbp
    mov rbp, rsp
    push rbx
    push r12
    push r13

    mov r12, rdi                ; Сохранение адреса переменной 'a'
    mov r13, rsi                ; Сохранение адреса переменной 'b'

; --- Чтение первого числа (переменная 'a') ---
    ; Вывод приглашения
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    lea rsi, [msg_a]
    mov rdx, len_a
    syscall

    call layer2_read_string_unsigned ; Чтение строки в parse_temp_buffer

    lea rdi, [parse_temp_buffer]     ; Адрес строки для парсинга
    call parse_uint16                ; Парсинг введённого значения

    test rdx, rdx                    ; Проверка кода ошибки (0 = успех)
    jnz .handle_error                ; Если ошибка - переход к обработке

    mov word [r12], ax               ; Сохранение значения в *a (младшие 16 бит)

; --- Чтение второго числа (переменная 'b') ---
    ; Вывод приглашения
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    lea rsi, [msg_b]
    mov rdx, len_b
    syscall

    call layer2_read_string_unsigned ; Чтение строки в parse_temp_buffer

    lea rdi, [parse_temp_buffer]     ; Адрес строки для парсинга
    call parse_uint16                ; Парсинг введённого значения

    test rdx, rdx                    ; Проверка кода ошибки
    jnz .handle_error                ; Если ошибка - переход к обработке

    mov word [r13], ax               ; Сохранение значения в *b

    pop r13
    pop r12
    pop rbx
    pop rbp
    ret

; --- Обработка ошибок парсинга ---
.handle_error:
    push rdx                    ; Сохранение кода ошибки
    
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2

    pop rbx                     ; Восстановление кода ошибки в rbx
    cmp rbx, 1                  ; Проверка: код ошибки = 1 (неверный формат)?
    je .print_format
    cmp rbx, 2                  ; Проверка: код ошибки = 2 (переполнение)?
    je .print_overflow
    cmp rbx, 3                  ; Проверка: код ошибки = 3 (буфер)?
    je .print_buffer

.print_format:
    lea rsi, [error_format_msg]   ; Адрес сообщения об ошибке формата
    mov rdx, error_format_len     ; Длина сообщения
    jmp .do_print

.print_overflow:
    lea rsi, [error_overflow_msg] ; Адрес сообщения о переполнении
    mov rdx, error_overflow_len   ; Длина сообщения
    jmp .do_print

.print_buffer:
    lea rsi, [error_buffer_msg]   ; Адрес сообщения о переполнении буфера
    mov rdx, error_buffer_len     ; Длина сообщения

.do_print:
    syscall
    
    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; ----------------------------------------------------------------------------
; print_unsigned_output_var
;
; Выводит 32-битное целое число в stdout в десятичном формате
; с префиксом "Result = " и переводом строки. Поддерживает отрицательные
; числа (для результатов арифметических операций, например вычитания).
;
; АЛГОРИТМ:
;   1. Обработка специального случая (ноль)
;   2. Определение знака и взятие модуля (для отрицательных результатов)
;   3. Конвертация справа налево: число % 10 → ASCII
;   4. Добавление знака '-' при необходимости
;   5. Вывод префикса, числа и перевода строки
;
; ДИАПАЗОН: -2147483648 до 2147483647 (int32_t)
; ФОРМАТ ВЫВОДА: "Result = <число>\n"
;
; ПРИМЕРЫ:
;   print_unsigned_output_var(0)      → "Result = 0\n"
;   print_unsigned_output_var(12345)  → "Result = 12345\n"
;   print_unsigned_output_var(-100)   → "Result = -100\n"
;
; ПРИМЕЧАНИЕ:
;   Хотя функция работает с unsigned, она принимает signed int32
;   для корректной обработки результатов операций (например, a - b,
;   где a < b даст отрицательный результат).
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   C-style:
;     int32_t result = 12345;
;     print_unsigned_output_var(result);
;
;   Assembly:
;     mov edi, 12345
;     call print_unsigned_output_var
;
; @param  edi  Значение для вывода (int32_t)
; @return none
; @uses   rax, rbx, rcx, rdx, rdi, rsi, r12, r13
;
; @complexity O(log₁₀(n)), где n - абсолютное значение числа
; @memory     O(1), использует фиксированный буфер
; ----------------------------------------------------------------------------
print_unsigned_output_var:
    push rbp
    mov rbp, rsp
    push rbx
    push r12
    push r13

    movsxd rax, edi             ; Знаковое расширение int32 → int64

    mov r12, 10                       ; Делитель = 10 (основание системы счисления)
    lea r13, [parse_temp_buffer + 63] ; r13 = указатель на конец буфера
    mov byte [r13], 0                 ; Установка null-терминатора

; --- Специальная обработка нуля ---
    test rax, rax               ; Проверка: число равно нулю?
    jnz .check_sign             ; Если нет - обработка знака
    dec r13                     ; Смещение указателя назад
    mov byte [r13], '0'         ; Запись символа '0'
    jmp .print                  ; Переход к выводу

; --- Обработка знака числа ---
.check_sign:
    xor rbx, rbx                ; rbx = флаг знака (0 по умолчанию)
    test rax, rax               ; Проверка знака числа (установка флагов)
    jge .convert                ; Если >= 0 - переход к конвертации
    neg rax                     ; Взятие модуля (двухкомплементное отрицание)
    mov rbx, 1                  ; Установка флага отрицательного числа

; --- Конвертация числа в строку (справа налево) ---
; Инвариант цикла: r13 указывает на следующую позицию для записи
.convert:
    dec r13                     ; Смещение указателя назад
    xor rdx, rdx                ; Обнуление rdx перед делением
    div r12                     ; rax = rax / 10, rdx = rax % 10 (остаток - цифра)
    add dl, '0'                 ; Преобразование цифры (0-9) в ASCII ('0'-'9')
    mov [r13], dl               ; Запись ASCII-символа в буфер
    test rax, rax               ; Проверка: остались ли ещё цифры?
    jnz .convert                ; Если да - продолжение конвертации

; --- Добавление знака минус для отрицательных чисел ---
    test rbx, rbx               ; Проверка флага отрицательного числа
    jz .print                   ; Если положительное - переход к выводу
    dec r13                     ; Смещение указателя назад
    mov byte [r13], '-'         ; Запись символа минуса

; --- Вывод результата ---
.print:
    ; Вывод префикса "Result = "
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    lea rsi, [msg_res]
    mov rdx, len_res
    syscall

    ; Вывод преобразованного числа
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    mov rsi, r13                        ; Адрес начала числовой строки
    lea rdx, [parse_temp_buffer + 63]   ; Адрес конца буфера
    sub rdx, r13                        ; Вычисление длины строки (конец - начало)
    syscall

    ; Вывод символа новой строки
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    lea rsi, [newline]
    mov rdx, 1
    syscall

    pop r13
    pop r12
    pop rbx
    pop rbp
    ret

; ============================================================================
; ОБЁРТКИ СОВМЕСТИМОСТИ (для программ со старым интерфейсом)
; ============================================================================

; Объявление слабых внешних ссылок (weak symbols)
; Если программа не определяет эти переменные, их адрес будет 0
extern a:weak               ; uint16_t - первая входная переменная
extern b:weak               ; uint16_t - вторая входная переменная
extern output:weak          ; int32_t - выходная переменная для результата

; ----------------------------------------------------------------------------
; read_unsigned_input
;
; Обёртка совместимости для чтения во внешние глобальные переменные 'a' и 'b'.
; Проверяет наличие символов через механизм weak linking.
;
; ТРЕБОВАНИЯ:
;   Вызывающая программа должна определить:
;     global a
;     global b
;     section .bss
;       a resw 1
;       b resw 1
;
; ДИАПАЗОН: 0 до 65535 для каждого числа
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   Old-style программа:
;     extern read_unsigned_input
;     global a, b
;     section .bss
;       a resw 1
;       b resw 1
;     section .text
;       call read_unsigned_input  ; Читает в a и b
;
; @param  none (читает в extern a, b)
; @return none
; @uses   rax, rdi, rsi (через вызов read_unsigned_input_vars)
; @calls  read_unsigned_input_vars
; @exit   Код 1 при ошибке ввода или отсутствии переменных a, b
;
; @see read_unsigned_input_vars - основная реализация
; ----------------------------------------------------------------------------
read_unsigned_input:
    push rbp
    mov rbp, rsp

; --- Проверка наличия символа 'a' ---
    mov rax, a                    ; Загрузка адреса переменной 'a'
    test rax, rax                 ; Проверка: адрес равен 0? (символ не определён)
    jz .missing_symbols           ; Если да - переход к обработке ошибки

; --- Проверка наличия символа 'b' ---
    mov rax, b                    ; Загрузка адреса переменной 'b'
    test rax, rax                 ; Проверка: адрес равен 0? (символ не определён)
    jz .missing_symbols           ; Если да - переход к обработке ошибки

; --- Вызов основной функции с адресами глобальных переменных ---
    lea rdi, [a]                  ; Загрузка адреса переменной 'a' в rdi
    lea rsi, [b]                  ; Загрузка адреса переменной 'b' в rsi
    call read_unsigned_input_vars ; Вызов функции чтения

    pop rbp
    ret

; --- Обработка отсутствия требуемых переменных ---
.missing_symbols:
    ; Вывод сообщения об ошибке
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2
    lea rsi, [err_compat]
    mov rdx, err_compat_len
    syscall
    
    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; ----------------------------------------------------------------------------
; print_unsigned_output
;
; Обёртка совместимости для вывода внешней глобальной переменной 'output'.
; Проверяет наличие символа через механизм weak linking.
;
; ТРЕБОВАНИЯ:
;   Вызывающая программа должна определить:
;     global output
;     section .bss
;       output resd 1
;
; ДИАПАЗОН: -2147483648 до 2147483647 (int32_t)
; ФОРМАТ ВЫВОДА: "Result = <число>\n"
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   Old-style программа:
;     extern print_unsigned_output
;     global output
;     section .bss
;       output resd 1
;     section .text
;       mov dword [output], 12345
;       call print_unsigned_output  ; Выводит: Result = 12345
;
; @param  none (читает из extern output)
; @return none
; @uses   rax, rdi (через вызов print_unsigned_output_var)
; @calls  print_unsigned_output_var
; @exit   Код 1 при отсутствии переменной output
;
; @see print_unsigned_output_var - основная реализация
; ----------------------------------------------------------------------------
print_unsigned_output:
    push rbp
    mov rbp, rsp

; --- Проверка наличия символа 'output' ---
    mov rax, output                ; Загрузка адреса переменной 'output'
    test rax, rax                  ; Проверка: адрес равен 0? (символ не определён)
    jz .missing_symbols_out        ; Если да - переход к обработке ошибки

; --- Загрузка значения и вызов основной функции ---
    mov edi, [output]              ; Загрузка значения переменной output в edi
    call print_unsigned_output_var ; Вызов функции вывода

    pop rbp
    ret

; --- Обработка отсутствия переменной output ---
.missing_symbols_out:
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2
    lea rsi, [err_compat]
    mov rdx, err_compat_len
    syscall
    
    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; ----------------------------------------------------------------------------
; layer2_read_string_unsigned
;
; Внутренняя функция буферизованного чтения строки из stdin до символа LF.
; Использует внутреннюю буферизацию для минимизации системных вызовов.
; Результат сохраняется в parse_temp_buffer с null-терминатором.
;
; АЛГОРИТМ:
;   1. Очистка выходного буфера
;   2. Цикл чтения:
;      - Проверка наличия данных в буфере
;      - При необходимости: системный вызов read() для новой порции
;      - Копирование символа в выходной буфер
;      - Проверка на LF (конец строки)
;   3. Установка null-терминатора
;
; БУФЕРИЗАЦИЯ:
;   Внутренний буфер: 128 байт
;   Выходной буфер: 64 байта
;   Минимизирует количество syscall для повышения производительности
;
; @param  none
; @return none (результат в parse_temp_buffer)
; @uses   rax, rbx, rcx, rdx, rdi, rsi
; @exit   Код 1 при EOF без данных
;
; @complexity O(n), где n - длина строки
; @calls      syscall read(stdin)
; ----------------------------------------------------------------------------
layer2_read_string_unsigned:
    push rbx
    push rcx
    push rdi

; --- Очистка выходного буфера ---
    lea rdi, [parse_temp_buffer] ; Адрес буфера для очистки
    mov rcx, 64                  ; Количество байт для очистки
    xor al, al                   ; Значение для заполнения (0)
    rep stosb                    ; Повторение stosb rcx раз (заполнение нулями)

    xor rbx, rbx                 ; rbx = позиция записи в parse_temp_buffer (0)

; --- Цикл чтения символов ---
.read_char:
    ; Проверка наличия данных в буфере
    mov rax, [io_interactive_size] ; Загрузка количества доступных байт
    test rax, rax                  ; Проверка: есть ли данные в буфере?
    jnz .has_data                  ; Если да - переход к чтению из буфера

    ; Буфер пуст - системный вызов
    ; syscall: read(stdin, buffer, count)
    xor rax, rax
    xor rdi, rdi
    lea rsi, [io_interactive_buffer]
    mov rdx, 128
    syscall

    test rax, rax               ; Проверка результата (rax = количество прочитанных байт)
    jle .eof                    ; Если <= 0 (EOF или ошибка) - обработка

    mov [io_interactive_size], rax ; Сохранение количества прочитанных байт
    mov qword [io_interactive_pos], 0 ; Сброс позиции чтения в начало буфера

; --- Извлечение символа из буфера ---
.has_data:
    mov rcx, [io_interactive_pos]              ; Загрузка текущей позиции чтения
    mov al, byte [io_interactive_buffer + rcx] ; Чтение символа из буфера

    inc qword [io_interactive_pos]  ; Увеличение позиции чтения
    dec qword [io_interactive_size] ; Уменьшение количества доступных байт

    ; Проверка 1: Достигнут ли лимит буфера parse_temp_buffer?
    cmp rbx, 63                  ; Проверка: буфер заполнен (осталось место для null)?
    jge .skip_write              ; Если да - НЕ записываем, но продолжаем читать

    ; Запись символа в выходной буфер (только если есть место)
    lea rdx, [parse_temp_buffer] ; Загрузка базового адреса выходного буфера
    mov byte [rdx + rbx], al     ; Запись символа по адресу [база + смещение]
    inc rbx                      ; Увеличение позиции записи

.skip_write:
    ; Проверка 2: Конец строки (LF)?
    cmp al, 10                  ; Проверка: LF (line feed)?
    je .done                    ; Если да - завершение чтения

    ; Продолжение чтения следующего символа (даже если буфер полон)
    jmp .read_char

; --- Обработка EOF без данных ---
.eof:
    test rbx, rbx               ; Проверка: были ли прочитаны данные?
    jnz .done                   ; Если да - завершение нормально (частичные данные)

    ; EOF без данных - это ошибка
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2
    lea rsi, [error_format_msg]
    mov rdx, error_format_len
    syscall

    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; --- Успешное завершение ---
.done:
    pop rdi
    pop rcx
    pop rbx
    ret

; ============================================================================
; io_float.asm
;
; Модуль ввода-вывода для чисел с плавающей точкой (float) и целых (int32).
; Обеспечивает безопасное чтение и вывод чисел с проверкой формата.
;
; АРХИТЕКТУРА:
;
;   СЛОЙ 1: Чистые функции парсинга
;     • parse_float - Парсинг строки в float (IEEE 754 single precision)
;     • parse_int32 - Парсинг строки в знаковое 32-битное число
;     • Не выполняют I/O операций, только обработка данных
;     • Возвращают значения через регистры
;
;   СЛОЙ 2: Интерактивный ввод-вывод (stdin/stdout)
;     • read_float_var, read_int_var - работа через параметры
;     • print_float_var, print_int_var - вывод через параметры
;     • read_float, read_int - обёртки для совместимости
;     • Буферизованное чтение, форматированный вывод
;
; ОСОБЕННОСТИ РАБОТЫ С FLOAT:
;   • Поддержка целой и дробной частей
;   • Точность вывода: 6 знаков после запятой
;   • Использование FPU (x87) для вычислений
;   • Формат IEEE 754 single precision (32 бита)
;   • Вывод в формате: [-]целая.дробная (hex: 0xXXXXXXXX)
;
; СОВМЕСТИМОСТЬ:
;   Поддерживает старый интерфейс через функции без префиксов
;
; ПРОИЗВОДИТЕЛЬНОСТЬ:
;   • Сложность парсинга: O(n), где n - количество цифр
;   • Память: O(1), используются фиксированные буферы
;   • Буферизация I/O минимизирует системные вызовы
; ============================================================================

default rel                             ; Использовать RIP-relative адресацию по умолчанию

section .data
    ; Константы FPU для вычислений с плавающей точкой
    io_const_ten dd 10.0                ; Константа 10.0 для умножения/деления
    io_const_one dd 1.0                 ; Константа 1.0 для вычисления степени

    ; Сообщения для форматированного вывода
    io_newline db 10, 0                 ; Символ новой строки с null-терминатором
    io_msg_hex db ' (hex: 0x', 0        ; Префикс для hex-представления
    io_msg_hex_end db ')', 0            ; Суффикс для hex-представления

    ; Сообщения об ошибках парсинга
    error_format_msg db "ERROR: Invalid number format", 10
    error_format_len equ $ - error_format_msg
    error_overflow_msg db "ERROR: Number overflow", 10
    error_overflow_len equ $ - error_overflow_msg

section .bss
    ; Буферы для работы всех слоёв
    parse_temp_buffer resb 64           ; Общий буфер для парсинга строк

    ; Буферы интерактивного режима (Слой 2)
    io_interactive_buffer resb 128      ; Буфер чтения из stdin
    io_interactive_pos resq 1           ; Текущая позиция чтения в буфере
    io_interactive_size resq 1          ; Количество непрочитанных байт в буфере

section .text
    ; Экспорт функций всех слоёв
    global parse_float              ; Слой 1: чистая функция парсинга float
    global parse_int32              ; Слой 1: чистая функция парсинга int32
    global read_float_var           ; Слой 2: чтение float через параметры
    global read_int_var             ; Слой 2: чтение int32 через параметры
    global print_float_var          ; Слой 2: вывод float через параметры
    global print_int_var            ; Слой 2: вывод int32 через параметры
    global read_float               ; Слой 2: обёртка совместимости для float
    global read_int                 ; Слой 2: обёртка совместимости для int32
    global print_float_from_eax     ; Слой 2: вывод float из регистра
    global print_string             ; Утилита: вывод строки
    global print_hex_32             ; Утилита: вывод 32-битного hex

; ============================================================================
; КОНСТАНТЫ
; ============================================================================
FPU_TRUNC_MODE  equ 0x0C00          ; Режим усечения FPU (округление к нулю)
BUFFER_SIZE     equ 64              ; Размер основного буфера
FRAC_DIGITS     equ 6               ; Количество знаков дробной части

; ============================================================================
; СЛОЙ 1: ФУНКЦИИ ПАРСИНГА
; ============================================================================

; ----------------------------------------------------------------------------
; parse_float
;
; Парсит текстовую строку в число с плавающей точкой (IEEE 754 single).
; Поддерживает знак '-', целую и дробную части, пропускает пробелы.
;
; АЛГОРИТМ:
;   1. Пропуск начальных пробелов
;   2. Обработка знака (только '-', плюс не требуется)
;   3. Посимвольный парсинг:
;      - До точки: накопление целой части (r10)
;      - После точки: накопление дробной части (r12) и счётчика цифр (r11)
;   4. Конвертация через FPU:
;      - Целая часть → FPU stack
;      - Дробная часть / 10^(кол-во цифр) → FPU stack
;      - Сложение
;      - Применение знака
;   5. Сохранение битового представления
;
; ФОРМАТ ЧИСЛА:
;   [пробелы][-]цифры[.цифры][пробел/LF/CR/null]
;
; ПРИМЕРЫ:
;   "  -3.14 "  → -3.14 (rdx=0)
;   "123.456"   → 123.456 (rdx=0)
;   "0.5"       → 0.5 (rdx=0)
;   "42"        → 42.0 (rdx=0, дробная часть опциональна)
;   "abc"       → 0 (rdx=1, неверный формат)
;
; @param  rdi  Указатель на null-терминированную строку
; @return eax  Битовое представление float (IEEE 754)
;         rdx  Код ошибки:
;              0 = успех
;              1 = неверный формат (нет цифр, недопустимые символы)
;              2 = переполнение (арифметическое переполнение при вычислениях)
; @uses   r8, r9, r10, r11, r12, r13, r14, FPU stack
;
; @complexity O(n), где n - длина входной строки
; @memory     O(1) + использование FPU stack
;
; @note Использует x87 FPU для точных вычислений с плавающей точкой
; ----------------------------------------------------------------------------
parse_float:
    push rbp
    mov rbp, rsp
    sub rsp, 32                 ; Локальное пространство для FPU операций
    push r8
    push r9
    push r10
    push r11
    push r12
    push r13
    push r14

    mov rcx, 0                  ; rcx = индекс текущего символа в строке
    xor r8, r8                  ; r8 = флаг знака (0 = положительное, 1 = отрицательное)
    xor r9, r9                  ; r9 = флаг точки (0 = ещё не встречена, 1 = уже встречена)
    xor r10, r10                ; r10 = накопитель целой части
    xor r11, r11                ; r11 = счётчик цифр дробной части
    xor r12, r12                ; r12 = накопитель дробной части
    xor r14, r14                ; r14 = счётчик цифр (валидация)

; --- Пропуск начальных пробелов ---
.skip_spaces:
    movzx rax, byte [rdi + rcx] ; Загрузка текущего символа с нулевым расширением
    cmp al, ' '                 ; Проверка: пробел?
    jne .check_sign             ; Если нет - переход к проверке знака
    inc rcx                     ; Переход к следующему символу
    jmp .skip_spaces            ; Продолжение пропуска пробелов

; --- Обработка знака числа ---
.check_sign:
    cmp byte [rdi + rcx], '-'   ; Проверка: минус?
    jne .parse                  ; Если нет - переход к парсингу
    mov r8, 1                   ; Установка флага отрицательного числа
    inc rcx                     ; Пропуск символа '-'

; --- Главный цикл парсинга цифр ---
; Инвариант: r10 = целая часть, r12 = дробная часть (без десятичной точки)
.parse:
    movzx rax, byte [rdi + rcx] ; Загрузка текущего символа
    call io_is_end_char         ; Проверка: символ окончания (LF/CR/пробел/null)?
    je .check_valid             ; Если да - завершение парсинга
    
    cmp al, '.'                 ; Проверка: десятичная точка?
    je .dot                     ; Если да - обработка точки
    
    ; Валидация символа как цифры
    cmp al, '0'                 ; Проверка: символ < '0'?
    jl .error_format            ; Если да - ошибка формата
    cmp al, '9'                 ; Проверка: символ > '9'?
    jg .error_format            ; Если да - ошибка формата
    
    inc r14                     ; Увеличение счётчика валидных цифр
    
    sub al, '0'                 ; Преобразование ASCII ('0'-'9') в число (0-9)
    movzx rax, al               ; Нулевое расширение до 64 бит
    
    cmp r9, 0                   ; Проверка: уже встретили точку?
    je .integer                 ; Если нет - это цифра целой части

; --- Обработка цифры дробной части ---
.fractional:
    imul r12, 10                ; r12 = r12 * 10 (сдвиг разряда)
    jo .error_overflow          ; Проверка переполнения при умножении
    add r12, rax                ; Добавление текущей цифры
    jo .error_overflow          ; Проверка переполнения при сложении
    inc r11                     ; Увеличение счётчика цифр дробной части
    jmp .next                   ; Переход к следующему символу

; --- Обработка цифры целой части ---
.integer:
    imul r10, 10                ; r10 = r10 * 10 (сдвиг разряда)
    jo .error_overflow          ; Проверка переполнения при умножении
    add r10, rax                ; Добавление текущей цифры
    jo .error_overflow          ; Проверка переполнения при сложении

.next:
    inc rcx                     ; Переход к следующему символу
    jmp .parse                  ; Продолжение парсинга

; --- Обработка десятичной точки ---
.dot:
    cmp r9, 1                   ; Проверка: точка уже встречалась?
    je .error_format            ; Если да - ошибка (две точки недопустимы)
    mov r9, 1                   ; Установка флага точки
    inc rcx                     ; Пропуск символа '.'
    jmp .parse                  ; Продолжение парсинга

; --- Проверка валидности числа (хотя бы одна цифра) ---
.check_valid:
    test r14, r14               ; Проверка: были ли обработаны цифры?
    jz .error_format            ; Если нет - ошибка формата

; --- Пропуск завершающих пробелов ---
.check_trailing:
    movzx rax, byte [rdi + rcx] ; Загрузка текущего символа
    cmp al, 0                   ; Проверка: null-терминатор?
    je .convert                 ; Если да - переход к конвертации
    cmp al, 10                  ; Проверка: LF?
    je .convert                 ; Если да - переход к конвертации
    cmp al, 13                  ; Проверка: CR?
    je .convert                 ; Если да - переход к конвертации
    cmp al, ' '                 ; Проверка: пробел?
    jne .error_format           ; Если другой символ - ошибка формата
    inc rcx                     ; Пропуск пробела
    jmp .check_trailing         ; Продолжение проверки

; --- Конвертация через FPU ---
; Алгоритм: float = целая_часть + (дробная_часть / 10^количество_цифр)
.convert:
    ; Загрузка целой части в FPU
    mov [rbp-8], r10            ; Сохранение целой части в памяти
    fild qword [rbp-8]          ; ST(0) = целая часть (int64 → float)
    
    cmp r11, 0                  ; Проверка: есть ли дробная часть?
    je .sign                    ; Если нет - переход к применению знака
    
    ; Загрузка дробной части в FPU
    mov [rbp-16], r12           ; Сохранение дробной части в памяти
    fild qword [rbp-16]         ; ST(0) = дробная часть, ST(1) = целая часть
    
    ; Вычисление делителя: 10^r11 (количество цифр дробной части)
    mov [rbp-24], r11           ; Сохранение количества цифр
    fild qword [rbp-24]         ; ST(0) = r11, ST(1) = дробная, ST(2) = целая
    fld dword [io_const_ten]    ; ST(0) = 10.0, ST(1) = r11, ST(2) = дробная, ST(3) = целая
    fxch st1                    ; ST(0) = r11, ST(1) = 10.0, ST(2) = дробная, ST(3) = целая
    
    ; Цикл возведения в степень: 10^r11
    mov r13, r11                ; r13 = счётчик итераций
    fld dword [io_const_one]    ; ST(0) = 1.0 (аккумулятор), ST(1) = r11, ST(2) = 10.0, ...
.pow:
    cmp r13, 0                  ; Проверка: остались ли итерации?
    je .pow_done                ; Если нет - завершение возведения в степень
    fmul st0, st2               ; ST(0) = ST(0) * 10.0 (умножение аккумулятора)
    dec r13                     ; Уменьшение счётчика
    jmp .pow                    ; Продолжение цикла

.pow_done:
    ; Стек FPU: ST(0) = 10^r11, ST(1) = r11, ST(2) = 10.0, ST(3) = дробная, ST(4) = целая
    fxch st3                    ; ST(0) = дробная, ST(1) = r11, ST(2) = 10.0, ST(3) = 10^r11, ST(4) = целая
    fdiv st0, st3               ; ST(0) = дробная / 10^r11 (нормализация дробной части)
    fxch st3                    ; ST(0) = 10^r11, ST(1) = r11, ST(2) = 10.0, ST(3) = дробная/10^r11, ST(4) = целая
    fstp st0                    ; Удаление 10^r11 из стека
    fstp st0                    ; Удаление r11 из стека
    fstp st0                    ; Удаление 10.0 из стека

    ; Стек FPU: ST(0) = дробная/10^r11, ST(1) = целая
    faddp st1, st0              ; ST(0) = целая + дробная/10^r11 (финальное значение)

; --- Применение знака ---
.sign:
    cmp r8, 1                   ; Проверка флага знака
    jne .done                   ; Если положительное - переход к сохранению
    fchs                        ; Изменение знака числа в FPU (ST(0) = -ST(0))

; --- Сохранение результата ---
.done:
    fstp dword [rbp-28]         ; Сохранение float из FPU в память
    mov eax, [rbp-28]           ; Загрузка битового представления в EAX
    xor rdx, rdx                ; Установка кода успеха (0)
    jmp .return                 ; Возврат из функции

; --- Обработка ошибок ---
.error_overflow:
    xor eax, eax                ; Результат = 0
    mov rdx, 2                  ; Код ошибки = 2 (переполнение)
    jmp .return

.error_format:
    xor eax, eax                ; Результат = 0
    mov rdx, 1                  ; Код ошибки = 1 (неверный формат)

.return:
    pop r14
    pop r13
    pop r12
    pop r11
    pop r10
    pop r9
    pop r8
    mov rsp, rbp
    pop rbp
    ret

; ----------------------------------------------------------------------------
; parse_int32
;
; Парсит текстовую строку в знаковое 32-битное целое число.
; Поддерживает знак '-', ведущие и завершающие пробелы.
; Выполняет проверку на переполнение int32_t.
;
; АЛГОРИТМ:
;   1. Пропуск начальных пробелов
;   2. Обработка знака (только '-')
;   3. Посимвольный парсинг цифр: result = result*10 + digit
;   4. Проверка на переполнение после каждой операции
;   5. Применение знака и валидация
;
; ДОПУСТИМЫЙ ДИАПАЗОН: -2147483648 до 2147483647
; ФОРМАТЫ: [пробелы][-]цифры[пробел/LF/CR/null]
;
; ПРИМЕРЫ:
;   "  -12345 " → -12345 (rdx=0)
;   "2147483647" → 2147483647 (rdx=0)
;   "2147483648" → 0 (rdx=2, переполнение)
;   "abc"        → 0 (rdx=1, неверный формат)
;
; @param  rdi  Указатель на null-терминированную строку
; @return eax  Распарсенное число (знаковое 32-битное)
;         rdx  Код ошибки:
;              0 = успех
;              1 = неверный формат
;              2 = переполнение
; @uses   rbx, rcx, r8, r12, r14
;
; @complexity O(n), где n - длина входной строки
; @memory     O(1), не использует динамическую память
; ----------------------------------------------------------------------------
parse_int32:
    push rbp
    mov rbp, rsp
    push r8
    push r12
    push r13
    push r14
    
    xor rcx, rcx                ; rcx = индекс текущего символа
    xor rax, rax                ; rax = аккумулятор результата
    xor r8, r8                  ; r8 = флаг знака (0 = положит., 1 = отрицат.)
    xor r14, r14                ; r14 = счётчик обработанных цифр

; --- Пропуск начальных пробелов ---
.skip_spaces:
    movzx rbx, byte [rdi + rcx] ; Загрузка текущего символа
    cmp bl, ' '                 ; Проверка: пробел?
    jne .check_sign             ; Если нет - переход к проверке знака
    inc rcx                     ; Переход к следующему символу
    jmp .skip_spaces            ; Продолжение пропуска

; --- Обработка знака ---
.check_sign:
    cmp byte [rdi + rcx], '-'   ; Проверка: минус?
    jne .parse                  ; Если нет - переход к парсингу
    mov r8, 1                   ; Установка флага отрицательного числа
    inc rcx                     ; Пропуск символа '-'

; --- Главный цикл парсинга цифр ---
; Инвариант: rax содержит частично собранное число
.parse:
    movzx rbx, byte [rdi + rcx] ; Загрузка текущего символа
    
    ; Проверка символов окончания числа
    cmp bl, 10                  ; Проверка: LF?
    je .check_valid             ; Если да - завершение парсинга
    cmp bl, 0                   ; Проверка: null-терминатор?
    je .check_valid             ; Если да - завершение парсинга
    cmp bl, 32                  ; Проверка: пробел?
    je .check_valid             ; Если да - завершение парсинга
    cmp bl, 13                  ; Проверка: CR?
    je .check_valid             ; Если да - завершение парсинга
    
    ; Валидация символа как цифры
    cmp bl, '0'                 ; Проверка: символ < '0'?
    jl .error_format            ; Если да - ошибка формата
    cmp bl, '9'                 ; Проверка: символ > '9'?
    jg .error_format            ; Если да - ошибка формата
    
    inc r14                     ; Увеличение счётчика цифр
    
    sub bl, '0'                 ; Преобразование ASCII в число
    movzx rbx, bl               ; Нулевое расширение
    
    mov r12, rax                ; Сохранение предыдущего значения для проверки
    imul rax, 10                ; rax = rax * 10
    jo .error_overflow          ; Проверка переполнения при умножении
    add rax, rbx                ; Добавление текущей цифры
    jo .error_overflow          ; Проверка переполнения при сложении
    
    inc rcx                     ; Переход к следующему символу
    jmp .parse                  ; Продолжение парсинга

; --- Проверка валидности (хотя бы одна цифра) ---
.check_valid:
    test r14, r14               ; Проверка: были ли обработаны цифры?
    jz .error_format            ; Если нет - ошибка формата

; --- Пропуск завершающих пробелов ---
.check_trailing:
    movzx rbx, byte [rdi + rcx] ; Загрузка текущего символа
    cmp bl, 0                   ; Проверка: null-терминатор?
    je .done                    ; Если да - завершение
    cmp bl, 10                  ; Проверка: LF?
    je .done                    ; Если да - завершение
    cmp bl, 13                  ; Проверка: CR?
    je .done                    ; Если да - завершение
    cmp bl, ' '                 ; Проверка: пробел?
    jne .error_format           ; Если другой символ - ошибка
    inc rcx                     ; Пропуск пробела
    jmp .check_trailing         ; Продолжение проверки

; --- Применение знака и валидация ---
.done:
    test rax, rax               ; Проверка знака результата
    js .overflow_check_neg      ; Если отрицательный - особая проверка
    
    cmp r8, 1                   ; Проверка флага знака
    jne .ret_ok                 ; Если должно быть положительным - готово
    neg rax                     ; Применение отрицательного знака
    jmp .ret_ok

; --- Проверка переполнения для отрицательных чисел ---
; Отрицательное значение в rax допустимо только если был знак минус
.overflow_check_neg:
    cmp r8, 1                   ; Проверка: был ли знак минус?
    je .ret_ok                  ; Если да - допустимо (INT_MIN = -2147483648)
    jmp .error_overflow         ; Если нет - переполнение

.ret_ok:
    xor rdx, rdx                ; Установка кода успеха (0)
    jmp .return

; --- Обработка ошибок ---
.error_overflow:
    xor eax, eax                ; Результат = 0
    mov rdx, 2                  ; Код ошибки = 2 (переполнение)
    jmp .return

.error_format:
    xor eax, eax                ; Результат = 0
    mov rdx, 1                  ; Код ошибки = 1 (неверный формат)

.return:
    pop r14
    pop r13
    pop r12
    pop r8
    pop rbp
    ret

; ============================================================================
; СЛОЙ 2: ИНТЕРАКТИВНЫЙ ВВОД-ВЫВОД
; ============================================================================

; ----------------------------------------------------------------------------
; read_float_var
;
; Читает число с плавающей точкой из стандартного ввода в переменную по адресу.
; Использует буферизованное чтение для эффективности.
;
; ВЗАИМОДЕЙСТВИЕ:
;   Ожидает ввод от пользователя (stdin), читает строку до LF,
;   парсит её через parse_float, сохраняет результат по указанному адресу.
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   C-style:
;     float value;
;     read_float_var(&value);
;     // value содержит введённое число
;
;   Assembly:
;     section .bss
;       my_float resd 1
;     section .text
;       lea rdi, [my_float]
;       call read_float_var
;
; @param  rdi  Адрес переменной для сохранения результата (float *)
; @return none (результат сохраняется по переданному адресу)
; @uses   rax, rbx, rcx, rdx, rdi
; @calls  layer2_read_string_float, parse_float
; @exit   Код 1 при ошибке парсинга (формат/переполнение)
;
; @see layer2_read_string_float - внутренняя буферизация
; @see parse_float - валидация и преобразование
; ----------------------------------------------------------------------------
read_float_var:
    push rbp
    mov rbp, rsp
    sub rsp, 16                   ; Выделяем место на стеке для локальной переменной
    push rbx

    mov [rbp-8], rdi              ; 1. СОХРАНЯЕМ АДРЕС назначения в локальную переменную
                                  ; (защита от изменений регистров в вызываемых функциях)

    call layer2_read_string_float ; Чтение строки в parse_temp_buffer

    lea rdi, [parse_temp_buffer]  ; Адрес строки для парсинга
    call parse_float              ; Парсинг введённого значения
    
    test rdx, rdx                 ; Проверка кода ошибки (0 = успех)
    jnz .handle_error             ; Если ошибка - переход к обработке
    
    mov rbx, [rbp-8]              ; 2. ВОССТАНАВЛИВАЕМ АДРЕС из локальной переменной
    mov [rbx], eax                ; 3. Запись битового представления float

    pop rbx
    mov rsp, rbp
    pop rbp
    ret

; --- Обработка ошибок парсинга ---
.handle_error:
    cmp rdx, 1                    ; Проверка: код ошибки = 1 (формат)?
    je .print_format
    lea rsi, [error_overflow_msg] ; Адрес сообщения о переполнении
    mov rdx, error_overflow_len   ; Длина сообщения
    jmp .do_print
.print_format:
    lea rsi, [error_format_msg]   ; Адрес сообщения об ошибке формата
    mov rdx, error_format_len     ; Длина сообщения
.do_print:
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2
    syscall
    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; ----------------------------------------------------------------------------
; read_int_var
;
; Читает знаковое 32-битное целое число из стандартного ввода в переменную.
; Использует буферизованное чтение для эффективности.
;
; ВЗАИМОДЕЙСТВИЕ:
;   Ожидает ввод от пользователя (stdin), читает строку до LF,
;   парсит её через parse_int32, сохраняет результат по указанному адресу.
;
; ДИАПАЗОН: -2147483648 до 2147483647
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   C-style:
;     int32_t value;
;     read_int_var(&value);
;     // value содержит введённое число
;
;   Assembly:
;     section .bss
;       my_int resd 1
;     section .text
;       lea rdi, [my_int]
;       call read_int_var
;
; @param  rdi  Адрес переменной для сохранения результата (int32_t *)
; @return none (результат сохраняется по переданному адресу)
; @uses   rax, rbx, rcx, rdx, rdi
; @calls  layer2_read_string_float, parse_int32
; @exit   Код 1 при ошибке парсинга (формат/переполнение)
;
; @see layer2_read_string_float - внутренняя буферизация
; @see parse_int32 - валидация и преобразование
; ----------------------------------------------------------------------------
read_int_var:
    push rbp
    mov rbp, rsp
    sub rsp, 16                   ; Выделяем место на стеке
    push rbx

    mov [rbp-8], rdi              ; 1. СОХРАНЯЕМ АДРЕС назначения в локальную переменную

    call layer2_read_string_float ; Чтение строки в parse_temp_buffer

    lea rdi, [parse_temp_buffer]  ; Адрес строки для парсинга
    call parse_int32              ; Парсинг введённого значения
    
    test rdx, rdx                 ; Проверка кода ошибки (0 = успех)
    jnz .handle_error             ; Если ошибка - переход к обработке
    
    mov rbx, [rbp-8]              ; 2. ВОССТАНАВЛИВАЕМ АДРЕС
    mov [rbx], eax                ; 3. Запись значения (32 бита)

    pop rbx
    mov rsp, rbp
    pop rbp
    ret

; --- Обработка ошибок парсинга ---
.handle_error:
    cmp rdx, 1                    ; Проверка: код ошибки = 1 (формат)?
    je .print_format
    lea rsi, [error_overflow_msg] ; Адрес сообщения о переполнении
    mov rdx, error_overflow_len   ; Длина сообщения
    jmp .do_print
.print_format:
    lea rsi, [error_format_msg]   ; Адрес сообщения об ошибке формата
    mov rdx, error_format_len     ; Длина сообщения
.do_print:
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2
    syscall

    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; ----------------------------------------------------------------------------
; print_float_var
;
; Выводит число с плавающей точкой в stdout в формате:
; [-]целая.дробная (hex: 0xXXXXXXXX)\n
;
; АЛГОРИТМ:
;   1. Загрузка float в FPU
;   2. Определение знака и вывод '-' при необходимости
;   3. Отделение целой части через FPU truncation
;   4. Вычисление дробной части (исходное - целая)
;   5. Вывод целой части
;   6. Вывод точки
;   7. Вывод дробной части (6 знаков)
;   8. Вывод hex-представления
;
; ФОРМАТ ВЫВОДА: [-]целая.дробная (hex: 0xXXXXXXXX)\n
; ТОЧНОСТЬ: 6 знаков после запятой (FRAC_DIGITS)
;
; ПРИМЕРЫ:
;   print_float_var(0x40490FDB) → "3.141593 (hex: 0x40490FDB)\n"  (π)
;   print_float_var(0xC0000000) → "-2.000000 (hex: 0xC0000000)\n"
;   print_float_var(0x00000000) → "0.000000 (hex: 0x00000000)\n"
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   C-style:
;     float pi = 3.14159f;
;     print_float_var(*(uint32_t*)&pi);
;
;   Assembly:
;     mov edi, 0x40490FDB    ; Битовое представление π
;     call print_float_var
;
; @param  edi  Битовое представление float (IEEE 754)
; @return none
; @uses   rax, rbx, r12, r13, r14, r15, FPU stack
;
; @complexity O(1), фиксированная точность вывода
; @memory     O(1), использует фиксированные буферы
;
; @note Использует FPU для разделения на целую и дробную части
; ----------------------------------------------------------------------------
print_float_var:
    push rbp
    mov rbp, rsp
    sub rsp, 64                 ; Локальное пространство для FPU и временных данных
    push rbx
    push r12
    push r13
    push r14
    push r15

    mov r12d, edi                     ; Сохранение битового представления для hex-вывода
    mov [rbp-4], edi                  ; Сохранение в памяти для загрузки в FPU
    fld dword [rbp-4]                 ; Загрузка float в FPU: ST(0) = число
    
    ; Проверка знака числа через FPU
    ftst                              ; Сравнение ST(0) с 0.0
    fstsw ax                          ; Копирование FPU status word в AX
    sahf                              ; Загрузка AH в флаги процессора
    jae .positive                     ; Если >= 0 - переход к обработке положительного
    
    ; Вывод знака минус
    mov byte [parse_temp_buffer], '-' ; Подготовка символа '-'
    call io_print_char                ; Вывод символа
    fabs                              ; Взятие модуля: ST(0) = |ST(0)|

; --- Разделение на целую и дробную части ---
.positive:
    fld st0                     ; Дублирование: ST(0) = число, ST(1) = число
    
    ; Усечение до целой части (truncation)
    push rax
    sub rsp, 8
    fnstcw [rsp]                ; Сохранение текущего control word FPU
    mov ax, [rsp]               ; Загрузка control word
    or ax, FPU_TRUNC_MODE       ; Установка режима усечения (0x0C00)
    mov [rsp+4], ax             ; Сохранение нового control word
    fldcw [rsp+4]               ; Загрузка нового control word в FPU
    frndint                     ; Округление ST(0) к целому (усечение)
    fldcw [rsp]                 ; Восстановление исходного control word
    add rsp, 8
    pop rax
    
    ; Сохранение целой части
    fist dword [rbp-8]          ; ST(0) → [rbp-8] (целая часть как int32)
    mov r13d, [rbp-8]           ; Загрузка целой части в r13d
    
    ; Вычисление дробной части
    fsubr st0, st1              ; ST(0) = ST(1) - ST(0) = исходное - целое
    fstp dword [rbp-12]         ; Сохранение дробной части: [rbp-12] = дробная
    fstp st0                    ; Удаление исходного числа из стека FPU
    
; --- Вывод компонентов ---
    call pf_int_part            ; Вывод целой части
    call pf_dec_point           ; Вывод десятичной точки '.'
    call pf_frac_part           ; Вывод дробной части (6 знаков)
    call print_hex_32_internal  ; Вывод hex-представления
    
    ; Вывод символа новой строки
    lea rdi, [io_newline]
    call print_string
    
    pop r15
    pop r14
    pop r13
    pop r12
    pop rbx
    mov rsp, rbp
    pop rbp
    ret

; ----------------------------------------------------------------------------
; print_int_var
;
; Выводит знаковое 32-битное целое число в stdout в десятичном формате
; с переводом строки.
;
; АЛГОРИТМ:
;   1. Обработка специального случая (ноль)
;   2. Определение знака и взятие модуля
;   3. Конвертация справа налево: число % 10 → ASCII
;   4. Добавление знака '-' при необходимости
;   5. Вывод числа и перевода строки
;
; ДИАПАЗОН: -2147483648 до 2147483647 (int32_t)
; ФОРМАТ ВЫВОДА: "<число>\n"
;
; ПРИМЕРЫ:
;   print_int_var(0)       → "0\n"
;   print_int_var(12345)   → "12345\n"
;   print_int_var(-9876)   → "-9876\n"
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   C-style:
;     int32_t value = -12345;
;     print_int_var(value);
;
;   Assembly:
;     mov edi, -12345
;     call print_int_var
;
; @param  edi  Значение для вывода (int32_t)
; @return none
; @uses   rax, rbx, rcx, rdx, rdi, rsi, r12, r13
;
; @complexity O(log₁₀(n)), где n - абсолютное значение числа
; @memory     O(1), использует фиксированный буфер
; ----------------------------------------------------------------------------
print_int_var:
    push rbp
    mov rbp, rsp
    push rbx
    push r12
    push r13
    
    movsxd rax, edi             ; Знаковое расширение int32 → int64
    
    mov r12, 10                 ; Делитель = 10 (основание системы счисления)
    lea r13, [parse_temp_buffer + 63] ; r13 = указатель на конец буфера
    mov byte [r13], 0           ; Установка null-терминатора
    
; --- Специальная обработка нуля ---
    test rax, rax               ; Проверка: число равно нулю?
    jnz .check_sign             ; Если нет - обработка знака
    dec r13                     ; Смещение указателя назад
    mov byte [r13], '0'         ; Запись символа '0'
    jmp .print                  ; Переход к выводу

; --- Обработка знака числа ---
.check_sign:
    xor rbx, rbx                ; rbx = флаг знака (0 по умолчанию)
    test rax, rax               ; Проверка знака числа (установка флагов)
    jge .convert                ; Если >= 0 - переход к конвертации
    neg rax                     ; Взятие модуля (двухкомплементное отрицание)
    mov rbx, 1                  ; Установка флага отрицательного числа

; --- Конвертация числа в строку (справа налево) ---
; Инвариант цикла: r13 указывает на следующую позицию для записи
.convert:
    dec r13                     ; Смещение указателя назад
    xor rdx, rdx                ; Обнуление rdx перед делением
    div r12                     ; rax = rax / 10, rdx = rax % 10 (остаток - цифра)
    add dl, '0'                 ; Преобразование цифры (0-9) в ASCII ('0'-'9')
    mov [r13], dl               ; Запись ASCII-символа в буфер
    test rax, rax               ; Проверка: остались ли ещё цифры?
    jnz .convert                ; Если да - продолжение конвертации
    
; --- Добавление знака минус для отрицательных чисел ---
    test rbx, rbx               ; Проверка флага отрицательного числа
    jz .print                   ; Если положительное - переход к выводу
    dec r13                     ; Смещение указателя назад
    mov byte [r13], '-'         ; Запись символа минуса

; --- Вывод результата ---
.print:
    ; Вывод числа
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    mov rsi, r13                ; Адрес начала числовой строки
    lea rdx, [parse_temp_buffer + 63] ; Адрес конца буфера
    sub rdx, r13                ; Вычисление длины строки (конец - начало)
    syscall
    
    ; Вывод символа новой строки
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    lea rsi, [io_newline]
    mov rdx, 1
    syscall
    
    pop r13
    pop r12
    pop rbx
    pop rbp
    ret

; ============================================================================
; ОБЁРТКИ СОВМЕСТИМОСТИ
; ============================================================================

; ----------------------------------------------------------------------------
; read_float (совместимость)
;
; Обёртка совместимости для чтения float без передачи адреса.
; Использует локальную переменную в стеке.
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   Assembly:
;     call read_float
;     ; EAX содержит битовое представление float
;
; @param  none
; @return eax  Битовое представление прочитанного float
; @uses   rax, rdi (через вызов read_float_var)
; @calls  read_float_var
;
; @see read_float_var - основная реализация
; ----------------------------------------------------------------------------
read_float:
    push rbp
    mov rbp, rsp
    sub rsp, 16
    lea rdi, [rbp-4]
    call read_float_var
    mov eax, [rbp-4]
    mov rsp, rbp
    pop rbp
    ret

; ----------------------------------------------------------------------------
; read_int (совместимость)
;
; Обёртка совместимости для чтения int32 без передачи адреса.
; Использует локальную переменную в стеке.
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   Assembly:
;     call read_int
;     ; EAX содержит прочитанное int32
;
; @param  none
; @return eax  Прочитанное значение int32
; @uses   rax, rdi (через вызов read_int_var)
; @calls  read_int_var
;
; @see read_int_var - основная реализация
; ----------------------------------------------------------------------------
read_int:
    push rbp
    mov rbp, rsp
    sub rsp, 16
    lea rdi, [rbp-4]
    call read_int_var
    mov eax, [rbp-4]
    mov rsp, rbp
    pop rbp
    ret

; ----------------------------------------------------------------------------
; print_float_from_eax (совместимость)
;
; Обёртка совместимости для вывода float из регистра EAX.
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   Assembly:
;     mov eax, 0x40490FDB    ; π
;     call print_float_from_eax
;
; @param  eax  Битовое представление float
; @return none
; @uses   edi (через вызов print_float_var)
; @calls  print_float_var
;
; @see print_float_var - основная реализация
; ----------------------------------------------------------------------------
print_float_from_eax:
    mov edi, eax
    call print_float_var
    ret

; ----------------------------------------------------------------------------
; layer2_read_string_float
;
; Внутренняя функция буферизованного чтения строки из stdin до символа LF.
; Использует внутреннюю буферизацию для минимизации системных вызовов.
; Результат сохраняется в parse_temp_buffer с null-терминатором.
;
; АЛГОРИТМ:
;   1. Очистка выходного буфера
;   2. Цикл чтения:
;      - Проверка наличия данных в буфере
;      - При необходимости: системный вызов read() для новой порции
;      - Копирование символа в выходной буфер
;      - Проверка на LF (конец строки)
;   3. Установка null-терминатора
;
; БУФЕРИЗАЦИЯ:
;   Внутренний буфер: 128 байт
;   Выходной буфер: 64 байта
;   Минимизирует количество syscall для повышения производительности
;
; @param  none
; @return none (результат в parse_temp_buffer)
; @uses   rax, rbx, rcx, rdx, rdi, rsi
; @exit   Код 1 при EOF без данных
;
; @complexity O(n), где n - длина строки
; @calls      syscall read(stdin)
; @internal   Используется внутри read_float_var и read_int_var
; ----------------------------------------------------------------------------
layer2_read_string_float:
    push rbx
    push rcx
    push rdi
    
; --- Очистка выходного буфера ---
    lea rdi, [parse_temp_buffer] ; Адрес буфера для очистки
    mov rcx, 64                  ; Количество байт для очистки
    xor al, al                   ; Значение для заполнения (0)
    rep stosb                    ; Повторение stosb rcx раз (заполнение нулями)
    
    xor rbx, rbx                 ; rbx = позиция записи в parse_temp_buffer (0)

; --- Цикл чтения символов ---
.read_char:
    ; Проверка наличия данных в буфере
    mov rax, [io_interactive_size]      ; Загрузка количества доступных байт
    test rax, rax                       ; Проверка: есть ли данные в буфере?
    jnz .has_data                       ; Если да - переход к чтению из буфера
    
    ; Буфер пуст - системный вызов
    ; syscall: read(stdin, buffer, count)
    xor rax, rax
    xor rdi, rdi
    lea rsi, [io_interactive_buffer]    ; Адрес буфера для чтения
    mov rdx, 128                        ; Количество байт для чтения
    syscall
    
    test rax, rax                       ; Проверка результата (rax = количество прочитанных байт)
    jle .eof                            ; Если <= 0 (EOF или ошибка) - обработка
    
    mov [io_interactive_size], rax      ; Сохранение количества прочитанных байт
    mov qword [io_interactive_pos], 0   ; Сброс позиции чтения в начало буфера

; --- Извлечение символа из буфера ---
.has_data:
    mov rcx, [io_interactive_pos]              ; Загрузка текущей позиции чтения
    mov al, byte [io_interactive_buffer + rcx] ; Чтение символа из буфера
    
    inc qword [io_interactive_pos]             ; Увеличение позиции чтения
    dec qword [io_interactive_size]            ; Уменьшение количества доступных байт
    
    ; Запись символа в выходной буфер
    lea rdx, [parse_temp_buffer]               ; Загрузка базового адреса выходного буфера
    mov byte [rdx + rbx], al                   ; Запись символа по адресу [база + смещение]
    inc rbx                                    ; Увеличение позиции записи
    
; --- Проверка на конец строки ---
    cmp al, 10                  ; Проверка: LF (line feed)?
    je .done                    ; Если да - завершение чтения
    
    cmp rbx, 63                 ; Проверка: буфер заполнен (осталось место для null)?
    jge .done                   ; Если да - завершение чтения
    
    jmp .read_char              ; Продолжение чтения следующего символа

; --- Обработка EOF без данных ---
.eof:
    test rbx, rbx               ; Проверка: были ли прочитаны данные?
    jnz .done                   ; Если да - завершение нормально (частичные данные)
    
    ; EOF без данных - это ошибка
    ; syscall: write(stderr, string, length)
    mov rax, 1
    mov rdi, 2                  ; stderr
    lea rsi, [error_format_msg]
    mov rdx, error_format_len
    syscall
    
    ; syscall: exit(1)
    mov rax, 60
    mov rdi, 1
    syscall

; --- Успешное завершение ---
.done:
    pop rdi
    pop rcx
    pop rbx
    ret

; ============================================================================
; ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ
; ============================================================================

; ----------------------------------------------------------------------------
; pf_int_part
;
; Внутренняя функция для вывода целой части float.
; Вызывается из print_float_var.
;
; АЛГОРИТМ:
;   1. Специальная обработка нуля
;   2. Конвертация справа налево в локальный буфер
;   3. Вывод слева направо через io_print_char
;
; @param  r13d Целая часть числа (int32)
; @uses   rax, rbx, rdx, r14, r15
; @calls  io_print_char
; @internal Используется только внутри print_float_var
; ----------------------------------------------------------------------------
pf_int_part:
    mov eax, r13d               ; Загрузка целой части
    test eax, eax               ; Проверка: равно нулю?
    jnz .convert                ; Если нет - конвертация
    mov byte [parse_temp_buffer], '0' ; Если ноль - подготовка '0'
    call io_print_char          ; Вывод символа '0'
    ret

.convert:
    lea r14, [rbp-32]           ; r14 = адрес локального буфера
    xor r15, r15                ; r15 = позиция записи (начинаем с 0)

.loop:
    xor edx, edx                ; Обнуление EDX перед делением
    mov ebx, 10                 ; Делитель = 10
    div ebx                     ; EAX = EAX / 10, EDX = EAX % 10 (цифра)
    add dl, '0'                 ; Преобразование цифры в ASCII
    mov [r14 + r15], dl         ; Запись цифры в локальный буфер
    inc r15                     ; Увеличение позиции
    test eax, eax               ; Проверка: остались ли цифры?
    jnz .loop                   ; Если да - продолжение

; --- Вывод цифр слева направо (обратный порядок записи) ---
.print:
    dec r15                     ; Переход к последней записанной цифре
    movzx eax, byte [r14 + r15] ; Загрузка цифры
    mov [parse_temp_buffer], al ; Подготовка для вывода
    call io_print_char          ; Вывод символа
    test r15, r15               ; Проверка: остались ли цифры?
    jnz .print                  ; Если да - продолжение вывода
    ret

; ----------------------------------------------------------------------------
; pf_dec_point
;
; Внутренняя функция для вывода десятичной точки.
; Вызывается из print_float_var.
;
; @uses   parse_temp_buffer
; @calls  io_print_char
; @internal Используется только внутри print_float_var
; ----------------------------------------------------------------------------
pf_dec_point:
    mov byte [parse_temp_buffer], '.' ; Подготовка символа '.'
    call io_print_char                ; Вывод символа
    ret

; ----------------------------------------------------------------------------
; pf_frac_part
;
; Внутренняя функция для вывода дробной части float (6 знаков).
; Вызывается из print_float_var.
;
; АЛГОРИТМ:
;   1. Загрузка дробной части в FPU
;   2. Цикл 6 итераций:
;      - Умножение на 10
;      - Усечение для получения текущей цифры
;      - Вывод цифры
;      - Удаление целой части
;
; @param  [rbp-12] Дробная часть числа (float)
; @uses   rax, r15, FPU stack
; @calls  io_print_char
; @internal Используется только внутри print_float_var
;
; @note Использует FPU для точных вычислений
; ----------------------------------------------------------------------------
pf_frac_part:
    fld dword [rbp-12]          ; Загрузка дробной части в FPU
    mov r15, FRAC_DIGITS        ; r15 = 6 (количество знаков)

.loop:
    fmul dword [io_const_ten]   ; ST(0) = ST(0) * 10.0 (сдвиг разряда)
    fld st0                     ; Дублирование: ST(0) = ST(1) = дробная * 10^i
    
    ; Усечение для получения текущей цифры
    push rax
    sub rsp, 8
    fnstcw [rsp]                ; Сохранение control word FPU
    mov ax, [rsp]
    or ax, FPU_TRUNC_MODE       ; Установка режима усечения
    mov [rsp+4], ax
    fldcw [rsp+4]               ; Загрузка режима усечения
    frndint                     ; Усечение до целого
    fldcw [rsp]                 ; Восстановление исходного control word
    add rsp, 8
    pop rax
    
    fist dword [rbp-20]         ; Сохранение текущей цифры
    mov eax, [rbp-20]           ; Загрузка цифры в EAX
    
    ; Валидация цифры (должна быть 0-9)
    cmp eax, 0                  ; Проверка: меньше 0?
    jl .zero                    ; Если да - использовать '0'
    cmp eax, 9                  ; Проверка: больше 9?
    jg .zero                    ; Если да - использовать '0'
    add al, '0'                 ; Преобразование в ASCII
    jmp .out

.zero:
    mov al, '0'                 ; Использование '0' для недопустимых значений

.out:
    mov [parse_temp_buffer], al ; Подготовка для вывода
    call io_print_char          ; Вывод символа
    
    fsubp st1, st0              ; Удаление целой части цифры из дробного остатка
    dec r15                     ; Уменьшение счётчика цифр
    jnz .loop                   ; Если остались цифры - продолжение
    
    fstp st0                    ; Удаление остатка из стека FPU
    ret

; ----------------------------------------------------------------------------
; print_hex_32_internal
;
; Внутренняя функция для вывода hex-представления float.
; Вызывается из print_float_var.
; Формат: " (hex: 0xXXXXXXXX)"
;
; @param  r12d Битовое представление float для hex-вывода
; @uses   rax, rdi
; @calls  print_string, print_hex_32
; @internal Используется только внутри print_float_var
; ----------------------------------------------------------------------------
print_hex_32_internal:
    lea rdi, [io_msg_hex]       ; Загрузка адреса " (hex: 0x"
    call print_string           ; Вывод префикса
    mov eax, r12d               ; Загрузка битового представления
    call print_hex_32           ; Вывод hex-значения
    lea rdi, [io_msg_hex_end]   ; Загрузка адреса ")"
    call print_string           ; Вывод суффикса
    ret

; ----------------------------------------------------------------------------
; print_hex_32
;
; Выводит 32-битное значение в шестнадцатеричном формате (8 символов).
; Публичная утилита, может использоваться отдельно.
;
; ФОРМАТ ВЫВОДА: XXXXXXXX (заглавные буквы A-F)
;
; ПРИМЕРЫ:
;   print_hex_32(0x40490FDB) → "40490FDB"
;   print_hex_32(0x00000000) → "00000000"
;   print_hex_32(0xFFFFFFFF) → "FFFFFFFF"
;
; @param  eax  Значение для вывода
; @return none
; @uses   rbx, rcx
; @calls  io_print_char
;
; @complexity O(1), всегда 8 символов
; ----------------------------------------------------------------------------
print_hex_32:
    push rbp
    mov rbp, rsp
    push rbx
    push rcx

    mov rbx, rax                ; Сохранение значения в RBX
    mov rcx, 8                  ; Счётчик: 8 hex-цифр (32 бита / 4)

.loop:
    rol ebx, 4                  ; Циклический сдвиг влево на 4 бита (1 hex-цифра)
    mov eax, ebx                ; Копирование для извлечения младших 4 бит
    and eax, 0xF                ; Маскирование: оставить только младшие 4 бита
    cmp al, 9                   ; Проверка: цифра 0-9 или A-F?
    jle .digit                  ; Если 0-9 - переход к обработке цифры
    add al, 'A' - 10            ; Преобразование 10-15 → 'A'-'F'
    jmp .out

.digit:
    add al, '0'                 ; Преобразование 0-9 → '0'-'9'

.out:
    mov [parse_temp_buffer], al ; Подготовка для вывода
    push rcx                    ; Сохранение счётчика
    call io_print_char          ; Вывод символа
    pop rcx                     ; Восстановление счётчика
    dec rcx                     ; Уменьшение счётчика
    jnz .loop                   ; Если остались цифры - продолжение

    pop rcx
    pop rbx
    pop rbp
    ret

; ----------------------------------------------------------------------------
; print_string
;
; Выводит null-терминированную строку в stdout.
; Публичная утилита, может использоваться отдельно.
;
; ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
;   Assembly:
;     section .data
;       msg db "Hello, World!", 0
;     section .text
;       lea rdi, [msg]
;       call print_string
;
; @param  rdi  Адрес null-терминированной строки
; @return none
; @uses   rax, rdx, rsi
;
; @complexity O(n), где n - длина строки
; ----------------------------------------------------------------------------
print_string:
    push rbp
    mov rbp, rsp
    push rdi                    ; Сохранение адреса строки
    
    xor rdx, rdx                ; rdx = счётчик длины (начинаем с 0)

; --- Вычисление длины строки ---
.len:
    cmp byte [rdi + rdx], 0     ; Проверка: null-терминатор?
    je .do_print                ; Если да - переход к выводу
    inc rdx                     ; Увеличение счётчика
    jmp .len                    ; Продолжение подсчёта

; --- Вывод строки ---
.do_print:
    pop rsi                     ; Восстановление адреса строки в RSI (для syscall)

    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    syscall
    
    pop rbp
    ret

; ----------------------------------------------------------------------------
; io_print_char
;
; Выводит один символ из parse_temp_buffer в stdout.
; Внутренняя утилита для вспомогательных функций.
;
; @param  [parse_temp_buffer] Символ для вывода
; @return none
; @uses   rax, rdi, rsi, rdx
; @internal Используется вспомогательными функциями
; ----------------------------------------------------------------------------
io_print_char:
    ; syscall: write(stdout, string, length)
    mov rax, 1
    mov rdi, 1
    lea rsi, [parse_temp_buffer] ; Адрес символа
    mov rdx, 1
    syscall
    ret

; ----------------------------------------------------------------------------
; io_is_end_char
;
; Проверяет, является ли символ в AL символом окончания числа.
; Символы окончания: LF (10), null (0), пробел (32), CR (13).
;
; @param  al   Символ для проверки
; @return ZF   Установлен, если символ является окончанием
; @uses   Только флаги (не изменяет регистры)
; @internal Используется в функциях парсинга
; ----------------------------------------------------------------------------
io_is_end_char:
    cmp al, 10                  ; Проверка: LF (line feed)?
    je .yes                     ; Если да - установка ZF и возврат
    cmp al, 0                   ; Проверка: null-терминатор?
    je .yes                     ; Если да - установка ZF и возврат
    cmp al, 32                  ; Проверка: пробел?
    je .yes                     ; Если да - установка ZF и возврат
    cmp al, 13                  ; Проверка: CR (carriage return)?
    je .yes                     ; Если да - установка ZF и возврат
    ret                         ; Возврат с ZF = 0 (не символ окончания)

.yes:
    cmp al, al                  ; Установка ZF = 1 (гарантированное равенство)
    ret                         ; Возврат с ZF = 1 (символ окончания)