/* MBR 을 필드 단위로 짓고 되읽는다 --- 표에 적은 오프셋이 진짜인지 코드가 증언한다.
   주의: 디스크를 건드리지 않는다. 기억 속 배열만 채우고 다시 읽어 화면에 찍는다. */
#include <stdio.h>
#include <stdint.h>
#include <string.h>

#define SEC 512u

static void put32(unsigned char *p, uint32_t v)
{ p[0] = v & 0xff; p[1] = v >> 8 & 0xff; p[2] = v >> 16 & 0xff; p[3] = v >> 24; }
static uint32_t get32(const unsigned char *p)
{ return (uint32_t)p[0] | (uint32_t)p[1] << 8 | (uint32_t)p[2] << 16 | (uint32_t)p[3] << 24; }

/* CHS 는 3바이트에 실린다: 머리 8비트, 실린더 10비트, 섹터 6비트.
   실린더의 위 두 비트가 섹터 바이트의 위 두 비트로 올라간다 --- 그 비좁음이 한계를 만든다. */
static void put_chs(unsigned char *p, uint32_t cyl, uint32_t head, uint32_t sect)
{
    if (cyl > 1023) { p[0] = 0xfe; p[1] = 0xff; p[2] = 0xff; return; }  /* 못 적으면 관용값 */
    p[0] = (unsigned char)head;
    p[1] = (unsigned char)(((cyl >> 2) & 0xc0) | (sect & 0x3f));
    p[2] = (unsigned char)(cyl & 0xff);
}
static void get_chs(const unsigned char *p, unsigned *cyl, unsigned *head, unsigned *sect)
{ *head = p[0]; *sect = p[1] & 0x3f; *cyl = ((unsigned)(p[1] & 0xc0) << 2) | p[2]; }

static void put_part(unsigned char *e, uint8_t boot, uint8_t type,
                     uint32_t lba, uint32_t count)
{
    e[0] = boot;
    put_chs(e + 1, lba / (255 * 63), (lba / 63) % 255, lba % 63 + 1);
    e[4] = type;
    put_chs(e + 5, (lba + count - 1) / (255 * 63), ((lba + count - 1) / 63) % 255,
            (lba + count - 1) % 63 + 1);
    put32(e + 8, lba);
    put32(e + 12, count);
}

static const char *type_name(uint8_t t)
{
    switch (t) {
    case 0x00: return "empty";
    case 0x05: return "extended (CHS)";
    case 0x07: return "NTFS / exFAT";
    case 0x0b: return "FAT32 (CHS)";
    case 0x0c: return "FAT32 (LBA)";
    case 0x0e: return "FAT16 (LBA)";
    case 0x0f: return "extended (LBA)";
    case 0x82: return "Linux swap";
    case 0x83: return "Linux";
    case 0xee: return "GPT protective MBR";
    case 0xef: return "EFI system partition";
    default:   return "other";
    }
}

static void show_entry(const char *tag, const unsigned char *e, uint32_t base)
{
    unsigned c0, h0, s0, c1, h1, s1;
    get_chs(e + 1, &c0, &h0, &s0);
    get_chs(e + 5, &c1, &h1, &s1);
    uint32_t rel = get32(e + 8), cnt = get32(e + 12);
    if (e[4] == 0 && cnt == 0) { printf("  %-10s (empty)\n", tag); return; }
    printf("  %-10s bootable=%s type=0x%02x (%s)\n", tag, e[0] == 0x80 ? "yes" : "no",
           e[4], type_name(e[4]));
    printf("             start LBA=%u (relative) -> %u (absolute)  size=%u sectors = %.1f MiB\n",
           rel, base + rel, cnt, cnt * (double)SEC / (1024 * 1024));
    printf("             CHS start=(%u,%u,%u) end=(%u,%u,%u)%s\n",
           c0, h0, s0, c1, h1, s1,
           (e[1] == 0xfe && e[2] == 0xff) ? "  <- beyond what CHS can express (the idiomatic value)" : "");
}

int main(void)
{
    unsigned char mbr[SEC] = { 0 };

    /* ── 주 파티션 넷 중 셋 + 확장 하나 ─────────────────────────── */
    put_part(mbr + 0x1be, 0x80, 0x0c, 2048,     204800);      /* FAT32(LBA) 100 MiB, 부팅 */
    put_part(mbr + 0x1ce, 0x00, 0x83, 206848,   2097152);     /* 리눅스 1 GiB */
    put_part(mbr + 0x1de, 0x00, 0x82, 2304000,  262144);      /* 스왑 128 MiB */
    put_part(mbr + 0x1ee, 0x00, 0x0f, 2566144,  4194304);     /* 확장(LBA) 2 GiB */
    mbr[510] = 0x55; mbr[511] = 0xaa;

    printf("== the MBR partition table (LBA 0) ==\n");
    for (int i = 0; i < 4; i++) {
        char tag[16]; snprintf(tag, sizeof tag, "entry %d", i + 1);
        show_entry(tag, mbr + 0x1be + 16 * i, 0);
    }
    printf("  signature 0x%02x%02x --- %s\n\n", mbr[510], mbr[511],
           (mbr[510] == 0x55 && mbr[511] == 0xaa) ? "accepted as a boot sector" : "not accepted");

    /* ── 확장 파티션 안의 EBR 사슬 ──────────────────────────────
       규칙이 둘이고, 둘의 기준이 *다르다*:
         1번 항목 = 이 EBR 바로 뒤의 논리 파티션 → 이 EBR 기준의 상대 LBA
         2번 항목 = 다음 EBR 의 자리          → 확장 파티션 시작 기준의 상대 LBA
       이 어긋남이 EBR 을 손으로 읽을 때 가장 많이 틀리는 자리다. */
    const uint32_t ext_start = 2566144;
    unsigned char ebr1[SEC] = { 0 }, ebr2[SEC] = { 0 };

    put_part(ebr1 + 0x1be, 0x00, 0x83, 2048, 1048576);        /* 논리 1: 512 MiB */
    put_part(ebr1 + 0x1ce, 0x00, 0x0f, 1050624, 2097152);     /* 다음 EBR: 확장 시작 기준 */
    ebr1[510] = 0x55; ebr1[511] = 0xaa;

    put_part(ebr2 + 0x1be, 0x00, 0x07, 2048, 2095104);        /* 논리 2: NTFS */
    ebr2[510] = 0x55; ebr2[511] = 0xaa;                       /* 2번 항목 비었다 = 사슬 끝 */

    printf("== the EBR chain inside the extended partition (extended start LBA=%u) ==\n", ext_start);
    uint32_t ebr_lba = ext_start;
    const unsigned char *chain[] = { ebr1, ebr2 };
    for (int i = 0; i < 2; i++) {
        printf("\n  [EBR %d] absolute LBA of this EBR = %u\n", i + 1, ebr_lba);
        show_entry("logical", chain[i] + 0x1be, ebr_lba);        /* 기준: 이 EBR */
        show_entry("next EBR", chain[i] + 0x1ce, ext_start);   /* 기준: 확장 시작 */
        uint32_t next = get32(chain[i] + 0x1ce + 8);
        if (next == 0) { printf("  -> end of the chain\n"); break; }
        ebr_lba = ext_start + next;
    }

    /* ── CHS 의 한계 ─────────────────────────────────────────── */
    printf("\n== the limit of what CHS can express ==\n");
    unsigned long long chs_max = 1024ull * 255 * 63 * SEC;
    printf("  1024 cylinders x 255 heads x 63 sectors x %u bytes = %llu bytes = %.1f GB\n",
           SEC, chs_max, chs_max / 1e9);
    printf("  beyond that the LBA field (4 bytes) takes over: 2^32 sectors x %u = %.1f TB\n",
           SEC, 4294967296.0 * SEC / 1e12);
    printf("  -> the MBR 2 TiB limit comes from here (the sector number is 32 bits).\n");
    return 0;
}

/* GPT 를 필드 단위로 짓고 되읽는다 --- 헤더 92바이트, 항목 128바이트, CRC 둘.
   주의: 디스크를 건드리지 않는다. 기억 속 배열만 채운다. */
#include <stdio.h>
#include <stdint.h>
#include <string.h>

#define SEC        512u
#define ENTRIES    128u          /* 표준이 권하는 최소 개수 */
#define ENTRY_SZ   128u
#define DISK_SECS  4194304u      /* 2 GiB 짜리 디스크라고 하자 */

static uint32_t crc32(const void *buf, size_t n)
{
    const unsigned char *p = buf;
    uint32_t c = 0xFFFFFFFFu;
    for (size_t i = 0; i < n; i++) {
        c ^= p[i];
        for (int k = 0; k < 8; k++) c = (c >> 1) ^ (0xEDB88320u & (uint32_t)-(int32_t)(c & 1));
    }
    return c ^ 0xFFFFFFFFu;
}

static void put32(unsigned char *p, uint32_t v)
{ for (int i = 0; i < 4; i++) p[i] = (unsigned char)(v >> (8 * i)); }
static void put64(unsigned char *p, uint64_t v)
{ for (int i = 0; i < 8; i++) p[i] = (unsigned char)(v >> (8 * i)); }
static uint32_t get32(const unsigned char *p)
{ uint32_t v = 0; for (int i = 3; i >= 0; i--) v = v << 8 | p[i]; return v; }
static uint64_t get64(const unsigned char *p)
{ uint64_t v = 0; for (int i = 7; i >= 0; i--) v = v << 8 | p[i]; return v; }

/* ★ GUID 의 함정: 글로 쓸 때와 디스크에 놓일 때의 바이트 차례가 *다르다*.
   앞의 세 마디(4·2·2바이트)는 작은 끝으로 뒤집혀 저장되고, 뒤의 두 마디(2·6바이트)는
   글자 순서 그대로다. 그래서 16진수 덤프와 문서의 GUID 가 달라 보인다. */
static void guid_parse(unsigned char *out, const char *s)
{
    unsigned b[16]; int n = 0;
    for (const char *p = s; *p && n < 16; ) {
        if (*p == '-') { p++; continue; }
        unsigned hi, lo;
        sscanf(p, "%1x%1x", &hi, &lo);
        b[n++] = hi << 4 | lo; p += 2;
    }
    out[0] = (unsigned char)b[3]; out[1] = (unsigned char)b[2];   /* 첫 마디 뒤집기 */
    out[2] = (unsigned char)b[1]; out[3] = (unsigned char)b[0];
    out[4] = (unsigned char)b[5]; out[5] = (unsigned char)b[4];   /* 둘째 마디 */
    out[6] = (unsigned char)b[7]; out[7] = (unsigned char)b[6];   /* 셋째 마디 */
    for (int i = 8; i < 16; i++) out[i] = (unsigned char)b[i];    /* 나머지는 그대로 */
}
static void guid_text(const unsigned char *g, char *out)
{
    sprintf(out, "%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
            g[3], g[2], g[1], g[0], g[5], g[4], g[7], g[6],
            g[8], g[9], g[10], g[11], g[12], g[13], g[14], g[15]);
}
static void guid_bytes(const unsigned char *g, char *out)
{ for (int i = 0; i < 16; i++) sprintf(out + i * 3, "%02x ", g[i]); }

/* 이름은 UTF-16LE 36글자 자리(72바이트)에 들어간다 --- ASCII 만 쓴다면 이렇게 */
static void put_name(unsigned char *p, const char *ascii)
{ for (int i = 0; ascii[i]; i++) { p[i * 2] = (unsigned char)ascii[i]; p[i * 2 + 1] = 0; } }

#define ESP   "C12A7328-F81F-11D2-BA4B-00A0C93EC93B"
#define LINUX "0FC63DAF-8483-4772-8E79-3D69D8477DE4"
#define SWAP  "0657FD6D-A4AB-43C4-84E5-0933C84B4F4F"

int main(void)
{
    static unsigned char ents[ENTRIES * ENTRY_SZ];   /* = 16384바이트 = 32섹터 */
    unsigned char hdr[92] = { 0 };
    char t1[64], t2[64];

    /* ── 항목 셋 ─────────────────────────────────────────────── */
    struct { const char *type, *name; uint64_t first, last; uint64_t attr; } part[] = {
        { ESP,   "EFI System",  2048,   206847,  0 },
        { LINUX, "root",        206848, 3358719, 0 },
        { SWAP,  "swap",        3358720, 4194270, 1ull << 63 },  /* 63: 자동 마운트 금지 */
    };
    for (unsigned i = 0; i < sizeof part / sizeof *part; i++) {
        unsigned char *e = ents + i * ENTRY_SZ;
        guid_parse(e, part[i].type);                       /* 0  : 종류 GUID */
        char uniq[40];
        sprintf(uniq, "12345678-1234-5678-9ABC-DEF01234567%X", i);   /* 파티션마다 달라야 한다 */
        guid_parse(e + 16, uniq);                          /* 16 : 이 파티션의 고유 GUID */
        put64(e + 32, part[i].first);                      /* 32 : 첫 LBA */
        put64(e + 40, part[i].last);                       /* 40 : 마지막 LBA(포함) */
        put64(e + 48, part[i].attr);                       /* 48 : 속성 비트 */
        put_name(e + 56, part[i].name);                    /* 56 : 이름 UTF-16LE 72바이트 */
    }

    /* ── 헤더 ────────────────────────────────────────────────── */
    uint64_t backup_lba = DISK_SECS - 1;
    uint64_t ents_sectors = (ENTRIES * ENTRY_SZ + SEC - 1) / SEC;   /* 32 */
    memcpy(hdr, "EFI PART", 8);            /* 0  : 서명 */
    put32(hdr + 8, 0x00010000u);           /* 8  : 개정 1.0 */
    put32(hdr + 12, 92);                   /* 12 : 헤더 크기 */
    put32(hdr + 16, 0);                    /* 16 : 헤더 CRC --- 계산 전에는 0 */
    put32(hdr + 20, 0);                    /* 20 : 예약 */
    put64(hdr + 24, 1);                    /* 24 : 이 헤더의 LBA */
    put64(hdr + 32, backup_lba);           /* 32 : 짝 헤더의 LBA */
    put64(hdr + 40, 2 + ents_sectors);     /* 40 : 쓸 수 있는 첫 LBA = 34 */
    put64(hdr + 48, backup_lba - ents_sectors - 1); /* 48 : 쓸 수 있는 마지막 LBA */
    guid_parse(hdr + 56, "01234567-89AB-CDEF-0123-456789ABCDEF");  /* 56 : 디스크 GUID */
    put64(hdr + 72, 2);                    /* 72 : 항목 배열의 LBA */
    put32(hdr + 80, ENTRIES);              /* 80 : 항목 개수 */
    put32(hdr + 84, ENTRY_SZ);             /* 84 : 항목 하나의 크기 */
    put32(hdr + 88, crc32(ents, ENTRIES * ENTRY_SZ));   /* 88 : 항목 배열 전체의 CRC */
    put32(hdr + 16, crc32(hdr, 92));       /* 마지막에 헤더 자신의 CRC */

    printf("== the GPT header (LBA 1, 92 bytes) ==\n");
    printf("  signature        : %.8s\n", hdr);
    printf("  revision         : %u.%u\n", get32(hdr + 8) >> 16, get32(hdr + 8) & 0xffff);
    printf("  header size      : %u bytes (the sector is 512; the header uses only 92)\n", get32(hdr + 12));
    printf("  header CRC32     : 0x%08x\n", get32(hdr + 16));
    printf("  this / alternate : LBA %llu / LBA %llu\n",
           (unsigned long long)get64(hdr + 24), (unsigned long long)get64(hdr + 32));
    printf("  usable range     : LBA %llu - %llu\n",
           (unsigned long long)get64(hdr + 40), (unsigned long long)get64(hdr + 48));
    guid_text(hdr + 56, t1);
    printf("  disk GUID        : %s\n", t1);
    printf("  entry array      : from LBA %llu, %u x %u bytes = %u sectors\n",
           (unsigned long long)get64(hdr + 72), get32(hdr + 80), get32(hdr + 84),
           (unsigned)ents_sectors);
    printf("  entry array CRC32: 0x%08x\n\n", get32(hdr + 88));

    printf("== checking it ==\n");
    unsigned char probe[92]; memcpy(probe, hdr, 92); put32(probe + 16, 0);
    printf("  header CRC recomputed (that field zeroed) : 0x%08x -> %s\n",
           crc32(probe, 92), crc32(probe, 92) == get32(hdr + 16) ? "matches" : "does not match");
    printf("  entry array CRC recomputed               : 0x%08x -> %s\n\n",
           crc32(ents, ENTRIES * ENTRY_SZ),
           crc32(ents, ENTRIES * ENTRY_SZ) == get32(hdr + 88) ? "matches" : "does not match");

    printf("== entries (128 bytes each) ==\n");
    for (unsigned i = 0; i < 3; i++) {
        const unsigned char *e = ents + i * ENTRY_SZ;
        guid_text(e, t1); guid_bytes(e, t2);
        uint64_t f = get64(e + 32), l = get64(e + 40), a = get64(e + 48);
        char name[40] = { 0 };
        for (int k = 0; k < 36 && e[56 + k * 2]; k++) name[k] = (char)e[56 + k * 2];
        printf("  [%u] name \"%s\"\n", i + 1, name);
        printf("      type GUID (as text) : %s\n", t1);
        printf("      type GUID (byte order): %s\n", t2);
        printf("      LBA %llu ~ %llu  = %.1f MiB\n", (unsigned long long)f,
               (unsigned long long)l, (l - f + 1) * (double)SEC / (1024 * 1024));
        printf("      attributes 0x%016llx%s\n", (unsigned long long)a,
               a & (1ull << 63) ? "  (bit 63 = do not automount)" : "");
    }

    printf("\n== where the alternate (backup) GPT is ==\n");
    printf("  disk %u sectors = %.1f GiB\n", DISK_SECS, DISK_SECS * (double)SEC / (1 << 30));
    printf("  alternate header: the last sector, LBA %llu\n", (unsigned long long)backup_lba);
    printf("  alternate array : LBA %llu - %llu (%u sectors just before the header)\n",
           (unsigned long long)(backup_lba - ents_sectors),
           (unsigned long long)(backup_lba - 1), (unsigned)ents_sectors);
    printf("  -> damage at the front is repaired from the back, and the back from the front.\n");
    return 0;
}

/* 파티션 *안*의 첫 섹터 --- FAT32 의 BPB 를 짓고 되읽어, 「클러스터 번호 → 섹터 번호」
   산수를 실제로 해 본다. 그리고 FAT 사슬을 하나 따라간다.
   주의: 디스크를 건드리지 않는다. */
#include <stdio.h>
#include <stdint.h>
#include <string.h>

#define SEC 512u

static void put16(unsigned char *p, uint16_t v) { p[0] = v & 0xff; p[1] = v >> 8; }
static void put32(unsigned char *p, uint32_t v)
{ for (int i = 0; i < 4; i++) p[i] = (unsigned char)(v >> (8 * i)); }
static uint16_t get16(const unsigned char *p) { return (uint16_t)(p[0] | p[1] << 8); }
static uint32_t get32(const unsigned char *p)
{ uint32_t v = 0; for (int i = 3; i >= 0; i--) v = v << 8 | p[i]; return v; }

int main(void)
{
    unsigned char bs[SEC] = { 0 };
    const uint32_t part_lba = 2048;        /* 이 파티션이 디스크에서 시작하는 자리 */
    const uint32_t tot_sec  = 2097152;     /* 1 GiB */
    const uint32_t spc_want = 8;           /* 클러스터 = 8섹터 = 4 KiB */
    const uint32_t rsvd_want = 32, nfat_want = 2;

    /* FAT 한 벌의 크기는 마음대로 정하는 값이 아니라 *계산해서 나오는* 값이다.
       규격이 주는 어림 공식(FAT32): 자료가 될 섹터를 「클러스터 하나가 먹는 섹터 +
       그 클러스터를 가리키는 FAT 항목이 먹는 자리」로 나눈다. */
    uint32_t t1 = tot_sec - rsvd_want;
    uint32_t t2 = (256 * spc_want + nfat_want) / 2;
    const uint32_t fat_sz = (t1 + t2 - 1) / t2;

    /* ── BPB 를 규격대로 채운다 ─────────────────────────────── */
    bs[0] = 0xeb; bs[1] = 0x58; bs[2] = 0x90;      /* 0  : 점프 명령(3바이트) */
    memcpy(bs + 3, "MSWIN4.1", 8);                 /* 3  : 만든 곳 이름(8) */
    put16(bs + 11, 512);                           /* 11 : 섹터 하나의 바이트 수 */
    bs[13] = (unsigned char)spc_want;              /* 13 : 클러스터 하나의 섹터 수 */
    put16(bs + 14, (uint16_t)rsvd_want);           /* 14 : 예약 섹터 수(FAT 앞) */
    bs[16] = (unsigned char)nfat_want;             /* 16 : FAT 벌 수(대개 2 --- 사본) */
    put16(bs + 17, 0);                             /* 17 : 루트 항목 수 --- FAT32 는 0 */
    put16(bs + 19, 0);                             /* 19 : 총 섹터(16비트) --- 안 쓰면 0 */
    bs[21] = 0xf8;                                 /* 21 : 매체 종류(고정 디스크) */
    put16(bs + 22, 0);                             /* 22 : FAT 크기(16비트) --- FAT32 는 0 */
    put16(bs + 24, 63);                            /* 24 : 트랙당 섹터(옛 CHS 흔적) */
    put16(bs + 26, 255);                           /* 26 : 머리 수(옛 CHS 흔적) */
    put32(bs + 28, part_lba);                      /* 28 : 이 파티션 앞의 숨은 섹터 수 */
    put32(bs + 32, tot_sec);                       /* 32 : 총 섹터(32비트) */
    put32(bs + 36, fat_sz);                        /* 36 : FAT 한 벌의 섹터 수(계산값) */
    put16(bs + 40, 0);                             /* 40 : FAT 미러링 표시 */
    put16(bs + 42, 0);                             /* 42 : 파일 시스템 판 번호 */
    put32(bs + 44, 2);                             /* 44 : 루트 디렉터리의 클러스터 번호 */
    put16(bs + 48, 1);                             /* 48 : FSInfo 섹터 */
    put16(bs + 50, 6);                             /* 50 : 부트 섹터 사본의 자리 */
    bs[64] = 0x80;                                 /* 64 : BIOS 드라이브 번호 */
    bs[66] = 0x29;                                 /* 66 : 확장 서명 --- 아래 셋이 있다는 표시 */
    put32(bs + 67, 0x1234ABCDu);                   /* 67 : 볼륨 일련번호 */
    memcpy(bs + 71, "NO NAME    ", 11);            /* 71 : 볼륨 이름(11) */
    memcpy(bs + 82, "FAT32   ", 8);                /* 82 : 파일 시스템 이름표(믿지 말 것) */
    bs[510] = 0x55; bs[511] = 0xaa;                /* 510: 서명 */

    /* ── 되읽는다 ───────────────────────────────────────────── */
    uint32_t bps   = get16(bs + 11);
    uint32_t spc   = bs[13];
    uint32_t rsvd  = get16(bs + 14);
    uint32_t nfat  = bs[16];
    uint32_t fatsz = get32(bs + 36);
    uint32_t tot   = get32(bs + 32);
    uint32_t root  = get32(bs + 44);

    printf("== the FAT32 BPB (first sector of the partition) ==\n");
    printf("  sector size       : %u bytes\n", bps);
    printf("  cluster size      : %u sectors = %u bytes (%u KiB)\n", spc, spc * bps, spc * bps / 1024);
    printf("  reserved sectors  : %u\n", rsvd);
    printf("  FAT copies / size : %u x %u sectors\n", nfat, fatsz);
    printf("  total sectors     : %u = %.1f MiB\n", tot, tot * (double)bps / (1024 * 1024));
    printf("  root cluster      : %u\n", root);
    printf("  volume label      : \"%.11s\", filesystem label \"%.8s\"\n",
           bs + 71, bs + 82);
    printf("  hidden sectors    : %u  <- where this partition starts on the disk\n\n",
           get32(bs + 28));

    /* ── 자리 계산 ──────────────────────────────────────────── */
    uint32_t first_data = rsvd + nfat * fatsz;         /* FAT32 는 루트 디렉터리 자리가 따로 없다 */
    uint32_t clusters   = (tot - first_data) / spc;

    printf("== how the partition divides up ==\n");
    printf("  reserved area : sectors 0 - %u  (boot sector, FSInfo, copies)\n", rsvd - 1);
    printf("  FAT copy 1    : sectors %u - %u\n", rsvd, rsvd + fatsz - 1);
    printf("  FAT copy 2    : sectors %u - %u  <- a duplicate of the same content\n",
           rsvd + fatsz, rsvd + 2 * fatsz - 1);
    printf("  data area     : from sector %u  (cluster numbers start here)\n", first_data);
    printf("  clusters      : %u --- FAT32 needs at least 65525 -> %s\n\n",
           clusters, clusters >= 65525 ? "it is FAT32" : "cannot be FAT32");

    printf("== changing the cluster size on the same volume ==\n");
    /* 한글은 한 글자가 두 칸이라 %-10s 로는 안 맞는다 --- 머리글은 손으로 맞춘다 */
    printf("  cluster   clusters       one FAT      usable as FAT32\n");
    for (uint32_t sc = 1; sc <= 64; sc *= 2) {
        uint32_t a  = tot - rsvd;
        uint32_t b  = (256 * sc + nfat) / 2;
        uint32_t fz = (a + b - 1) / b;                 /* 규격의 어림 공식 */
        uint32_t cl = (tot - (rsvd + nfat * fz)) / sc; /* 실제로 남는 클러스터 수 */
        char csz[16];
        snprintf(csz, sizeof csz, "%u KiB", sc * bps / 1024 ? sc * bps / 1024 : 0);
        if (sc * bps < 1024) snprintf(csz, sizeof csz, "%u B", sc * bps);
        char fsz[16]; snprintf(fsz, sizeof fsz, "%u sectors", fz);
        printf("  %-10s %-14u %-12s %s\n", csz, cl, fsz,
               cl >= 65525 ? "yes" : "no --- too few clusters");
    }
    printf("\n  -> this is why a small volume ends up FAT16. Larger clusters mean fewer\n");
    printf("     of them to manage, and the count falls below 65525.\n\n");

    printf("== cluster number -> sector number ==\n");
    printf("  formula: start of data area + (N - 2) x sectors per cluster\n");
    printf("        (why subtract 2: 0 and 1 are used as labels and have no real place)\n\n");
    for (uint32_t n = 2; n <= 5; n++) {
        uint32_t rel = first_data + (n - 2) * spc;
        printf("  cluster %-3u -> sector %-6u in the partition -> absolute LBA %-8u%s\n",
               n, rel, part_lba + rel, n == root ? "  <- the root directory" : "");
    }

    /* ── FAT 사슬 따라가기 ──────────────────────────────────── */
    static unsigned char fat[SEC * 4];      /* FAT 앞 네 섹터만 흉내 낸다 */
    put32(fat + 3 * 4, 4);                  /* 3번 다음은 4번 */
    put32(fat + 4 * 4, 7);                  /* 4번 다음은 7번 */
    put32(fat + 7 * 4, 0x0FFFFFFFu);        /* 7번이 마지막 */

    printf("\n== when one file is scattered --- the FAT chain ==\n");
    printf("  the FAT is an array of cluster number -> next cluster number (4 bytes each).\n");
    printf("  if a file starts at cluster 3:\n\n");
    uint32_t n = 3;
    for (int step = 0; step < 8; step++) {
        uint32_t next = get32(fat + n * 4) & 0x0FFFFFFFu;   /* 위 4비트는 예약 */
        uint32_t lba  = part_lba + first_data + (n - 2) * spc;
        printf("    cluster %-3u (LBA %-8u, %u KiB)", n, lba, spc * bps / 1024);
        if (next >= 0x0FFFFFF8u) { printf(" -> end of chain\n"); break; }
        if (next == 0x0FFFFFF7u) { printf(" -> bad cluster\n"); break; }
        printf(" -> next is %u\n", next);
        n = next;
    }
    printf("\n  so a file that is not contiguous can still be read. And damage to one FAT\n");
    printf("  removes the way to find the rest of a file --- which is why there are two copies.\n");
    return 0;
}