diff --git a/lab04/lab04.cpp b/lab04/lab04.cpp
index bd4efef..9fe5284 100644
--- a/lab04/lab04.cpp
+++ b/lab04/lab04.cpp
@@ -1,84 +1,96 @@
-#include <cassert>
+#include <cassert>
 #include <iostream>
 using namespace std;
 
+// Преобразует младшую тетраду (nibble) числа в шестнадцатеричный символ ('0'-'9', 'a'-'f').
 char nibble_to_hex(uint8_t i) {
-    assert(0x0 <= i && i <= 0xf);
-    if (i < 10) return '0' + i;
-    return 'a' + (i - 10);
+    assert(0x0 <= i && i <= 0xf); // Утверждение, что значение i находится в пределах одной тетрады (4 бита).
+    if (i < 10) return '0' + i;  // Если меньше 10, возвращает цифру.
+    return 'a' + (i - 10);       // Если больше, возвращает букву (a-f).
 }
 
+// Тестирует функцию nibble_to_hex.
 void test_nibble_to_hex() {
-    assert(nibble_to_hex(0x0) == '0');
-    assert(nibble_to_hex(0xf) == 'f');
+    assert(nibble_to_hex(0x0) == '0'); // Тест: 0x0 → '0'
+    assert(nibble_to_hex(0xf) == 'f'); // Тест: 0xf → 'f'
     cout << "nibble_to_hex() tests passed!\n";
 }
 
+// Извлекает младшую тетраду из байта.
 uint8_t low_nibble(uint8_t byte) {
-    return byte & 0x0f;
+    return byte & 0x0f; // Маска оставляет младшие 4 бита.
 }
 
+// Извлекает старшую тетраду из байта.
 uint8_t high_nibble(uint8_t byte) {
-    return byte >> 4;
+    return byte >> 4; // Сдвиг вправо на 4 бита.
 }
 
+// Тестирует функции извлечения тетрад.
 void test_nibbles() {
-    assert(low_nibble(0xab) == 0xb);
-    assert(high_nibble(0xab) == 0xa);
+    assert(low_nibble(0xab) == 0xb);  // Младшая тетрада 0xab → 0xb
+    assert(high_nibble(0xab) == 0xa); // Старшая тетрада 0xab → 0xa
     cout << "Nibble extraction tests passed!\n";
 }
 
+// Печатает байт в шестнадцатеричном виде.
 void print_in_hex(uint8_t byte) {
-    cout << nibble_to_hex(high_nibble(byte))
-        << nibble_to_hex(low_nibble(byte));
+    cout << nibble_to_hex(high_nibble(byte))  // Старшая тетрада.
+        << nibble_to_hex(low_nibble(byte)); // Младшая тетрада.
 }
 
+// Тестирует печать байтов в шестнадцатеричном виде.
 void test_print_in_hex() {
-    print_in_hex(0x0); cout << "\n";
-    print_in_hex(0xab); cout << "\n";
-    print_in_hex(0xff); cout << "\n";
+    print_in_hex(0x0); cout << "\n";  // Печатает: 00
+    print_in_hex(0xab); cout << "\n"; // Печатает: ab
+    print_in_hex(0xff); cout << "\n"; // Печатает: ff
 }
 
+// Преобразует указатель на данные в указатель на массив байтов.
 const uint8_t* as_bytes(const void* data) {
-    return reinterpret_cast<const uint8_t*>(data);
+    return reinterpret_cast<const uint8_t*>(data); // Преобразование типа указателя.
 }
 
+// Печатает массив байтов в шестнадцатеричном виде.
 void print_in_hex(const void* data, size_t size) {
-    const uint8_t* bytes = as_bytes(data);
+    const uint8_t* bytes = as_bytes(data); // Преобразует данные в массив байтов.
     for (size_t i = 0; i < size; i++) {
-        print_in_hex(bytes[i]);
-        cout << ((i + 1) % 16 == 0 ? '\n' : ' ');
+        print_in_hex(bytes[i]);           // Печатает каждый байт в шестнадцатеричном виде.
+        cout << ((i + 1) % 16 == 0 ? '\n' : ' '); // Разделяет байты пробелом, каждые 16 байтов перенос строки.
     }
 }
 
+// Тестирует печать массива байтов (например, целого числа).
 void test_print_array_in_hex() {
-    uint32_t u32 = 0x42;
+    uint32_t u32 = 0x42; // Число 0x42 в 4 байтах.
     cout << "u32 bytes: ";
-    print_in_hex(&u32, sizeof(u32));
+    print_in_hex(&u32, sizeof(u32)); // Печатает байты числа.
     cout << "\n";
 }
 
+// Возвращает символ '1' или '0', если указанный бит установлен или нет.
 char bit_digit(uint8_t byte, uint8_t bit) {
-    return (byte & (1 << bit)) ? '1' : '0';
+    return (byte & (1 << bit)) ? '1' : '0'; // Проверяет, установлен ли бит.
 }
 
+// Печатает байт в двоичном виде (8 бит).
 void print_in_binary(uint8_t byte) {
-    for (int8_t bit = 7; bit >= 0; --bit) {
+    for (int8_t bit = 7; bit >= 0; --bit) { // Перебирает биты с 7-го по 0-й.
         cout << bit_digit(byte, bit);
     }
 }
 
+// Тестирует печать байтов в двоичном виде.
 void test_print_in_binary() {
-    print_in_binary(0x2a); cout << "\n"; // 00101010
+    print_in_binary(0x2a); cout << "\n"; // Печатает: 00101010
 }
 
-
-
+// Основная функция программы: выполняет тесты и демонстрации.
 int main() {
-    test_nibble_to_hex();
-    test_nibbles();
-    test_print_in_hex();
-    test_print_array_in_hex();
-    test_print_in_binary();
-    return 0;
+    test_nibble_to_hex();       // Тесты nibble_to_hex.
+    test_nibbles();             // Тесты извлечения тетрад.
+    test_print_in_hex();        // Тесты печати в шестнадцатеричном виде.
+    test_print_array_in_hex();  // Тесты печати массива байтов.
+    test_print_in_binary();     // Тесты печати в двоичном виде.
+    return 0;                   // Завершение программы.
 }