Объясни, как вот этот код: #include <fcntl.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>

#define BLOCK_SIZE 4096
#define NODE_SIZE 12
#define NODES_PER_BLOCK (BLOCK_SIZE / NODE_SIZE)
#define SHIFT_4 4
#define SHIFT_8 8
#define SHIFT_16 16
#define SHIFT_24 24

struct Node {
    int32_t key;
    int32_t left_idx;
    int32_t right_idx;
};

struct FileCache {
    int fd;
    size_t block_num;
    unsigned char buffer[BLOCK_SIZE];
};

int32_t read_int32_le(const unsigned char *buf) {
    return (int32_t)(((int32_t)buf[0]) | ((int32_t)buf[1] << SHIFT_8) |
                     ((int32_t)buf[2] << SHIFT_16) |
                     ((int32_t)buf[3] << SHIFT_24));
}

int read_node(int32_t node_idx, struct FileCache *cache, struct Node *out_node,
              size_t total_nodes) {
    if (node_idx < 0 || (size_t)node_idx >= total_nodes) {
        return -1;
    }

    size_t block_num = (size_t)node_idx / NODES_PER_BLOCK;
    size_t node_offset_in_block = (size_t)node_idx % NODES_PER_BLOCK;

    if (cache->block_num != block_num) {
        off_t offset = (off_t)(block_num * BLOCK_SIZE);
        size_t bytes_to_read;

        off_t file_size = (off_t)(total_nodes * NODE_SIZE);
        off_t remaining = file_size - offset;

        if (remaining <= 0) {
            return -1;
        }

        bytes_to_read =
            (remaining < BLOCK_SIZE) ? (size_t)remaining : BLOCK_SIZE;

        ssize_t bytes_read =
            pread(cache->fd, cache->buffer, sizeof(cache->buffer), offset);
        if (bytes_read != (ssize_t)bytes_to_read) {
            return -1;
        }
        cache->block_num = block_num;
    }

    unsigned char *node_buf = cache->buffer + node_offset_in_block * NODE_SIZE;
    out_node->key = read_int32_le(node_buf);
    out_node->left_idx = read_int32_le(node_buf + SHIFT_4);
    out_node->right_idx = read_int32_le(node_buf + SHIFT_8);

    return 0;
}

void traverse(int32_t node_idx, struct FileCache *cache, size_t total_nodes,
              bool *first_printed) {
    if (node_idx < 0 || (size_t)node_idx >= total_nodes) {
        return;
    }

    struct Node current_node;
    if (read_node(node_idx, cache, &current_node, total_nodes) != 0) {
        return;
    }

    if (current_node.right_idx > 0) {
        traverse(current_node.right_idx, cache, total_nodes, first_printed);
    }

    if (*first_printed) {
        printf(" %d", current_node.key);
    } else {
        printf("%d", current_node.key);
        *first_printed = true;
    }

    if (current_node.left_idx > 0) {
        traverse(current_node.left_idx, cache, total_nodes, first_printed);
    }
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        return 1;
    }

    const char *filename = argv[1];
    int fd = open(filename, O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }

    struct stat st;
    if (fstat(fd, &st) != 0) {
        close(fd);
        return 1;
    }

    if (st.st_size % NODE_SIZE != 0) {
        close(fd);
        return 1;
    }

    size_t total_nodes = st.st_size / NODE_SIZE;

    struct FileCache cache;
    cache.fd = fd;
    cache.block_num = (size_t)(-1);

    if (total_nodes == 0) {
        printf("\n");
        close(fd);
        return 0;
    }

    bool first_printed = false;
    traverse(0, &cache, total_nodes, &first_printed);
    printf("\n");

    close(fd);
    return 0;
}
решает задачу: Problem sm09-3: unix/files/binary-tree-2

В аргументах командной строки задается имя входного бинарного файла произвольного доступа. Бинарный файл рассматривается как массив структур:

struct Node
{
    int32_t key;
    int32_t left_idx;
    int32_t right_idx;
};
Структура описывает вершину бинарного дерева поиска, где key – ключ поиска, а значения left_idx и right_idx – индексы в массиве соответственно левой и правой вершины. Корень дерева находится в элементе массива с индексом 0. Признаком отсутствия соответствующего поддерева в вершине является индекс, равный 0.

Числа в файле хранятся в естественном для x86 представлении (little-endian).

На стандартный поток вывода напечатайте ключи, размещенные в данном дереве, в порядке убывания.

Считывать содержимое всего файла в память целиком (хранить полное дерево в памяти) запрещается. Для чтения содержимого файла необходимо пользоваться низкоуровневым вводом-выводом (open/read/etc). Корректная работа на big-endian архитектуре не требуется. Не используйте низкоуровневые манипуляции с памятью (union, приведение типов указателей). Не используйте библиотечные функции преобразования.

Для вывода ключей можно использовать высокоуровневые потоки (stdout).

Не забывайте выводить '\n' в конце вывода.

В программе должна быть реализована проверка корректности чтения из файла. Минимизируйте число системных вызовов, необходимых для чтения одной записи из файла.

Например для этого файла надо вывести 9 8 7 6 5 4 3 2 1