use16
org 7c00h

        jmp     after_data
        nop

                    db 'MSWIN4.1'       ;oem disk label (8 bytes)

                    dw 512              ;bytes per sector
                    db 1                ;sectors per cluster
                    dw 1                ;reserved sectors (1 for boot code)
                    db 2                ;number of file allocation tables
                    dw 224              ;number of root directory entries
                    dw 2880             ;number of logical sectors
                    db 0f0h             ;media descriptor byte
                    dw 9                ;9 sectors per FAT
_sectors_per_track  dw 18               ;18 sectors per track (36/cylinder)
_heads_per_cylinder dw 2                ;2 heads per cylinder
                    dd 0                ;no hidden sectors
                    dd 0                ;no large sectors

_drive_number       db 0                ;drive number (for drive A)
                    db 0                ;reserved (current head)
                    db 29h              ;drive signature (29h for floppy)
                    dd 0                ;volume ID (serial number)
                    db 'NONAME     '    ;volume label (11 bytes)
                    db 'FAT12   '       ;file system type (8 bytes)

_file_name          db 'SYSTEM  BIN'    ;file name (11 bytes)

after_data:

        jmp     0:purge_code

purge_code:

        cld

        mov     ax,cs
        mov     ds,ax
        mov     es,ax

        mov     [ds:_drive_number],dl

        cli
        mov     ss,ax
        mov     sp,system_stack
        sti

        mov     al,14
        mov     bx,disk_buffer
       ;ES:BX -> near buffer
        mov     cx,2
        mov     dh,1
        call    read_sectors

        mov     si,_file_name
        mov     di,bx;disk_buffer
        mov     cx,224

parse_root:

        pusha
        mov     cx,11
        rep     cmpsb
        popa

        je      load_fat
        add     di,32
        loop    parse_root

        mov     al,'F'

fatal_error:

        mov     ah,0eh
        xor     bh,bh
        int     10h

        xor     ah,ah
        int     16h

        int     18h

read_sectors:
        ;       AL = number of sectors to read
        ;       ES:BX -> destination buffer
        ;       CX,DH = cylinder/head/sector
        pusha
        mov     dl,[ds:_drive_number]
        mov     si,5            ; attempts to read
.read:  mov     ah,02h          ; BIOS read sectors function
        stc
        int     13h
        jnc     .done
        dec     si
        jnc     .reset
        mov     al,'R'
        jmp     fatal_error
.reset: mov     di,5            ; attempts to reset
.retry: xor     ah,ah           ; BIOS reset disk function
        stc
        int     13h
        jnc     .read
        dec     di
        jnc     .retry
        mov     al,'D'
        jmp     fatal_error
.done:  popa
        ret                     ; never returns if failure

load_fat:

        mov     si,[es:di+26]

        mov     al,9
       ;ES:BX -> near buffer
        mov     cx,2
        xor     dx,dx
        call    read_sectors

        mov     ax,0050h
        mov     es,ax
        mov     fs,ax
        mov     gs,ax

        xor     bx,bx
       ;ES:BX -> far buffer

load_file:

        mov     ax,si
        add     ax,31

        xor     dx,dx
        div     word[ds:_sectors_per_track]
        inc     dx
        mov     cl,dl
        xor     dx,dx
        div     word[ds:_heads_per_cylinder]
        mov     ch,al
        mov     dh,dl

        mov     al,1
       ;ES:BX -> far buffer
        call    read_sectors
        add     bx,512

        mov     ax,si
        mov     cx,3
        mul     cx
        dec     cx
        div     cx

        mov     di,ax
        mov     si,[ds:di+disk_buffer]

        or      dx,dx
        jz      even_cluster

        shr     si,4
even_cluster:
        and     si,0fffh
        cmp     si,0ff8h
        jl      load_file

        mov     dl,[ds:_drive_number]

        push    es
        pop     ds

        push    es
        push    0
        retf

rb 510-($-$$)
dw 0aa55h

disk_buffer:
rb 8192

rb 8192
system_stack:
    

macro PRINT_HEX16 _r {
        mov     word[g_format_string],`_r
        mov     dx,_r
        call    format_hex
}

use16
org 0

        jmp     start
        rb      4096 ; ensure long files are loaded normally

start:

        PRINT_HEX16 cs
        PRINT_HEX16 ds
        PRINT_HEX16 es
        PRINT_HEX16 fs
        PRINT_HEX16 gs
        PRINT_HEX16 ss
        PRINT_HEX16 sp

        jmp     $

format_hex:
        ; DX = value
        mov     cx,4
        mov     di,g_format_string+5
.fmt:   rol     dx,4
        mov     al,dl
        and     al,0x0f
        cmp     al,0x0a
        sbb     al,0x69
        das
        stosb
        loop    .fmt
        mov     si,g_format_string
.get:   lodsb
        test    al,al
        jz      .eos
        mov     ah,0eh
        int     10h
        jmp     .get
.eos:   ret

g_format_string:
        db '?? 0x????',13,10,0
    

> Don't XOR DX,DX before MUL CX, it's useless

There is a div instruction a little further down uses it.

> Drop DS: and ES: everywhere

Im ot sure how/where that will make any difference?

> You don't really need the JMP 0:purge_code

Its to make sure we have valid CS:IP

> Because you're working on a floppy you can byte-divide by the number of heads thus saving the XOR DX,DX

How you mean that?

> Better use REPE CMPSB instead of trusting default behaviour of any assembler

What? and Where?

Each time you use a segment override prefix like DS: or ES: the assembler adds 1 byte to the code. When optimizing for size that counts!