ifndef  ??version
?debug  macro
    endm
publicdll macro name
    public  name
    endm
    endif
    ?debug  V 300h
    ?debug  S "LAB5.C"
    ?debug  C E92D13993B064C4142352E43
    ?debug  C E94019CA1814433A5C4243335C494E434C5544455C444F532E48
    ?debug  C E94019CA1816433A5C4243335C494E434C5544455C5F444546532E+
    ?debug  C 48
LAB5_TEXT   segment byte public 'CODE'
LAB5_TEXT   ends
DGROUP  group   _DATA,_BSS
    assume  cs:LAB5_TEXT,ds:DGROUP
_DATA   segment word public 'DATA'
d@  label   byte
d@w label   word
_DATA   ends
_BSS    segment word public 'BSS'
b@  label   byte
b@w label   word
_BSS    ends
LAB5_TEXT   segment byte public 'CODE'
    ?debug  C E801064C4142352E432D13993B
   ;
   ;    void napiszZnak(unsigned char strona, unsigned char znak,
   ;
^ Funkcja służąca do wyświetlania znaków na ekranie.   Do wypisywania znaków na ekranie można też wykorzystać funkcję BIOSu (nr.9) w ramach przerwania 10H.
    ?debug  L 10
    assume  cs:LAB5_TEXT
_napiszZnak proc    far
    ?debug  B
    push    bp
    mov bp,sp
    ?debug  C E603696C650A0A0C00000761747279627574080A+
    ?debug  C 0A0000047A6E616B080A080000067374726F6E61+
    ?debug  C 080A060000
    ?debug  B
   ;
   ;         unsigned char atrybut, unsigned int ile)
   ;    {
   ;            regs.h.ah = 9;
   ;
^ 'regs' jest unią zawierającą rejestry. Pole regs.h z kolei zawiera same rejestry 8-bitowe (regs.x rejestry 16-bitowe). Powyżej przypisujemy '9' do AH.
    ?debug  L 13
    mov byte ptr DGROUP:_regs+1,9
   ;
   ;            regs.h.al = znak;
   ;
^ Do AL (młodsza część) wpisujemy wartość 'znak', na początku 'regs'.
    ?debug  L 14
    mov al,byte ptr [bp+8]
    mov byte ptr DGROUP:_regs,al
   ;
   ;            regs.h.bh = strona;
   ;
^ Do pola BH wpisujemy wartość 'strona' (w unii regs).
    ?debug  L 15
    mov al,byte ptr [bp+6]
    mov byte ptr DGROUP:_regs+3,al
   ;
   ;            regs.h.bl = atrybut;
   ;
^ Do pola BL wpisujemy wartość 'atrybut' (w unii regs).
    ?debug  L 16
    mov al,byte ptr [bp+10]
    mov byte ptr DGROUP:_regs+2,al
   ;
   ;            regs.x.cx = ile;
   ;
^ Do pola CX wpisujemy wartość 'ile' (w unii regs), określającą ile razy znak ma być powtórzony.
    ?debug  L 17
    mov ax,word ptr [bp+12]
    mov word ptr DGROUP:_regs+4,ax
   ;
   ;            int86(0x10, &regs, &regs);
   ;
^ Funkcja DOS wywołująca przerwanie 0x10. Do AX idzie offset unii regs, po czym zapisujemy na stosie z pozostałymi rejestrami i parametrami. Wywołana zostaje daleka funkcja _int86. Wracając z niej zwiększamy wskaźnik stosu o 10, ustawiając go na pole przed zapisywaniem stosu.
    ?debug  L 18
    push    ds
    mov ax,offset DGROUP:_regs
    push    ax
    push    ds
    push    ax
    mov ax,16
    push    ax
    call    far ptr _int86
    add sp,10
   ;
   ;    }
   ;
^ Powrót z funkcji wyświetlającej znak na ekranie
    ?debug  L 19
    pop bp
    ret
    ?debug  C E6067374726F6E61080A060000047A6E616B080A+
    ?debug  C 0800000761747279627574080A0A000003696C65+
    ?debug  C 0A0A0C0000
    ?debug  E
    ?debug  E
_napiszZnak endp
   ;
   ;    void interrupt new_1c(void)
   ;
^ Funkcja obsługi przerwania. Na stosie kładzione są wszystkie rejestry w celu ich zabezpieczenia.
    ?debug  L 21
    assume  cs:LAB5_TEXT
_new_1c proc    far
    ?debug  B
    push    ax
    push    bx
    push    cx
    push    dx
    push    es
    push    ds
    push    si
    push    di
    push    bp
    mov bp,DGROUP
    mov ds,bp
    ?debug  B
   ;
   ;    {
   ;            i++;
   ;
^ Inkrementacja zmiennej 'i'.
    ?debug  L 23
    inc word ptr DGROUP:_i
   ;
   ;            znak=(i%10)+'0';
   ;
^ Ustawienie wartości 'znak'. Do AX przypisujemy 'i', do BX wpisujemy 10. Konwertujemy AX do pary rejestrów DX:AX (convert word to double), następnie dzielimy AX przez BX, dodajemy do DL (młodsza część DX) wartość 48 (ASCII – '0'), i do znaku przypisujemy zawartość DL.
    ?debug  L 24
    mov ax,word ptr DGROUP:_i
    mov bx,10
    cwd
    idiv    bx
    add dl,48
    mov byte ptr DGROUP:_znak,dl
   ;
   ;            ptr=MK_FP(0xB800,0);
   ;
^ Ustawienie wskaźnika na początek pamięci obrazu. Pamięć ekranu w trybie
tekstowym rozpoczyna się pod adresem B800:0000.     Wpisanie do starszej części ptr wartości -18432 (czyli wartości 0xB800), a do młodszej części wartości 0. Następnie do AX wpisujemy wartość 0x1F00. Kładziemy AX na stosie. Następnie zmienna znak zostaje przeniesiona do AL, który zostaje rozszerzony do AX (convert byte to word). Zdjęcie DX ze stosu, suma logiczna DX z AX, oraz przypisanie DX do CX, oraz skok bezwarunkowy do etykiety.
    ?debug  L 25
    mov word ptr DGROUP:_ptr+2,-18432
    mov word ptr DGROUP:_ptr,0
    mov ax,7936
    push    ax
    mov al,byte ptr DGROUP:_znak
    cbw
    pop dx
    or  dx,ax
    mov cx,dx
    jmp short @2@114
@2@86:
   ;
   ;            while(x++<5)
   ;            {
   ;                    ptr[x]=0x1F00|znak;
   ;
^ Funkcja odpowiadająca za wypisanie znaku bezpośrednio do pamięci ekranu. Do rejestru AX przypisane zostaje 'x', a następnie rejestr AX zostaje przesunięty w lewo o 1. Następnie BX zostaje rozszerzony do pary rejestrów ES:BX, oraz przypisany zostaje do niego ptr. Następuje dodanie AX do BX, oraz wpisanie do ES:BX wartości CX. Następnie zostaje sprawdzone wyrażenie x++<5. Jeżeli jest mniejsze od 5, następuje skok do etykiety.
    ?debug  L 28
    mov ax,word ptr DGROUP:_x
    shl ax,1
    les bx,dword ptr DGROUP:_ptr
    add bx,ax
    mov word ptr es:[bx],cx
@2@114:
    ?debug  L 26
    mov ax,word ptr DGROUP:_x
    inc word ptr DGROUP:_x
    cmp ax,5
    jl  short @2@86
   ;
   ;            }
   ;            //napiszZnak(0,znak,0,5);
   ;            old_1c();
   ;
^ pushf odkłada na stos zawartość rejestrów znaczników. Wykonuje się wywołanie funkcji obsługi przerwania old_1c.
    ?debug  L 31
    pushf
    call    dword ptr DGROUP:_old_1c
   ;
   ;    }
   ;
^ Następuje zdjęcie wszystkich rejestrów ze stosu (w kolejności odwrotnej niż były kładzione).
    ?debug  L 32
    pop bp
    pop di
    pop si
    pop ds
    pop es
    pop dx
    pop cx
    pop bx
    pop ax
    iret
    ?debug  E
    ?debug  E
_new_1c endp
   ;
   ;    void main(void)
   ;
^ Funkcja main().
    ?debug  L 34
    assume  cs:LAB5_TEXT
_main   proc    far
    ?debug  B
    ?debug  B
   ;
   ;    {
   ;            old_1c = getvect(0x1c);
   ;
^ Linijka odpowiadająca za pobranie wektora przerwań za pomocą funkcji DOS. Do AX zostaje przypisana wartość 28, oraz rejestr wędruje na stos. Wywołana zostaje funkcja getvect. Po powrocie z niej wskaźnik stosu zostaje zwiększony o 2 (przed AX). Funkcja getvect zwraca wartość do AX. Wartość ta zostaje przypisana do młodszej części zmiennej old_1c.
    ?debug  L 36
    mov ax,28
    push    ax
    call    far ptr _getvect
    add sp,2
    mov word ptr DGROUP:_old_1c+2,dx
    mov word ptr DGROUP:_old_1c,ax
   ;
   ;            setvect(0x1c,new_1c);
   ;
^ Funkcja setvect ustawiająca wektor przerwań. Kopiujemy segment new_1c (nazwa naszej funkcji obsługi przerwań) do AX, i kładziemy AX na stos. Podajemy wartość przesunięcia względem początku segmentu new_1c do AX i kładziemy AX na stos. Przypisujemy do AX wartość 28, i AX ponownie wędruje na stos. Następnie zostaje wywołana funkcja DOS setvect, ustawiająca wektor przerwań. Wracając z niej zwiększmy wskaźnik stosu o 6, przesuwając go przed położone wcześniej na stosie zawartości AX.
    ?debug  L 37
    mov ax,seg _new_1c
    push    ax
    mov ax,offset _new_1c
    push    ax
    mov ax,28
    push    ax
    call    far ptr _setvect
    add sp,6
   ;
   ;            keep(0,8192/16);
   ;
^ Kończymy program, zostawiając go 'rezydentem'. Przypisujemy do AX wartość 512, i kładziemy na stos. Przypisujemy do AL '0' i AX ponownie na stos. Następnie wykonuje się wywołanie funkcji DOS-owej 'keep'. Wracając z funkcji wskaźnik stosu zostaje zwiększony o 4.
    ?debug  L 38
    mov ax,512
    push    ax
    mov al,0
    push    ax
    call    far ptr _keep
    add sp,4
   ;
   ;    }
   ;
    ?debug  L 39
    ret
    ?debug  E
    ?debug  E
_main   endp
LAB5_TEXT   ends
_BSS    segment word public 'BSS'
_regs   label   word
    db  16 dup (?)
_znak   label   byte
    db  1 dup (?)
_ptr    label   dword
    db  4 dup (?)
_x  label   word
    db  2 dup (?)
_i  label   word
    db  2 dup (?)
_old_1c label   dword
    db  4 dup (?)
    ?debug  C E9
    ?debug  C FA09000000
_BSS    ends
_DATA   segment word public 'DATA'
s@  label   byte
_DATA   ends
LAB5_TEXT   segment byte public 'CODE'
LAB5_TEXT   ends
    public  _main
    public  _new_1c
    public  _napiszZnak
    public  _regs
    public  _znak
    public  _ptr
    public  _x
    public  _i
    public  _old_1c
    extrn   _setvect:far
    extrn   _getvect:far
    extrn   _keep:far
    extrn   _int86:far
_s@ equ s@
    ?debug  C EA010C
    ?debug  C E31800000023010400
    ?debug  C EC055F6D61696E181800
    ?debug  C E31900000023010700
    ?debug  C EC075F6E65775F3163199800
    ?debug  C E31A00000023010400
    ?debug  C EC0B5F6E617069737A5A6E616B1A1800
    ?debug  C E31B045245475310001F01
    ?debug  C E31C08574F52445245475310001E04
    ?debug  C E31D08425954455245475308001E0D
    ?debug  C EC055F726567731B0000
    ?debug  C EC055F7A6E616B020000
    ?debug  C E31E000400160400
    ?debug  C EC045F7074721E0000
    ?debug  C EC025F78040000
    ?debug  C EC025F69040000
    ?debug  C E32000000023010700
    ?debug  C E31F000400162000
    ?debug  C EC075F6F6C645F31631F0000
    ?debug  C E32100000023010400
    ?debug  C EB085F736574766563742100
    ?debug  C E32400000023010700
    ?debug  C E323000400162400
    ?debug  C E32200000023230400
    ?debug  C EB085F676574766563742200
    ?debug  C E32500000023010400
    ?debug  C EB055F6B6565702500
    ?debug  C E32600000023040400
    ?debug  C EB065F696E7438362600
    ?debug  C E604524547531B07000842595445524547531D07+
    ?debug  C 0008574F5244524547531C0700
    ?debug  C E20001781C0001681DC010000000
    ?debug  C E2000261780A000262780A000263780A00026478+
    ?debug  C 0A000273690A000264690A000563666C61670A00+
    ?debug  C 05666C6167730AC010000000
    ?debug  C E20002616C0800026168080002626C0800026268+
    ?debug  C 080002636C0800026368080002646C0800026468+
    ?debug  C 08C008000000
    end