diff --git a/crc16.c b/crc16.c
index 02453ae..86650a2 100644
--- a/crc16.c
+++ b/crc16.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 
-#define kDataAddr ((uint8_t*) 0x0000)
+#define kDataAddr ((uint8_t*)0x0000)
 
 uint16_t crc16(int data_len) {
     const uint8_t* data = kDataAddr;
@@ -19,17 +19,15 @@ uint16_t crc16(int data_len) {
     return crc;
 }
 
-asm (
-        ".global main      \n"
-        "main:             \n"
-        "  push %bp        \n"
-        "  mov %sp, %bp    \n"
-        "  mov 8(%bp), %si \n"
-        "  push (%si)      \n"
-        "  call crc16      \n"
-        "  add $0x2, %sp   \n"
-        "  mov 6(%bp), %di \n"
-        "  mov %ax, (%di)  \n"
-        "  pop %bp         \n"
-        "  lret $4         \n"
-        );
+asm(".global main      \n"
+    "main:             \n"
+    "  push %bp        \n"
+    "  mov %sp, %bp    \n"
+    "  mov 8(%bp), %si \n"
+    "  push (%si)      \n"
+    "  call crc16      \n"
+    "  add $0x2, %sp   \n"
+    "  mov 6(%bp), %di \n"
+    "  mov %ax, (%di)  \n"
+    "  pop %bp         \n"
+    "  lret $4         \n");
diff --git a/crt0.c b/crt0.c
index a5b7580..43f40b8 100644
--- a/crt0.c
+++ b/crt0.c
@@ -3,24 +3,22 @@
 
 int main();
 
-asm (
-        ".section .init     \n"
-        ".global _start     \n"
-        "_start:            \n\t"
-        "mov %cs, %ax       \n\t"
-        "mov %ax, %ds       \n\t"
-        "mov %ax, %es       \n\t"
-        "cli                \n\t"
-        "mov %ax, %ss       \n\t"
-        "mov $0x1000, %ax   \n\t"
-        "mov %ax, %sp       \n\t"
-        "sti                \n\t"
-        "jmp main"
-);
+asm(".section .init     \n"
+    ".global _start     \n"
+    "_start:            \n\t"
+    "mov %cs, %ax       \n\t"
+    "mov %ax, %ds       \n\t"
+    "mov %ax, %es       \n\t"
+    "cli                \n\t"
+    "mov %ax, %ss       \n\t"
+    "mov $0x1000, %ax   \n\t"
+    "mov %ax, %sp       \n\t"
+    "sti                \n\t"
+    "jmp main");
 
 void* memset(void* ptr, int val, size_t len) {
     uint8_t* p = ptr;
-    while(len--) {
+    while (len--) {
         *p++ = val;
     }
     return ptr;
diff --git a/fat12.c b/fat12.c
index 74bd14d..4484184 100644
--- a/fat12.c
+++ b/fat12.c
@@ -6,8 +6,7 @@
 #define kHeads 2
 #define kFatSizeSectors 2
 #define kRootDirSizeSectors 7
-#define kDataRegionStartSector (1 + kFatSizeSectors*2 + kRootDirSizeSectors)
-
+#define kDataRegionStartSector (1 + kFatSizeSectors * 2 + kRootDirSizeSectors)
 
 typedef struct {
     char name[8];
@@ -24,22 +23,22 @@ static uint8_t* gFat;
 static direntry* gRootdir;
 
 static int readsector(int c, int h, int s, uint8_t* addr) {
-    register uint8_t* dest asm ("bx") = addr;
-    register uint8_t nsects asm ("al") = 1;
-    register uint8_t func asm ("ah") = 0x02;
-    register uint8_t sect asm ("cl") = s;
-    register uint8_t cyl asm ("ch") = c;
-    register uint8_t head asm ("dh") = h;
-    register uint8_t drive asm ("dl") = 0;
-    register uint16_t seg asm ("es") = 0;
+    register uint8_t* dest asm("bx") = addr;
+    register uint8_t nsects asm("al") = 1;
+    register uint8_t func asm("ah") = 0x02;
+    register uint8_t sect asm("cl") = s;
+    register uint8_t cyl asm("ch") = c;
+    register uint8_t head asm("dh") = h;
+    register uint8_t drive asm("dl") = 0;
+    register uint16_t seg asm("es") = 0;
 
     register uint8_t ret asm("ah");
 
     for (int i = 0; i < 3; i++) {
-        asm volatile ("int $0x13"
-                : "=r" (ret)
-                : "r" (dest), "r" (nsects), "r" (func), "r" (sect),
-                  "r" (cyl), "r" (head), "r" (drive), "r" (seg));
+        asm volatile("int $0x13"
+                     : "=r"(ret)
+                     : "r"(dest), "r"(nsects), "r"(func), "r"(sect), "r"(cyl),
+                       "r"(head), "r"(drive), "r"(seg));
         if (ret != 0x80) {
             break;
         }
@@ -52,20 +51,21 @@ static int readcluster(int cluster) {
     int offs = cluster * 3 / 2;
     if (cluster % 2) {
         // high nibble is lsb + whole byte
-        return ((gFat[offs] & 0xf0) >> 4) + (gFat[offs+1] << 4);
+        return ((gFat[offs] & 0xf0) >> 4) + (gFat[offs + 1] << 4);
     } else {
-        return gFat[offs] + ((gFat[offs+1] & 0x0f) << 8);
+        return gFat[offs] + ((gFat[offs + 1] & 0x0f) << 8);
     }
 }
 
 static void cluster2chs(int cluster, int* c, int* h, int* s) {
-    int logicalsector = kDataRegionStartSector + (cluster - 2) * kSectorsPerCluster;
+    int logicalsector =
+            kDataRegionStartSector + (cluster - 2) * kSectorsPerCluster;
     *s = (logicalsector % kSectorsPerTrack) + 1;
     *h = (logicalsector / kSectorsPerTrack) % kHeads;
     *c = logicalsector / (kHeads * kSectorsPerTrack);
 }
 
-static int strncmp(const char* s1, const char *s2, size_t len) {
+static int strncmp(const char* s1, const char* s2, size_t len) {
     for (int i = 0; i < len && s1[i]; i++) {
         if (s1[i] != s2[i]) {
             return 1;
@@ -77,7 +77,7 @@ static int strncmp(const char* s1, const char *s2, size_t len) {
 
 static int loadfile(direntry* entry, void* addr) {
     int cluster = entry->cluster;
-    for (int i = 0; i < entry->size; i+=1024) {
+    for (int i = 0; i < entry->size; i += 1024) {
         int c, h, s;
         cluster2chs(cluster, &c, &h, &s);
         if (readsector(c, h, s, addr + i)) {
diff --git a/fat12.h b/fat12.h
index 85eb0b3..af3fb1e 100644
--- a/fat12.h
+++ b/fat12.h
@@ -11,5 +11,5 @@ int fat12_init(void* fat_addr, void* rootdir_addr);
  * Returns:
  *  -4 if file is not found
  *  -5 if there is a disk error
- */ 
+ */
 int fat12_readfile(const char* name, void* addr);
diff --git a/fat12boot.c b/fat12boot.c
index 69f56c8..a179412 100644
--- a/fat12boot.c
+++ b/fat12boot.c
@@ -7,15 +7,12 @@
 #define kFatAddress ((void*)0x1000)
 #define kRootDirAddress ((void*)0x1200)
 
-
 static int putchar(int c) {
-    register uint8_t khar asm ("al") = c;
-    register uint8_t func asm ("ah") = 0x0e;
-    register uint8_t page asm ("bh") = 0;
+    register uint8_t khar asm("al") = c;
+    register uint8_t func asm("ah") = 0x0e;
+    register uint8_t page asm("bh") = 0;
 
-    asm volatile ("int $0x10"
-            :: "r" (khar), "r" (func), "r" (page)
-            : "bp");
+    asm volatile("int $0x10" ::"r"(khar), "r"(func), "r"(page) : "bp");
 
     return c;
 }
@@ -27,37 +24,30 @@ static int puts(const char* msg) {
     return 0;
 }
 
-__attribute__((noreturn))
-static void die(const char* msg) {
+__attribute__((noreturn)) static void die(const char* msg) {
     puts(msg);
     while (1) {
     }
     __builtin_unreachable();
 }
 
-__attribute__((noreturn))
-static void jump(void* addr) {
-    asm volatile ("ljmp $0,%0" :: "i"(addr));
+__attribute__((noreturn)) static void jump(void* addr) {
+    asm volatile("ljmp $0,%0" ::"i"(addr));
     __builtin_unreachable();
 }
 
-__attribute__((noreturn))
-static void loadpolmon() {
+__attribute__((noreturn)) static void loadpolmon() {
     if (fat12_init(kFatAddress, kRootDirAddress)) {
         die("fi");
     }
 
     while (fat12_readfile("POLIO   COM", kPolmonAddress)) {
-        asm volatile (
-                "mov $00, %%ah      \n\t"
-                "int $0x16          \n\t"
-                ::: "ax"
-                );
+        asm volatile("mov $00, %%ah      \n\t"
+                     "int $0x16          \n\t" ::
+                             : "ax");
     }
 
     jump(kPolmonAddress);
 }
 
-int main() {
-    loadpolmon();
-}
+int main() { loadpolmon(); }
diff --git a/paracomm.c b/paracomm.c
index 557f8b4..fb140ce 100644
--- a/paracomm.c
+++ b/paracomm.c
@@ -33,32 +33,31 @@ static void swapbuffers() {
 
 uint8_t paracomm_nextbyte() {
     switch (mosi_state) {
-        case 0:
+    case 0:
+        if (mosi_size == 0) {
+            swapbuffers();
             if (mosi_size == 0) {
-                swapbuffers();
-                if (mosi_size == 0) {
-                    return kMosiIdleByte;
-                }
+                return kMosiIdleByte;
             }
-            mosi_state = 1;
-            return kMosiStartByte;
-        case 1:
-            // assert(mosi_size > 0)
-            mosi_sent = 0;
-            mosi_state = 2;
-            return mosi_size;
-        case 2:
-            {
-                uint8_t b = mosi_sendbuf[mosi_sent];
-                mosi_sent += 1;
+        }
+        mosi_state = 1;
+        return kMosiStartByte;
+    case 1:
+        // assert(mosi_size > 0)
+        mosi_sent = 0;
+        mosi_state = 2;
+        return mosi_size;
+    case 2: {
+        uint8_t b = mosi_sendbuf[mosi_sent];
+        mosi_sent += 1;
 
-                if (mosi_sent == mosi_size) {
-                    swapbuffers();
-                    mosi_state = 0;
-                }
+        if (mosi_sent == mosi_size) {
+            swapbuffers();
+            mosi_state = 0;
+        }
 
-                return b;
-            }
+        return b;
+    }
     }
 
     __builtin_unreachable();
@@ -66,41 +65,39 @@ uint8_t paracomm_nextbyte() {
 
 void paracomm_feed(uint8_t n) {
     switch (miso_state) {
-        case 0:
-            if (n == kMisoStartNibble) {
-                miso_state = 1;
-            } else if (n == kMisoIdleNibble) {
-            } else {
-                // error: spurious nibble
-            }
-            break;
-        case 1:
-            miso_size = n;
-            miso_state = 2;
-            break;
-        case 2:
-            miso_size += n << 4;
-            miso_received_nibbles = 0;
-            miso_state = 3;
-            break;
-        case 3:
-            {
-                uint8_t idx = miso_received_nibbles / 2;
-                if (miso_received_nibbles % 2 == 0) {
-                    miso_recvbuf[idx] = n;
-                } else {
-                    miso_recvbuf[idx] += n << 4;
-                }
-                miso_received_nibbles += 1;
+    case 0:
+        if (n == kMisoStartNibble) {
+            miso_state = 1;
+        } else if (n == kMisoIdleNibble) {
+        } else {
+            // error: spurious nibble
+        }
+        break;
+    case 1:
+        miso_size = n;
+        miso_state = 2;
+        break;
+    case 2:
+        miso_size += n << 4;
+        miso_received_nibbles = 0;
+        miso_state = 3;
+        break;
+    case 3: {
+        uint8_t idx = miso_received_nibbles / 2;
+        if (miso_received_nibbles % 2 == 0) {
+            miso_recvbuf[idx] = n;
+        } else {
+            miso_recvbuf[idx] += n << 4;
+        }
+        miso_received_nibbles += 1;
 
-                if (miso_received_nibbles == 2*miso_size) {
-                    if (miso_cb != 0) {
-                        miso_cb(miso_recvbuf, miso_size);
-                    }
-                    miso_state = 0;
-                }
+        if (miso_received_nibbles == 2 * miso_size) {
+            if (miso_cb != 0) {
+                miso_cb(miso_recvbuf, miso_size);
             }
-            break;
+            miso_state = 0;
+        }
+    } break;
     }
 }
 
diff --git a/polmon.cc b/polmon.cc
index 4a5b166..20a2088 100644
--- a/polmon.cc
+++ b/polmon.cc
@@ -43,27 +43,21 @@ namespace {
 #if WOZMON
 
 int getchar() {
-    register char c asm ("al");
-    asm volatile (
-            "movb $0x00, %%ah\n\t"
-            "int $0x16"
-            : "=r" (c)
-            :: "ah", "cc"
-            );
+    register char c asm("al");
+    asm volatile("movb $0x00, %%ah\n\t"
+                 "int $0x16"
+                 : "=r"(c)::"ah", "cc");
     return c;
 }
 
 void putchar(int c) {
-    asm volatile (
-            "push %%bp          \n\t"
-            "mov %0, %%ax       \n\t"
-            "movb $0x0e, %%ah   \n\t"
-            "movb $0, %%bh      \n\t"
-            "int $0x10          \n\t"
-            "pop %%bp           \n\t"
-            :: "r" (c)
-            : "ax", "bh", "cc"
-            );
+    asm volatile("push %%bp          \n\t"
+                 "mov %0, %%ax       \n\t"
+                 "movb $0x0e, %%ah   \n\t"
+                 "movb $0, %%bh      \n\t"
+                 "int $0x10          \n\t"
+                 "pop %%bp           \n\t" ::"r"(c)
+                 : "ax", "bh", "cc");
 }
 
 #endif  // WOZMON
@@ -72,29 +66,28 @@ constexpr int kDumpSize = 16;
 
 // arguments on the stack in reverse order
 extern "C" uint16_t Int80h(uint8_t fun, int nargs);
-asm (
-        ".section .text.Int80h  \n"
-        "Int80h:                \n"
-        "   push %si            \n"
-        "   push %bp            \n"
-        "   mov %al, %ah        \n"
-        "   mov %sp, %bp        \n"
-        "   lea 6(%bp), %si     \n"  // 4 for pushed stuff, 2 for return addr
-        "0:                     \n"
-        "   test %dx, %dx       \n"
-        "   jz 1f               \n"
-        "   push (%si)          \n"
-        "   dec %dx             \n"
-        "   add $2, %si         \n"
-        "   jmp 0b              \n"
-        "1:                     \n"
-        "   int $0x80           \n"
-        "   mov %bp, %sp        \n"
-        "   pop %bp             \n"
-        "   pop %si             \n"
-        "   ret"
-        // return value in ax
-        );
+asm(".section .text.Int80h  \n"
+    "Int80h:                \n"
+    "   push %si            \n"
+    "   push %bp            \n"
+    "   mov %al, %ah        \n"
+    "   mov %sp, %bp        \n"
+    "   lea 6(%bp), %si     \n"  // 4 for pushed stuff, 2 for return addr
+    "0:                     \n"
+    "   test %dx, %dx       \n"
+    "   jz 1f               \n"
+    "   push (%si)          \n"
+    "   dec %dx             \n"
+    "   add $2, %si         \n"
+    "   jmp 0b              \n"
+    "1:                     \n"
+    "   int $0x80           \n"
+    "   mov %bp, %sp        \n"
+    "   pop %bp             \n"
+    "   pop %si             \n"
+    "   ret"
+    // return value in ax
+);
 
 constexpr uint8_t kBackspace = 0x7f;
 constexpr uint8_t kOtherBackspace = 0x08;
@@ -119,13 +112,9 @@ uint16_t ReadUintN(int n, const char* buf) {
     return out;
 }
 
-uint8_t ReadUint8(const char* buf) {
-    return ReadUintN(2, buf);
-}
+uint8_t ReadUint8(const char* buf) { return ReadUintN(2, buf); }
 
-uint16_t ReadUint16(const char* buf) {
-    return ReadUintN(4, buf);
-}
+uint16_t ReadUint16(const char* buf) { return ReadUintN(4, buf); }
 
 void WriteHexNibble(uint8_t c) {
     if (c > 9) {
@@ -146,35 +135,24 @@ void WriteUint16(uint16_t a) {
 }
 
 uint8_t __get_far_u8__(uint16_t addr, uint16_t seg) {
-    register uint16_t ad asm ("si") = addr;
-    register uint16_t sg asm ("ds") = seg;
-    register uint8_t ret asm ("al");
-    asm (
-            "lodsb              \n\t"
-            : "=r" (ret)
-            : "r" (ad), "r" (sg)
-            );
+    register uint16_t ad asm("si") = addr;
+    register uint16_t sg asm("ds") = seg;
+    register uint8_t ret asm("al");
+    asm("lodsb              \n\t" : "=r"(ret) : "r"(ad), "r"(sg));
     return ret;
 }
 
 void __set_far_u8__(uint16_t addr, uint16_t seg, uint8_t val) {
-    register uint16_t ad asm ("di") = addr;
-    register uint16_t sg asm ("es") = seg;
-    register uint8_t v asm ("al") = val;
-    asm (
-            "stosb      \n\t"
-            :: "r" (sg), "r" (ad), "r" (v)
-            : "memory"
-            );
+    register uint16_t ad asm("di") = addr;
+    register uint16_t sg asm("es") = seg;
+    register uint8_t v asm("al") = val;
+    asm("stosb      \n\t" ::"r"(sg), "r"(ad), "r"(v) : "memory");
 }
 
-__attribute__((noreturn))
-inline static void __basic__() {
-    asm volatile (
-            "movw $0x40, %ax    \n\t"
-            "mov %ax, %ds       \n\t"
-            "int $0x18"
-            );
+__attribute__((noreturn)) inline static void __basic__() {
+    asm volatile("movw $0x40, %ax    \n\t"
+                 "mov %ax, %ds       \n\t"
+                 "int $0x18");
     __builtin_unreachable();
 }
 
@@ -213,30 +191,26 @@ void DumpHex(uint16_t addr, uint16_t seg) {
 }
 
 void ClearScreen() {
-    asm volatile (
-            "movw $0x0002, %%ax  \n\t"
-            "int $0x10"
-            ::: "ax", "cc"
-            );
+    asm volatile("movw $0x0002, %%ax  \n\t"
+                 "int $0x10" ::
+                         : "ax", "cc");
 }
 
 void Status(uint8_t status) {
-    asm volatile (
-            "xorb %%bh, %%bh    \n\t"
-            "movb $0x03, %%ah   \n\t"
-            "int $0x10          \n\t"
-            "mov %%dx, %%di     \n\t"
-            "movb $0x02, %%ah   \n\t"
-            "movw $77, %%dx     \n\t"
-            "int $0x10          \n\t"
-            "movb %0, %%al      \n\t"
-            "call %1            \n\t"
-            "movb $0x02, %%ah   \n\t"
-            "movw %%di, %%dx    \n\t"
-            "int $0x10"
-            :: "rm" (status), "l" (WriteUint8)
-            : "ax", "bh", "dx", "cx", "di", "cc"
-            );
+    asm volatile("xorb %%bh, %%bh    \n\t"
+                 "movb $0x03, %%ah   \n\t"
+                 "int $0x10          \n\t"
+                 "mov %%dx, %%di     \n\t"
+                 "movb $0x02, %%ah   \n\t"
+                 "movw $77, %%dx     \n\t"
+                 "int $0x10          \n\t"
+                 "movb %0, %%al      \n\t"
+                 "call %1            \n\t"
+                 "movb $0x02, %%ah   \n\t"
+                 "movw %%di, %%dx    \n\t"
+                 "int $0x10" ::"rm"(status),
+                 "l"(WriteUint8)
+                 : "ax", "bh", "dx", "cx", "di", "cc");
 }
 
 bool ParseCommand(const char* buf, uint16_t& cur_addr, uint16_t& cur_seg) {
@@ -244,14 +218,14 @@ bool ParseCommand(const char* buf, uint16_t& cur_addr, uint16_t& cur_seg) {
     for (const char* ptr = buf; *ptr;) {
         if (*ptr == 's') {
             cur_addr = 0;
-            cur_seg = ReadUint16(ptr+1);
+            cur_seg = ReadUint16(ptr + 1);
             ptr += 5;
         } else if (*ptr == '$') {
             __basic__();
         } else if (*ptr == 'j') {
             dump = false;
             ptr++;
-            auto jump = reinterpret_cast<uint16_t(*)()>(cur_addr);
+            auto jump = reinterpret_cast<uint16_t (*)()>(cur_addr);
             uint16_t ret = jump();
             WriteUint16(ret);
             putchar('\r');
@@ -269,17 +243,14 @@ bool ParseCommand(const char* buf, uint16_t& cur_addr, uint16_t& cur_seg) {
                     continue;
                 }
                 uint16_t d = ReadUint16(ptr);
-                asm volatile ("push %0" :: "r" (d));
+                asm volatile("push %0" ::"r"(d));
                 nargs++;
                 ptr += 4;
             }
             uint16_t ret = Int80h(fun, nargs);
-            asm volatile (
-                    "shl %0   \n\t"
-                    "add %0, %%sp"
-                    :: "r"(nargs)
-                    );
-            WriteUint16(ret); 
+            asm volatile("shl %0   \n\t"
+                         "add %0, %%sp" ::"r"(nargs));
+            WriteUint16(ret);
             putchar('\r');
             putchar('\n');
 #endif  // INT80H
@@ -324,7 +295,7 @@ void polmon() {
     char* inptr = inbuf;
 
     ClearScreen();
-#if SHOWTITLE    
+#if SHOWTITLE
     puts("PolMon 0.2\r\n");
 #endif  // SHOWTITLE
     DisplayPrompt();
@@ -368,13 +339,10 @@ void polmon() {
 
 }  // namespace
 
-int main() {
-    polmon();
-}
+int main() { polmon(); }
 
 #if BOOTSTRAP
-__attribute__((section(".init"), noreturn, used))
-void _start() {
+__attribute__((section(".init"), noreturn, used)) void _start() {
     main();
     __builtin_unreachable();
 }
diff --git a/stdlib.c b/stdlib.c
index 0cf55e2..e3ccc1f 100644
--- a/stdlib.c
+++ b/stdlib.c
@@ -1,25 +1,19 @@
 int getchar() {
-    register char c asm ("al");
-    asm volatile (
-            "movb $0x00, %%ah\n\t"
-            "int $0x16"
-            : "=r" (c)
-            :: "ah", "cc"
-            );
+    register char c asm("al");
+    asm volatile("movb $0x00, %%ah\n\t"
+                 "int $0x16"
+                 : "=r"(c)::"ah", "cc");
     return c;
 }
 
 int putchar(int c) {
-    asm volatile (
-            "push %%bp          \n\t"
-            "mov %0, %%ax      \n\t"
-            "movb $0x0e, %%ah   \n\t"
-            "movb $0, %%bh      \n\t"
-            "int $0x10          \n\t"
-            "pop %%bp           \n\t"
-            :: "r" (c)
-            : "ax", "bh", "cc"
-            );
+    asm volatile("push %%bp          \n\t"
+                 "mov %0, %%ax      \n\t"
+                 "movb $0x0e, %%ah   \n\t"
+                 "movb $0, %%bh      \n\t"
+                 "int $0x10          \n\t"
+                 "pop %%bp           \n\t" ::"r"(c)
+                 : "ax", "bh", "cc");
     return 0;
 }