mam se kodzik boot loadera i chce go przerobić tak aby działał inaczej a mianowicie:

mam sobie 3 części tzn boot loader który już mam napisany i który ma ładować mały pliczek który już nie wszedł w skład bootloadera bo za dużo zajmował :( i ten boot ładuje taki pliczek który wyświetla tekst do pÓÓÓÓki nie załaduje pliku końcowego jak takie coś zrobic na podstawie tego??? :

[BITS 16]
[ORG 0000h]

jmp START

 OEM_ID                db "Water OS"
 BytesPerSector        dw 0x0200
 SectorsPerCluster     db 0x01
 ReservedSectors       dw 0x0001
 TotalFATs             db 0x02
 MaxRootEntries        dw 0x00E0
 TotalSectorsSmall     dw 0x0B40
 MediaDescriptor       db 0xF0
 SectorsPerFAT         dw 0x0009
 SectorsPerTrack       dw 0x0012
 NumHeads              dw 0x0002
 HiddenSectors         dd 0x00000000
 TotalSectorsLarge     dd 0x00000000
 DriveNumber           db 0x00
 Flags                 db 0x00
 Signature             db 0x29
 VolumeID              dd 0xFFFFFFFF
 VolumeLabel           db "Water OS"
 SystemID              db "FAT12   "

 START:
      cli
      mov     ax, 0x07C0
      mov     ds, ax
      mov     es, ax
      mov     fs, ax
      mov     gs, ax
      mov     ax, 0x0000
      mov     ss, ax
      mov     sp, 0xFFFF
      sti

 ; wyswietl wiadomosc
      mov     si, msgLoading
      call    DisplayMessage

LOAD_ROOT:
 ; oblicz wielkosc root directory i zapisz w 'cx'
      xor     cx, cx
      xor     dx, dx
      mov     ax, 0x0020                          ; 32 bajtowy opis katalogu
      mul     WORD [MaxRootEntries]               ; liczba pozycji w katalogu glownym
      div     WORD [BytesPerSector]               ; bajty na sektor
      xchg    ax, cx

 ; oblicz polozenie root directory i zapisz w 'ax'
      mov     al, BYTE [TotalFATs]                ; liczba tablic FAT
      mul     WORD [SectorsPerFAT]                ; liczba sektorow uzywanych przez tablice FAT
      add     ax, WORD [ReservedSectors]        
      mov     WORD [datasector], ax            
      add     WORD [datasector], cx

 ; odczytaj root directory do pamieci pod adres (07C0:0200)
      mov     bx, 0x0200                       
      call    ReadSectors

 ; przegladaj root directory w poszukiwaniu binary image
      mov     cx, WORD [MaxRootEntries]          
      mov     di, 0x0200                          ; adres pierwszego root entry
 .LOOP:
      push    cx
      mov     cx, 0x000B                          ; nazwa ma 11 znakow
      mov     si, ImageName                       ; nazwa pliku do znalezienia
      push    di
      rep     cmpsb                               ; sprawdz
      pop     di
      je      LOAD_FAT
      pop     cx
      add     di, 0x0020                          ; przestaw na nastepny directory entry
      loop    .LOOP
      jmp     FAILURE

 LOAD_FAT:
 ; zapisz poczatkowy klaster boot image
      mov     si, msgCRLF
      call    DisplayMessage
      mov     dx, WORD [di + 0x001A]
      mov     WORD [cluster], dx                  ; pierwszy klaster pliku

 ; oblicz rozmiar tablicy FAT i zapisz w 'cx'
      xor     ax, ax
      mov     al, BYTE [TotalFATs]                ; liczba tablic FAT
      mul     WORD [SectorsPerFAT]                ; liczba sektorow uzywanych przez FAT
      mov     cx, ax

 ; oblicz polozenie FAT i zapisz w 'ax'
      mov     ax, WORD [ReservedSectors]          

      mov     bx, 0x0200                        
      call    ReadSectors

      mov     ax, 0100h                         
      mov     es, ax
      mov     bx, 0000h                        
      push    bx

 LOAD_IMAGE:
      mov     ax, WORD [cluster]                 
      pop     bx                                 
      call    ClusterLBA                       
      xor     cx, cx
      mov     cl, BYTE [SectorsPerCluster]        
      call    ReadSectors
      push    bx

 ;oblicz adres nastepnego klastra
      mov     ax, WORD [cluster]              
      mov     cx, ax                           
      mov     dx, ax                           
      shr     dx, 0x0001                        
 ;divide by two
      add     cx, dx                         
      mov     bx, 0x0200                    
      add     bx, cx                        
      mov     dx, WORD [bx]                
      test    ax, 0x0001
      jnz     .ODD_CLUSTER
 .EVEN_CLUSTER:
      and     dx, 0000111111111111b         
     jmp     .DONE
 .ODD_CLUSTER:
      shr     dx, 0x0004                   
 .DONE:
      mov     WORD [cluster], dx               
      cmp     dx, 0x0FF0                       
      jb      LOAD_IMAGE
 DONE:
      mov     si, msgCRLF
      call    DisplayMessage
      push    WORD 0x0100
      push    WORD 0x0000
      retf

 FAILURE:
      mov     si, msgFailure
      call    DisplayMessage
      mov     ah, 00h
      int     16h                               
      int     19h                             

 DisplayMessage:
      lodsb
      or      al, al                         
      jz      .DONE
      mov     ah, 0x0E                         
      mov     bh, 0x00 
      mov     bl, 0x07                           
      int     0x10                            
      jmp     DisplayMessage
 .DONE:
      ret

 ; odczytaj cx sektorow z dyskietki zaczynajac od ax pod adres bx
ReadSectors:
 .MAIN
      mov     di, 0x0005                   
 .SECTORLOOP
      push    ax
      push    bx
      push    cx
      call    LBACHS
      mov     ah, 0x02                           
      mov     al, 0x01                        
      mov     ch, BYTE [absoluteTrack]          
      mov     cl, BYTE [absoluteSector]         
      mov     dh, BYTE [absoluteHead]            
      mov     dl, BYTE [DriveNumber]           
      int     0x13                               
      jnc     .SUCCESS                          
      xor     ax, ax                          
      int     0x13                             
      dec     di                           
      pop     cx
      pop     bx
      pop     ax
      jnz     .SECTORLOOP                    
      int     0x18
 .SUCCESS
      mov     si, msgProgress
      call    DisplayMessage
      pop     cx
      pop     bx
      pop     ax
      add     bx, WORD [BytesPerSector]      
      inc     ax 
      loop    .MAIN
      ret

 ; zamien numer klastra na adres w trybie lba
 ClusterLBA:
      sub     ax, 0x0002      
      xor     cx, cx
      mov     cl, BYTE [SectorsPerCluster]        
      mul     cx
      add     ax, WORD [datasector] 
      ret

 ; zamien adres lba w ax na adres w formacie CHS
 LBACHS:
      xor     dx, dx                          
      div     WORD [SectorsPerTrack]            
      inc     dl                                
      mov     BYTE [absoluteSector], dl
      xor     dx, dx                       
      div     WORD [NumHeads]                
      mov     BYTE [absoluteHead], dl
      mov     BYTE [absoluteTrack], al
      ret

 absoluteSector db 0x00
 absoluteHead   db 0x00
 absoluteTrack  db 0x00

 datasector  dw 0x0000
 cluster     dw 0x0000
 ImageName   db "WATEROS BIN"
 msgLoading  db 0x0D, 0x0A, "WaterOS Loadinggre34hg34hh43h34h43h43h", 0x0D, 0x0A, 0x00
 msgCRLF     db 0x0D, 0x0A, 0x00
 msgProgress db ""
 msgFailure  db 0x0D, 0x0A, "Error: Press any key to reboot", 0x00

DW 0xAA55