diff --git a/kernel/trunk/core/syscall.inc b/kernel/trunk/core/syscall.inc
index e004d74a93..2724866b05 100644
--- a/kernel/trunk/core/syscall.inc
+++ b/kernel/trunk/core/syscall.inc
@@ -46,7 +46,7 @@ i40:
 align 32
 sysenter_entry:
 	; ����������� ����
-        mov     esp, [ss:tss._esp0]
+	mov	esp, [ss:tss._esp0]
 	sti
 	push	ebp			; save app esp + 4
 	mov	ebp, [ebp]		; ebp - original ebp
@@ -76,13 +76,13 @@ sysenter_entry:
 align 32
 syscall_entry:
   ;     cli                 syscall clear IF
-        xchg    esp, [ss:tss._esp0]
-        push    ecx
-        lea     ecx, [esp+4]
-        xchg    ecx, [ss:tss._esp0]
-        sti
-        push    ecx
-        mov     ecx, [ecx]
+	xchg	esp, [ss:tss._esp0]
+	push	ecx
+	lea	ecx, [esp+4]
+	xchg	ecx, [ss:tss._esp0]
+	sti
+	push	ecx
+	mov	ecx, [ecx]
 	;------------------
 	pushad
 	cld
@@ -92,8 +92,8 @@ syscall_entry:
 
 	popad
 	;------------------
-        mov     ecx, [ss:esp+4]
-        pop     esp
+	mov	ecx, [ss:esp+4]
+	pop	esp
 	sysret
 iglobal
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -123,59 +123,59 @@ iglobal
       dd 0
       dd 0
       dd 0
-      dd sys_midi                ; 20-ResetMidi and OutputMidi
-      dd sys_setup               ; 21-SetMidiBase,SetKeymap,SetShiftKeymap,.
-      dd sys_settime             ; 22-setting date,time,clock and alarm-clock
+      dd sys_midi		 ; 20-ResetMidi and OutputMidi
+      dd sys_setup		 ; 21-SetMidiBase,SetKeymap,SetShiftKeymap,.
+      dd sys_settime		 ; 22-setting date,time,clock and alarm-clock
       dd 0
-      dd syscall_cdaudio         ; 24-PlayCdTrack,StopCd and GetCdPlaylist
-      dd sys_sb16                ; 25-SetSb16
-      dd sys_getsetup            ; 26-GetMidiBase,GetKeymap,GetShiftKeymap,.
+      dd syscall_cdaudio	 ; 24-PlayCdTrack,StopCd and GetCdPlaylist
+      dd sys_sb16		 ; 25-SetSb16
+      dd sys_getsetup		 ; 26-GetMidiBase,GetKeymap,GetShiftKeymap,.
       dd 0
-      dd sys_sb16II              ; 28-SetSb16
+      dd sys_sb16II		 ; 28-SetSb16
       dd 0
-      dd sys_current_directory   ; 30-Get/SetCurrentDirectory
+      dd sys_current_directory	 ; 30-Get/SetCurrentDirectory
       dd 0
       dd syscall_delramdiskfile  ; 32-DelRamdiskFile
       dd syscall_writeramdiskfile; 33-WriteRamdiskFile
       dd 0
       dd 0
       dd 0
-      dd readmousepos            ; 37-GetMousePosition_ScreenRelative,.
-      dd syscall_drawline        ; 38-DrawLine
-      dd sys_getbackground       ; 39-GetBackgroundSize,ReadBgrData,.
+      dd readmousepos		 ; 37-GetMousePosition_ScreenRelative,.
+      dd syscall_drawline	 ; 38-DrawLine
+      dd sys_getbackground	 ; 39-GetBackgroundSize,ReadBgrData,.
       dd 0
-      dd syscall_getirqowner     ; 41-GetIrqOwner
-      dd get_irq_data            ; 42-ReadIrqData
-      dd sys_outport             ; 43-SendDeviceData
-      dd sys_programirq          ; 44-ProgramIrqs
-      dd reserve_free_irq        ; 45-ReserveIrq and FreeIrq
+      dd 0
+      dd	     ; 42-ReadIrqData
+      dd sys_outport		 ; 43-SendDeviceData
+      dd sys_programirq 	 ; 44-ProgramIrqs
+      dd reserve_free_irq	 ; 45-ReserveIrq and FreeIrq
       dd syscall_reserveportarea ; 46-ReservePortArea and FreePortArea
-      dd display_number          ; 47-WriteNum
-      dd display_settings        ; 48-SetRedrawType and SetButtonType
-      dd sys_apm                 ; 49-Advanced Power Management (APM)
-      dd random_shaped_window    ; 50-Window shape & scale
-      dd syscall_threads         ; 51-Threads
-      dd stack_driver_stat       ; 52-Stack driver status
-      dd socket                  ; 53-Socket interface
+      dd display_number 	 ; 47-WriteNum
+      dd display_settings	 ; 48-SetRedrawType and SetButtonType
+      dd sys_apm		 ; 49-Advanced Power Management (APM)
+      dd random_shaped_window	 ; 50-Window shape & scale
+      dd syscall_threads	 ; 51-Threads
+      dd stack_driver_stat	 ; 52-Stack driver status
+      dd socket 		 ; 53-Socket interface
       dd 0
-      dd sound_interface         ; 55-Sound interface
+      dd sound_interface	 ; 55-Sound interface
       dd 0
-      dd sys_pcibios             ; 57-PCI BIOS32
-      dd file_system             ; 58-Common file system interface
+      dd sys_pcibios		 ; 57-PCI BIOS32
+      dd file_system		 ; 58-Common file system interface
       dd 0
-      dd sys_IPC                 ; 60-Inter Process Communication
-      dd sys_gs                  ; 61-Direct graphics access
-      dd sys_pci                 ; 62-PCI functions
-      dd sys_msg_board           ; 63-System message board
-      dd sys_resize_app_memory   ; 64-Resize application memory usage
+      dd sys_IPC		 ; 60-Inter Process Communication
+      dd sys_gs 		 ; 61-Direct graphics access
+      dd sys_pci		 ; 62-PCI functions
+      dd sys_msg_board		 ; 63-System message board
+      dd sys_resize_app_memory	 ; 64-Resize application memory usage
       dd syscall_putimage_palette; 65-PutImagePalette
-      dd sys_process_def         ; 66-Process definitions - keyboard
-      dd sys_window_move         ; 67-Window move or resize
-      dd new_services            ; 68-Some internal services
-      dd sys_debug_services      ; 69-Debug
-      dd file_system_lfn         ; 70-Common file system interface, version 2
+      dd sys_process_def	 ; 66-Process definitions - keyboard
+      dd sys_window_move	 ; 67-Window move or resize
+      dd new_services		 ; 68-Some internal services
+      dd sys_debug_services	 ; 69-Debug
+      dd file_system_lfn	 ; 70-Common file system interface, version 2
       dd syscall_windowsettings  ; 71-Window settings
-      dd sys_sendwindowmsg       ; 72-Send window message
+      dd sys_sendwindowmsg	 ; 72-Send window message
 
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;; NEW SYSTEM FUNCTIONS TABLE ;;
@@ -183,80 +183,80 @@ iglobal
   align 4
   servetable2:
 
-      dd sys_drawwindow          ; 0-DrawWindow
-      dd syscall_setpixel        ; 1-SetPixel
-      dd sys_getkey              ; 2-GetKey
-      dd sys_clock               ; 3-GetTime
-      dd syscall_writetext       ; 4-WriteText
-      dd delay_hs                ; 5-DelayHs
+      dd sys_drawwindow 	 ; 0-DrawWindow
+      dd syscall_setpixel	 ; 1-SetPixel
+      dd sys_getkey		 ; 2-GetKey
+      dd sys_clock		 ; 3-GetTime
+      dd syscall_writetext	 ; 4-WriteText
+      dd delay_hs		 ; 5-DelayHs
       dd syscall_openramdiskfile ; 6-OpenRamdiskFile
-      dd syscall_putimage        ; 7-PutImage
-      dd sys_button              ; 8-DefineButton
-      dd sys_cpuusage            ; 9-GetProcessInfo
-      dd sys_waitforevent        ; 10-WaitForEvent
-      dd sys_getevent            ; 11-CheckForEvent
-      dd sys_redrawstat          ; 12-BeginDraw and EndDraw
-      dd syscall_drawrect        ; 13-DrawRect
-      dd syscall_getscreensize   ; 14-GetScreenSize
-      dd sys_background          ; 15-bgr
-      dd sys_cachetodiskette     ; 16-FlushFloppyCache
-      dd sys_getbutton           ; 17-GetButton
-      dd sys_system              ; 18-System Services
-      dd paleholder              ; 19-reserved
-      dd cross_order             ; 20-ResetMidi and OutputMidi
-      dd cross_order             ; 21-SetMidiBase,SetKeymap,SetShiftKeymap,.
-      dd cross_order             ; 22-setting date,time,clock and alarm-clock
+      dd syscall_putimage	 ; 7-PutImage
+      dd sys_button		 ; 8-DefineButton
+      dd sys_cpuusage		 ; 9-GetProcessInfo
+      dd sys_waitforevent	 ; 10-WaitForEvent
+      dd sys_getevent		 ; 11-CheckForEvent
+      dd sys_redrawstat 	 ; 12-BeginDraw and EndDraw
+      dd syscall_drawrect	 ; 13-DrawRect
+      dd syscall_getscreensize	 ; 14-GetScreenSize
+      dd sys_background 	 ; 15-bgr
+      dd sys_cachetodiskette	 ; 16-FlushFloppyCache
+      dd sys_getbutton		 ; 17-GetButton
+      dd sys_system		 ; 18-System Services
+      dd paleholder		 ; 19-reserved
+      dd cross_order		 ; 20-ResetMidi and OutputMidi
+      dd cross_order		 ; 21-SetMidiBase,SetKeymap,SetShiftKeymap,.
+      dd cross_order		 ; 22-setting date,time,clock and alarm-clock
       dd sys_wait_event_timeout  ; 23-TimeOutWaitForEvent
-      dd cross_order             ; 24-PlayCdTrack,StopCd and GetCdPlaylist
-      dd cross_order             ; 25-SetSb16
-      dd cross_order             ; 26-GetMidiBase,GetKeymap,GetShiftKeymap,.
-      dd undefined_syscall       ; 27-reserved
-      dd cross_order             ; 28-SetSb16
-      dd sys_date                ; 29-GetDate
-      dd cross_order             ; 30-Get/SetCurrentDirectory
-      dd undefined_syscall       ; 31-reserved
-      dd cross_order             ; 32-DelRamdiskFile
-      dd cross_order             ; 33-WriteRamdiskFile
-      dd undefined_syscall       ; 34-reserved
-      dd syscall_getpixel        ; 35-GetPixel
-      dd undefined_syscall       ; 36-reserved
-      dd cross_order             ; 37-GetMousePosition_ScreenRelative,.
-      dd cross_order             ; 38-DrawLine
-      dd cross_order             ; 39-GetBackgroundSize,ReadBgrData,.
-      dd set_app_param           ; 40-WantEvents
-      dd cross_order             ; 41-GetIrqOwner
-      dd cross_order             ; 42-ReadIrqData
-      dd cross_order             ; 43-SendDeviceData
-      dd cross_order             ; 44-ProgramIrqs
-      dd cross_order             ; 45-ReserveIrq and FreeIrq
-      dd cross_order             ; 46-ReservePortArea and FreePortArea
-      dd cross_order             ; 47-WriteNum
-      dd cross_order             ; 48-SetRedrawType and SetButtonType
-      dd cross_order             ; 49-Advanced Power Management (APM)
-      dd cross_order             ; 50-Window shape & scale
-      dd cross_order             ; 51-Threads
-      dd cross_order             ; 52-Stack driver status
-      dd cross_order             ; 53-Socket interface
-      dd undefined_syscall       ; 54-reserved
-      dd cross_order             ; 55-Sound interface
-      dd undefined_syscall       ; 56-reserved
-      dd cross_order             ; 57-PCI BIOS32
-      dd cross_order             ; 58-Common file system interface
-      dd undefined_syscall       ; 59-reserved
-      dd cross_order             ; 60-Inter Process Communication
-      dd cross_order             ; 61-Direct graphics access
-      dd cross_order             ; 62-PCI functions
-      dd cross_order             ; 63-System message board
-      dd cross_order             ; 64-Resize application memory usage
-      dd cross_order             ; 65-PutImagePalette
-      dd cross_order             ; 66-Process definitions - keyboard
-      dd cross_order             ; 67-Window move or resize
-      dd cross_order             ; 68-Some internal services
-      dd cross_order             ; 69-Debug
-      dd cross_order             ; 70-Common file system interface, version 2
-      dd cross_order             ; 71-Window settings
-      dd cross_order             ; 72-Send window message
+      dd cross_order		 ; 24-PlayCdTrack,StopCd and GetCdPlaylist
+      dd cross_order		 ; 25-SetSb16
+      dd cross_order		 ; 26-GetMidiBase,GetKeymap,GetShiftKeymap,.
+      dd undefined_syscall	 ; 27-reserved
+      dd cross_order		 ; 28-SetSb16
+      dd sys_date		 ; 29-GetDate
+      dd cross_order		 ; 30-Get/SetCurrentDirectory
+      dd undefined_syscall	 ; 31-reserved
+      dd cross_order		 ; 32-DelRamdiskFile
+      dd cross_order		 ; 33-WriteRamdiskFile
+      dd undefined_syscall	 ; 34-reserved
+      dd syscall_getpixel	 ; 35-GetPixel
+      dd undefined_syscall	 ; 36-reserved
+      dd cross_order		 ; 37-GetMousePosition_ScreenRelative,.
+      dd cross_order		 ; 38-DrawLine
+      dd cross_order		 ; 39-GetBackgroundSize,ReadBgrData,.
+      dd set_app_param		 ; 40-WantEvents
+      dd syscall_getirqowner	 ; 41-GetIrqOwner
+      dd get_irq_data		 ; 42-ReadIrqData
+      dd cross_order		 ; 43-SendDeviceData
+      dd cross_order		 ; 44-ProgramIrqs
+      dd cross_order		 ; 45-ReserveIrq and FreeIrq
+      dd cross_order		 ; 46-ReservePortArea and FreePortArea
+      dd cross_order		 ; 47-WriteNum
+      dd cross_order		 ; 48-SetRedrawType and SetButtonType
+      dd cross_order		 ; 49-Advanced Power Management (APM)
+      dd cross_order		 ; 50-Window shape & scale
+      dd cross_order		 ; 51-Threads
+      dd cross_order		 ; 52-Stack driver status
+      dd cross_order		 ; 53-Socket interface
+      dd undefined_syscall	 ; 54-reserved
+      dd cross_order		 ; 55-Sound interface
+      dd undefined_syscall	 ; 56-reserved
+      dd cross_order		 ; 57-PCI BIOS32
+      dd cross_order		 ; 58-Common file system interface
+      dd undefined_syscall	 ; 59-reserved
+      dd cross_order		 ; 60-Inter Process Communication
+      dd cross_order		 ; 61-Direct graphics access
+      dd cross_order		 ; 62-PCI functions
+      dd cross_order		 ; 63-System message board
+      dd cross_order		 ; 64-Resize application memory usage
+      dd cross_order		 ; 65-PutImagePalette
+      dd cross_order		 ; 66-Process definitions - keyboard
+      dd cross_order		 ; 67-Window move or resize
+      dd cross_order		 ; 68-Some internal services
+      dd cross_order		 ; 69-Debug
+      dd cross_order		 ; 70-Common file system interface, version 2
+      dd cross_order		 ; 71-Window settings
+      dd cross_order		 ; 72-Send window message
 	times 255 - ( ($-servetable2) /4 )  dd undefined_syscall
-      dd sys_end                 ; -1-end application
+      dd sys_end		 ; -1-end application
    
 endg
diff --git a/kernel/trunk/kernel.asm b/kernel/trunk/kernel.asm
index ed98ca6c95..8d1accabfb 100644
--- a/kernel/trunk/kernel.asm
+++ b/kernel/trunk/kernel.asm
@@ -65,14 +65,14 @@ include "kglobals.inc"
 include "lang.inc"
 
 include "const.inc"
-max_processes    equ   255
-tss_step         equ   (128+8192) ; tss & i/o - 65535 ports, * 256=557056*4
+max_processes	 equ   255
+tss_step	 equ   (128+8192) ; tss & i/o - 65535 ports, * 256=557056*4
 
 
-os_stack       equ  (os_data_l-gdts)    ; GDTs
+os_stack       equ  (os_data_l-gdts)	; GDTs
 os_code        equ  (os_code_l-gdts)
 graph_data     equ  (3+graph_data_l-gdts)
-tss0           equ  (tss0_l-gdts)
+tss0	       equ  (tss0_l-gdts)
 app_code       equ  (3+app_code_l-gdts)
 app_data       equ  (3+app_data_l-gdts)
 pci_code_sel   equ  (pci_code_32-gdts)
@@ -110,8 +110,8 @@ pci_data_sel   equ  (pci_data_32-gdts)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 use16
-                  org   0x0
-                  jmp   start_of_code
+		  org	0x0
+		  jmp	start_of_code
 
 version db    'Kolibri OS  version 0.7.1.0      ',13,10,13,10,0
 
@@ -122,10 +122,10 @@ if lang eq en
 include "boot/booteng.inc"     ; english system boot messages
 else if lang eq ru
 include "boot/bootru.inc"      ; russian system boot messages
-include "boot/ru.inc"          ; Russian font
+include "boot/ru.inc"	       ; Russian font
 else if lang eq et
 include "boot/bootet.inc"      ; estonian system boot messages
-include "boot/et.inc"          ; Estonian font
+include "boot/et.inc"	       ; Estonian font
 else
 include "boot/bootge.inc"      ; german system boot messages
 end if
@@ -143,58 +143,58 @@ include "detect/biosdisk.inc"
 
 ; CR0 Flags - Protected mode and Paging
 
-        mov ecx, CR0_PE
+	mov ecx, CR0_PE
 
 ; Enabling 32 bit protected mode
 
-        sidt    [cs:old_ints_h]
+	sidt	[cs:old_ints_h]
 
-        cli                             ; disable all irqs
-        cld
-        mov     al,255                  ; mask all irqs
-        out     0xa1,al
-        out     0x21,al
-   l.5: in      al, 0x64                ; Enable A20
-        test    al, 2
-        jnz     l.5
-        mov     al, 0xD1
-        out     0x64, al
-   l.6: in      al, 0x64
-        test    al, 2
-        jnz     l.6
-        mov     al, 0xDF
-        out     0x60, al
-   l.7: in      al, 0x64
-        test    al, 2
-        jnz     l.7
-        mov     al, 0xFF
-        out     0x64, al
+	cli				; disable all irqs
+	cld
+	mov	al,255			; mask all irqs
+	out	0xa1,al
+	out	0x21,al
+   l.5: in	al, 0x64		; Enable A20
+	test	al, 2
+	jnz	l.5
+	mov	al, 0xD1
+	out	0x64, al
+   l.6: in	al, 0x64
+	test	al, 2
+	jnz	l.6
+	mov	al, 0xDF
+	out	0x60, al
+   l.7: in	al, 0x64
+	test	al, 2
+	jnz	l.7
+	mov	al, 0xFF
+	out	0x64, al
 
-        lgdt    [cs:tmp_gdt]            ; Load GDT
-        mov     eax, cr0                ; protected mode
-        or      eax, ecx
-        and     eax, 10011111b *65536*256 + 0xffffff ; caching enabled
-        mov     cr0, eax
-        jmp     pword os_code:B32       ; jmp to enable 32 bit mode
+	lgdt	[cs:tmp_gdt]		; Load GDT
+	mov	eax, cr0		; protected mode
+	or	eax, ecx
+	and	eax, 10011111b *65536*256 + 0xffffff ; caching enabled
+	mov	cr0, eax
+	jmp	pword os_code:B32	; jmp to enable 32 bit mode
 
 align 8
 tmp_gdt:
 
-        dw     23
-        dd     tmp_gdt+0x10000
-        dw     0
+	dw     23
+	dd     tmp_gdt+0x10000
+	dw     0
 
-        dw     0xffff
-        dw     0x0000
-        db     0x00
-        dw     11011111b *256 +10011010b
-        db     0x00
+	dw     0xffff
+	dw     0x0000
+	db     0x00
+	dw     11011111b *256 +10011010b
+	db     0x00
 
-        dw     0xffff
-        dw     0x0000
-        db     0x00
-        dw     11011111b *256 +10010010b
-        db     0x00
+	dw     0xffff
+	dw     0x0000
+	db     0x00
+	dw     11011111b *256 +10010010b
+	db     0x00
 
 include "data16.inc"
 
@@ -203,65 +203,65 @@ org $+0x10000
 
 align 4
 B32:
-           mov   ax,os_stack       ; Selector for os
-           mov   ds,ax
-           mov   es,ax
-           mov   fs,ax
-           mov   gs,ax
-           mov   ss,ax
-           mov   esp,0x3ec00       ; Set stack
+	   mov	 ax,os_stack	   ; Selector for os
+	   mov	 ds,ax
+	   mov	 es,ax
+	   mov	 fs,ax
+	   mov	 gs,ax
+	   mov	 ss,ax
+	   mov	 esp,0x3ec00	   ; Set stack
 
 ; CLEAR 0x280000 - HEAP_BASE
 
-           xor   eax,eax
-           mov   edi,0x280000
-           mov   ecx,(HEAP_BASE-OS_BASE-0x280000) / 4
-           cld
-           rep   stosd
+	   xor	 eax,eax
+	   mov	 edi,0x280000
+	   mov	 ecx,(HEAP_BASE-OS_BASE-0x280000) / 4
+	   cld
+	   rep	 stosd
 
-           mov   edi,0x40000
-           mov   ecx,(0x90000-0x40000)/4
-           rep   stosd
+	   mov	 edi,0x40000
+	   mov	 ecx,(0x90000-0x40000)/4
+	   rep	 stosd
 
 ; CLEAR KERNEL UNDEFINED GLOBALS
-           mov   edi, endofcode-OS_BASE
-           mov   ecx, (uglobals_size/4)+4
-           rep   stosd
+	   mov	 edi, endofcode-OS_BASE
+	   mov	 ecx, (uglobals_size/4)+4
+	   rep	 stosd
 
 ; SAVE & CLEAR 0-0xffff
 
-           xor esi, esi
-           mov   edi,0x2F0000
-           mov   ecx,0x10000 / 4
-           rep   movsd
-           xor edi, edi
-           mov   ecx,0x10000 / 4
-           rep   stosd
+	   xor esi, esi
+	   mov	 edi,0x2F0000
+	   mov	 ecx,0x10000 / 4
+	   rep	 movsd
+	   xor edi, edi
+	   mov	 ecx,0x10000 / 4
+	   rep	 stosd
 
-           call test_cpu
-           bts [cpu_caps-OS_BASE], CAPS_TSC     ;force use rdtsc
+	   call test_cpu
+	   bts [cpu_caps-OS_BASE], CAPS_TSC	;force use rdtsc
 
-           call init_BIOS32
+	   call init_BIOS32
 ; MEMORY MODEL
-           call mem_test
-           call init_mem
-           call init_page_map
+	   call mem_test
+	   call init_mem
+	   call init_page_map
 
 ; ENABLE PAGING
 
-           mov eax, sys_pgdir-OS_BASE
-           mov cr3, eax
+	   mov eax, sys_pgdir-OS_BASE
+	   mov cr3, eax
 
-           mov eax,cr0
-           or eax,CR0_PG+CR0_WP
-           mov cr0,eax
+	   mov eax,cr0
+	   or eax,CR0_PG+CR0_WP
+	   mov cr0,eax
 
-           lgdt [gdts]
-           jmp pword os_code:high_code
+	   lgdt [gdts]
+	   jmp pword os_code:high_code
 
 align 4
-bios32_entry    dd ?
-tmp_page_tabs   dd ?
+bios32_entry	dd ?
+tmp_page_tabs	dd ?
 
 use16
 org $-0x10000
@@ -277,45 +277,45 @@ org OS_BASE+$
 
 align 4
 high_code:
-           mov ax,os_stack
-           mov bx,app_data
-           mov ss,ax
-           add  esp, OS_BASE
+	   mov ax,os_stack
+	   mov bx,app_data
+	   mov ss,ax
+	   add	esp, OS_BASE
 
-           mov ds,bx
-           mov es,bx
-           mov fs,bx
-           mov gs,bx
+	   mov ds,bx
+	   mov es,bx
+	   mov fs,bx
+	   mov gs,bx
 
-           bt [cpu_caps], CAPS_PGE
-           jnc @F
+	   bt [cpu_caps], CAPS_PGE
+	   jnc @F
 
-           or dword [sys_pgdir+(OS_BASE shr 20)], PG_GLOBAL
+	   or dword [sys_pgdir+(OS_BASE shr 20)], PG_GLOBAL
 
-           mov ebx, cr4
-           or ebx, CR4_PGE
-           mov cr4, ebx
+	   mov ebx, cr4
+	   or ebx, CR4_PGE
+	   mov cr4, ebx
 @@:
-           xor eax, eax
-           mov dword [sys_pgdir], eax
-           mov dword [sys_pgdir+4], eax
+	   xor eax, eax
+	   mov dword [sys_pgdir], eax
+	   mov dword [sys_pgdir+4], eax
 
-           mov eax, cr3
-           mov cr3, eax           ; flush TLB
+	   mov eax, cr3
+	   mov cr3, eax 	  ; flush TLB
 
 ; SAVE REAL MODE VARIABLES
-        mov     ax, [BOOT_VAR + 0x9031]
-        mov     [IDEContrRegsBaseAddr], ax
+	mov	ax, [BOOT_VAR + 0x9031]
+	mov	[IDEContrRegsBaseAddr], ax
 ; --------------- APM ---------------------
 
 ; init selectors
-    mov ebx,    [BOOT_VAR+0x9040]              ; offset of APM entry point
+    mov ebx,	[BOOT_VAR+0x9040]	       ; offset of APM entry point
     movzx eax, word [BOOT_VAR+0x9050] ; real-mode segment base address of
-                                      ; protected-mode 32-bit code segment
+				      ; protected-mode 32-bit code segment
     movzx ecx, word [BOOT_VAR+0x9052] ; real-mode segment base address of
-                                      ; protected-mode 16-bit code segment
+				      ; protected-mode 16-bit code segment
     movzx edx, word [BOOT_VAR+0x9054] ; real-mode segment base address of
-                                      ; protected-mode 16-bit data segment
+				      ; protected-mode 16-bit data segment
 
     shl    eax, 4
     mov    [dword apm_code_32 + 2], ax
@@ -340,96 +340,96 @@ high_code:
 ; -----------------------------------------
 ;        movzx eax,byte [BOOT_VAR+0x9010]  ; mouse port
 ;        mov   [0xF604],byte 1  ;al
-        mov     al, [BOOT_VAR+0x901F]   ; DMA access
-        mov     [allow_dma_access], al
-        mov   al,[BOOT_VAR+0x9000]        ; bpp
-        mov   [ScreenBPP],al
-        movzx eax,word [BOOT_VAR+0x900A]  ; X max
-        dec   eax
-        mov   [ScreenWidth],eax
-        mov   [screen_workarea.right],eax
-        movzx eax,word [BOOT_VAR+0x900C]  ; Y max
-        dec   eax
-        mov   [ScreenHeight],eax
-        mov   [screen_workarea.bottom],eax
-        movzx eax,word [BOOT_VAR+0x9008]  ; screen mode
-        mov   [SCR_MODE],eax
-        mov   eax,[BOOT_VAR+0x9014]       ; Vesa 1.2 bnk sw add
-        mov   [BANK_SWITCH],eax
-        mov   [BytesPerScanLine],word 640*4         ; Bytes PerScanLine
-        cmp   [SCR_MODE],word 0x13          ; 320x200
-        je    @f
-        cmp   [SCR_MODE],word 0x12          ; VGA 640x480
-        je    @f
-        mov   ax,[BOOT_VAR+0x9001]        ; for other modes
-        mov   [BytesPerScanLine],ax
+	mov	al, [BOOT_VAR+0x901F]	; DMA access
+	mov	[allow_dma_access], al
+	mov   al,[BOOT_VAR+0x9000]	  ; bpp
+	mov   [ScreenBPP],al
+	movzx eax,word [BOOT_VAR+0x900A]  ; X max
+	dec   eax
+	mov   [ScreenWidth],eax
+	mov   [screen_workarea.right],eax
+	movzx eax,word [BOOT_VAR+0x900C]  ; Y max
+	dec   eax
+	mov   [ScreenHeight],eax
+	mov   [screen_workarea.bottom],eax
+	movzx eax,word [BOOT_VAR+0x9008]  ; screen mode
+	mov   [SCR_MODE],eax
+	mov   eax,[BOOT_VAR+0x9014]	  ; Vesa 1.2 bnk sw add
+	mov   [BANK_SWITCH],eax
+	mov   [BytesPerScanLine],word 640*4	    ; Bytes PerScanLine
+	cmp   [SCR_MODE],word 0x13	    ; 320x200
+	je    @f
+	cmp   [SCR_MODE],word 0x12	    ; VGA 640x480
+	je    @f
+	mov   ax,[BOOT_VAR+0x9001]	  ; for other modes
+	mov   [BytesPerScanLine],ax
 @@:
-        mov     esi, BOOT_VAR+0x9080
-        movzx   ecx, byte [esi-1]
-        mov     [NumBiosDisks], ecx
-        mov     edi, BiosDisksData
-        rep     movsd
+	mov	esi, BOOT_VAR+0x9080
+	movzx	ecx, byte [esi-1]
+	mov	[NumBiosDisks], ecx
+	mov	edi, BiosDisksData
+	rep	movsd
 
 ; GRAPHICS ADDRESSES
 
-        mov     byte [BOOT_VAR+0x901e],0x0
-        mov     eax,[BOOT_VAR+0x9018]
-        mov     [LFBAddress],eax
+	mov	byte [BOOT_VAR+0x901e],0x0
+	mov	eax,[BOOT_VAR+0x9018]
+	mov	[LFBAddress],eax
 
-        cmp     [SCR_MODE],word 0100000000000000b
-        jge     setvesa20
-        cmp     [SCR_MODE],word 0x13
-        je      v20ga32
-        mov     [PUTPIXEL],dword Vesa12_putpixel24  ; Vesa 1.2
-        mov     [GETPIXEL],dword Vesa12_getpixel24
-        cmp     [ScreenBPP],byte 24
-        jz      ga24
-        mov     [PUTPIXEL],dword Vesa12_putpixel32
-        mov     [GETPIXEL],dword Vesa12_getpixel32
+	cmp	[SCR_MODE],word 0100000000000000b
+	jge	setvesa20
+	cmp	[SCR_MODE],word 0x13
+	je	v20ga32
+	mov	[PUTPIXEL],dword Vesa12_putpixel24  ; Vesa 1.2
+	mov	[GETPIXEL],dword Vesa12_getpixel24
+	cmp	[ScreenBPP],byte 24
+	jz	ga24
+	mov	[PUTPIXEL],dword Vesa12_putpixel32
+	mov	[GETPIXEL],dword Vesa12_getpixel32
       ga24:
-        jmp     v20ga24
+	jmp	v20ga24
       setvesa20:
-        mov     [PUTPIXEL],dword Vesa20_putpixel24  ; Vesa 2.0
-        mov     [GETPIXEL],dword Vesa20_getpixel24
-        cmp     [ScreenBPP],byte 24
-        jz      v20ga24
+	mov	[PUTPIXEL],dword Vesa20_putpixel24  ; Vesa 2.0
+	mov	[GETPIXEL],dword Vesa20_getpixel24
+	cmp	[ScreenBPP],byte 24
+	jz	v20ga24
       v20ga32:
-        mov     [PUTPIXEL],dword Vesa20_putpixel32
-        mov     [GETPIXEL],dword Vesa20_getpixel32
+	mov	[PUTPIXEL],dword Vesa20_putpixel32
+	mov	[GETPIXEL],dword Vesa20_getpixel32
       v20ga24:
-        cmp     [SCR_MODE],word 0x12                ; 16 C VGA 640x480
-        jne     no_mode_0x12
-        mov     [PUTPIXEL],dword VGA_putpixel
-        mov     [GETPIXEL],dword Vesa20_getpixel32
+	cmp	[SCR_MODE],word 0x12		    ; 16 C VGA 640x480
+	jne	no_mode_0x12
+	mov	[PUTPIXEL],dword VGA_putpixel
+	mov	[GETPIXEL],dword Vesa20_getpixel32
       no_mode_0x12:
 
 ; -------- Fast System Call init ----------
 ; Intel SYSENTER/SYSEXIT (AMD CPU support it too)
-           bt [cpu_caps], CAPS_SEP
-           jnc .SEnP   ; SysEnter not Present
-           xor edx, edx
-           mov ecx, MSR_SYSENTER_CS
-           mov eax, os_code
-           wrmsr
-           mov ecx, MSR_SYSENTER_ESP
+	   bt [cpu_caps], CAPS_SEP
+	   jnc .SEnP   ; SysEnter not Present
+	   xor edx, edx
+	   mov ecx, MSR_SYSENTER_CS
+	   mov eax, os_code
+	   wrmsr
+	   mov ecx, MSR_SYSENTER_ESP
 ;           mov eax, sysenter_stack ; Check it
-           xor     eax, eax
-           wrmsr
-           mov ecx, MSR_SYSENTER_EIP
-           mov eax, sysenter_entry
-           wrmsr
+	   xor	   eax, eax
+	   wrmsr
+	   mov ecx, MSR_SYSENTER_EIP
+	   mov eax, sysenter_entry
+	   wrmsr
 .SEnP:
 ; AMD SYSCALL/SYSRET
-           cmp byte[cpu_vendor], 'A'
-           jne .noSYSCALL
-           mov eax, 0x80000001
-           cpuid
-           test edx, 0x800  ; bit_11 - SYSCALL/SYSRET support
-           jz .noSYSCALL
-           mov ecx, MSR_AMD_EFER
-           rdmsr
-           or eax, 1   ; bit_0 - System Call Extension (SCE)
-           wrmsr
+	   cmp byte[cpu_vendor], 'A'
+	   jne .noSYSCALL
+	   mov eax, 0x80000001
+	   cpuid
+	   test edx, 0x800  ; bit_11 - SYSCALL/SYSRET support
+	   jz .noSYSCALL
+	   mov ecx, MSR_AMD_EFER
+	   rdmsr
+	   or eax, 1   ; bit_0 - System Call Extension (SCE)
+	   wrmsr
 
 	; !!!! It`s dirty hack, fix it !!!
 	; Bits of EDX :
@@ -438,140 +438,140 @@ high_code:
 	; Bit 15�0 During the SYSCALL instruction, this field is copied into the CS register
 	;  and the contents of this field, plus 8, are copied into the SS register.
 
-	; mov	edx, (os_code + 16) * 65536 + os_code
-           mov edx, 0x1B0008
+	; mov   edx, (os_code + 16) * 65536 + os_code
+	   mov edx, 0x1B0008
 
-           mov eax, syscall_entry
-           mov ecx, MSR_AMD_STAR
-           wrmsr
+	   mov eax, syscall_entry
+	   mov ecx, MSR_AMD_STAR
+	   wrmsr
 .noSYSCALL:
 ; -----------------------------------------
 
 ; LOAD IDT
 
-           call build_interrupt_table
-           lidt [idtreg]
+	   call build_interrupt_table
+	   lidt [idtreg]
 
-           call init_kernel_heap
-           stdcall kernel_alloc, RING0_STACK_SIZE+512
-           mov [os_stack_seg], eax
+	   call init_kernel_heap
+	   stdcall kernel_alloc, RING0_STACK_SIZE+512
+	   mov [os_stack_seg], eax
 
-           lea esp, [eax+RING0_STACK_SIZE]
+	   lea esp, [eax+RING0_STACK_SIZE]
 
-           mov [tss._ss0], os_stack
-           mov [tss._esp0], esp
-           mov [tss._esp], esp
-           mov [tss._cs],os_code
-           mov [tss._ss],os_stack
-           mov [tss._ds],app_data
-           mov [tss._es],app_data
-           mov [tss._fs],app_data
-           mov [tss._gs],app_data
-           mov [tss._io],128
+	   mov [tss._ss0], os_stack
+	   mov [tss._esp0], esp
+	   mov [tss._esp], esp
+	   mov [tss._cs],os_code
+	   mov [tss._ss],os_stack
+	   mov [tss._ds],app_data
+	   mov [tss._es],app_data
+	   mov [tss._fs],app_data
+	   mov [tss._gs],app_data
+	   mov [tss._io],128
 ;Add IO access table - bit array of permitted ports
-           mov edi, tss._io_map_0
-           xor eax, eax
-           not eax
-           mov ecx, 8192/4
-           rep stosd                 ; access to 4096*8=65536 ports
+	   mov edi, tss._io_map_0
+	   xor eax, eax
+	   not eax
+	   mov ecx, 8192/4
+	   rep stosd		     ; access to 4096*8=65536 ports
 
-           mov  ax,tss0
-           ltr  ax
+	   mov	ax,tss0
+	   ltr	ax
 
-           mov [LFBSize], 0x800000
-           call init_LFB
-           call init_fpu
-           call init_malloc
+	   mov [LFBSize], 0x800000
+	   call init_LFB
+	   call init_fpu
+	   call init_malloc
 
-           stdcall alloc_kernel_space, 0x51000
-           mov [default_io_map], eax
+	   stdcall alloc_kernel_space, 0x51000
+	   mov [default_io_map], eax
 
-           add eax, 0x2000
-           mov [ipc_tmp], eax
-           mov ebx, 0x1000
+	   add eax, 0x2000
+	   mov [ipc_tmp], eax
+	   mov ebx, 0x1000
 
-           add eax, 0x40000
-           mov [proc_mem_map], eax
+	   add eax, 0x40000
+	   mov [proc_mem_map], eax
 
-           add eax, 0x8000
-           mov [proc_mem_pdir], eax
+	   add eax, 0x8000
+	   mov [proc_mem_pdir], eax
 
-           add eax, ebx
-           mov [proc_mem_tab], eax
+	   add eax, ebx
+	   mov [proc_mem_tab], eax
 
-           add eax, ebx
-           mov [tmp_task_pdir], eax
+	   add eax, ebx
+	   mov [tmp_task_pdir], eax
 
-           add eax, ebx
-           mov [tmp_task_ptab], eax
+	   add eax, ebx
+	   mov [tmp_task_ptab], eax
 
-           add eax, ebx
-           mov [ipc_pdir], eax
+	   add eax, ebx
+	   mov [ipc_pdir], eax
 
-           add eax, ebx
-           mov [ipc_ptab], eax
+	   add eax, ebx
+	   mov [ipc_ptab], eax
 
-           stdcall kernel_alloc, (unpack.LZMA_BASE_SIZE+(unpack.LZMA_LIT_SIZE shl \
-                                 (unpack.lc+unpack.lp)))*4
+	   stdcall kernel_alloc, (unpack.LZMA_BASE_SIZE+(unpack.LZMA_LIT_SIZE shl \
+				 (unpack.lc+unpack.lp)))*4
 
-           mov [unpack.p], eax
+	   mov [unpack.p], eax
 
-           call init_events
-           mov eax, srv.fd-SRV_FD_OFFSET
-           mov [srv.fd], eax
-           mov [srv.bk], eax
+	   call init_events
+	   mov eax, srv.fd-SRV_FD_OFFSET
+	   mov [srv.fd], eax
+	   mov [srv.bk], eax
 
-           mov edi, irq_tab
-           xor eax, eax
-           mov ecx, 16
-           rep stosd
+	   mov edi, irq_tab
+	   xor eax, eax
+	   mov ecx, 16
+	   rep stosd
 
 ;Set base of graphic segment to linear address of LFB
-        mov     eax,[LFBAddress]          ; set for gs
-        mov     [graph_data_l+2],ax
-        shr     eax,16
-        mov     [graph_data_l+4],al
-        mov     [graph_data_l+7],ah
+	mov	eax,[LFBAddress]	  ; set for gs
+	mov	[graph_data_l+2],ax
+	shr	eax,16
+	mov	[graph_data_l+4],al
+	mov	[graph_data_l+7],ah
 
-        mov [CURRENT_TASK],dword 1
-        mov [TASK_COUNT],dword 1
-        mov [TASK_BASE],dword TASK_DATA
-        mov [current_slot], SLOT_BASE+256
+	mov [CURRENT_TASK],dword 1
+	mov [TASK_COUNT],dword 1
+	mov [TASK_BASE],dword TASK_DATA
+	mov [current_slot], SLOT_BASE+256
 
 ; set background
-        xor  eax,eax
-        inc  eax
-        mov   [BgrDrawMode],eax
-        mov   [BgrDataWidth],eax
-        mov   [BgrDataHeight],eax
-        mov    [mem_BACKGROUND],4095
-        stdcall kernel_alloc, [mem_BACKGROUND]
-        mov [img_background], eax
+	xor  eax,eax
+	inc  eax
+	mov   [BgrDrawMode],eax
+	mov   [BgrDataWidth],eax
+	mov   [BgrDataHeight],eax
+	mov    [mem_BACKGROUND],4095
+	stdcall kernel_alloc, [mem_BACKGROUND]
+	mov [img_background], eax
 
-        mov     [SLOT_BASE + 256 + APPDATA.dir_table], sys_pgdir - OS_BASE
+	mov	[SLOT_BASE + 256 + APPDATA.dir_table], sys_pgdir - OS_BASE
 
 ; REDIRECT ALL IRQ'S TO INT'S 0x20-0x2f
 
-        call  rerouteirqs
+	call  rerouteirqs
 
 ; Initialize system V86 machine
-        call    init_sys_v86
+	call	init_sys_v86
 
 ; TIMER SET TO 1/100 S
 
-        mov   al,0x34              ; set to 100Hz
-        out   0x43,al
-        mov   al,0x9b              ; lsb    1193180 / 1193
-        out   0x40,al
-        mov   al,0x2e              ; msb
-        out   0x40,al
+	mov   al,0x34		   ; set to 100Hz
+	out   0x43,al
+	mov   al,0x9b		   ; lsb    1193180 / 1193
+	out   0x40,al
+	mov   al,0x2e		   ; msb
+	out   0x40,al
 
 ; Enable timer IRQ (IRQ0) and hard drives IRQs (IRQ14, IRQ15)
 ; they are used: when partitions are scanned, hd_read relies on timer
-        mov     al, 0xFE
-        out     0x21, al
-        mov     al, 0x3F
-        out     0xA1, al
+	mov	al, 0xFE
+	out	0x21, al
+	mov	al, 0x3F
+	out	0xA1, al
 
 ;!!!!!!!!!!!!!!!!!!!!!!!!!!
 include 'detect/disks.inc'
@@ -587,7 +587,7 @@ include 'boot/rdload.inc'
 ;    mov    [dma_hdd],1
 ; CALCULATE FAT CHAIN FOR RAMDISK
 
-        call  calculatefatchain
+	call  calculatefatchain
 
 ; LOAD VMODE DRIVER
 
@@ -599,237 +599,237 @@ include 'vmodeld.inc'
   cmp ax,'r1'		; if using not ram disk, then load librares and parameters {SPraid.simba}
   je  no_lib_load
 ; LOADING LIBRARES
-   stdcall dll.Load,@IMPORT                 ; loading librares for kernel (.obj files)
-   call load_file_parse_table               ; prepare file parse table
-   call set_kernel_conf                     ; configure devices and gui
+   stdcall dll.Load,@IMPORT		    ; loading librares for kernel (.obj files)
+   call load_file_parse_table		    ; prepare file parse table
+   call set_kernel_conf 		    ; configure devices and gui
 no_lib_load:
 
 ; LOAD FONTS I and II
 
-        stdcall read_file, char, FONT_I, 0, 2304
-        stdcall read_file, char2, FONT_II, 0, 2560
+	stdcall read_file, char, FONT_I, 0, 2304
+	stdcall read_file, char2, FONT_II, 0, 2560
 
-        mov   esi,boot_fonts
-        call  boot_log
+	mov   esi,boot_fonts
+	call  boot_log
 
 ; PRINT AMOUNT OF MEMORY
-        mov     esi, boot_memdetect
-        call    boot_log
+	mov	esi, boot_memdetect
+	call	boot_log
 
-        movzx   ecx, word [boot_y]
-        or      ecx, (10+29*6) shl 16 ; "Determining amount of memory"
-        sub     ecx, 10
-        mov     edx, 0xFFFFFF
-        mov     ebx, [MEM_AMOUNT]
-        shr     ebx, 20
-        mov     edi, 1
-        mov     eax, 0x00040000
-        call    display_number_force
+	movzx	ecx, word [boot_y]
+	or	ecx, (10+29*6) shl 16 ; "Determining amount of memory"
+	sub	ecx, 10
+	mov	edx, 0xFFFFFF
+	mov	ebx, [MEM_AMOUNT]
+	shr	ebx, 20
+	mov	edi, 1
+	mov	eax, 0x00040000
+	call	display_number_force
 
 ; BUILD SCHEDULER
 
-        call   build_scheduler ; sys32.inc
+	call   build_scheduler ; sys32.inc
 
-        mov    esi,boot_devices
-        call   boot_log
+	mov    esi,boot_devices
+	call   boot_log
 
-        mov  [pci_access_enabled],1
+	mov  [pci_access_enabled],1
 
-        call   detect_devices
-        stdcall load_driver, szPS2MDriver
+	call   detect_devices
+	stdcall load_driver, szPS2MDriver
 
 ; SET MOUSE
 
-        mov   esi,boot_setmouse
-        call  boot_log
-        call  setmouse
+	mov   esi,boot_setmouse
+	call  boot_log
+	call  setmouse
 
 
 ; SET PRELIMINARY WINDOW STACK AND POSITIONS
 
-        mov   esi,boot_windefs
-        call  boot_log
-        call  setwindowdefaults
+	mov   esi,boot_windefs
+	call  boot_log
+	call  setwindowdefaults
 
 ; SET BACKGROUND DEFAULTS
 
-        mov   esi,boot_bgr
-        call  boot_log
-        call  init_background
-        call  calculatebackground
+	mov   esi,boot_bgr
+	call  boot_log
+	call  init_background
+	call  calculatebackground
 
 ; RESERVE SYSTEM IRQ'S JA PORT'S
 
-        mov   esi,boot_resirqports
-        call  boot_log
-        call  reserve_irqs_ports
+	mov   esi,boot_resirqports
+	call  boot_log
+	call  reserve_irqs_ports
 
 ; SET PORTS FOR IRQ HANDLERS
 
-        mov  esi,boot_setrports
-        call boot_log
-        call setirqreadports
+	mov  esi,boot_setrports
+	call boot_log
+	call setirqreadports
 
 ; SET UP OS TASK
 
-        mov  esi,boot_setostask
-        call boot_log
+	mov  esi,boot_setostask
+	call boot_log
 
-        xor  eax, eax
-        mov  dword [SLOT_BASE+APPDATA.fpu_state], fpu_data
-        mov  dword [SLOT_BASE+APPDATA.fpu_handler], eax
-        mov  dword [SLOT_BASE+APPDATA.sse_handler], eax
+	xor  eax, eax
+	mov  dword [SLOT_BASE+APPDATA.fpu_state], fpu_data
+	mov  dword [SLOT_BASE+APPDATA.fpu_handler], eax
+	mov  dword [SLOT_BASE+APPDATA.sse_handler], eax
 
-        ; name for OS/IDLE process
+	; name for OS/IDLE process
 
-        mov dword [SLOT_BASE+256+APPDATA.app_name],   dword 'OS/I'
-        mov dword [SLOT_BASE+256+APPDATA.app_name+4], dword 'DLE '
-        mov edi, [os_stack_seg]
-        mov dword [SLOT_BASE+256+APPDATA.pl0_stack], edi
-        add edi, 0x2000-512
-        mov dword [SLOT_BASE+256+APPDATA.fpu_state], edi
-        mov dword [SLOT_BASE+256+APPDATA.saved_esp0], edi ; just for case
-        mov dword [SLOT_BASE+256+APPDATA.io_map],\
-                  (tss._io_map_0-OS_BASE+PG_MAP)
-        mov dword [SLOT_BASE+256+APPDATA.io_map+4],\
-                  (tss._io_map_1-OS_BASE+PG_MAP)
+	mov dword [SLOT_BASE+256+APPDATA.app_name],   dword 'OS/I'
+	mov dword [SLOT_BASE+256+APPDATA.app_name+4], dword 'DLE '
+	mov edi, [os_stack_seg]
+	mov dword [SLOT_BASE+256+APPDATA.pl0_stack], edi
+	add edi, 0x2000-512
+	mov dword [SLOT_BASE+256+APPDATA.fpu_state], edi
+	mov dword [SLOT_BASE+256+APPDATA.saved_esp0], edi ; just for case
+	mov dword [SLOT_BASE+256+APPDATA.io_map],\
+		  (tss._io_map_0-OS_BASE+PG_MAP)
+	mov dword [SLOT_BASE+256+APPDATA.io_map+4],\
+		  (tss._io_map_1-OS_BASE+PG_MAP)
 
-        mov esi, fpu_data
-        mov ecx, 512/4
-        cld
-        rep movsd
+	mov esi, fpu_data
+	mov ecx, 512/4
+	cld
+	rep movsd
 
-        mov dword [SLOT_BASE+256+APPDATA.fpu_handler], eax
-        mov dword [SLOT_BASE+256+APPDATA.sse_handler], eax
+	mov dword [SLOT_BASE+256+APPDATA.fpu_handler], eax
+	mov dword [SLOT_BASE+256+APPDATA.sse_handler], eax
 
-        mov ebx, SLOT_BASE+256+APP_OBJ_OFFSET
-        mov  dword [SLOT_BASE+256+APPDATA.fd_obj], ebx
-        mov  dword [SLOT_BASE+256+APPDATA.bk_obj], ebx
+	mov ebx, SLOT_BASE+256+APP_OBJ_OFFSET
+	mov  dword [SLOT_BASE+256+APPDATA.fd_obj], ebx
+	mov  dword [SLOT_BASE+256+APPDATA.bk_obj], ebx
 
-        mov  dword [SLOT_BASE+256+APPDATA.cur_dir], sysdir_path
+	mov  dword [SLOT_BASE+256+APPDATA.cur_dir], sysdir_path
 
-        ; task list
-        mov  [CURRENT_TASK],dword 1
-        mov  [TASK_COUNT],dword 1
-        mov  [current_slot], SLOT_BASE+256
-        mov  [TASK_BASE],dword TASK_DATA
-        mov  [TASK_DATA+TASKDATA.wnd_number], 1 ; on screen number
-        mov  [TASK_DATA+TASKDATA.pid], 1        ; process id number
-        mov  [TASK_DATA+TASKDATA.mem_start], 0  ; process base address
+	; task list
+	mov  [CURRENT_TASK],dword 1
+	mov  [TASK_COUNT],dword 1
+	mov  [current_slot], SLOT_BASE+256
+	mov  [TASK_BASE],dword TASK_DATA
+	mov  [TASK_DATA+TASKDATA.wnd_number], 1 ; on screen number
+	mov  [TASK_DATA+TASKDATA.pid], 1	; process id number
+	mov  [TASK_DATA+TASKDATA.mem_start], 0	; process base address
 
-        call init_cursors
-        mov eax, [def_cursor]
-        mov [SLOT_BASE+APPDATA.cursor],eax
-        mov [SLOT_BASE+APPDATA.cursor+256],eax
+	call init_cursors
+	mov eax, [def_cursor]
+	mov [SLOT_BASE+APPDATA.cursor],eax
+	mov [SLOT_BASE+APPDATA.cursor+256],eax
 
   ; READ TSC / SECOND
 
-        mov   esi,boot_tsc
-        call  boot_log
-        cli
-        call  _rdtsc
-        mov   ecx,eax
-        mov   esi,250               ; wait 1/4 a second
-        call  delay_ms
-        call  _rdtsc
-        sti
-        sub   eax,ecx
-        shl   eax,2
-        mov   [CPU_FREQ],eax          ; save tsc / sec
-        mov ebx, 1000000
-        div ebx
-        mov [stall_mcs], eax
+	mov   esi,boot_tsc
+	call  boot_log
+	cli
+	call  _rdtsc
+	mov   ecx,eax
+	mov   esi,250		    ; wait 1/4 a second
+	call  delay_ms
+	call  _rdtsc
+	sti
+	sub   eax,ecx
+	shl   eax,2
+	mov   [CPU_FREQ],eax	      ; save tsc / sec
+	mov ebx, 1000000
+	div ebx
+	mov [stall_mcs], eax
 
 ; SET VARIABLES
 
-        call  set_variables
+	call  set_variables
 
 ; STACK AND FDC
 
-        call  stack_init
-        call  fdc_init
+	call  stack_init
+	call  fdc_init
 
 ; PALETTE FOR 320x200 and 640x480 16 col
 
-        cmp   [SCR_MODE],word 0x12
-        jne   no_pal_vga
-        mov   esi,boot_pal_vga
-        call  boot_log
-        call  paletteVGA
+	cmp   [SCR_MODE],word 0x12
+	jne   no_pal_vga
+	mov   esi,boot_pal_vga
+	call  boot_log
+	call  paletteVGA
       no_pal_vga:
 
-        cmp   [SCR_MODE],word 0x13
-        jne   no_pal_ega
-        mov   esi,boot_pal_ega
-        call  boot_log
-        call  palette320x200
+	cmp   [SCR_MODE],word 0x13
+	jne   no_pal_ega
+	mov   esi,boot_pal_ega
+	call  boot_log
+	call  palette320x200
       no_pal_ega:
 
 ; LOAD DEFAULT SKIN
 
-        call    load_default_skin
+	call	load_default_skin
 
 ;protect io permission map
 
-           mov esi, [default_io_map]
-           stdcall map_page,esi,(tss._io_map_0-OS_BASE), PG_MAP
-           add esi, 0x1000
-           stdcall map_page,esi,(tss._io_map_1-OS_BASE), PG_MAP
+	   mov esi, [default_io_map]
+	   stdcall map_page,esi,(tss._io_map_0-OS_BASE), PG_MAP
+	   add esi, 0x1000
+	   stdcall map_page,esi,(tss._io_map_1-OS_BASE), PG_MAP
 
-           stdcall map_page,tss._io_map_0,\
-                   (tss._io_map_0-OS_BASE), PG_MAP
-           stdcall map_page,tss._io_map_1,\
-                   (tss._io_map_1-OS_BASE), PG_MAP
+	   stdcall map_page,tss._io_map_0,\
+		   (tss._io_map_0-OS_BASE), PG_MAP
+	   stdcall map_page,tss._io_map_1,\
+		   (tss._io_map_1-OS_BASE), PG_MAP
 
   mov ax,[OS_BASE+0x10000+bx_from_load]
   cmp ax,'r1'		; if not rused ram disk - load network configuration from files {SPraid.simba}
   je  no_st_network
-        call set_network_conf
+	call set_network_conf
   no_st_network:
 
 ; LOAD FIRST APPLICATION
-        cli
+	cli
 
-        cmp   byte [BOOT_VAR+0x9030],1
-        jne   no_load_vrr_m
+	cmp   byte [BOOT_VAR+0x9030],1
+	jne   no_load_vrr_m
 
-        mov     ebp, vrr_m
-        call    fs_execute_from_sysdir
+	mov	ebp, vrr_m
+	call	fs_execute_from_sysdir
 
-        cmp   eax,2                  ; if vrr_m app found (PID=2)
-        je    first_app_found
+	cmp   eax,2		     ; if vrr_m app found (PID=2)
+	je    first_app_found
 
 no_load_vrr_m:
 
-        mov     ebp, firstapp
-        call    fs_execute_from_sysdir
+	mov	ebp, firstapp
+	call	fs_execute_from_sysdir
 
-        cmp   eax,2                  ; continue if a process has been loaded
-        je    first_app_found
+	cmp   eax,2		     ; continue if a process has been loaded
+	je    first_app_found
 
-        mov     esi, boot_failed
-        call    boot_log
+	mov	esi, boot_failed
+	call	boot_log
 
-        mov   eax, 0xDEADBEEF        ; otherwise halt
-        hlt
+	mov   eax, 0xDEADBEEF	     ; otherwise halt
+	hlt
 
 first_app_found:
 
-        cli
+	cli
 
-        ;mov   [TASK_COUNT],dword 2
-        mov   [CURRENT_TASK],dword 1       ; set OS task fisrt
+	;mov   [TASK_COUNT],dword 2
+	mov   [CURRENT_TASK],dword 1	   ; set OS task fisrt
 
 ; SET KEYBOARD PARAMETERS
-        mov   al, 0xf6         ; reset keyboard, scan enabled
-        call  kb_write
+	mov   al, 0xf6	       ; reset keyboard, scan enabled
+	call  kb_write
 
-        ; wait until 8042 is ready
-        xor ecx,ecx
+	; wait until 8042 is ready
+	xor ecx,ecx
       @@:
-        in     al,64h
-        and    al,00000010b
-        loopnz @b
+	in     al,64h
+	and    al,00000010b
+	loopnz @b
 
        ; mov   al, 0xED       ; svetodiody - only for testing!
        ; call  kb_write
@@ -838,96 +838,96 @@ first_app_found:
        ; call  kb_write
        ; call  kb_read
 
-        mov   al, 0xF3       ; set repeat rate & delay
-        call  kb_write
+	mov   al, 0xF3	     ; set repeat rate & delay
+	call  kb_write
 ;        call  kb_read
-        mov   al, 0 ; 30 250 ;00100010b ; 24 500  ;00100100b  ; 20 500
-        call  kb_write
+	mov   al, 0 ; 30 250 ;00100010b ; 24 500  ;00100100b  ; 20 500
+	call  kb_write
 ;        call  kb_read
      ;// mike.dld [
-        call  set_lights
+	call  set_lights
      ;// mike.dld ]
 
 ; START MULTITASKING
 
-        mov   esi,boot_tasking
-        call  boot_log
+	mov   esi,boot_tasking
+	call  boot_log
 
 ;       mov   [ENABLE_TASKSWITCH],byte 1        ; multitasking enabled
 
 ; UNMASK ALL IRQ'S
 
-        mov   esi,boot_allirqs
-        call  boot_log
+	mov   esi,boot_allirqs
+	call  boot_log
 
-        cli                          ;guarantee forbidance of interrupts.
-        mov   al,0                   ; unmask all irq's
-        out   0xA1,al
-        out   0x21,al
+	cli			     ;guarantee forbidance of interrupts.
+	mov   al,0		     ; unmask all irq's
+	out   0xA1,al
+	out   0x21,al
 
-        mov   ecx,32
+	mov   ecx,32
 
      ready_for_irqs:
 
-        mov   al,0x20                ; ready for irqs
-        out   0x20,al
-        out   0xa0,al
+	mov   al,0x20		     ; ready for irqs
+	out   0x20,al
+	out   0xa0,al
 
-        loop  ready_for_irqs         ; flush the queue
+	loop  ready_for_irqs	     ; flush the queue
 
-        stdcall attach_int_handler, dword 1, irq1
+	stdcall attach_int_handler, dword 1, irq1
 
 ;        mov    [dma_hdd],1
-        cmp     [IDEContrRegsBaseAddr], 0
-        setnz   [dma_hdd]
-        mov [timer_ticks_enable],1		; for cd driver
+	cmp	[IDEContrRegsBaseAddr], 0
+	setnz	[dma_hdd]
+	mov [timer_ticks_enable],1		; for cd driver
 
 ;        stdcall init_uart_service, DRV_ENTRY
 
-        sti
-        call change_task
+	sti
+	call change_task
 
-        jmp osloop
+	jmp osloop
 
 ;        jmp   $                      ; wait here for timer to take control
 
-        ; Fly :)
+	; Fly :)
 
 include 'unpacker.inc'
 include 'fdo.inc'
 
 align 4
 boot_log:
-         pushad
+	 pushad
 
-         mov   ebx,10*65536
-         mov   bx,word [boot_y]
-         add   [boot_y],dword 10
-         mov   ecx,0x80ffffff   ; ASCIIZ string with white color
-         mov   edx,esi
-         mov   edi,1
-         call  dtext
+	 mov   ebx,10*65536
+	 mov   bx,word [boot_y]
+	 add   [boot_y],dword 10
+	 mov   ecx,0x80ffffff	; ASCIIZ string with white color
+	 mov   edx,esi
+	 mov   edi,1
+	 call  dtext
 
-         mov   [novesachecksum],1000
-         call  checkVga_N13
+	 mov   [novesachecksum],1000
+	 call  checkVga_N13
 
-         cmp   [preboot_blogesc+OS_BASE+0x10000],byte 1
-         je    .bll2
+	 cmp   [preboot_blogesc+OS_BASE+0x10000],byte 1
+	 je    .bll2
 
-         cmp   esi,boot_tasking
-         jne   .bll2
-         ; begin ealex 04.08.05
+	 cmp   esi,boot_tasking
+	 jne   .bll2
+	 ; begin ealex 04.08.05
 ;         in    al,0x61
 ;         and   al,01111111b
 ;         out   0x61,al
-         ; end ealex 04.08.05
-.bll1:   in    al,0x60    ; wait for ESC key press
-         cmp   al,129
-         jne   .bll1
+	 ; end ealex 04.08.05
+.bll1:	 in    al,0x60	  ; wait for ESC key press
+	 cmp   al,129
+	 jne   .bll1
 
-.bll2:   popad
+.bll2:	 popad
 
-         ret
+	 ret
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -937,17 +937,17 @@ boot_log:
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 32
 osloop:
-        call   [draw_pointer]
-        call   checkbuttons
-        call   checkwindows
+	call   [draw_pointer]
+	call   checkbuttons
+	call   checkwindows
 ;       call   check_window_move_request
-        call   checkmisc
-        call   checkVga_N13
-        call   stack_handler
-        call   checkidle
-        call   check_fdd_motor_status
-        call   check_ATAPI_device_event
-        jmp    osloop
+	call   checkmisc
+	call   checkVga_N13
+	call   stack_handler
+	call   checkidle
+	call   check_fdd_motor_status
+	call   check_ATAPI_device_event
+	jmp    osloop
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;                                                                    ;
 ;                      MAIN OS LOOP END                              ;
@@ -955,61 +955,61 @@ osloop:
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 checkidle:
-        pushad
+	pushad
 
-        cmp  [check_idle_semaphore],0
-        jne  no_idle_state
+	cmp  [check_idle_semaphore],0
+	jne  no_idle_state
 
-        call change_task
-        mov  eax,[idlemem]
-        mov  ebx,[timer_ticks] ;[0xfdf0]
-        cmp  eax,ebx
-        jnz  idle_exit
-        call _rdtsc
-        mov  ecx,eax
+	call change_task
+	mov  eax,[idlemem]
+	mov  ebx,[timer_ticks] ;[0xfdf0]
+	cmp  eax,ebx
+	jnz  idle_exit
+	call _rdtsc
+	mov  ecx,eax
       idle_loop:
-        hlt
-        cmp  [check_idle_semaphore],0
-        jne  idle_loop_exit
-        mov  eax,[timer_ticks] ;[0xfdf0]
-        cmp  ebx,eax
-        jz   idle_loop
+	hlt
+	cmp  [check_idle_semaphore],0
+	jne  idle_loop_exit
+	mov  eax,[timer_ticks] ;[0xfdf0]
+	cmp  ebx,eax
+	jz   idle_loop
       idle_loop_exit:
-        mov  [idlemem],eax
-        call _rdtsc
-        sub  eax,ecx
-        mov  ebx,[idleuse]
-        add  ebx,eax
-        mov  [idleuse],ebx
+	mov  [idlemem],eax
+	call _rdtsc
+	sub  eax,ecx
+	mov  ebx,[idleuse]
+	add  ebx,eax
+	mov  [idleuse],ebx
 
-        popad
-        ret
+	popad
+	ret
 
       idle_exit:
 
-        mov  ebx,[timer_ticks] ;[0xfdf0]
-        mov  [idlemem],ebx
-        call change_task
+	mov  ebx,[timer_ticks] ;[0xfdf0]
+	mov  [idlemem],ebx
+	call change_task
 
-        popad
-        ret
+	popad
+	ret
 
       no_idle_state:
 
-        dec  [check_idle_semaphore]
+	dec  [check_idle_semaphore]
 
-        mov  ebx,[timer_ticks] ;[0xfdf0]
-        mov  [idlemem],ebx
-        call change_task
+	mov  ebx,[timer_ticks] ;[0xfdf0]
+	mov  [idlemem],ebx
+	call change_task
 
-        popad
-        ret
+	popad
+	ret
 
 uglobal
-  idlemem               dd   0x0
-  idleuse               dd   0x0
-  idleusesec            dd   0x0
-  check_idle_semaphore  dd   0x0
+  idlemem		dd   0x0
+  idleuse		dd   0x0
+  idleusesec		dd   0x0
+  check_idle_semaphore	dd   0x0
 endg
 
 
@@ -1032,64 +1032,64 @@ include "kernel32.inc"
 
 reserve_irqs_ports:
 
-        pushad
+	pushad
 
-        mov  [irq_owner+4*0], 1    ; timer
-        mov  [irq_owner+4*1], 1    ; keyboard
-        mov  [irq_owner+4*5], 1    ; sound blaster
-        mov  [irq_owner+4*6], 1    ; floppy diskette
-        mov  [irq_owner+4*13], 1   ; math co-pros
-        mov  [irq_owner+4*14], 1   ; ide I
-        mov  [irq_owner+4*15], 1   ; ide II
+	mov  [irq_owner+4*0], 1    ; timer
+	mov  [irq_owner+4*1], 1    ; keyboard
+	mov  [irq_owner+4*5], 1    ; sound blaster
+	mov  [irq_owner+4*6], 1    ; floppy diskette
+	mov  [irq_owner+4*13], 1   ; math co-pros
+	mov  [irq_owner+4*14], 1   ; ide I
+	mov  [irq_owner+4*15], 1   ; ide II
 
 	; RESERVE PORTS
-        mov   edi,1                    ; 0x00-0x2d
-        mov   [RESERVED_PORTS],edi
-        shl   edi,4
-        mov   [RESERVED_PORTS+edi+0],dword 1
-        mov   [RESERVED_PORTS+edi+4],dword 0x0
-        mov   [RESERVED_PORTS+edi+8],dword 0x2d
+	mov   edi,1		       ; 0x00-0x2d
+	mov   [RESERVED_PORTS],edi
+	shl   edi,4
+	mov   [RESERVED_PORTS+edi+0],dword 1
+	mov   [RESERVED_PORTS+edi+4],dword 0x0
+	mov   [RESERVED_PORTS+edi+8],dword 0x2d
 
-        inc   dword [RESERVED_PORTS]          ; 0x30-0x4d
-        mov   edi,[RESERVED_PORTS]
-        shl   edi,4
-        mov   [RESERVED_PORTS+edi+0],dword 1
-        mov   [RESERVED_PORTS+edi+4],dword 0x30
-        mov   [RESERVED_PORTS+edi+8],dword 0x4d
+	inc   dword [RESERVED_PORTS]	      ; 0x30-0x4d
+	mov   edi,[RESERVED_PORTS]
+	shl   edi,4
+	mov   [RESERVED_PORTS+edi+0],dword 1
+	mov   [RESERVED_PORTS+edi+4],dword 0x30
+	mov   [RESERVED_PORTS+edi+8],dword 0x4d
 
-        inc   dword [RESERVED_PORTS]          ; 0x50-0xdf
-        mov   edi,[RESERVED_PORTS]
-        shl   edi,4
-        mov   [RESERVED_PORTS+edi+0],dword 1
-        mov   [RESERVED_PORTS+edi+4],dword 0x50
-        mov   [RESERVED_PORTS+edi+8],dword 0xdf
+	inc   dword [RESERVED_PORTS]	      ; 0x50-0xdf
+	mov   edi,[RESERVED_PORTS]
+	shl   edi,4
+	mov   [RESERVED_PORTS+edi+0],dword 1
+	mov   [RESERVED_PORTS+edi+4],dword 0x50
+	mov   [RESERVED_PORTS+edi+8],dword 0xdf
 
-        inc   dword [RESERVED_PORTS]          ; 0xe5-0xff
-        mov   edi,[RESERVED_PORTS]
-        shl   edi,4
-        mov   [RESERVED_PORTS+edi+0],dword 1
-        mov   [RESERVED_PORTS+edi+4],dword 0xe5
-        mov   [RESERVED_PORTS+edi+8],dword 0xff
+	inc   dword [RESERVED_PORTS]	      ; 0xe5-0xff
+	mov   edi,[RESERVED_PORTS]
+	shl   edi,4
+	mov   [RESERVED_PORTS+edi+0],dword 1
+	mov   [RESERVED_PORTS+edi+4],dword 0xe5
+	mov   [RESERVED_PORTS+edi+8],dword 0xff
 
-        popad
-        ret
+	popad
+	ret
 
 iglobal
-mouseirqtable   db  12    ; ps2
-                db  4     ; com1
-                db  3     ; com2
+mouseirqtable	db  12	  ; ps2
+		db  4	  ; com1
+		db  3	  ; com2
 endg
 
 setirqreadports:
 
-        mov   [irq12read+0],dword 0x60 + 0x01000000  ; read port 0x60 , byte
-        mov   [irq12read+4],dword 0                  ; end of port list
-        mov   [irq04read+0],dword 0x3f8 + 0x01000000 ; read port 0x3f8 , byte
-        mov   [irq04read+4],dword 0                  ; end of port list
-        mov   [irq03read+0],dword 0x2f8 + 0x01000000 ; read port 0x2f8 , byte
-        mov   [irq03read+4],dword 0                  ; end of port list
+	mov   [irq12read+0],dword 0x60 + 0x01000000  ; read port 0x60 , byte
+	mov   [irq12read+4],dword 0		     ; end of port list
+	mov   [irq04read+0],dword 0x3f8 + 0x01000000 ; read port 0x3f8 , byte
+	mov   [irq04read+4],dword 0		     ; end of port list
+	mov   [irq03read+0],dword 0x2f8 + 0x01000000 ; read port 0x2f8 , byte
+	mov   [irq03read+4],dword 0		     ; end of port list
 
-        ret
+	ret
 
 iglobal
   process_number dd 0x1
@@ -1097,50 +1097,50 @@ endg
 
 set_variables:
 
-        mov   ecx,0x100                       ; flush port 0x60
-.fl60:  in    al,0x60
-        loop  .fl60
-        mov   [MOUSE_BUFF_COUNT],byte 0                 ; mouse buffer
-        mov   [KEY_COUNT],byte 0                 ; keyboard buffer
-        mov   [BTN_COUNT],byte 0                 ; button buffer
+	mov   ecx,0x100 		      ; flush port 0x60
+.fl60:	in    al,0x60
+	loop  .fl60
+	mov   [MOUSE_BUFF_COUNT],byte 0 		; mouse buffer
+	mov   [KEY_COUNT],byte 0		 ; keyboard buffer
+	mov   [BTN_COUNT],byte 0		 ; button buffer
 ;        mov   [MOUSE_X],dword 100*65536+100    ; mouse x/y
 
-        push  eax
-        mov   ax,[BOOT_VAR+0x900c]
-        shr   ax,1
-        shl   eax,16
-        mov   ax,[BOOT_VAR+0x900A]
-        shr   ax,1
-        mov   [MOUSE_X],eax
-        pop   eax
+	push  eax
+	mov   ax,[BOOT_VAR+0x900c]
+	shr   ax,1
+	shl   eax,16
+	mov   ax,[BOOT_VAR+0x900A]
+	shr   ax,1
+	mov   [MOUSE_X],eax
+	pop   eax
 
-        mov   byte [SB16_Status],0            ; Minazzi Paolo
-        mov   [BTN_ADDR],dword BUTTON_INFO    ; address of button list
+	mov   byte [SB16_Status],0	      ; Minazzi Paolo
+	mov   [BTN_ADDR],dword BUTTON_INFO    ; address of button list
 
      ;!! IP 04.02.2005:
-        mov   [next_usage_update], 100
-        mov   byte [DONT_SWITCH], 0 ; change task if possible
+	mov   [next_usage_update], 100
+	mov   byte [DONT_SWITCH], 0 ; change task if possible
 
-        ret
+	ret
 
 ;* mouse centered - start code- Mario79
 mouse_centered:
-        push  eax
-        mov   eax,[ScreenWidth]
-        shr   eax,1
-        mov   [MOUSE_X],ax
-        mov   eax,[ScreenHeight]
-        shr   eax,1
-        mov   [MOUSE_Y],ax
-        pop   eax
-        ret
+	push  eax
+	mov   eax,[ScreenWidth]
+	shr   eax,1
+	mov   [MOUSE_X],ax
+	mov   eax,[ScreenHeight]
+	shr   eax,1
+	mov   [MOUSE_Y],ax
+	pop   eax
+	ret
 ;* mouse centered - end code- Mario79
 
 align 4
 
 sys_outport:
 
-    mov   edi,ebx          ; separate flag for read / write
+    mov   edi,ebx	   ; separate flag for read / write
     and   ebx,65535
 
     mov   ecx,[RESERVED_PORTS]
@@ -1162,9 +1162,9 @@ sys_outport:
     cmp   edx,[esi+0]
     jne   sopl2
     cmp   ebx,[esi+4]
-    jb    sopl2
+    jb	  sopl2
     cmp   ebx,[esi+8]
-    jg    sopl2
+    jg	  sopl2
     jmp   sopl3
 
   sopl2:
@@ -1179,15 +1179,15 @@ sys_outport:
     test  edi,0x80000000 ; read ?
     jnz   sopl4
 
-    mov   dx,bx          ; write
+    mov   dx,bx 	 ; write
     out   dx,al
     mov   [esp+36],dword 0
     ret
 
   sopl4:
 
-    mov   dx,bx          ; read
-    in    al,dx
+    mov   dx,bx 	 ; read
+    in	  al,dx
     and   eax,0xff
     mov   [esp+36],dword 0
     mov   [esp+24],eax
@@ -1470,9 +1470,9 @@ draw_num_text:
      add   eax,[edi+SLOT_BASE+APPDATA.wnd_clientbox.top]
      add   ebx,eax
      mov   ecx,[esp+64+32-12+4]
-        and     ecx, not 0x80000000     ; force counted string
-        mov     eax, [esp+64+8]         ; background color (if given)
-        mov     edi, [esp+64+4]
+	and	ecx, not 0x80000000	; force counted string
+	mov	eax, [esp+64+8] 	; background color (if given)
+	mov	edi, [esp+64+4]
      jmp   dtext
 
 align 4
@@ -1493,7 +1493,7 @@ sys_setup:
 
 
      mov  [esp+36],dword 0
-     cmp  eax,1                      ; MIDI
+     cmp  eax,1 		     ; MIDI
      jnz  nsyse1
      cmp  ebx,0x100
      jb   nsyse1
@@ -1512,7 +1512,7 @@ endg
 
    nsyse1:
 
-     cmp  eax,2                      ; KEYBOARD
+     cmp  eax,2 		     ; KEYBOARD
      jnz  nsyse2
      cmp  ebx,1
      jnz  kbnobase
@@ -1552,7 +1552,7 @@ endg
      mov  [esp+36],dword 1
      ret
    nsyse2:
-     cmp  eax,3                      ; CD
+     cmp  eax,3 		     ; CD
      jnz  nsyse3
      test ebx,ebx
      jz   nosesl
@@ -1585,7 +1585,7 @@ cd_base db 0
 
    nsyse3:
 
-     cmp  eax,4                      ; SB
+     cmp  eax,4 		     ; SB
      jnz  nsyse4
      cmp  ebx,0x100
      jb   nsyse4
@@ -1596,13 +1596,13 @@ cd_base db 0
      ret
    nsyse4:
 
-     cmp  eax,5                      ; SYSTEM LANGUAGE
+     cmp  eax,5 		     ; SYSTEM LANGUAGE
      jnz  nsyse5
      mov  [syslang],ebx
      ret
    nsyse5:
 
-     cmp  eax,7                      ; HD BASE
+     cmp  eax,7 		     ; HD BASE
      jne  nsyse7
      test ebx,ebx
      jz   nosethd
@@ -1640,7 +1640,7 @@ cd_base db 0
     call  reserve_hd1
     call  reserve_hd_channel
     call  free_hd_channel
-    mov   [hd1_status],0        ; free
+    mov   [hd1_status],0	; free
    nosethd:
      ret
 
@@ -1650,7 +1650,7 @@ endg
 
    nsyse7:
 
-     cmp  eax,8                      ; HD PARTITION
+     cmp  eax,8 		     ; HD PARTITION
      jne  nsyse8
      mov  [fat32part],ebx
 ;     call set_FAT32_variables
@@ -1660,11 +1660,11 @@ endg
      pusha
      call  choice_necessity_partition_1
      popa
-    mov   [hd1_status],0        ; free
+    mov   [hd1_status],0	; free
      ret
    nsyse8:
 
-     cmp  eax,10                     ; SOUND DMA CHANNEL
+     cmp  eax,10		     ; SOUND DMA CHANNEL
      jne  no_set_sound_dma
      cmp  ebx,3
      ja   sys_setup_err
@@ -1672,14 +1672,14 @@ endg
      ret
    no_set_sound_dma:
 
-     cmp  eax,11                     ; ENABLE LBA READ
+     cmp  eax,11		     ; ENABLE LBA READ
      jne  no_set_lba_read
      and  ebx,1
      mov  [lba_read_enabled],ebx
      ret
    no_set_lba_read:
 
-     cmp  eax,12                     ; ENABLE PCI ACCESS
+     cmp  eax,12		     ; ENABLE PCI ACCESS
      jne  no_set_pci_access
      and  ebx,1
      mov  [pci_access_enabled],ebx
@@ -1819,10 +1819,10 @@ get_timer_ticks:
 iglobal
 align 4
 mousefn dd msscreen, mswin, msbutton, msset
-        dd app_load_cursor
-        dd app_set_cursor
-        dd app_delete_cursor
-        dd msz
+	dd app_load_cursor
+	dd app_set_cursor
+	dd app_delete_cursor
+	dd msz
 endg
 
 readmousepos:
@@ -1836,107 +1836,107 @@ readmousepos:
 ; eax=6 delete cursor   ; reserved
 ; eax=7 get mouse_z
 
-           cmp eax, 7
-           ja msset
-           jmp [mousefn+eax*4]
+	   cmp eax, 7
+	   ja msset
+	   jmp [mousefn+eax*4]
 msscreen:
-           mov  eax,[MOUSE_X]
-           shl  eax,16
-           mov  ax,[MOUSE_Y]
-           mov  [esp+36],eax
-           ret
+	   mov	eax,[MOUSE_X]
+	   shl	eax,16
+	   mov	ax,[MOUSE_Y]
+	   mov	[esp+36],eax
+	   ret
 mswin:
-           mov  eax,[MOUSE_X]
-           shl  eax,16
-           mov  ax,[MOUSE_Y]
-           mov  esi,[TASK_BASE]
-           mov  bx, word [esi-twdw+WDATA.box.left]
-           shl  ebx,16
-           mov  bx, word [esi-twdw+WDATA.box.top]
-           sub  eax,ebx
+	   mov	eax,[MOUSE_X]
+	   shl	eax,16
+	   mov	ax,[MOUSE_Y]
+	   mov	esi,[TASK_BASE]
+	   mov	bx, word [esi-twdw+WDATA.box.left]
+	   shl	ebx,16
+	   mov	bx, word [esi-twdw+WDATA.box.top]
+	   sub	eax,ebx
 
-           mov  edi,[CURRENT_TASK]
-           shl  edi,8
-           sub  ax,word[edi+SLOT_BASE+APPDATA.wnd_clientbox.top]
-           rol  eax,16
-           sub  ax,word[edi+SLOT_BASE+APPDATA.wnd_clientbox.left]
-           rol  eax,16
-           mov  [esp+36],eax
-           ret
+	   mov	edi,[CURRENT_TASK]
+	   shl	edi,8
+	   sub	ax,word[edi+SLOT_BASE+APPDATA.wnd_clientbox.top]
+	   rol	eax,16
+	   sub	ax,word[edi+SLOT_BASE+APPDATA.wnd_clientbox.left]
+	   rol	eax,16
+	   mov	[esp+36],eax
+	   ret
 msbutton:
-           movzx eax,byte [BTN_DOWN]
-           mov  [esp+36],eax
-           ret
+	   movzx eax,byte [BTN_DOWN]
+	   mov	[esp+36],eax
+	   ret
 msz:
-           mov   edi, [TASK_COUNT]
-           movzx edi, word [WIN_POS + edi*2]
-           cmp   edi, [CURRENT_TASK]
-           jne   @f
-           mov   ax,[MOUSE_SCROLL_H]
-           shl   eax,16
-           mov   ax,[MOUSE_SCROLL_V]
-           mov   [esp+36],eax
-           mov   [MOUSE_SCROLL_H],word 0
-           mov   [MOUSE_SCROLL_V],word 0
-           ret
+	   mov	 edi, [TASK_COUNT]
+	   movzx edi, word [WIN_POS + edi*2]
+	   cmp	 edi, [CURRENT_TASK]
+	   jne	 @f
+	   mov	 ax,[MOUSE_SCROLL_H]
+	   shl	 eax,16
+	   mov	 ax,[MOUSE_SCROLL_V]
+	   mov	 [esp+36],eax
+	   mov	 [MOUSE_SCROLL_H],word 0
+	   mov	 [MOUSE_SCROLL_V],word 0
+	   ret
        @@:
-           mov  [esp+36],dword 0
-           ret
+	   mov	[esp+36],dword 0
+	   ret
 msset:
-           ret
+	   ret
 
 app_load_cursor:
       ;     add ebx, new_app_base
-           cmp ebx, OS_BASE
-           jae msset
-           stdcall load_cursor, ebx, ecx
-           mov [esp+36], eax
-           ret
+	   cmp ebx, OS_BASE
+	   jae msset
+	   stdcall load_cursor, ebx, ecx
+	   mov [esp+36], eax
+	   ret
 
 app_set_cursor:
-           stdcall set_cursor, ebx
-           mov [esp+36], eax
-           ret
+	   stdcall set_cursor, ebx
+	   mov [esp+36], eax
+	   ret
 
 app_delete_cursor:
-           stdcall delete_cursor, ebx
-           mov [esp+36], eax
-           ret
+	   stdcall delete_cursor, ebx
+	   mov [esp+36], eax
+	   ret
 
 is_input:
 
    push edx
-   mov  dx,word [midisp]
-   in   al,dx
-   and  al,0x80
-   pop  edx
+   mov	dx,word [midisp]
+   in	al,dx
+   and	al,0x80
+   pop	edx
    ret
 
 is_output:
 
    push edx
-   mov  dx,word [midisp]
-   in   al,dx
-   and  al,0x40
-   pop  edx
+   mov	dx,word [midisp]
+   in	al,dx
+   and	al,0x40
+   pop	edx
    ret
 
 
 get_mpu_in:
 
    push edx
-   mov  dx,word [mididp]
-   in   al,dx
-   pop  edx
+   mov	dx,word [mididp]
+   in	al,dx
+   pop	edx
    ret
 
 
 put_mpu_out:
 
    push edx
-   mov  dx,word [mididp]
-   out  dx,al
-   pop  edx
+   mov	dx,word [mididp]
+   out	dx,al
+   pop	edx
    ret
 
 
@@ -1944,28 +1944,28 @@ setuart:
 
  su1:
    call is_output
-   cmp  al,0
-   jnz  su1
-   mov  dx,word [midisp]
-   mov  al,0xff
-   out  dx,al
+   cmp	al,0
+   jnz	su1
+   mov	dx,word [midisp]
+   mov	al,0xff
+   out	dx,al
  su2:
-   mov  dx,word [midisp]
-   mov  al,0xff
-   out  dx,al
+   mov	dx,word [midisp]
+   mov	al,0xff
+   out	dx,al
    call is_input
-   cmp  al,0
-   jnz  su2
+   cmp	al,0
+   jnz	su2
    call get_mpu_in
-   cmp  al,0xfe
-   jnz  su2
+   cmp	al,0xfe
+   jnz	su2
  su3:
    call is_output
-   cmp  al,0
-   jnz  su3
-   mov  dx,word [midisp]
-   mov  al,0x3f
-   out  dx,al
+   cmp	al,0
+   jnz	su3
+   mov	dx,word [midisp]
+   mov	al,0x3f
+   out	dx,al
 
    ret
 
@@ -2018,7 +2018,7 @@ sys_end:
      mov   eax,[TASK_BASE]
      mov   [eax+TASKDATA.state], 3  ; terminate this program
 
-    waitterm:            ; wait here for termination
+    waitterm:		 ; wait here for termination
      mov   ebx,100
      call  delay_hs
      jmp   waitterm
@@ -2026,41 +2026,41 @@ sys_end:
 iglobal
 align 4
 sys_system_table:
-        dd      sysfn_shutdown          ; 1 = system shutdown
-        dd      sysfn_terminate         ; 2 = terminate thread
-        dd      sysfn_activate          ; 3 = activate window
-        dd      sysfn_getidletime       ; 4 = get idle time
-        dd      sysfn_getcpuclock       ; 5 = get cpu clock
-        dd      sysfn_saveramdisk       ; 6 = save ramdisk
-        dd      sysfn_getactive         ; 7 = get active window
-        dd      sysfn_sound_flag        ; 8 = get/set sound_flag
-        dd      sysfn_shutdown_param    ; 9 = shutdown with parameter
-        dd      sysfn_minimize          ; 10 = minimize window
-        dd      sysfn_getdiskinfo       ; 11 = get disk subsystem info
-        dd      sysfn_lastkey           ; 12 = get last pressed key
-        dd      sysfn_getversion        ; 13 = get kernel version
-        dd      sysfn_waitretrace       ; 14 = wait retrace
-        dd      sysfn_centermouse       ; 15 = center mouse cursor
-        dd      sysfn_getfreemem        ; 16 = get free memory size
-        dd      sysfn_getallmem         ; 17 = get total memory size
-        dd      sysfn_terminate2        ; 18 = terminate thread using PID
-                                        ;                 instead of slot
-        dd      sysfn_mouse_acceleration; 19 = set/get mouse acceleration
-        dd      sysfn_meminfo           ; 20 = get extended memory info
-        dd      sysfn_pid_to_slot       ; 21 = get slot number for pid
-        dd      sysfn_min_rest_window   ; 22 = minimize and restore any window
+	dd	sysfn_shutdown		; 1 = system shutdown
+	dd	sysfn_terminate 	; 2 = terminate thread
+	dd	sysfn_activate		; 3 = activate window
+	dd	sysfn_getidletime	; 4 = get idle time
+	dd	sysfn_getcpuclock	; 5 = get cpu clock
+	dd	sysfn_saveramdisk	; 6 = save ramdisk
+	dd	sysfn_getactive 	; 7 = get active window
+	dd	sysfn_sound_flag	; 8 = get/set sound_flag
+	dd	sysfn_shutdown_param	; 9 = shutdown with parameter
+	dd	sysfn_minimize		; 10 = minimize window
+	dd	sysfn_getdiskinfo	; 11 = get disk subsystem info
+	dd	sysfn_lastkey		; 12 = get last pressed key
+	dd	sysfn_getversion	; 13 = get kernel version
+	dd	sysfn_waitretrace	; 14 = wait retrace
+	dd	sysfn_centermouse	; 15 = center mouse cursor
+	dd	sysfn_getfreemem	; 16 = get free memory size
+	dd	sysfn_getallmem 	; 17 = get total memory size
+	dd	sysfn_terminate2	; 18 = terminate thread using PID
+					;                 instead of slot
+	dd	sysfn_mouse_acceleration; 19 = set/get mouse acceleration
+	dd	sysfn_meminfo		; 20 = get extended memory info
+	dd	sysfn_pid_to_slot	; 21 = get slot number for pid
+	dd	sysfn_min_rest_window	; 22 = minimize and restore any window
 sysfn_num = ($ - sys_system_table)/4
 endg
 
 sys_system:
-        dec     ebx
-        cmp     ebx, sysfn_num
-        jae     @f
-        jmp     dword [sys_system_table + ebx*4]
+	dec	ebx
+	cmp	ebx, sysfn_num
+	jae	@f
+	jmp	dword [sys_system_table + ebx*4]
 @@:
-        ret
+	ret
 
-sysfn_shutdown:         ; 18.1 = BOOT
+sysfn_shutdown: 	; 18.1 = BOOT
      mov  [BOOT_VAR+0x9030],byte 0
   for_shutdown_parameter:
 
@@ -2073,7 +2073,7 @@ sysfn_shutdown:         ; 18.1 = BOOT
    shutdown_processes: dd 0x0
   endg
 
-sysfn_terminate:        ; 18.2 = TERMINATE
+sysfn_terminate:	; 18.2 = TERMINATE
      cmp  ecx,2
      jb   noprocessterminate
      mov  edx,[TASK_COUNT]
@@ -2087,7 +2087,7 @@ sysfn_terminate:        ; 18.2 = TERMINATE
      jz   noprocessterminate
 
      ;call MEM_Heap_Lock      ;guarantee that process isn't working with heap
-     mov  [ecx],byte 3       ; clear possible i40's
+     mov  [ecx],byte 3	     ; clear possible i40's
      ;call MEM_Heap_UnLock
 
      cmp  edx,[application_table_status]    ; clear app table stat
@@ -2102,7 +2102,7 @@ sysfn_terminate2:
 .table_status:
     cli
     cmp    [application_table_status],0
-    je     .stf
+    je	   .stf
     sti
     call   change_task
     jmp    .table_status
@@ -2111,7 +2111,7 @@ sysfn_terminate2:
     mov    eax,ecx
     call   pid_to_slot
     test   eax,eax
-    jz     .not_found
+    jz	   .not_found
     mov    ecx,eax
     cli
     call   sysfn_terminate
@@ -2121,10 +2121,10 @@ sysfn_terminate2:
     ret
 .not_found:
     mov    [application_table_status],0
-    or     dword [esp+32],-1
+    or	   dword [esp+32],-1
     ret
 
-sysfn_activate:         ; 18.3 = ACTIVATE WINDOW
+sysfn_activate: 	; 18.3 = ACTIVATE WINDOW
      cmp  ecx,2
      jb   .nowindowactivate
      cmp  ecx,[TASK_COUNT]
@@ -2145,12 +2145,12 @@ sysfn_activate:         ; 18.3 = ACTIVATE WINDOW
 .nowindowactivate:
      ret
 
-sysfn_getidletime:              ; 18.4 = GET IDLETIME
+sysfn_getidletime:		; 18.4 = GET IDLETIME
      mov  eax,[idleusesec]
      mov  [esp+32], eax
      ret
 
-sysfn_getcpuclock:              ; 18.5 = GET TSC/SEC
+sysfn_getcpuclock:		; 18.5 = GET TSC/SEC
      mov  eax,[CPU_FREQ]
      mov  [esp+32], eax
      ret
@@ -2160,13 +2160,13 @@ sysfn_getcpuclock:              ; 18.5 = GET TSC/SEC
    include 'blkdev/rdsave.inc'
 ;!!!!!!!!!!!!!!!!!!!!!!!!
 
-sysfn_getactive:        ; 18.7 = get active window
+sysfn_getactive:	; 18.7 = get active window
      mov  eax, [TASK_COUNT]
    movzx  eax, word [WIN_POS + eax*2]
      mov  [esp+32],eax
      ret
 
-sysfn_sound_flag:       ; 18.8 = get/set sound_flag
+sysfn_sound_flag:	; 18.8 = get/set sound_flag
      cmp  ecx,1
      jne  nogetsoundflag
      movzx  eax,byte [sound_flag] ; get sound_flag
@@ -2179,7 +2179,7 @@ sysfn_sound_flag:       ; 18.8 = get/set sound_flag
  nosoundflag:
      ret
 
-sysfn_shutdown_param:   ; 18.9 = system shutdown with param
+sysfn_shutdown_param:	; 18.9 = system shutdown with param
      cmp  ecx,1
      jl   exit_for_anyone
      cmp  ecx,4
@@ -2187,12 +2187,12 @@ sysfn_shutdown_param:   ; 18.9 = system shutdown with param
      mov  [BOOT_VAR+0x9030],cl
      jmp  for_shutdown_parameter
 
-sysfn_minimize:         ; 18.10 = minimize window
+sysfn_minimize: 	; 18.10 = minimize window
      mov   [window_minimize],1
  exit_for_anyone:
      ret
 
-sysfn_getdiskinfo:      ; 18.11 = get disk info table
+sysfn_getdiskinfo:	; 18.11 = get disk info table
      cmp  ecx,1
      jnz  full_table
   small_table:
@@ -2214,11 +2214,11 @@ sysfn_getdiskinfo:      ; 18.11 = get disk info table
      rep movsd
      ret
 
-sysfn_lastkey:          ; 18.12 = return 0 (backward compatibility)
-        and     dword [esp+32], 0
-        ret
+sysfn_lastkey:		; 18.12 = return 0 (backward compatibility)
+	and	dword [esp+32], 0
+	ret
 
-sysfn_getversion:       ; 18.13 = get kernel ID and version
+sysfn_getversion:	; 18.13 = get kernel ID and version
      mov edi,ebx
      mov esi,version_inf
      mov ecx,version_end-version_inf
@@ -2236,7 +2236,7 @@ sysfn_waitretrace:     ; 18.14 = sys wait retrace
      and [esp+32],dword 0
      ret
 
-sysfn_centermouse:      ; 18.15 = mouse centered
+sysfn_centermouse:	; 18.15 = mouse centered
      call  mouse_centered
      and [esp+32],dword 0
      ret
@@ -2301,14 +2301,14 @@ sysfn_pid_to_slot:
 
 sysfn_min_rest_window:
      pushad
-     mov   eax, edx      ; ebx - operating
+     mov   eax, edx	 ; ebx - operating
      shr   ecx, 1
      jnc    @f
      call  pid_to_slot
 @@:
-     or    eax, eax      ; eax - number of slot
+     or    eax, eax	 ; eax - number of slot
      jz    .error
-     cmp   eax, 255         ; varify maximal slot number
+     cmp   eax, 255	    ; varify maximal slot number
      ja    .error
      movzx eax, word [WIN_STACK + eax*2]
      shr   ecx, 1
@@ -2336,7 +2336,7 @@ uglobal
 screen_workarea RECT
 ;// mike.dld, 2006-29-01 ]
 window_minimize db 0
-sound_flag      db 0
+sound_flag	db 0
 endg
 
 iglobal
@@ -2348,8 +2348,8 @@ version_end:
 endg
 
 UID_NONE=0
-UID_MENUETOS=1   ;official
-UID_KOLIBRI=2    ;russian
+UID_MENUETOS=1	 ;official
+UID_KOLIBRI=2	 ;russian
 
 sys_cachetodiskette:
 	cmp	ebx, 1
@@ -2378,19 +2378,19 @@ endg
 
 sys_background:
 
-    cmp   ebx,1                            ; BACKGROUND SIZE
+    cmp   ebx,1 			   ; BACKGROUND SIZE
     jnz   nosb1
     cmp   ecx,0
-    je    sbgrr
+    je	  sbgrr
     cmp   edx,0
-    je    sbgrr
+    je	  sbgrr
 @@:
-        mov     al, 1
-        xchg    [bgrlock], al
-        test    al, al
-        jz      @f
-        call    change_task
-        jmp     @b
+	mov	al, 1
+	xchg	[bgrlock], al
+	test	al, al
+	jz	@f
+	call	change_task
+	jmp	@b
 @@:
     mov   [BgrDataWidth],ecx
     mov   [BgrDataHeight],edx
@@ -2421,14 +2421,14 @@ sys_background:
     mov [img_background], eax
 .exit_mem:
     popad
-        mov     [bgrlock], 0
+	mov	[bgrlock], 0
 
   sbgrr:
     ret
 
   nosb1:
 
-    cmp   ebx,2                            ; SET PIXEL
+    cmp   ebx,2 			   ; SET PIXEL
     jnz   nosb2
     cmp   ecx,[mem_BACKGROUND]
     jae   nosb2
@@ -2442,7 +2442,7 @@ sys_background:
     ret
   nosb2:
 
-    cmp   ebx,3                            ; DRAW BACKGROUND
+    cmp   ebx,3 			   ; DRAW BACKGROUND
     jnz   nosb3
 draw_background_temp:
 ;    cmp   [bgrchanged],1 ;0
@@ -2456,17 +2456,17 @@ draw_background_temp:
     ret
   nosb3:
 
-    cmp   ebx,4                            ; TILED / STRETCHED
+    cmp   ebx,4 			   ; TILED / STRETCHED
     jnz   nosb4
     cmp   ecx,[BgrDrawMode]
-    je    nosb41
+    je	  nosb41
     mov   [BgrDrawMode],ecx
 ;    mov   [bgrchanged],1
    nosb41:
     ret
   nosb4:
 
-    cmp   ebx,5                            ; BLOCK MOVE TO BGR
+    cmp   ebx,5 			   ; BLOCK MOVE TO BGR
     jnz   nosb5
   ; bughere
     mov   eax, ecx
@@ -2478,83 +2478,83 @@ draw_background_temp:
     ret
   nosb5:
 
-        cmp     ebx, 6
-        jnz     nosb6
+	cmp	ebx, 6
+	jnz	nosb6
 @@:
-        mov     al, 1
-        xchg    [bgrlock], al
-        test    al, al
-        jz      @f
-        call    change_task
-        jmp     @b
+	mov	al, 1
+	xchg	[bgrlock], al
+	test	al, al
+	jz	@f
+	call	change_task
+	jmp	@b
 @@:
-        mov     eax, [CURRENT_TASK]
-        mov     [bgrlockpid], eax
-        stdcall user_alloc, [mem_BACKGROUND]
-        mov     [esp+32], eax
-        test    eax, eax
-        jz      .nomem
-        mov     ebx, eax
-        shr     ebx, 12
-        or      dword [page_tabs+(ebx-1)*4], DONT_FREE_BLOCK
-        mov     esi, [img_background]
-        shr     esi, 12
-        mov     ecx, [mem_BACKGROUND]
-        add     ecx, 0xFFF
-        shr     ecx, 12
+	mov	eax, [CURRENT_TASK]
+	mov	[bgrlockpid], eax
+	stdcall user_alloc, [mem_BACKGROUND]
+	mov	[esp+32], eax
+	test	eax, eax
+	jz	.nomem
+	mov	ebx, eax
+	shr	ebx, 12
+	or	dword [page_tabs+(ebx-1)*4], DONT_FREE_BLOCK
+	mov	esi, [img_background]
+	shr	esi, 12
+	mov	ecx, [mem_BACKGROUND]
+	add	ecx, 0xFFF
+	shr	ecx, 12
 .z:
-        mov     eax, [page_tabs+ebx*4]
-        test    al, 1
-        jz      @f
-        call    free_page
+	mov	eax, [page_tabs+ebx*4]
+	test	al, 1
+	jz	@f
+	call	free_page
 @@:
-        mov     eax, [page_tabs+esi*4]
-        or      al, PG_UW
-        mov     [page_tabs+ebx*4], eax
-        mov     eax, ebx
-        shl     eax, 12
-        invlpg  [eax]
-        inc     ebx
-        inc     esi
-        loop    .z
-        ret
+	mov	eax, [page_tabs+esi*4]
+	or	al, PG_UW
+	mov	[page_tabs+ebx*4], eax
+	mov	eax, ebx
+	shl	eax, 12
+	invlpg	[eax]
+	inc	ebx
+	inc	esi
+	loop	.z
+	ret
 .nomem:
-        and     [bgrlockpid], 0
-        mov     [bgrlock], 0
+	and	[bgrlockpid], 0
+	mov	[bgrlock], 0
 nosb6:
-        cmp     ebx, 7
-        jnz     nosb7
-        cmp     [bgrlock], 0
-        jz      .err
-        mov     eax, [CURRENT_TASK]
-        cmp     [bgrlockpid], eax
-        jnz     .err
-        mov     eax, ecx
-        mov     ebx, ecx
-        shr     eax, 12
-        mov     ecx, [page_tabs+(eax-1)*4]
-        test    cl, USED_BLOCK+DONT_FREE_BLOCK
-        jz      .err
-        jnp     .err
-        push    eax
-        shr     ecx, 12
+	cmp	ebx, 7
+	jnz	nosb7
+	cmp	[bgrlock], 0
+	jz	.err
+	mov	eax, [CURRENT_TASK]
+	cmp	[bgrlockpid], eax
+	jnz	.err
+	mov	eax, ecx
+	mov	ebx, ecx
+	shr	eax, 12
+	mov	ecx, [page_tabs+(eax-1)*4]
+	test	cl, USED_BLOCK+DONT_FREE_BLOCK
+	jz	.err
+	jnp	.err
+	push	eax
+	shr	ecx, 12
 @@:
-        and     dword [page_tabs+eax*4], 0
-        mov     edx, eax
-        shl     edx, 12
-        invlpg  [edx]
-        inc     eax
-        loop    @b
-        pop     eax
-        and     dword [page_tabs+(eax-1)*4], not DONT_FREE_BLOCK
-        stdcall user_free, ebx
-        mov     [esp+32], eax
-        and     [bgrlockpid], 0
-        mov     [bgrlock], 0
-        ret
+	and	dword [page_tabs+eax*4], 0
+	mov	edx, eax
+	shl	edx, 12
+	invlpg	[edx]
+	inc	eax
+	loop	@b
+	pop	eax
+	and	dword [page_tabs+(eax-1)*4], not DONT_FREE_BLOCK
+	stdcall user_free, ebx
+	mov	[esp+32], eax
+	and	[bgrlockpid], 0
+	mov	[bgrlock], 0
+	ret
 .err:
-        and     dword [esp+32], 0
-        ret
+	and	dword [esp+32], 0
+	ret
 
 nosb7:
     ret
@@ -2575,7 +2575,7 @@ align 4
 
 sys_getbackground:
 
-    cmp   eax,1                                  ; SIZE
+    cmp   eax,1 				 ; SIZE
     jnz   nogb1
     mov   eax,[BgrDataWidth]
     shl   eax,16
@@ -2584,7 +2584,7 @@ sys_getbackground:
     ret
   nogb1:
 
-    cmp   eax,2                                  ; PIXEL
+    cmp   eax,2 				 ; PIXEL
     jnz   nogb2
 ;    mov   edx,0x160000-16
 ;    cmp   edx,ebx
@@ -2598,7 +2598,7 @@ sys_getbackground:
     ret
   nogb2:
 
-    cmp   eax,4                                  ; TILED / STRETCHED
+    cmp   eax,4 				 ; TILED / STRETCHED
     jnz   nogb4
     mov   eax,[BgrDrawMode]
   nogb4:
@@ -2611,7 +2611,7 @@ align 4
 sys_getkey:
 	mov	[esp + 32],dword 1
 	; test main buffer
-	mov	ebx, [CURRENT_TASK]                          ; TOP OF WINDOW STACK
+	mov	ebx, [CURRENT_TASK]			     ; TOP OF WINDOW STACK
 	movzx	ecx, word [WIN_STACK + ebx * 2]
 	mov	edx, [TASK_COUNT]
 	cmp	ecx, edx
@@ -2655,7 +2655,7 @@ align 4
 
 sys_getbutton:
 
-	mov	ebx, [CURRENT_TASK]                         ; TOP OF WINDOW STACK
+	mov	ebx, [CURRENT_TASK]			    ; TOP OF WINDOW STACK
 	mov	[esp + 32], dword 1
 	movzx	ecx, word [WIN_STACK + ebx * 2]
 	mov	edx, [TASK_COUNT] ; less than 256 processes
@@ -2687,78 +2687,78 @@ sys_cpuusage:
 ;  +30 dword     PID , process idenfification number
 ;
 
-    cmp  ecx,-1         ; who am I ?
+    cmp  ecx,-1 	; who am I ?
     jne  .no_who_am_i
     mov  ecx,[CURRENT_TASK]
   .no_who_am_i:
-        cmp     ecx, max_processes
-        ja      .nofillbuf
+	cmp	ecx, max_processes
+	ja	.nofillbuf
 
 ; +4: word: position of the window of thread in the window stack
-        mov     ax, [WIN_STACK + ecx * 2]
-        mov     [ebx+4], ax
+	mov	ax, [WIN_STACK + ecx * 2]
+	mov	[ebx+4], ax
 ; +6: word: number of the thread slot, which window has in the window stack
 ;           position ecx (has no relation to the specific thread)
-        mov     ax, [WIN_POS + ecx * 2]
-        mov     [ebx+6], ax
+	mov	ax, [WIN_POS + ecx * 2]
+	mov	[ebx+6], ax
 
-        shl     ecx, 5
+	shl	ecx, 5
 
 ; +0: dword: memory usage
-        mov     eax, [ecx+CURRENT_TASK+TASKDATA.cpu_usage]
-        mov     [ebx], eax
+	mov	eax, [ecx+CURRENT_TASK+TASKDATA.cpu_usage]
+	mov	[ebx], eax
 ; +10: 11 bytes: name of the process
-        push    ecx
-        lea     eax, [ecx*8+SLOT_BASE+APPDATA.app_name]
-        add     ebx, 10
-        mov     ecx, 11
-        call    memmove
-        pop     ecx
+	push	ecx
+	lea	eax, [ecx*8+SLOT_BASE+APPDATA.app_name]
+	add	ebx, 10
+	mov	ecx, 11
+	call	memmove
+	pop	ecx
 
 ; +22: address of the process in memory
 ; +26: size of used memory - 1
-        push    edi
-        lea     edi, [ebx+12]
-        xor     eax, eax
-        mov     edx, 0x100000*16
-        cmp     ecx, 1 shl 5
-        je      .os_mem
-        mov     edx, [SLOT_BASE+ecx*8+APPDATA.mem_size]
-        mov     eax, std_application_base_address
+	push	edi
+	lea	edi, [ebx+12]
+	xor	eax, eax
+	mov	edx, 0x100000*16
+	cmp	ecx, 1 shl 5
+	je	.os_mem
+	mov	edx, [SLOT_BASE+ecx*8+APPDATA.mem_size]
+	mov	eax, std_application_base_address
 .os_mem:
-        stosd
-        lea     eax, [edx-1]
-        stosd
+	stosd
+	lea	eax, [edx-1]
+	stosd
 
 ; +30: PID/TID
-        mov     eax, [ecx+CURRENT_TASK+TASKDATA.pid]
-        stosd
+	mov	eax, [ecx+CURRENT_TASK+TASKDATA.pid]
+	stosd
 
     ; window position and size
-        push    esi
-        lea     esi, [ecx + window_data + WDATA.box]
-        movsd
-        movsd
-        movsd
-        movsd
+	push	esi
+	lea	esi, [ecx + window_data + WDATA.box]
+	movsd
+	movsd
+	movsd
+	movsd
 
     ; Process state (+50)
-        mov     eax, dword [ecx+CURRENT_TASK+TASKDATA.state]
-        stosd
+	mov	eax, dword [ecx+CURRENT_TASK+TASKDATA.state]
+	stosd
 
     ; Window client area box
-        lea     esi, [ecx*8 + SLOT_BASE + APPDATA.wnd_clientbox]
-        movsd
-        movsd
-        movsd
-        movsd
+	lea	esi, [ecx*8 + SLOT_BASE + APPDATA.wnd_clientbox]
+	movsd
+	movsd
+	movsd
+	movsd
 
     ; Window state
-        mov     al, [ecx+window_data+WDATA.fl_wstate]
-        stosb
+	mov	al, [ecx+window_data+WDATA.fl_wstate]
+	stosb
 
-        pop     esi
-        pop     edi
+	pop	esi
+	pop	edi
 
 .nofillbuf:
     ; return number of processes
@@ -2769,72 +2769,72 @@ sys_cpuusage:
 
 align 4
 sys_clock:
-        cli
+	cli
   ; Mikhail Lisovin  xx Jan 2005
-  @@:   mov   al, 10
-        out   0x70, al
-        in    al, 0x71
-        test  al, al
-        jns   @f
-        mov   esi, 1
-        call  delay_ms
-        jmp   @b
+  @@:	mov   al, 10
+	out   0x70, al
+	in    al, 0x71
+	test  al, al
+	jns   @f
+	mov   esi, 1
+	call  delay_ms
+	jmp   @b
   @@:
   ; end Lisovin's fix
 
-        xor   al,al           ; seconds
-        out   0x70,al
-        in    al,0x71
-        movzx ecx,al
-        mov   al,02           ; minutes
-        shl   ecx,16
-        out   0x70,al
-        in    al,0x71
-        movzx edx,al
-        mov   al,04           ; hours
-        shl   edx,8
-        out   0x70,al
-        in    al,0x71
-        add   ecx,edx
-        movzx edx,al
-        add   ecx,edx
-        sti
+	xor   al,al	      ; seconds
+	out   0x70,al
+	in    al,0x71
+	movzx ecx,al
+	mov   al,02	      ; minutes
+	shl   ecx,16
+	out   0x70,al
+	in    al,0x71
+	movzx edx,al
+	mov   al,04	      ; hours
+	shl   edx,8
+	out   0x70,al
+	in    al,0x71
+	add   ecx,edx
+	movzx edx,al
+	add   ecx,edx
+	sti
 	mov	[esp + 32], ecx
-        ret
+	ret
 
 
 align 4
 
 sys_date:
 
-        cli
-  @@:   mov   al, 10
-        out   0x70, al
-        in    al, 0x71
-        test  al, al
-        jns   @f
-        mov   esi, 1
-        call  delay_ms
-        jmp   @b
+	cli
+  @@:	mov   al, 10
+	out   0x70, al
+	in    al, 0x71
+	test  al, al
+	jns   @f
+	mov   esi, 1
+	call  delay_ms
+	jmp   @b
   @@:
 
-        mov     ch,0
-        mov     al,7            ; date
-        out     0x70,al
-        in      al,0x71
-        mov     cl,al
-        mov     al,8            ; month
-        shl     ecx,16
-        out     0x70,al
-        in      al,0x71
-        mov     ch,al
-        mov     al,9            ; year
-        out     0x70,al
-        in      al,0x71
-        mov     cl,al
-        sti
-        mov     [esp+32], ecx
-        ret
+	mov	ch,0
+	mov	al,7		; date
+	out	0x70,al
+	in	al,0x71
+	mov	cl,al
+	mov	al,8		; month
+	shl	ecx,16
+	out	0x70,al
+	in	al,0x71
+	mov	ch,al
+	mov	al,9		; year
+	out	0x70,al
+	in	al,0x71
+	mov	cl,al
+	sti
+	mov	[esp+32], ecx
+	ret
 
 
 ; redraw status
@@ -2846,7 +2846,7 @@ sys_redrawstat:
 	mov	ecx,[CURRENT_TASK]
   sys_newba2:
 	mov	edi,[BTN_ADDR]
-	cmp	[edi], dword 0  ; empty button list ?
+	cmp	[edi], dword 0	; empty button list ?
 	je	end_of_buttons_away
 	movzx	ebx, word [edi]
 	inc	ebx
@@ -2917,7 +2917,7 @@ sys_drawwindow:
     jmp   draw_window_caption.2
   nosyswI:
 
-    cmp   al,1    ; type II   - only reserve area, no draw
+    cmp   al,1	  ; type II   - only reserve area, no draw
     jne   nosyswII
     inc   [mouse_pause]
     call  [disable_mouse]
@@ -2929,7 +2929,7 @@ sys_drawwindow:
     ret
   nosyswII:
 
-    cmp   al,2    ; type III  - new style
+    cmp   al,2	  ; type III  - new style
     jne   nosyswIII
     inc   [mouse_pause]
     call  [disable_mouse]
@@ -2942,9 +2942,9 @@ sys_drawwindow:
     jmp   draw_window_caption.2
   nosyswIII:
 
-    cmp   al,3    ; type IV - skinned window
-    je    draw_skin_window
-    cmp   al,4    ; type V - skinned window not sized! {not_sized_skin_window}
+    cmp   al,3	  ; type IV - skinned window
+    je	  draw_skin_window
+    cmp   al,4	  ; type V - skinned window not sized! {not_sized_skin_window}
     jne   nosyswV
   draw_skin_window:
 
@@ -2969,177 +2969,177 @@ sys_drawwindow:
 
 
 draw_window_caption:
-        inc     [mouse_pause]
-        call    [disable_mouse]
+	inc	[mouse_pause]
+	call	[disable_mouse]
 
-        xor     eax,eax
-        mov     edx,[TASK_COUNT]
-        movzx   edx,word[WIN_POS+edx*2]
-        cmp     edx,[CURRENT_TASK]
-        jne     @f
-        inc     eax
-    @@: mov     edx,[CURRENT_TASK]
-        shl     edx,5
-        add     edx,window_data
-        movzx   ebx,[edx+WDATA.fl_wstyle]
-        and     bl,0x0F
-        cmp     bl,3
-        je      .draw_caption_style_3		;{for 3 and 4 style write caption}
-        cmp     bl,4
-        je      .draw_caption_style_3
+	xor	eax,eax
+	mov	edx,[TASK_COUNT]
+	movzx	edx,word[WIN_POS+edx*2]
+	cmp	edx,[CURRENT_TASK]
+	jne	@f
+	inc	eax
+    @@: mov	edx,[CURRENT_TASK]
+	shl	edx,5
+	add	edx,window_data
+	movzx	ebx,[edx+WDATA.fl_wstyle]
+	and	bl,0x0F
+	cmp	bl,3
+	je	.draw_caption_style_3		;{for 3 and 4 style write caption}
+	cmp	bl,4
+	je	.draw_caption_style_3
 
-        jmp     .not_style_3
+	jmp	.not_style_3
   .draw_caption_style_3:
 
-        push    edx
-        call    drawwindow_IV_caption
-        add     esp,4
-        jmp     .2
+	push	edx
+	call	drawwindow_IV_caption
+	add	esp,4
+	jmp	.2
 
   .not_style_3:
-        cmp     bl,2
-        jne     .not_style_2
+	cmp	bl,2
+	jne	.not_style_2
 
-        call    drawwindow_III_caption
-        jmp     .2
+	call	drawwindow_III_caption
+	jmp	.2
 
   .not_style_2:
-        cmp     bl,0
-        jne     .2
+	cmp	bl,0
+	jne	.2
 
-        call    drawwindow_I_caption
+	call	drawwindow_I_caption
 
 ;--------------------------------------------------------------
-  .2:   ;jmp     @f
-        mov     edi,[CURRENT_TASK]
-        shl     edi,5
-        test    [edi+window_data+WDATA.fl_wstyle],WSTYLE_HASCAPTION
-        jz      @f
-        mov     edx,[edi*8+SLOT_BASE+APPDATA.wnd_caption]
-        or      edx,edx
-        jz      @f
+  .2:	;jmp     @f
+	mov	edi,[CURRENT_TASK]
+	shl	edi,5
+	test	[edi+window_data+WDATA.fl_wstyle],WSTYLE_HASCAPTION
+	jz	@f
+	mov	edx,[edi*8+SLOT_BASE+APPDATA.wnd_caption]
+	or	edx,edx
+	jz	@f
 
-        movzx   eax,[edi+window_data+WDATA.fl_wstyle]
-        and     al,0x0F
-        cmp     al,3
-        je      .skinned
-        cmp     al,4
-        je      .skinned
+	movzx	eax,[edi+window_data+WDATA.fl_wstyle]
+	and	al,0x0F
+	cmp	al,3
+	je	.skinned
+	cmp	al,4
+	je	.skinned
 
-        jmp     .not_skinned
+	jmp	.not_skinned
   .skinned:
-        mov     ebp,[edi+window_data+WDATA.box.left-2]
-        mov     bp,word[edi+window_data+WDATA.box.top]
-        movzx   eax,word[edi+window_data+WDATA.box.width]
-        sub     ax,[_skinmargins.left]
-        sub     ax,[_skinmargins.right]
-        push    edx
-        cwde
-        cdq
-        mov     ebx,6
-        idiv    ebx
-        pop     edx
-        or      eax,eax
-        js      @f
-        mov     esi,eax
-        mov     ebx,dword[_skinmargins.left-2]
-        mov     bx,word[_skinh]
-        sub     bx,[_skinmargins.bottom]
-        sub     bx,[_skinmargins.top]
-        sar     bx,1
-        adc     bx,0
-        add     bx,[_skinmargins.top]
-        add     bx,-3
-        add     ebx,ebp
-        jmp     .dodraw
+	mov	ebp,[edi+window_data+WDATA.box.left-2]
+	mov	bp,word[edi+window_data+WDATA.box.top]
+	movzx	eax,word[edi+window_data+WDATA.box.width]
+	sub	ax,[_skinmargins.left]
+	sub	ax,[_skinmargins.right]
+	push	edx
+	cwde
+	cdq
+	mov	ebx,6
+	idiv	ebx
+	pop	edx
+	or	eax,eax
+	js	@f
+	mov	esi,eax
+	mov	ebx,dword[_skinmargins.left-2]
+	mov	bx,word[_skinh]
+	sub	bx,[_skinmargins.bottom]
+	sub	bx,[_skinmargins.top]
+	sar	bx,1
+	adc	bx,0
+	add	bx,[_skinmargins.top]
+	add	bx,-3
+	add	ebx,ebp
+	jmp	.dodraw
 
   .not_skinned:
-        cmp     al,1
-        je      @f
+	cmp	al,1
+	je	@f
 
-        mov     ebp,[edi+window_data+WDATA.box.left-2]
-        mov     bp,word[edi+window_data+WDATA.box.top]
-        movzx   eax,word[edi+window_data+WDATA.box.width]
-        sub     eax,16
-        push    edx
-        cwde
-        cdq
-        mov     ebx,6
-        idiv    ebx
-        pop     edx
-        or      eax,eax
-        js      @f
-        mov     esi,eax
-        mov     ebx,0x00080007
-        add     ebx,ebp
+	mov	ebp,[edi+window_data+WDATA.box.left-2]
+	mov	bp,word[edi+window_data+WDATA.box.top]
+	movzx	eax,word[edi+window_data+WDATA.box.width]
+	sub	eax,16
+	push	edx
+	cwde
+	cdq
+	mov	ebx,6
+	idiv	ebx
+	pop	edx
+	or	eax,eax
+	js	@f
+	mov	esi,eax
+	mov	ebx,0x00080007
+	add	ebx,ebp
 .dodraw:
-        mov     ecx,[common_colours+16];0x00FFFFFF
-        or      ecx, 0x80000000
-        xor     edi,edi
-        call    dtext
+	mov	ecx,[common_colours+16];0x00FFFFFF
+	or	ecx, 0x80000000
+	xor	edi,edi
+	call	dtext
 
     @@:
 ;--------------------------------------------------------------
-        dec     [mouse_pause]
-        call    [draw_pointer]
-        ret
+	dec	[mouse_pause]
+	call	[draw_pointer]
+	ret
 
 iglobal
 align 4
 window_topleft dd \
   1, 21,\		;type 0
-  0,  0,\       ;type 1
-  5, 20,\       ;type 2
-  5,  ?,\       ;type 3 {set by skin}
-  5,  ?         ;type 4 {set by skin}
+  0,  0,\	;type 1
+  5, 20,\	;type 2
+  5,  ?,\	;type 3 {set by skin}
+  5,  ? 	;type 4 {set by skin}
 endg
 
 set_window_clientbox:
-        push    eax ecx edi
+	push	eax ecx edi
 
-        mov     eax,[_skinh]
-        mov     [window_topleft+4*7],eax
-        mov     [window_topleft+4*9],eax
+	mov	eax,[_skinh]
+	mov	[window_topleft+4*7],eax
+	mov	[window_topleft+4*9],eax
 
-        mov     ecx,edi
-        sub     edi,window_data
-        shl     edi,3
-        test    [ecx+WDATA.fl_wstyle],WSTYLE_CLIENTRELATIVE
-        jz      @f
+	mov	ecx,edi
+	sub	edi,window_data
+	shl	edi,3
+	test	[ecx+WDATA.fl_wstyle],WSTYLE_CLIENTRELATIVE
+	jz	@f
 
-        movzx   eax,[ecx+WDATA.fl_wstyle]
-        and     eax,0x0F
-        mov     eax,[eax*8+window_topleft+0]
-        mov     [edi+SLOT_BASE+APPDATA.wnd_clientbox.left],eax
-        shl     eax,1
-        neg     eax
-        add     eax,[ecx+WDATA.box.width]
-        mov     [edi+SLOT_BASE+APPDATA.wnd_clientbox.width],eax
+	movzx	eax,[ecx+WDATA.fl_wstyle]
+	and	eax,0x0F
+	mov	eax,[eax*8+window_topleft+0]
+	mov	[edi+SLOT_BASE+APPDATA.wnd_clientbox.left],eax
+	shl	eax,1
+	neg	eax
+	add	eax,[ecx+WDATA.box.width]
+	mov	[edi+SLOT_BASE+APPDATA.wnd_clientbox.width],eax
 
-        movzx   eax,[ecx+WDATA.fl_wstyle]
-        and     eax,0x0F
-        push    [eax*8+window_topleft+0]
-        mov     eax,[eax*8+window_topleft+4]
-        mov     [edi+SLOT_BASE+APPDATA.wnd_clientbox.top],eax
-        neg     eax
-        sub     eax,[esp]
-        add     eax,[ecx+WDATA.box.height]
-        mov     [edi+SLOT_BASE+APPDATA.wnd_clientbox.height],eax
-        add     esp,4
+	movzx	eax,[ecx+WDATA.fl_wstyle]
+	and	eax,0x0F
+	push	[eax*8+window_topleft+0]
+	mov	eax,[eax*8+window_topleft+4]
+	mov	[edi+SLOT_BASE+APPDATA.wnd_clientbox.top],eax
+	neg	eax
+	sub	eax,[esp]
+	add	eax,[ecx+WDATA.box.height]
+	mov	[edi+SLOT_BASE+APPDATA.wnd_clientbox.height],eax
+	add	esp,4
 
-        pop     edi ecx eax
-        ret
+	pop	edi ecx eax
+	ret
     @@:
-        xor     eax,eax
-        mov     [edi+SLOT_BASE+APPDATA.wnd_clientbox.left],eax
-        mov     [edi+SLOT_BASE+APPDATA.wnd_clientbox.top],eax
-        mov     eax,[ecx+WDATA.box.width]
-        mov     [edi+SLOT_BASE+APPDATA.wnd_clientbox.width],eax
-        mov     eax,[ecx+WDATA.box.height]
-        mov     [edi+SLOT_BASE+APPDATA.wnd_clientbox.height],eax
+	xor	eax,eax
+	mov	[edi+SLOT_BASE+APPDATA.wnd_clientbox.left],eax
+	mov	[edi+SLOT_BASE+APPDATA.wnd_clientbox.top],eax
+	mov	eax,[ecx+WDATA.box.width]
+	mov	[edi+SLOT_BASE+APPDATA.wnd_clientbox.width],eax
+	mov	eax,[ecx+WDATA.box.height]
+	mov	[edi+SLOT_BASE+APPDATA.wnd_clientbox.height],eax
 
-        pop     edi ecx eax
-        ret
+	pop	edi ecx eax
+	ret
 
 sys_set_window:
 
@@ -3173,39 +3173,39 @@ sys_set_window:
 
     call  set_window_clientbox
 
-    push  ecx esi edi               ; save for window fullscreen/resize
+    push  ecx esi edi		    ; save for window fullscreen/resize
     ;mov   esi,edi
 
-        mov     cl, [edi+WDATA.fl_wstyle]
-        mov     eax, [edi+WDATA.cl_frames]
+	mov	cl, [edi+WDATA.fl_wstyle]
+	mov	eax, [edi+WDATA.cl_frames]
 
     sub   edi,window_data
     shl   edi,3
     add   edi,SLOT_BASE
 
-        and     cl,0x0F
-        mov     [edi+APPDATA.wnd_caption],0
-        cmp     cl,3
-        je      set_APPDATA_wnd_caption
-        cmp     cl,4								; {SPraid.simba}
-        je      set_APPDATA_wnd_caption
+	and	cl,0x0F
+	mov	[edi+APPDATA.wnd_caption],0
+	cmp	cl,3
+	je	set_APPDATA_wnd_caption
+	cmp	cl,4								; {SPraid.simba}
+	je	set_APPDATA_wnd_caption
 
-        jmp     @f
+	jmp	@f
     set_APPDATA_wnd_caption:
-        mov     [edi+APPDATA.wnd_caption],eax
-    @@: mov     esi,[esp+0]
+	mov	[edi+APPDATA.wnd_caption],eax
+    @@: mov	esi,[esp+0]
 
     add   edi, APPDATA.saved_box
-        movsd
-        movsd
-        movsd
-        movsd
+	movsd
+	movsd
+	movsd
+	movsd
     pop   edi esi ecx
 
-        mov     esi, [CURRENT_TASK]
-        movzx   esi, word [WIN_STACK+esi*2]
-        lea     esi, [WIN_POS+esi*2]
-        call    waredraw
+	mov	esi, [CURRENT_TASK]
+	movzx	esi, word [WIN_STACK+esi*2]
+	lea	esi, [WIN_POS+esi*2]
+	call	waredraw
 
 ;;;    mov   ebx, 1
 ;;;    call  delay_hs
@@ -3217,11 +3217,11 @@ sys_set_window:
     add   edx, ebx
     call  calculatescreen
 
-    mov   [KEY_COUNT],byte 0           ; empty keyboard buffer
-    mov   [BTN_COUNT],byte 0           ; empty button buffer
+    mov   [KEY_COUNT],byte 0	       ; empty keyboard buffer
+    mov   [BTN_COUNT],byte 0	       ; empty button buffer
 
   newd:
-    mov   [edi+WDATA.fl_redraw],byte 0   ; no redraw
+    mov   [edi+WDATA.fl_redraw],byte 0	 ; no redraw
     mov   edx,edi
 
     ret
@@ -3229,18 +3229,18 @@ sys_set_window:
 syscall_windowsettings:
 
   .set_window_caption:
-        dec     eax     ; subfunction #1 - set window caption
-        jnz     .get_window_caption
+	dec	eax	; subfunction #1 - set window caption
+	jnz	.get_window_caption
 
-        ; NOTE: only window owner thread can set its caption,
-        ;       so there's no parameter for PID/TID
+	; NOTE: only window owner thread can set its caption,
+	;       so there's no parameter for PID/TID
 
-        mov     edi,[CURRENT_TASK]
-        shl     edi,5
+	mov	edi,[CURRENT_TASK]
+	shl	edi,5
 
-        ; have to check if caption is within application memory limit
-        ; check is trivial, and if application resizes its memory,
-        ;   caption still can become over bounds
+	; have to check if caption is within application memory limit
+	; check is trivial, and if application resizes its memory,
+	;   caption still can become over bounds
 ; diamond, 31.10.2006: check removed because with new memory manager
 ; there can be valid data after APPDATA.mem_size bound
 ;        mov     ecx,[edi*8+SLOT_BASE+APPDATA.mem_size]
@@ -3248,115 +3248,115 @@ syscall_windowsettings:
 ;        cmp     ebx,ecx
 ;        ja      .exit_fail
 
-        mov     [edi*8+SLOT_BASE+APPDATA.wnd_caption],ebx
-        or      [edi+window_data+WDATA.fl_wstyle],WSTYLE_HASCAPTION
+	mov	[edi*8+SLOT_BASE+APPDATA.wnd_caption],ebx
+	or	[edi+window_data+WDATA.fl_wstyle],WSTYLE_HASCAPTION
 
-        call    draw_window_caption
+	call	draw_window_caption
 
-        xor     eax,eax ; eax = 0 (success)
-        ret
+	xor	eax,eax ; eax = 0 (success)
+	ret
 
   .get_window_caption:
-        dec     eax     ; subfunction #2 - get window caption
-        jnz     .exit_fail
+	dec	eax	; subfunction #2 - get window caption
+	jnz	.exit_fail
 
-        ; not implemented yet
+	; not implemented yet
 
   .exit_fail:
-        xor     eax,eax
-        inc     eax     ; eax = 1 (fail)
-        ret
+	xor	eax,eax
+	inc	eax	; eax = 1 (fail)
+	ret
 
 
 sys_window_move:
 
-        mov     edi,[CURRENT_TASK]
-        shl     edi,5
-        add     edi,window_data
+	mov	edi,[CURRENT_TASK]
+	shl	edi,5
+	add	edi,window_data
 
-        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
-        jnz     .window_move_return
+	test	[edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
+	jnz	.window_move_return
 
-        push    dword [edi + WDATA.box.left]  ; save old coordinates
-        push    dword [edi + WDATA.box.top]
-        push    dword [edi + WDATA.box.width]
-        push    dword [edi + WDATA.box.height]
+	push	dword [edi + WDATA.box.left]  ; save old coordinates
+	push	dword [edi + WDATA.box.top]
+	push	dword [edi + WDATA.box.width]
+	push	dword [edi + WDATA.box.height]
 
-        cmp   eax,-1                  ; set new position and size
-        je    .no_x_reposition
-        mov     [edi + WDATA.box.left], eax
+	cmp   eax,-1		      ; set new position and size
+	je    .no_x_reposition
+	mov	[edi + WDATA.box.left], eax
       .no_x_reposition:
-        cmp   ebx,-1
-        je    .no_y_reposition
-        mov     [edi + WDATA.box.top], ebx
+	cmp   ebx,-1
+	je    .no_y_reposition
+	mov	[edi + WDATA.box.top], ebx
       .no_y_reposition:
 
-        test    [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
-        jnz     .no_y_resizing
+	test	[edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
+	jnz	.no_y_resizing
 
-        cmp   ecx,-1
-        je    .no_x_resizing
-        mov     [edi + WDATA.box.width], ecx
+	cmp   ecx,-1
+	je    .no_x_resizing
+	mov	[edi + WDATA.box.width], ecx
       .no_x_resizing:
-        cmp   edx,-1
-        je    .no_y_resizing
-        mov     [edi + WDATA.box.height], edx
+	cmp   edx,-1
+	je    .no_y_resizing
+	mov	[edi + WDATA.box.height], edx
       .no_y_resizing:
 
-        call  check_window_position
-        call  set_window_clientbox
+	call  check_window_position
+	call  set_window_clientbox
 
-        pushad                       ; save for window fullscreen/resize
-        mov   esi,edi
-        sub   edi,window_data
-        shr   edi,5
-        shl   edi,8
-        add   edi, SLOT_BASE + APPDATA.saved_box
-        mov   ecx,4
-        cld
-        rep   movsd
-        popad
+	pushad			     ; save for window fullscreen/resize
+	mov   esi,edi
+	sub   edi,window_data
+	shr   edi,5
+	shl   edi,8
+	add   edi, SLOT_BASE + APPDATA.saved_box
+	mov   ecx,4
+	cld
+	rep   movsd
+	popad
 
-        pushad                       ; calculcate screen at new position
-        mov   eax, [edi + WDATA.box.left]
-        mov   ebx, [edi + WDATA.box.top]
-        mov   ecx, [edi + WDATA.box.width]
-        mov   edx, [edi + WDATA.box.height]
-        add   ecx,eax
-        add   edx,ebx
+	pushad			     ; calculcate screen at new position
+	mov   eax, [edi + WDATA.box.left]
+	mov   ebx, [edi + WDATA.box.top]
+	mov   ecx, [edi + WDATA.box.width]
+	mov   edx, [edi + WDATA.box.height]
+	add   ecx,eax
+	add   edx,ebx
 
-        call  calculatescreen
-        popad
+	call  calculatescreen
+	popad
 
-        pop   edx                   ; calculcate screen at old position
-        pop   ecx
-        pop   ebx
-        pop   eax
-        add   ecx,eax
-        add   edx,ebx
-        mov   [dlx],eax             ; save for drawlimits
-        mov   [dly],ebx
-        mov   [dlxe],ecx
-        mov   [dlye],edx
-        call  calculatescreen
+	pop   edx		    ; calculcate screen at old position
+	pop   ecx
+	pop   ebx
+	pop   eax
+	add   ecx,eax
+	add   edx,ebx
+	mov   [dlx],eax 	    ; save for drawlimits
+	mov   [dly],ebx
+	mov   [dlxe],ecx
+	mov   [dlye],edx
+	call  calculatescreen
 
-        mov   [edi + WDATA.fl_redraw], 1 ; flag the process as redraw
+	mov   [edi + WDATA.fl_redraw], 1 ; flag the process as redraw
 
-        mov   eax,edi               ; redraw screen at old position
-        xor   esi,esi
-        call  redrawscreen
+	mov   eax,edi		    ; redraw screen at old position
+	xor   esi,esi
+	call  redrawscreen
 
-        mov   [DONT_DRAW_MOUSE],byte 0 ; mouse pointer
-        mov   [MOUSE_BACKGROUND],byte 0 ; no mouse under
-        mov   [MOUSE_DOWN],byte 0 ; react to mouse up/down
+	mov   [DONT_DRAW_MOUSE],byte 0 ; mouse pointer
+	mov   [MOUSE_BACKGROUND],byte 0 ; no mouse under
+	mov   [MOUSE_DOWN],byte 0 ; react to mouse up/down
 
-        call  [draw_pointer]
+	call  [draw_pointer]
 
-        mov   [window_move_pr],0
+	mov   [window_move_pr],0
 
       .window_move_return:
 
-        ret
+	ret
 
 uglobal
   window_move_pr   dd  0x0
@@ -3442,8 +3442,8 @@ wrmsr_instr:
 
 	mov	eax, esi
 	wrmsr
-	; mov	[esp + 36], eax
-	; mov	[esp + 24], edx ;ret in ebx?
+	; mov   [esp + 36], eax
+	; mov   [esp + 24], edx ;ret in ebx?
 @@:
 ret
 
@@ -3485,27 +3485,27 @@ ret
 ; check if pixel is allowed to be drawn
 
 checkpixel:
-        push eax edx
+	push eax edx
 
-        mov  edx,[ScreenWidth]     ; screen x size
-        inc  edx
-        imul edx, ebx
-        mov  dl, [eax+edx+display_data] ; lea eax, [...]
+	mov  edx,[ScreenWidth]	   ; screen x size
+	inc  edx
+	imul edx, ebx
+	mov  dl, [eax+edx+display_data] ; lea eax, [...]
 
-        xor  ecx, ecx
-        mov  eax, [CURRENT_TASK]
-        cmp  al, dl
-        setne cl
+	xor  ecx, ecx
+	mov  eax, [CURRENT_TASK]
+	cmp  al, dl
+	setne cl
 
-        pop  edx eax
-        ret
+	pop  edx eax
+	ret
 
 iglobal
   cpustring db 'CPU',0
 endg
 
 uglobal
-background_defined    db    0    ; diamond, 11.04.2006
+background_defined    db    0	 ; diamond, 11.04.2006
 endg
 
 align 4
@@ -3516,8 +3516,8 @@ checkmisc:
     cmp   [ctrl_alt_del], 1
     jne   nocpustart
 
-        mov     ebp, cpustring
-        call    fs_execute_from_sysdir
+	mov	ebp, cpustring
+	call	fs_execute_from_sysdir
 
     mov   [ctrl_alt_del], 0
 
@@ -3526,24 +3526,24 @@ nocpustart:
     jne   mouse_not_active
     mov   [mouse_active], 0
     xor   edi, edi
-    mov   ecx,  [TASK_COUNT]
+    mov   ecx,	[TASK_COUNT]
 set_mouse_event:
     add   edi, 256
-    or    [edi+SLOT_BASE+APPDATA.event_mask], dword 100000b
+    or	  [edi+SLOT_BASE+APPDATA.event_mask], dword 100000b
     loop  set_mouse_event
 
 mouse_not_active:
-    cmp   [REDRAW_BACKGROUND],byte 0               ; background update ?
-    jz    nobackgr
+    cmp   [REDRAW_BACKGROUND],byte 0		   ; background update ?
+    jz	  nobackgr
     cmp    [background_defined], 0
-    jz    nobackgr
+    jz	  nobackgr
     cmp   [REDRAW_BACKGROUND], byte 2
     jnz   no_set_bgr_event
     xor   edi, edi
-    mov   ecx,  [TASK_COUNT]
+    mov   ecx,	[TASK_COUNT]
 set_bgr_event:
     add   edi, 256
-    or    [edi+SLOT_BASE+APPDATA.event_mask], 16
+    or	  [edi+SLOT_BASE+APPDATA.event_mask], 16
     loop  set_bgr_event
 no_set_bgr_event:
 ;    mov   [draw_data+32 + RECT.left],dword 0
@@ -3561,7 +3561,7 @@ nobackgr:
     ; system shutdown request
 
     cmp  [SYS_SHUTDOWN],byte 0
-    je   noshutdown
+    je	 noshutdown
 
     mov  edx,[shutdown_processes]
 
@@ -3582,21 +3582,21 @@ markz:
     call [disable_mouse]
 
     dec  byte [SYS_SHUTDOWN]
-    je   system_shutdown
+    je	 system_shutdown
 
 noshutdown:
 
 
-    mov   eax,[TASK_COUNT]                  ; termination
+    mov   eax,[TASK_COUNT]		    ; termination
     mov   ebx,TASK_DATA+TASKDATA.state
     mov   esi,1
 
 newct:
     mov   cl,[ebx]
     cmp   cl,byte 3
-    jz    terminate
+    jz	  terminate
     cmp   cl,byte 4
-    jz    terminate
+    jz	  terminate
 
     add   ebx,0x20
     inc   esi
@@ -3610,152 +3610,152 @@ redrawscreen:
 
 ; eax , if process window_data base is eax, do not set flag/limits
 
-         pushad
-         push  eax
+	 pushad
+	 push  eax
 
 ;;;         mov   ebx,2
 ;;;         call  delay_hs
 
-         ;mov   ecx,0               ; redraw flags for apps
-         xor   ecx,ecx
+	 ;mov   ecx,0               ; redraw flags for apps
+	 xor   ecx,ecx
        newdw2:
 
-         inc   ecx
-         push  ecx
+	 inc   ecx
+	 push  ecx
 
-         mov   eax,ecx
-         shl   eax,5
-         add   eax,window_data
+	 mov   eax,ecx
+	 shl   eax,5
+	 add   eax,window_data
 
-         cmp   eax,[esp+4]
-         je    not_this_task
-                                   ; check if window in redraw area
-         mov   edi,eax
+	 cmp   eax,[esp+4]
+	 je    not_this_task
+				   ; check if window in redraw area
+	 mov   edi,eax
 
-         cmp   ecx,1               ; limit for background
-         jz    bgli
+	 cmp   ecx,1		   ; limit for background
+	 jz    bgli
 
-         mov   eax, [edi + WDATA.box.left]
-         mov   ebx, [edi + WDATA.box.top]
-         mov   ecx, [edi + WDATA.box.width]
-         mov   edx, [edi + WDATA.box.height]
-         add   ecx,eax
-         add   edx,ebx
+	 mov   eax, [edi + WDATA.box.left]
+	 mov   ebx, [edi + WDATA.box.top]
+	 mov   ecx, [edi + WDATA.box.width]
+	 mov   edx, [edi + WDATA.box.height]
+	 add   ecx,eax
+	 add   edx,ebx
 
-         mov   ecx,[dlye]   ; ecx = area y end     ebx = window y start
-         cmp   ecx,ebx
-         jb    ricino
+	 mov   ecx,[dlye]   ; ecx = area y end     ebx = window y start
+	 cmp   ecx,ebx
+	 jb    ricino
 
-         mov   ecx,[dlxe]   ; ecx = area x end     eax = window x start
-         cmp   ecx,eax
-         jb    ricino
+	 mov   ecx,[dlxe]   ; ecx = area x end     eax = window x start
+	 cmp   ecx,eax
+	 jb    ricino
 
-         mov   eax, [edi + WDATA.box.left]
-         mov   ebx, [edi + WDATA.box.top]
-         mov   ecx, [edi + WDATA.box.width]
-         mov   edx, [edi + WDATA.box.height]
-         add   ecx, eax
-         add   edx, ebx
+	 mov   eax, [edi + WDATA.box.left]
+	 mov   ebx, [edi + WDATA.box.top]
+	 mov   ecx, [edi + WDATA.box.width]
+	 mov   edx, [edi + WDATA.box.height]
+	 add   ecx, eax
+	 add   edx, ebx
 
-         mov   eax,[dly]    ; eax = area y start     edx = window y end
-         cmp   edx,eax
-         jb    ricino
+	 mov   eax,[dly]    ; eax = area y start     edx = window y end
+	 cmp   edx,eax
+	 jb    ricino
 
-         mov   eax,[dlx]    ; eax = area x start     ecx = window x end
-         cmp   ecx,eax
-         jb    ricino
+	 mov   eax,[dlx]    ; eax = area x start     ecx = window x end
+	 cmp   ecx,eax
+	 jb    ricino
 
-        bgli:
+	bgli:
 
-         cmp   ecx,1
-         jnz   .az
-         mov   al,[REDRAW_BACKGROUND]
-         cmp   al,2
-         jz    newdw8
-         test  al,al
-         jz    .az
-         lea   eax,[edi+draw_data-window_data]
-         mov   ebx,[dlx]
-         cmp   ebx,[eax+RECT.left]
-         jae   @f
-         mov   [eax+RECT.left],ebx
-        @@:
-         mov   ebx,[dly]
-         cmp   ebx,[eax+RECT.top]
-         jae   @f
-         mov   [eax+RECT.top],ebx
-        @@:
-         mov   ebx,[dlxe]
-         cmp   ebx,[eax+RECT.right]
-         jbe   @f
-         mov   [eax+RECT.right],ebx
-        @@:
-         mov   ebx,[dlye]
-         cmp   ebx,[eax+RECT.bottom]
-         jbe   @f
-         mov   [eax+RECT.bottom],ebx
-        @@:
-         jmp   newdw8
-        .az:
+	 cmp   ecx,1
+	 jnz   .az
+	 mov   al,[REDRAW_BACKGROUND]
+	 cmp   al,2
+	 jz    newdw8
+	 test  al,al
+	 jz    .az
+	 lea   eax,[edi+draw_data-window_data]
+	 mov   ebx,[dlx]
+	 cmp   ebx,[eax+RECT.left]
+	 jae   @f
+	 mov   [eax+RECT.left],ebx
+	@@:
+	 mov   ebx,[dly]
+	 cmp   ebx,[eax+RECT.top]
+	 jae   @f
+	 mov   [eax+RECT.top],ebx
+	@@:
+	 mov   ebx,[dlxe]
+	 cmp   ebx,[eax+RECT.right]
+	 jbe   @f
+	 mov   [eax+RECT.right],ebx
+	@@:
+	 mov   ebx,[dlye]
+	 cmp   ebx,[eax+RECT.bottom]
+	 jbe   @f
+	 mov   [eax+RECT.bottom],ebx
+	@@:
+	 jmp   newdw8
+	.az:
 
-         mov   eax,edi
-         add   eax,draw_data-window_data
+	 mov   eax,edi
+	 add   eax,draw_data-window_data
 
-         mov   ebx,[dlx]          ; set limits
-         mov   [eax + RECT.left], ebx
-         mov   ebx,[dly]
-         mov   [eax + RECT.top], ebx
-         mov   ebx,[dlxe]
-         mov   [eax + RECT.right], ebx
-         mov   ebx,[dlye]
-         mov   [eax + RECT.bottom], ebx
+	 mov   ebx,[dlx]	  ; set limits
+	 mov   [eax + RECT.left], ebx
+	 mov   ebx,[dly]
+	 mov   [eax + RECT.top], ebx
+	 mov   ebx,[dlxe]
+	 mov   [eax + RECT.right], ebx
+	 mov   ebx,[dlye]
+	 mov   [eax + RECT.bottom], ebx
 
-         sub   eax,draw_data-window_data
+	 sub   eax,draw_data-window_data
 
-         cmp   dword [esp],1
-         jne   nobgrd
-         mov   byte [REDRAW_BACKGROUND], 1
+	 cmp   dword [esp],1
+	 jne   nobgrd
+	 mov   byte [REDRAW_BACKGROUND], 1
 
        newdw8:
        nobgrd:
 
-         mov   [eax + WDATA.fl_redraw],byte 1    ; mark as redraw
+	 mov   [eax + WDATA.fl_redraw],byte 1	 ; mark as redraw
 
        ricino:
 
        not_this_task:
 
-         pop   ecx
+	 pop   ecx
 
-         cmp   ecx,[TASK_COUNT]
-         jle   newdw2
+	 cmp   ecx,[TASK_COUNT]
+	 jle   newdw2
 
-         pop  eax
-         popad
+	 pop  eax
+	 popad
 
-         ret
+	 ret
 
 calculatebackground:   ; background
 
-        ; all black
+	; all black
 
-        mov   edi, [img_background]  ;IMG_BACKGROUND                 ; set background to black
-        xor   eax, eax
-        mov   ecx, 1023    ;0x0fff00 / 4
-        cld
-        rep   stosd
+	mov   edi, [img_background]  ;IMG_BACKGROUND                 ; set background to black
+	xor   eax, eax
+	mov   ecx, 1023    ;0x0fff00 / 4
+	cld
+	rep   stosd
 
-        mov   edi,display_data              ; set os to use all pixels
-        mov   eax,0x01010101
-        mov   ecx,1280*1024 / 4
-        rep   stosd
+	mov   edi,display_data		    ; set os to use all pixels
+	mov   eax,0x01010101
+	mov   ecx,1280*1024 / 4
+	rep   stosd
 
-        mov   byte [REDRAW_BACKGROUND], 0              ; do not draw background!
+	mov   byte [REDRAW_BACKGROUND], 0	       ; do not draw background!
 
-        ret
+	ret
 
 uglobal
-  imax    dd 0x0
+  imax	  dd 0x0
 endg
 
 
@@ -3763,63 +3763,63 @@ endg
 delay_ms:     ; delay in 1/1000 sec
 
 
-        push  eax
-        push  ecx
+	push  eax
+	push  ecx
 
-        mov   ecx,esi
-        ; <CPU clock fix by Sergey Kuzmin aka Wildwest>
-        imul  ecx, 33941
-        shr   ecx, 9
-        ; </CPU clock fix>
+	mov   ecx,esi
+	; <CPU clock fix by Sergey Kuzmin aka Wildwest>
+	imul  ecx, 33941
+	shr   ecx, 9
+	; </CPU clock fix>
 
-        in    al,0x61
-        and   al,0x10
-        mov   ah,al
-        cld
+	in    al,0x61
+	and   al,0x10
+	mov   ah,al
+	cld
 
- cnt1:  in    al,0x61
-        and   al,0x10
-        cmp   al,ah
-        jz    cnt1
+ cnt1:	in    al,0x61
+	and   al,0x10
+	cmp   al,ah
+	jz    cnt1
 
-        mov   ah,al
-        loop  cnt1
+	mov   ah,al
+	loop  cnt1
 
-        pop   ecx
-        pop   eax
+	pop   ecx
+	pop   eax
 
-        ret
+	ret
 
 
 set_app_param:
-        mov	edi, [TASK_BASE]
-        mov	[edi + TASKDATA.event_mask], ebx
-        ret
+	mov	edi, [TASK_BASE]
+	mov	[edi + TASKDATA.event_mask], ebx
+	ret
 
 
 
 delay_hs:     ; delay in 1/100 secs
 ; ebx = delay time
-        push  ecx
-        push  edx
+	push  ecx
+	push  edx
 
-        mov   edx,[timer_ticks]
+	mov   edx,[timer_ticks]
 
       newtic:
-        mov   ecx,[timer_ticks]
-        sub   ecx,edx
-        cmp   ecx,ebx
-        jae   zerodelay
+	mov   ecx,[timer_ticks]
+	sub   ecx,edx
+	cmp   ecx,ebx
+	jae   zerodelay
 
-        call  change_task
+	call  change_task
 
-        jmp   newtic
+	jmp   newtic
 
       zerodelay:
-        pop   edx
-        pop   ecx
+	pop   edx
+	pop   ecx
 
-        ret
+	ret
 
 
 memmove:       ; memory move in bytes
@@ -3837,14 +3837,14 @@ memmove:       ; memory move in bytes
     mov  esi, eax
 
     test ecx, not 11b
-    jz   @f
+    jz	 @f
 
     push ecx
     shr  ecx, 2
     rep  movsd
     pop  ecx
     and  ecx, 11b
-    jz   .finish
+    jz	 .finish
   @@:
     rep  movsb
 
@@ -3914,7 +3914,7 @@ sys_programirq:
     mov   edi,[TASK_BASE]
     mov   edi,[edi+TASKDATA.pid]
     cmp   edi,[irq_owner+ebx*4]
-    je    spril1
+    je	  spril1
 .not_owner:
     mov   [esp+36],dword 1
     ret
@@ -3934,45 +3934,44 @@ sys_programirq:
 align 4
 
 get_irq_data:
-     cmp   eax,16
+     cmp   ebx,16
      jae   .not_owner
-     mov   edx,eax           ; check for correct owner
-     shl   edx,2
-     add   edx,irq_owner
-     mov   edx,[edx]
+     mov   eax, [4 * ebx + irq_owner]
+
      mov   edi,[TASK_BASE]
-     mov   edi,[edi+TASKDATA.pid]
-     cmp   edx,edi
+
+     cmp   eax,[edi+TASKDATA.pid]
      je    gidril1
 .not_owner:
-     mov   [esp+32],dword 2     ; ecx=2
+     mov   [esp+28],dword 2	; ecx=2
      ret
 
   gidril1:
 
-     mov   ebx,eax
      shl   ebx,12
-     add   ebx,IRQ_SAVE
-     mov   eax,[ebx]
      mov   ecx,1
-     test  eax,eax
+     lea   eax,[ebx + IRQ_SAVE + 0x10]
+     mov   edx,[eax - 0x10]
+     test  edx,edx
      jz    gid1
 
-     dec   eax
-     mov   esi,ebx
-     mov   [ebx],eax
-     movzx ebx,byte [ebx+0x10]
-     add   esi,0x10
-     mov   edi,esi
+     dec   dword [eax - 0x10]
+
+     movzx ebx,byte [eax]
+
+     mov   edi, eax
+     xchg  esi, eax
      inc   esi
+
      mov   ecx,4000 / 4
      cld
      rep   movsd
 ;     xor   ecx,ecx     ; as result of 'rep' ecx=0
+     dec   edx
    gid1:
-     mov   [esp+36],eax
-     mov   [esp+32],ecx
-     mov   [esp+24],ebx
+     mov   [esp+32],edx
+     mov   [esp+28],ecx
+     mov   [esp+20],ebx
      ret
 
 
@@ -3991,7 +3990,7 @@ set_io_access_rights:
 ;     mov   ebx,1
 ;     shl   ebx,cl
 
-     cmp   ebp,0                ; enable access - ebp = 0
+     cmp   ebp,0		; enable access - ebp = 0
      jne   siar1
 
 ;     not   ebx
@@ -4022,14 +4021,14 @@ r_f_port_area:
 
      pushad
 
-     cmp   ebx,ecx            ; beginning > end ?
+     cmp   ebx,ecx	      ; beginning > end ?
      ja    rpal1
      cmp   ecx,65536
      jae   rpal1
      mov   esi,[RESERVED_PORTS]
-     test  esi,esi            ; no reserved areas ?
+     test  esi,esi	      ; no reserved areas ?
      je    rpal2
-     cmp   esi,255            ; max reserved
+     cmp   esi,255	      ; max reserved
      jae   rpal1
  rpal3:
      mov   edi,esi
@@ -4057,7 +4056,7 @@ r_f_port_area:
 
      ; enable port access at port IO map
      cli
-     pushad                        ; start enable io map
+     pushad			   ; start enable io map
 
      cmp   ecx,65536 ;16384
      jae   no_unmask_io ; jge
@@ -4068,7 +4067,7 @@ r_f_port_area:
 
      pushad
 
-     xor   ebp,ebp                ; enable - eax = port
+     xor   ebp,ebp		  ; enable - eax = port
      call  set_io_access_rights
 
      popad
@@ -4079,7 +4078,7 @@ r_f_port_area:
 
    no_unmask_io:
 
-     popad                         ; end enable io map
+     popad			   ; end enable io map
      sti
 
      mov   edi,[RESERVED_PORTS]
@@ -4139,7 +4138,7 @@ free_port_area:
 
      ; disable port access at port IO map
 
-     pushad                        ; start disable io map
+     pushad			   ; start disable io map
 
      cmp   ecx,65536 ;16384
      jge   no_mask_io
@@ -4150,7 +4149,7 @@ free_port_area:
 
      pushad
 
-     mov   ebp,1                  ; disable - eax = port
+     mov   ebp,1		  ; disable - eax = port
      call  set_io_access_rights
 
      popad
@@ -4161,7 +4160,7 @@ free_port_area:
 
    no_mask_io:
 
-     popad                         ; end disable io map
+     popad			   ; end disable io map
 
      xor   eax, eax
      ret
@@ -4228,7 +4227,7 @@ drawbackground:
 
 align 4
 
-syscall_putimage:                       ; PutImage
+syscall_putimage:			; PutImage
 sys_putimage:
      test  ecx,0x80008000
      jnz   .exit
@@ -4239,40 +4238,40 @@ sys_putimage:
   .exit:
      ret
  @@:
-        mov     edi,[current_slot]
-        add     dx,word[edi+APPDATA.wnd_clientbox.top]
-        rol     edx,16
-        add     dx,word[edi+APPDATA.wnd_clientbox.left]
-        rol     edx,16
+	mov	edi,[current_slot]
+	add	dx,word[edi+APPDATA.wnd_clientbox.top]
+	rol	edx,16
+	add	dx,word[edi+APPDATA.wnd_clientbox.left]
+	rol	edx,16
   .forced:
-        push    ebp esi 0
-        mov     ebp, putimage_get24bpp
-        mov     esi, putimage_init24bpp
+	push	ebp esi 0
+	mov	ebp, putimage_get24bpp
+	mov	esi, putimage_init24bpp
 sys_putimage_bpp:
 ;        call    [disable_mouse] ; this will be done in xxx_putimage
 ;        mov     eax, vga_putimage
-        cmp     [SCR_MODE], word 0x12
-        jz      @f   ;.doit
-        mov     eax, vesa12_putimage
-        cmp     [SCR_MODE], word 0100000000000000b
-        jae     @f
-        cmp     [SCR_MODE], word 0x13
-        jnz     .doit
+	cmp	[SCR_MODE], word 0x12
+	jz	@f   ;.doit
+	mov	eax, vesa12_putimage
+	cmp	[SCR_MODE], word 0100000000000000b
+	jae	@f
+	cmp	[SCR_MODE], word 0x13
+	jnz	.doit
 @@:
-        mov     eax, vesa20_putimage
+	mov	eax, vesa20_putimage
 .doit:
-        inc     [mouse_pause]
-        call    eax
-        dec     [mouse_pause]
-        pop     ebp esi ebp
-        jmp     [draw_pointer]
+	inc	[mouse_pause]
+	call	eax
+	dec	[mouse_pause]
+	pop	ebp esi ebp
+	jmp	[draw_pointer]
 
 syscall_putimage_palette:
-        mov     edi, esi
-        mov     esi, edx
-        mov     edx, ecx
-        mov     ecx, ebx
-        mov     ebx, eax
+	mov	edi, esi
+	mov	esi, edx
+	mov	edx, ecx
+	mov	ecx, ebx
+	mov	ebx, eax
 sys_putimage_palette:
 ; ebx = pointer to image
 ; ecx = [xsize]*65536 + [ysize]
@@ -4280,59 +4279,59 @@ sys_putimage_palette:
 ; esi = number of bits per pixel, must be 8, 24 or 32
 ; edi = pointer to palette
 ; ebp = row delta
-        mov     eax, [CURRENT_TASK]
-        shl     eax, 8
-        add     dx, word [eax+SLOT_BASE+APPDATA.wnd_clientbox.top]
-        rol     edx, 16
-        add     dx, word [eax+SLOT_BASE+APPDATA.wnd_clientbox.left]
-        rol     edx, 16
+	mov	eax, [CURRENT_TASK]
+	shl	eax, 8
+	add	dx, word [eax+SLOT_BASE+APPDATA.wnd_clientbox.top]
+	rol	edx, 16
+	add	dx, word [eax+SLOT_BASE+APPDATA.wnd_clientbox.left]
+	rol	edx, 16
 .forced:
-        push    ebp esi ebp
-        cmp     esi, 8
-        jnz     @f
-        mov     ebp, putimage_get8bpp
-        mov     esi, putimage_init8bpp
-        jmp     sys_putimage_bpp
+	push	ebp esi ebp
+	cmp	esi, 8
+	jnz	@f
+	mov	ebp, putimage_get8bpp
+	mov	esi, putimage_init8bpp
+	jmp	sys_putimage_bpp
 @@:
-        cmp     esi, 24
-        jnz     @f
-        mov     ebp, putimage_get24bpp
-        mov     esi, putimage_init24bpp
-        jmp     sys_putimage_bpp
+	cmp	esi, 24
+	jnz	@f
+	mov	ebp, putimage_get24bpp
+	mov	esi, putimage_init24bpp
+	jmp	sys_putimage_bpp
 @@:
-        cmp     esi, 32
-        jnz     @f
-        mov     ebp, putimage_get32bpp
-        mov     esi, putimage_init32bpp
-        jmp     sys_putimage_bpp
+	cmp	esi, 32
+	jnz	@f
+	mov	ebp, putimage_get32bpp
+	mov	esi, putimage_init32bpp
+	jmp	sys_putimage_bpp
 @@:
-        pop     ebp esi
-        ret
+	pop	ebp esi
+	ret
 
 putimage_init24bpp:
-        lea     eax, [eax*3]
+	lea	eax, [eax*3]
 putimage_init8bpp:
-        ret
+	ret
 
 putimage_get24bpp:
-        mov     eax, [esi]
-        add     esi, 3
-        ret     4
+	mov	eax, [esi]
+	add	esi, 3
+	ret	4
 putimage_get8bpp:
-        movzx   eax, byte [esi]
-        push    edx
-        mov     edx, [esp+8]
-        mov     eax, [edx+eax*4]
-        pop     edx
-        inc     esi
-        ret     4
+	movzx	eax, byte [esi]
+	push	edx
+	mov	edx, [esp+8]
+	mov	eax, [edx+eax*4]
+	pop	edx
+	inc	esi
+	ret	4
 
 putimage_init32bpp:
-        shl     eax, 2
-        ret
+	shl	eax, 2
+	ret
 putimage_get32bpp:
-        lodsd
-        ret     4
+	lodsd
+	ret	4
 
 ; eax x beginning
 ; ebx y beginning
@@ -4341,21 +4340,21 @@ putimage_get32bpp:
 ; edi color
 
 __sys_drawbar:
-        mov     esi,[current_slot]
-        add     eax,[esi+APPDATA.wnd_clientbox.left]
-        add     ecx,[esi+APPDATA.wnd_clientbox.left]
-        add     ebx,[esi+APPDATA.wnd_clientbox.top]
-        add     edx,[esi+APPDATA.wnd_clientbox.top]
+	mov	esi,[current_slot]
+	add	eax,[esi+APPDATA.wnd_clientbox.left]
+	add	ecx,[esi+APPDATA.wnd_clientbox.left]
+	add	ebx,[esi+APPDATA.wnd_clientbox.top]
+	add	edx,[esi+APPDATA.wnd_clientbox.top]
   .forced:
     inc   [mouse_pause]
 ;        call    [disable_mouse]
     cmp   [SCR_MODE],word 0x12
-    je   dbv20
+    je	 dbv20
    sdbv20:
     cmp  [SCR_MODE],word 0100000000000000b
     jge  dbv20
     cmp  [SCR_MODE],word 0x13
-    je   dbv20
+    je	 dbv20
     call vesa12_drawbar
     dec   [mouse_pause]
     call   [draw_pointer]
@@ -4370,36 +4369,36 @@ __sys_drawbar:
 
 kb_read:
 
-        push    ecx edx
+	push	ecx edx
 
-        mov     ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
+	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
       kr_loop:
-        in      al,0x64
-        test    al,1
-        jnz     kr_ready
-        loop    kr_loop
-        mov     ah,1
-        jmp     kr_exit
+	in	al,0x64
+	test	al,1
+	jnz	kr_ready
+	loop	kr_loop
+	mov	ah,1
+	jmp	kr_exit
       kr_ready:
-        push    ecx
-        mov     ecx,32
+	push	ecx
+	mov	ecx,32
       kr_delay:
-        loop    kr_delay
-        pop     ecx
-        in      al,0x60
-        xor     ah,ah
+	loop	kr_delay
+	pop	ecx
+	in	al,0x60
+	xor	ah,ah
       kr_exit:
 
-        pop     edx ecx
+	pop	edx ecx
 
-        ret
+	ret
 
 
 kb_write:
 
-        push    ecx edx
+	push	ecx edx
 
-        mov     dl,al
+	mov	dl,al
 ;        mov     ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
 ;      kw_loop1:
 ;        in      al,0x64
@@ -4409,75 +4408,75 @@ kb_write:
 ;        mov     ah,1
 ;        jmp     kw_exit
 ;      kw_ok1:
-        in      al,0x60
-        mov     ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
+	in	al,0x60
+	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
       kw_loop:
-        in      al,0x64
-        test    al,2
-        jz      kw_ok
-        loop    kw_loop
-        mov     ah,1
-        jmp     kw_exit
+	in	al,0x64
+	test	al,2
+	jz	kw_ok
+	loop	kw_loop
+	mov	ah,1
+	jmp	kw_exit
       kw_ok:
-        mov     al,dl
-        out     0x60,al
-        mov     ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
+	mov	al,dl
+	out	0x60,al
+	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
       kw_loop3:
-        in      al,0x64
-        test    al,2
-        jz      kw_ok3
-        loop    kw_loop3
-        mov     ah,1
-        jmp     kw_exit
+	in	al,0x64
+	test	al,2
+	jz	kw_ok3
+	loop	kw_loop3
+	mov	ah,1
+	jmp	kw_exit
       kw_ok3:
-        mov     ah,8
+	mov	ah,8
       kw_loop4:
-        mov     ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
+	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
       kw_loop5:
-        in      al,0x64
-        test    al,1
-        jnz     kw_ok4
-        loop    kw_loop5
-        dec     ah
-        jnz     kw_loop4
+	in	al,0x64
+	test	al,1
+	jnz	kw_ok4
+	loop	kw_loop5
+	dec	ah
+	jnz	kw_loop4
       kw_ok4:
-        xor     ah,ah
+	xor	ah,ah
       kw_exit:
 
-        pop     edx ecx
+	pop	edx ecx
 
-        ret
+	ret
 
 
 kb_cmd:
 
-        mov     ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
+	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
       c_wait:
-        in      al,0x64
-        test    al,2
-        jz      c_send
-        loop    c_wait
-        jmp     c_error
+	in	al,0x64
+	test	al,2
+	jz	c_send
+	loop	c_wait
+	jmp	c_error
       c_send:
-        mov     al,bl
-        out     0x64,al
-        mov     ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
+	mov	al,bl
+	out	0x64,al
+	mov	ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
       c_accept:
-        in      al,0x64
-        test    al,2
-        jz      c_ok
-        loop    c_accept
+	in	al,0x64
+	test	al,2
+	jz	c_ok
+	loop	c_accept
       c_error:
-        mov     ah,1
-        jmp     c_exit
+	mov	ah,1
+	jmp	c_exit
       c_ok:
-        xor     ah,ah
+	xor	ah,ah
       c_exit:
-        ret
+	ret
 
 
 setmouse:  ; set mousepicture -pointer
-           ; ps2 mouse enable
+	   ; ps2 mouse enable
 
      mov     [MOUSE_PICTURE],dword mousepointer
 
@@ -4516,12 +4515,12 @@ setmouse:  ; set mousepicture -pointer
 
      mov   dx,bx
      add   dx,0
-     mov   al,0x30*2    ; 0x30 / 4
+     mov   al,0x30*2	; 0x30 / 4
      out   dx,al
 
      mov   dx,bx
      add   dx,3
-     mov   al,2         ; 3
+     mov   al,2 	; 3
      out   dx,al
 
      mov   dx,bx
@@ -4584,60 +4583,60 @@ _rdtsc:
 
 rerouteirqs:
 
-        cli
+	cli
 
-        mov     al,0x11         ;  icw4, edge triggered
-        out     0x20,al
-        call    pic_delay
-        out     0xA0,al
-        call    pic_delay
+	mov	al,0x11 	;  icw4, edge triggered
+	out	0x20,al
+	call	pic_delay
+	out	0xA0,al
+	call	pic_delay
 
-        mov     al,0x20         ;  generate 0x20 +
-        out     0x21,al
-        call    pic_delay
-        mov     al,0x28         ;  generate 0x28 +
-        out     0xA1,al
-        call    pic_delay
+	mov	al,0x20 	;  generate 0x20 +
+	out	0x21,al
+	call	pic_delay
+	mov	al,0x28 	;  generate 0x28 +
+	out	0xA1,al
+	call	pic_delay
 
-        mov     al,0x04         ;  slave at irq2
-        out     0x21,al
-        call    pic_delay
-        mov     al,0x02         ;  at irq9
-        out     0xA1,al
-        call    pic_delay
+	mov	al,0x04 	;  slave at irq2
+	out	0x21,al
+	call	pic_delay
+	mov	al,0x02 	;  at irq9
+	out	0xA1,al
+	call	pic_delay
 
-        mov     al,0x01         ;  8086 mode
-        out     0x21,al
-        call    pic_delay
-        out     0xA1,al
-        call    pic_delay
+	mov	al,0x01 	;  8086 mode
+	out	0x21,al
+	call	pic_delay
+	out	0xA1,al
+	call	pic_delay
 
-        mov     al,255          ; mask all irq's
-        out     0xA1,al
-        call    pic_delay
-        out     0x21,al
-        call    pic_delay
+	mov	al,255		; mask all irq's
+	out	0xA1,al
+	call	pic_delay
+	out	0x21,al
+	call	pic_delay
 
-        mov     ecx,0x1000
-        cld
-picl1:  call    pic_delay
-        loop    picl1
+	mov	ecx,0x1000
+	cld
+picl1:	call	pic_delay
+	loop	picl1
 
-        mov     al,255          ; mask all irq's
-        out     0xA1,al
-        call    pic_delay
-        out     0x21,al
-        call    pic_delay
+	mov	al,255		; mask all irq's
+	out	0xA1,al
+	call	pic_delay
+	out	0x21,al
+	call	pic_delay
 
-        cli
+	cli
 
-        ret
+	ret
 
 
 pic_delay:
 
-        jmp     pdl1
-pdl1:   ret
+	jmp	pdl1
+pdl1:	ret
 
 
 sys_msg_board_str:
@@ -4659,43 +4658,43 @@ sys_msg_board_byte:
 ; in: al = byte to display
 ; out: nothing
 ; destroys: nothing
-        pushad
-        mov     ecx, 2
-        shl     eax, 24
-        jmp     @f
+	pushad
+	mov	ecx, 2
+	shl	eax, 24
+	jmp	@f
 
 sys_msg_board_word:
 ; in: ax = word to display
 ; out: nothing
 ; destroys: nothing
-        pushad
-        mov     ecx, 4
-        shl     eax, 16
-        jmp     @f
+	pushad
+	mov	ecx, 4
+	shl	eax, 16
+	jmp	@f
 
 sys_msg_board_dword:
 ; in: eax = dword to display
 ; out: nothing
 ; destroys: nothing
-        pushad
-        mov     ecx, 8
+	pushad
+	mov	ecx, 8
 @@:
-        push    ecx
-        rol     eax, 4
-        push    eax
-        and     al, 0xF
-        cmp     al, 10
-        sbb     al, 69h
-        das
-        mov     bl, al
-        xor     eax, eax
-        inc     eax
-        call    sys_msg_board
-        pop     eax
-        pop     ecx
-        loop    @b
-        popad
-        ret
+	push	ecx
+	rol	eax, 4
+	push	eax
+	and	al, 0xF
+	cmp	al, 10
+	sbb	al, 69h
+	das
+	mov	bl, al
+	xor	eax, eax
+	inc	eax
+	call	sys_msg_board
+	pop	eax
+	pop	ecx
+	loop	@b
+	popad
+	ret
 
 uglobal
   msg_board_data: times 4096 db 0
@@ -4740,9 +4739,9 @@ sys_msg_board:
 
 
 sys_process_def:
-        mov     edi, [CURRENT_TASK]
+	mov	edi, [CURRENT_TASK]
 
-        dec     eax             ; 1 = set keyboard mode
+	dec	eax		; 1 = set keyboard mode
      jne   no_set_keyboard_setup
 
      shl   edi,8
@@ -4752,7 +4751,7 @@ sys_process_def:
 
    no_set_keyboard_setup:
 
-        dec     eax             ; 2 = get keyboard mode
+	dec	eax		; 2 = get keyboard mode
      jne   no_get_keyboard_setup
 
      shl   edi,8
@@ -4764,7 +4763,7 @@ sys_process_def:
 
    no_get_keyboard_setup:
 
-        dec     eax             ; 3 = get keyboard ctrl, alt, shift
+	dec	eax		; 3 = get keyboard ctrl, alt, shift
      jne   no_get_keyboard_cas
 
 ;     xor   eax,eax
@@ -4786,70 +4785,70 @@ sys_process_def:
 
    no_get_keyboard_cas:
 
-        dec     eax
-        jnz     no_add_keyboard_hotkey
+	dec	eax
+	jnz	no_add_keyboard_hotkey
 
-        mov     eax, hotkey_list
+	mov	eax, hotkey_list
 @@:
-        cmp     dword [eax+8], 0
-        jz      .found_free
-        add     eax, 16
-        cmp     eax, hotkey_list+16*256
-        jb      @b
-        mov     dword [esp+36], 1
-        ret
+	cmp	dword [eax+8], 0
+	jz	.found_free
+	add	eax, 16
+	cmp	eax, hotkey_list+16*256
+	jb	@b
+	mov	dword [esp+36], 1
+	ret
 .found_free:
-        mov     [eax+8], edi
-        mov     [eax+4], ecx
-        movzx   ebx, bl
-        lea     ebx, [hotkey_scancodes+ebx*4]
-        mov     ecx, [ebx]
-        mov     [eax], ecx
-        mov     [ebx], eax
-        mov     [eax+12], ebx
-        jecxz   @f
-        mov     [ecx+12], eax
+	mov	[eax+8], edi
+	mov	[eax+4], ecx
+	movzx	ebx, bl
+	lea	ebx, [hotkey_scancodes+ebx*4]
+	mov	ecx, [ebx]
+	mov	[eax], ecx
+	mov	[ebx], eax
+	mov	[eax+12], ebx
+	jecxz	@f
+	mov	[ecx+12], eax
 @@:
-        and     dword [esp+36], 0
-        ret
+	and	dword [esp+36], 0
+	ret
 
 no_add_keyboard_hotkey:
 
-        dec     eax
-        jnz     no_del_keyboard_hotkey
+	dec	eax
+	jnz	no_del_keyboard_hotkey
 
-        movzx   ebx, bl
-        lea     ebx, [hotkey_scancodes+ebx*4]
-        mov     eax, [ebx]
+	movzx	ebx, bl
+	lea	ebx, [hotkey_scancodes+ebx*4]
+	mov	eax, [ebx]
 .scan:
-        test    eax, eax
-        jz      .notfound
-        cmp     [eax+8], edi
-        jnz     .next
-        cmp     [eax+4], ecx
-        jz      .found
+	test	eax, eax
+	jz	.notfound
+	cmp	[eax+8], edi
+	jnz	.next
+	cmp	[eax+4], ecx
+	jz	.found
 .next:
-        mov     eax, [eax]
-        jmp     .scan
+	mov	eax, [eax]
+	jmp	.scan
 .notfound:
-        mov     dword [esp+36], 1
-        ret
+	mov	dword [esp+36], 1
+	ret
 .found:
-        mov     ecx, [eax]
-        jecxz   @f
-        mov     edx, [eax+12]
-        mov     [ecx+12], edx
+	mov	ecx, [eax]
+	jecxz	@f
+	mov	edx, [eax+12]
+	mov	[ecx+12], edx
 @@:
-        mov     ecx, [eax+12]
-        mov     edx, [eax]
-        mov     [ecx], edx
-        xor     edx, edx
-        mov     [eax+4], edx
-        mov     [eax+8], edx
-        mov     [eax+12], edx
-        mov     [eax], edx
-        mov     [esp+36], edx
-        ret
+	mov	ecx, [eax+12]
+	mov	edx, [eax]
+	mov	[ecx], edx
+	xor	edx, edx
+	mov	[eax+4], edx
+	mov	[eax+8], edx
+	mov	[eax+12], edx
+	mov	[eax], edx
+	mov	[esp+36], edx
+	ret
 
 no_del_keyboard_hotkey:
      ret
@@ -4857,9 +4856,9 @@ no_del_keyboard_hotkey:
 
 align 4
 
-sys_gs:                         ; direct screen access
+sys_gs: 			; direct screen access
 
-     cmp  eax,1                 ; resolution
+     cmp  eax,1 		; resolution
      jne  no_gs1
      mov  eax,[ScreenWidth]
      shl  eax,16
@@ -4869,14 +4868,14 @@ sys_gs:                         ; direct screen access
      ret
    no_gs1:
 
-     cmp   eax,2                ; bits per pixel
+     cmp   eax,2		; bits per pixel
      jne   no_gs2
      movzx eax,byte [ScreenBPP]
      mov   [esp+36],eax
      ret
    no_gs2:
 
-     cmp   eax,3                ; bytes per scanline
+     cmp   eax,3		; bytes per scanline
      jne   no_gs3
      mov   eax,[BytesPerScanLine]
      mov   [esp+36],eax
@@ -4898,56 +4897,56 @@ sys_pci:
 
 align 4  ;  system functions
 
-syscall_setpixel:                       ; SetPixel
+syscall_setpixel:			; SetPixel
 
-        mov     eax, ebx
-        mov     ebx, ecx
-        mov     ecx, edx
-        mov     edx, [TASK_BASE]
-        add     eax, [edx-twdw+WDATA.box.left]
-        add     ebx, [edx-twdw+WDATA.box.top]
-        mov     edi, [current_slot]
-        add     eax, [edi+APPDATA.wnd_clientbox.left]
-        add     ebx, [edi+APPDATA.wnd_clientbox.top]
-        xor     edi, edi ; no force
+	mov	eax, ebx
+	mov	ebx, ecx
+	mov	ecx, edx
+	mov	edx, [TASK_BASE]
+	add	eax, [edx-twdw+WDATA.box.left]
+	add	ebx, [edx-twdw+WDATA.box.top]
+	mov	edi, [current_slot]
+	add	eax, [edi+APPDATA.wnd_clientbox.left]
+	add	ebx, [edi+APPDATA.wnd_clientbox.top]
+	xor	edi, edi ; no force
 ;       mov     edi, 1
-        call    [disable_mouse]
-        jmp     [putpixel]
+	call	[disable_mouse]
+	jmp	[putpixel]
 
 align 4
 
-syscall_writetext:                      ; WriteText
+syscall_writetext:			; WriteText
 
-        mov   eax,[TASK_BASE]
-        mov   ebp,[eax-twdw+WDATA.box.left]
-        push  esi
-        mov   esi,[current_slot]
-        add   ebp,[esi+APPDATA.wnd_clientbox.left]
-        shl   ebp,16
-        add   ebp,[eax-twdw+WDATA.box.top]
-        add   bp,word[esi+APPDATA.wnd_clientbox.top]
-        pop   esi
-        add   ebx,ebp
-        mov   eax,edi
-        xor   edi,edi
-        jmp   dtext
+	mov   eax,[TASK_BASE]
+	mov   ebp,[eax-twdw+WDATA.box.left]
+	push  esi
+	mov   esi,[current_slot]
+	add   ebp,[esi+APPDATA.wnd_clientbox.left]
+	shl   ebp,16
+	add   ebp,[eax-twdw+WDATA.box.top]
+	add   bp,word[esi+APPDATA.wnd_clientbox.top]
+	pop   esi
+	add   ebx,ebp
+	mov   eax,edi
+	xor   edi,edi
+	jmp   dtext
 
 align 4
 
-syscall_openramdiskfile:                ; OpenRamdiskFile
+syscall_openramdiskfile:		; OpenRamdiskFile
 
-        mov     eax, ebx
-        mov     ebx, ecx
-        mov     ecx, edx
-        mov     edx, esi
-        mov     esi, 12
-        call    fileread
-        mov     [esp+32], eax
-        ret
+	mov	eax, ebx
+	mov	ebx, ecx
+	mov	ecx, edx
+	mov	edx, esi
+	mov	esi, 12
+	call	fileread
+	mov	[esp+32], eax
+	ret
 
 align 4
 
-syscall_drawrect:                       ; DrawRect
+syscall_drawrect:			; DrawRect
 
 	mov	edi, edx ; color + gradient
 	and	edi, 0x80FFFFFF
@@ -4974,7 +4973,7 @@ syscall_drawrect:                       ; DrawRect
 	ret
 
 align 4
-syscall_getscreensize:                  ; GetScreenSize
+syscall_getscreensize:			; GetScreenSize
 	mov	ax, [ScreenWidth]
 	shl	eax, 16
 	mov	ax, [ScreenHeight]
@@ -4983,25 +4982,25 @@ syscall_getscreensize:                  ; GetScreenSize
 
 align 4
 
-syscall_cdaudio:                        ; CD
+syscall_cdaudio:			; CD
 
-        cmp     eax, 4
-        jb      .audio
-        jz      .eject
-        cmp     eax, 5
-        jnz     .ret
+	cmp	eax, 4
+	jb	.audio
+	jz	.eject
+	cmp	eax, 5
+	jnz	.ret
 .load:
-        call    .reserve
-        call    LoadMedium
-        call    .free
-        ret
+	call	.reserve
+	call	LoadMedium
+	call	.free
+	ret
 .eject:
-        call    .reserve
-        call    clear_CD_cache
-        call    allow_medium_removal
-        call    EjectMedium
-        call    .free
-        ret
+	call	.reserve
+	call	clear_CD_cache
+	call	allow_medium_removal
+	call	EjectMedium
+	call	.free
+	ret
 .audio:
      call  sys_cd_audio
      mov   [esp+36],eax
@@ -5009,39 +5008,39 @@ syscall_cdaudio:                        ; CD
      ret
 
 .reserve:
-        call    reserve_cd
-        mov     eax, ebx
-        shr     eax, 1
-        and     eax, 1
-        inc     eax
-        mov     [ChannelNumber], ax
-        mov     eax, ebx
-        and     eax, 1
-        mov     [DiskNumber], al
-        call    reserve_cd_channel
-        and     ebx, 3
-        inc     ebx
-        mov     [cdpos], ebx
-        add     ebx, ebx
-        mov     cl, 8
-        sub     cl, bl
-        mov     al, [DRIVE_DATA+1]
-        shr     al, cl
-        test    al, 2
-        jz      .err
-        ret
+	call	reserve_cd
+	mov	eax, ebx
+	shr	eax, 1
+	and	eax, 1
+	inc	eax
+	mov	[ChannelNumber], ax
+	mov	eax, ebx
+	and	eax, 1
+	mov	[DiskNumber], al
+	call	reserve_cd_channel
+	and	ebx, 3
+	inc	ebx
+	mov	[cdpos], ebx
+	add	ebx, ebx
+	mov	cl, 8
+	sub	cl, bl
+	mov	al, [DRIVE_DATA+1]
+	shr	al, cl
+	test	al, 2
+	jz	.err
+	ret
 .free:
-        call    free_cd_channel
-        and     [cd_status], 0
-        ret
+	call	free_cd_channel
+	and	[cd_status], 0
+	ret
 .err:
-        call    .free
-        pop     eax
-        ret
+	call	.free
+	pop	eax
+	ret
 
 align 4
 
-syscall_delramdiskfile:                 ; DelRamdiskFile
+syscall_delramdiskfile: 		; DelRamdiskFile
 
      mov   edi,[TASK_BASE]
      add   edi,TASKDATA.mem_start
@@ -5052,7 +5051,7 @@ syscall_delramdiskfile:                 ; DelRamdiskFile
 
 align 4
 
-syscall_writeramdiskfile:               ; WriteRamdiskFile
+syscall_writeramdiskfile:		; WriteRamdiskFile
 
      mov   edi,[TASK_BASE]
      add   edi,TASKDATA.mem_start
@@ -5064,7 +5063,7 @@ syscall_writeramdiskfile:               ; WriteRamdiskFile
 
 align 4
 
-syscall_getpixel:                       ; GetPixel
+syscall_getpixel:			; GetPixel
      mov   ecx, [ScreenWidth]
      inc   ecx
      xor   edx, edx
@@ -5079,7 +5078,7 @@ syscall_getpixel:                       ; GetPixel
 
 align 4
 
-syscall_drawline:                       ; DrawLine
+syscall_drawline:			; DrawLine
 
 	mov	edi, [TASK_BASE]
 	movzx	edx, word[edi-twdw+WDATA.box.left]
@@ -5102,21 +5101,22 @@ syscall_drawline:                       ; DrawLine
 
 align 4
 
-syscall_getirqowner:                    ; GetIrqOwner
-     cmp   eax,16
+syscall_getirqowner:			; GetIrqOwner
+
+     cmp   ebx,16
      jae   .err
-     shl   eax,2
-     add   eax,irq_owner
-     mov   eax,[eax]
-     mov   [esp+36],eax
+
+     mov   eax,[4 * ebx + irq_owner]
+     mov   [esp+32],eax
+
      ret
 .err:
-     or    dword [esp+36], -1
+     or    dword [esp+32], -1
      ret
 
 align 4
 
-syscall_reserveportarea:                ; ReservePortArea and FreePortArea
+syscall_reserveportarea:		; ReservePortArea and FreePortArea
 
      call  r_f_port_area
      mov   [esp+36],eax
@@ -5124,7 +5124,7 @@ syscall_reserveportarea:                ; ReservePortArea and FreePortArea
 
 align 4
 
-syscall_threads:                        ; CreateThreads
+syscall_threads:			; CreateThreads
 
      call  sys_threads
      mov   [esp+36],eax
@@ -5134,7 +5134,7 @@ align 4
 
 stack_driver_stat:
 
-     call  app_stack_handler            ; Stack status
+     call  app_stack_handler		; Stack status
 
 ;     mov   [check_idle_semaphore],5    ; enable these for zero delay
 ;     call  change_task                 ; between sent packet
@@ -5144,7 +5144,7 @@ stack_driver_stat:
 
 align 4
 
-socket:                                 ; Socket interface
+socket: 				; Socket interface
      call  app_socket_handler
 
 ;     mov   [check_idle_semaphore],5    ; enable these for zero delay
@@ -5156,7 +5156,7 @@ socket:                                 ; Socket interface
 
 align 4
 
-read_from_hd:                           ; Read from hd - fn not in use
+read_from_hd:				; Read from hd - fn not in use
 
      mov   edi,[TASK_BASE]
      add   edi,TASKDATA.mem_start
@@ -5171,18 +5171,18 @@ read_from_hd:                           ; Read from hd - fn not in use
      ret
 
 paleholder:
-        ret
+	ret
 
 
 ; --------------- APM ---------------------
 apm_entry    dp    0
-apm_vf        dd    0
+apm_vf	      dd    0
 align 4
 sys_apm:
     cmp    word [apm_vf], 0    ; Check APM BIOS enable
     jne    @f
-    or    [esp + 56], byte 1    ; error
-    mov    [esp + 36], dword 8    ; 32-bit protected-mode interface not supported
+    or	  [esp + 56], byte 1	; error
+    mov    [esp + 36], dword 8	  ; 32-bit protected-mode interface not supported
     ret
 
 @@:
@@ -5190,7 +5190,7 @@ sys_apm:
     xchg    ebx, ecx
 
     cmp    al, 3
-    ja    @f
+    ja	  @f
     and    [esp + 56], byte 0xfe    ; emulate func 0..3 as func 0
     mov    eax, [apm_vf]
     mov    [esp + 36], eax
@@ -5204,9 +5204,9 @@ sys_apm:
     xchg [master_tab], esi
     push esi
     mov edi, cr3
-    mov cr3, edi                 ;flush TLB
+    mov cr3, edi		 ;flush TLB
 
-    call    pword [apm_entry]    ; call APM BIOS
+    call    pword [apm_entry]	 ; call APM BIOS
 
     xchg eax, [esp]
     mov [master_tab], eax
@@ -5222,7 +5222,7 @@ sys_apm:
     mov    [esp + 36], eax
     setc    al
     and    [esp + 56], byte 0xfe
-    or    [esp + 56], al
+    or	  [esp + 56], al
 
 
     ret
@@ -5230,177 +5230,177 @@ sys_apm:
 
 align 4
 
-undefined_syscall:                      ; Undefined system call
+undefined_syscall:			; Undefined system call
      mov   [esp + 32], dword -1
      ret
 
 align 4
-system_shutdown:          ; shut down the system
+system_shutdown:	  ; shut down the system
 
-           cmp byte [BOOT_VAR+0x9030], 1
-           jne @F
-           ret
+	   cmp byte [BOOT_VAR+0x9030], 1
+	   jne @F
+	   ret
 @@:
-           call stop_all_services
-           push 3                ; stop playing cd
-           pop  eax
-           call sys_cd_audio
+	   call stop_all_services
+	   push 3		 ; stop playing cd
+	   pop	eax
+	   call sys_cd_audio
 
 yes_shutdown_param:
-           cli
+	   cli
 
-           mov  eax, kernel_file ; load kernel.mnt to 0x7000:0
-           push 12
-           pop  esi
-           xor  ebx,ebx
-           or   ecx,-1
-           mov  edx, OS_BASE+0x70000
-           call fileread
+	   mov	eax, kernel_file ; load kernel.mnt to 0x7000:0
+	   push 12
+	   pop	esi
+	   xor	ebx,ebx
+	   or	ecx,-1
+	   mov	edx, OS_BASE+0x70000
+	   call fileread
 
-           mov  esi, restart_kernel_4000+OS_BASE+0x10000 ; move kernel re-starter to 0x4000:0
-           mov  edi,OS_BASE+0x40000
-           mov  ecx,1000
-           rep  movsb
+	   mov	esi, restart_kernel_4000+OS_BASE+0x10000 ; move kernel re-starter to 0x4000:0
+	   mov	edi,OS_BASE+0x40000
+	   mov	ecx,1000
+	   rep	movsb
 
-           mov  esi,OS_BASE+0x2F0000    ; restore 0x0 - 0xffff
-           mov  edi, OS_BASE
-           mov  ecx,0x10000/4
-           cld
-           rep movsd
+	   mov	esi,OS_BASE+0x2F0000	; restore 0x0 - 0xffff
+	   mov	edi, OS_BASE
+	   mov	ecx,0x10000/4
+	   cld
+	   rep movsd
 
-           call restorefatchain
+	   call restorefatchain
 
-           mov al, 0xFF
-           out 0x21, al
-           out 0xA1, al
+	   mov al, 0xFF
+	   out 0x21, al
+	   out 0xA1, al
 
 if 1
-           mov  word [OS_BASE+0x467+0],pr_mode_exit
-           mov  word [OS_BASE+0x467+2],0x1000
+	   mov	word [OS_BASE+0x467+0],pr_mode_exit
+	   mov	word [OS_BASE+0x467+2],0x1000
 
-           mov  al,0x0F
-           out  0x70,al
-           mov  al,0x05
-           out  0x71,al
+	   mov	al,0x0F
+	   out	0x70,al
+	   mov	al,0x05
+	   out	0x71,al
 
-           mov  al,0xFE
-           out  0x64,al
+	   mov	al,0xFE
+	   out	0x64,al
 
-           hlt
+	   hlt
 
 else
-        cmp     byte [OS_BASE + 0x9030], 2
-        jnz     no_acpi_power_off
+	cmp	byte [OS_BASE + 0x9030], 2
+	jnz	no_acpi_power_off
 
 ; scan for RSDP
 ; 1) The first 1 Kb of the Extended BIOS Data Area (EBDA).
-        movzx   eax, word [OS_BASE + 0x40E]
-        shl     eax, 4
-        jz      @f
-        mov     ecx, 1024/16
-        call    scan_rsdp
-        jnc     .rsdp_found
+	movzx	eax, word [OS_BASE + 0x40E]
+	shl	eax, 4
+	jz	@f
+	mov	ecx, 1024/16
+	call	scan_rsdp
+	jnc	.rsdp_found
 @@:
 ; 2) The BIOS read-only memory space between 0E0000h and 0FFFFFh.
-        mov     eax, 0xE0000
-        mov     ecx, 0x2000
-        call    scan_rsdp
-        jc      no_acpi_power_off
+	mov	eax, 0xE0000
+	mov	ecx, 0x2000
+	call	scan_rsdp
+	jc	no_acpi_power_off
 .rsdp_found:
-        mov     esi, [eax+16]   ; esi contains physical address of the RSDT
-        mov     ebp, [ipc_tmp]
-        stdcall map_page, ebp, esi, PG_MAP
-        lea     eax, [esi+1000h]
-        lea     edx, [ebp+1000h]
-        stdcall map_page, edx, eax, PG_MAP
-        and     esi, 0xFFF
-        add     esi, ebp
-        cmp     dword [esi], 'RSDT'
-        jnz     no_acpi_power_off
-        mov     ecx, [esi+4]
-        sub     ecx, 24h
-        jbe     no_acpi_power_off
-        shr     ecx, 2
-        add     esi, 24h
+	mov	esi, [eax+16]	; esi contains physical address of the RSDT
+	mov	ebp, [ipc_tmp]
+	stdcall map_page, ebp, esi, PG_MAP
+	lea	eax, [esi+1000h]
+	lea	edx, [ebp+1000h]
+	stdcall map_page, edx, eax, PG_MAP
+	and	esi, 0xFFF
+	add	esi, ebp
+	cmp	dword [esi], 'RSDT'
+	jnz	no_acpi_power_off
+	mov	ecx, [esi+4]
+	sub	ecx, 24h
+	jbe	no_acpi_power_off
+	shr	ecx, 2
+	add	esi, 24h
 .scan_fadt:
-        lodsd
-        mov     ebx, eax
-        lea     eax, [ebp+2000h]
-        stdcall map_page, eax, ebx, PG_MAP
-        lea     eax, [ebp+3000h]
-        add     ebx, 0x1000
-        stdcall map_page, eax, ebx, PG_MAP
-        and     ebx, 0xFFF
-        lea     ebx, [ebx+ebp+2000h]
-        cmp     dword [ebx], 'FACP'
-        jz      .fadt_found
-        loop    .scan_fadt
-        jmp     no_acpi_power_off
+	lodsd
+	mov	ebx, eax
+	lea	eax, [ebp+2000h]
+	stdcall map_page, eax, ebx, PG_MAP
+	lea	eax, [ebp+3000h]
+	add	ebx, 0x1000
+	stdcall map_page, eax, ebx, PG_MAP
+	and	ebx, 0xFFF
+	lea	ebx, [ebx+ebp+2000h]
+	cmp	dword [ebx], 'FACP'
+	jz	.fadt_found
+	loop	.scan_fadt
+	jmp	no_acpi_power_off
 .fadt_found:
 ; ebx is linear address of FADT
-        mov     edx, [ebx+48]
-        test    edx, edx
-        jz      .nosmi
-        mov     al, [ebx+52]
-        out     dx, al
-        mov     edx, [ebx+64]
+	mov	edx, [ebx+48]
+	test	edx, edx
+	jz	.nosmi
+	mov	al, [ebx+52]
+	out	dx, al
+	mov	edx, [ebx+64]
 @@:
-        in      ax, dx
-        test    al, 1
-        jz      @b
+	in	ax, dx
+	test	al, 1
+	jz	@b
 .nosmi:
-        mov     edx, [ebx+64]
-        in      ax, dx
-        and     ax, 203h
-        or      ax, 3C00h
-        out     dx, ax
-        mov     edx, [ebx+68]
-        test    edx, edx
-        jz      @f
-        in      ax, dx
-        and     ax, 203h
-        or      ax, 3C00h
-        out     dx, ax
+	mov	edx, [ebx+64]
+	in	ax, dx
+	and	ax, 203h
+	or	ax, 3C00h
+	out	dx, ax
+	mov	edx, [ebx+68]
+	test	edx, edx
+	jz	@f
+	in	ax, dx
+	and	ax, 203h
+	or	ax, 3C00h
+	out	dx, ax
 @@:
-        jmp     $
+	jmp	$
 
 
 no_acpi_power_off:
-           mov  word [OS_BASE+0x467+0],pr_mode_exit
-           mov  word [OS_BASE+0x467+2],0x1000
+	   mov	word [OS_BASE+0x467+0],pr_mode_exit
+	   mov	word [OS_BASE+0x467+2],0x1000
 
-           mov  al,0x0F
-           out  0x70,al
-           mov  al,0x05
-           out  0x71,al
+	   mov	al,0x0F
+	   out	0x70,al
+	   mov	al,0x05
+	   out	0x71,al
 
-           mov  al,0xFE
-           out  0x64,al
+	   mov	al,0xFE
+	   out	0x64,al
 
-           hlt
+	   hlt
 
 scan_rsdp:
-        add     eax, OS_BASE
+	add	eax, OS_BASE
 .s:
-        cmp     dword [eax], 'RSD '
-        jnz     .n
-        cmp     dword [eax+4], 'PTR '
-        jnz     .n
-        xor     edx, edx
-        xor     esi, esi
+	cmp	dword [eax], 'RSD '
+	jnz	.n
+	cmp	dword [eax+4], 'PTR '
+	jnz	.n
+	xor	edx, edx
+	xor	esi, esi
 @@:
-        add     dl, [eax+esi]
-        inc     esi
-        cmp     esi, 20
-        jnz     @b
-        test    dl, dl
-        jz      .ok
+	add	dl, [eax+esi]
+	inc	esi
+	cmp	esi, 20
+	jnz	@b
+	test	dl, dl
+	jz	.ok
 .n:
-        add     eax, 10h
-        loop    .s
-        stc
+	add	eax, 10h
+	loop	.s
+	stc
 .ok:
-        ret
+	ret
 end if
 
 include "data32.inc"