Index: /trunk/Config.kmk =================================================================== --- /trunk/Config.kmk (revision 55077) +++ /trunk/Config.kmk (revision 55078) @@ -203,11 +203,11 @@ # Major version. -VBOX_VERSION_MAJOR = 4 +VBOX_VERSION_MAJOR = 5 # Minor version. -VBOX_VERSION_MINOR = 3 +VBOX_VERSION_MINOR = 0 # This is the current build number. It should be increased every time we publish a # new build. The define is available in every source file. Only even build numbers # will be published, odd numbers are set during development. -VBOX_VERSION_BUILD = 53 +VBOX_VERSION_BUILD = 0 # The raw version string. This *must not* contain any other information/fields than # major, minor and build revision (as it is now) -- also will be used for host/guest version @@ -221,5 +221,5 @@ # publisher so that RTStrVersionCompare have a chance of comparing # prerelease from different publishers correctly. -VBOX_VERSION_STRING = $(VBOX_VERSION_STRING_RAW)$(VBOX_BUILD_PUBLISHER) +VBOX_VERSION_STRING = $(VBOX_VERSION_STRING_RAW)_BETA1$(VBOX_BUILD_PUBLISHER) # Force the additions.sh script to get an exact additions build when we're doing the release. Index: /trunk/debian/changelog =================================================================== --- /trunk/debian/changelog (revision 55077) +++ /trunk/debian/changelog (revision 55078) @@ -1,2 +1,8 @@ +virtualbox-ose (5.0.0~beta1) unstable; urgency=low + + * rebuild Debian package. + + -- Oracle Corporation Wed, 01 Apr 2015 18:00:00 +0200 + virtualbox-ose (4.3.51~rc1) unstable; urgency=low Index: /trunk/doc/manual/user_ChangeLogImpl.xml =================================================================== --- /trunk/doc/manual/user_ChangeLogImpl.xml (revision 55077) +++ /trunk/doc/manual/user_ChangeLogImpl.xml (revision 55078) @@ -2,5 +2,5 @@ - Version 4.4.0 (yyyy-mm-dd) + Version 5.0.0 Beta 1 (2015-04-01) This is a major update. The following major new features @@ -74,5 +74,5 @@ - Version 4.3.8 (2014-02-25) + Version 4.3.26 (2015-03-16) This is a maintenance release. The following items were fixed and/or @@ -82,4 +82,1193 @@ + GUI: in the snapshots pane, protect the age of snapshots against + wrong host time (bug #13955) + + + + NAT Network: fixed a bug which prevented to propagate any DNS + name server / domain / search string information to the NAT network + (4.3.24 regression; bugs #13915, #13918) + + + + NAT Network: don't delay the shutdown of VBoxSVC on + Windows hosts + + + + Mouse support: the mouse could not be moved under rare + conditions if no Guest Additions are installed (4.3.24 regression; + bug #13935) + + + + Storage: if the guest ejects a virtual CD/DVD medium, make the + change permanent (bugs #9858, #12885) + + + + VGA: made saving secondary screen sizes possible in X11 guests + + + + SDK: fixed the VirtualBox.tlb file (4.3.20 regression; bug #13943) + + + + rdesktop-vrdp: make it work with USB devices again + (4.3.14 regression; bug #13901) + + + + USB: fixed a possible BSOD on Windows hosts under rare conditions + + + + iPXE: enable the HTTP download protocol on non-Linux hosts (bug #13628) + + + + Mac OS X hosts: don't panic on hosts with activated SMAP (Broadwell + and later; bug #13951) + + + + Linux hosts: don't crash Linux 4.0 hosts (bug #13835) + + + + + + + Version 4.3.24 (2015-03-02) + + This is a maintenance release. The following items were fixed and/or + added: + + + + + VMM: emulation fix for the ENTER instruction + under certain conditions; fixes Solaris 10 guests (VT-x without + unrestricted guest execution) + + + + VMM: fix for handling NMIs on Linux hosts with X2APIC enabled + + + + NAT/NAT Network: fix connection drops when the host's DHCP lease + was renewed (4.3.22 regression; Windows hosts only; bug #13839) + + + + NAT: don't crash on an empty domain list when switching the + DNS host configuration (4.3.22 regression; Mac OS X hosts only; + bug #13874) + + + + PXE: re-enable it on Windows hosts (4.3.22 regression; Windows hosts + only; bug #13842) + + + + + Shared Folders: fixed a problem with Windows guests (4.3.22 regression; + bug #13786) + + + + Audio: improved record quality when using the DirectSound audio + backend + + + + VBoxManage: when executing the controlvm command + take care that the corresponding VM runtime changes are saved permanently + (bug #13892) + + + + Windows Installer: properly install the 32-bit version of VBoxRes.dll + on 32-bit hosts (bug #13876) + + + + Linux hosts / guests: Linux 4.0 fixes (bug #13835) + + + + OS/2 Additions: fixed mouse integration (4.3.22 regression; + bug #13825) + + + + + + + Version 4.3.22 (2015-02-12) + + This is a maintenance release. The following items were fixed and/or + added: + + + + + VMM: refined measurement of TSC frequency on the host, improves + timekeeping for guests + + + + VMM: decreased CPU load resulting from guest MMIO writes to the + virtual APIC + + + + VMM: fixed interception of debug exceptions, observed while using + the dbx debugger on Solaris guests (VT-x only) + + + + GUI: 3D overlay window positioning code improved, fixed potential + misplacement of 3D accelerated guest graphics content + + + + GUI: fixed accident SSL authentication failures during update + check on Windows hosts (bug #12969) + + + + GUI: never send the "ACPI power" keyboard scancode to the guest, + we have the ACPI power button for that + + + + GUI: was unable to properly restore seamless mode VM from + snapshot/saved-state under some circumstances + + + + VBoxHeadless: don't crash if 3D is enabled in the VM settings + (bug #10250) + + + + ATA: fixed several passthrough issues (bugs #12310, #1360) + + + + Audio: fixed DirectSound failure when the the host has no audio + input device (Windows hosts only; bug #9205) + + + + SB16: fixed compatibility issue (bug #13769) + + + + Storage: fixed broken CD/DVD passthrough when using the + IDE controller (bug #12310) + + + + NAT: new ping proxy for Windows hosts (bug #11871) + + + + NAT: Properly report outbound connect(2) failures to + guest with TCP RST or ICMP (bug #10525) + + + + NAT Network: no need for frequent wakeups in VBoxNetDHCP + and VBoxNetNAT (bug #11681) + + + + Host-only adapter: prevent Windows from creating an "Unidentified + network" (bug #9688) + + + + Bridged Networking: don't leak host-to-guest traffic to + the wireless network when bridging to a wireless interface + (bug #13714) + + + + Main: fixed a possible race when changing the medium leading + to a deadlock under rare conditions (bug #13722) + + + + VBoxManage: fixed return code if starting a VM failed + (bug #13773) + + + + Settings: on Windows host, do not use environment variable HOME + at all, the settings location is derived from the user profile + directory (bug #7689) + + + + API: fixed 2 deadlock opportunities related to medium handling + (bugs #13789, #13801, thank you Alexander Urakov) + + + + API: fixed bug in XPCOM which created too few worker threads, + sporadically resulting in a deadlock (bug #13802, thank you Alexander + Urakov) + + + + SDK: fixed a garbage collection leak in the Python VirtualBox + webservice API binding (bug #13817) + + + + Linux hosts: fixes for activated SMAP (Broadwell and later, + bug #13820) + + + + X11 guests: prevent unwanted hiding of guest screens + on multi-monitor guests (bug #13287) + + + + X11 guests: added support for X.Org Server 1.17 + + + + X11 Additions: fixed a memory leak in VBoxService if libdbus + is available but dbus-daemon isn't running (bug #13770) + + + + Windows Additions: prevent VBox WDDM driver from loading if host + reports weak OpenGL capabilities. 3D content now can be shown over + Remote Desktop connection. + + + + Winodws Additions: some fixes for recent Windows 10 Previews + + + + Linux Additions: fixed a compatibility issue with 64-bit + Linux 2.4 kernels + + + + Linux Additions: fixed a potential use-after-free when unloading + the VBoxGuest module + + + + Linux Additions: Linux 3.19 fixes (bug #13741) + + + + + + + Version 4.3.20 (2014-11-21) + + This is a maintenance release. The following items were fixed and/or + added: + + + + + VMM: fixed reboot hang of 32-bit Windows SMP guests (bugs #13319, + #13462) + + + + VMM: proper Math Fault handling with certain + legacy guests (bug #9042, AMD hosts) + + + + VMM: fixed a Guru Meditation VINF_EM_TRIPLE_FAULT + on older CPUs that don't support MSR-bitmaps (VT-x only; + bugs #13034, #13125, #13311, #13425, #13426, #13463, #13585) + + + + GUI: fix 3D overlay window reparenting issue when VM goes to + fullscreen mode on X11 hosts. + + + + GUI: fix occasional loss of focus in full-screen mode on X11 + host systems (4.3.16 regression) + + + + GUI: Mac OS X: wizards should have Cancel button + (bug #12541) + + + + GUI: added a global option to prevent automatic raising of the + new window by mouse move with multi-screen guests (bug #8878) + + + + API: accept remote display port 0 as the default RDP port + (bug #8534) + + + + VBoxManage: fixed crash when executing showvminfo + command under certain circumstances (bug #13190) + + + + ACPI: fixed occassional Guru Meditations in ACPI timer code + (4.3.18 regression; bug #13521) + + + + EFI: improved performance of IDE disk access + + + + EFI: fixed a bug in the EFI video driver which prevented + Windows to boot in UEFI mode (bug #12022) + + + + EFI: properly announce the amount of RAM for big VMs + (bugs #11103 and #13211) + + + + Storage: fixed a crash under certain cicrumstances when a medium + was ejected from a drive attached to the SATA controller without + inserting a new medium before pausing or closing the VM + (4.3.16 regression) + + + + Storage: fixed an interrupt acknowledge issue causing hanging guests + or slower I/O (4.3.18 regression) + + + + Storage: fixed broken resume after the VM was suspended due to + a full disk if host I/O caching is used + + + + Storage: fixed a Guru Meditation under certain conditions when + using the DevLsiLogic controller with VMs running in raw mode + (4.3 regression; bugs #12254, #12655, #12709, #12774, #12886) + + + + Guest Control: fixed a bug which might lead to a crash during + recursive copy + + + + SDK: Java COM bindings fixes + + + + iPXE: enable the HTTP download protocol (bug #13628) + + + + Runtime: do not use a fixed stack size creating temporary threads + during initialization (bug #13038) + + + + Windows hosts: fixed more startup problems on certain Windows hosts due + to conflicts with anti-virus software; better error reporting + (4.3.14 regression; bug #13187) + + + + Windows hosts: fixed DirectSound host audio failure under certain conditions + (bug #13418) + + + + Windows hosts: fixed additional cases of 4.3.14 regression + whereby AltGr stopped working for some people (bug #13216) + + + + Windows Additions: preserve guest monitor layout when resizing + Windows 7 or newer guests + + + + Linux Additions: Linux 3.18 compile fixes (bug #13515) + + + + + + + Version 4.3.18 (2014-10-10) + + This is a maintenance release. The following items were fixed and/or + added: + + + + + VMM: fixed a potential misbehavior after restoring the A20 state + from a saved state + + + + GUI: fixed full-screen mode mini-toolbar related regressions + for different platforms and window managers (bug #13369) + + + + GUI: X11: fixed full-screen mode Unity panels quirk caused by + mini-toolbar code changes in last release (bug #13365) + + + + GUI: X11: added possibility to use legacy full-screen mode + as the new one can cause multi-screen issues under Unity, see + (bug #13365) + + + + GUI: Mac OS X: fixed full-screen mode artifact causing black screen + when 3D acceleration was enabled on 10.10 Yosemite hosts (bug #13448) + + + + GUI: Mac OS X: fixed regression in user-space swiping from/to + VBox in full-screen mode + + + + GUI: Mac OS X: fixed issue with switching to VBox in full-screen + mode through Alt+Tab and Mission Control + + + + Storage: fixed data corruption when resizing huge VHD images under + certain circumstances (bug #11960) + + + + Storage: fixed a rare hang during startup when the BIOS enumerates the + storage devices attached to the SATA controller + + + + Storage: follow the spec with AHCI interrupt acknowledge (bug #13474) + + + + Storage: fixed broken iSCSI authentication (4.3.14 regression; bugs #13386, + #13435) + + + + NAT Network: properly parse port forwarding rules to allow UDP + rules + + + + USB: fixed a crash on Linux hosts with older Linux kernels (bug #13400) and + several other fixes + + + + ACPI: fixed ACPI timer anomalies (bug #12076) + + + + Guest Control: fixed a memory leak (bug #13434) + + + + Main: when removing a VM, do also remove the VBoxStartup.log file + which might exist on Windows hosts (bug #13478) + + + + Windows hosts: fixed more startup problems on certain Windows hosts due + to conflicts with anti-virus software; better error reporting + (4.3.14 regression; bug #13187) + + + + Windows hosts: propagate the process startup information to the child + process (4.3.14 regression; bug #13243) + + + + Mac OS X hosts: don't force using the discrete GPU (bug #11111) + + + + Windows Additions: some Windows 10 tweaks + + + + X11 guests: fix a bug handling video driver display properties + which prevented GNOME Shell on Fedora 21 from starting + + + + Linux hosts / guests: fixed a few remaining warnings in the kernel + log if memory allocation fails (bug #11171) + + + + + + + Version 4.3.16 (2014-09-09) + + This is a maintenance release. The following items were fixed and/or + added: + + + + + VMM: fixed restoring 32-bit FPU state on 64-bit capable VMs + and restoring guest FPU in raw-mode VMs (bug #12646; 4.3 regression) + + + + GUI: properly restore normal/scale mode guest-screen size + after exiting full-screen/seamless mode + + + + GUI: mini-toolbar should provoke less artifacts/conflicts with + 3D guest rendering + + + + GUI: Mac OS X: Native full-screen multi-screen transition + was able to blackout host-screens for nearly minute + + + + GUI: X11: Modern window managers should now use native full-screen + multi-screen mapping API + + + + GUI: added extradata item for configuring the mouse capture + behavior, see + (bug #3506) + + + + Storage: fixed a VBoxSVC crash when querying an iSCSI target with + authentication configured (4.3.14 regression) + + + + Storage: fixed a rare data corruption during reads if another + allocating write is running concurrently and accesses the same range + + + + Storage: fixed a rare crash for certain VHD images from other products + + + + Storage: fixed a rare release assertion when using the AHCI controller + + + + Floppy: fixed read errors and guest memory corruption when running + under control of QEMM + + + + 3D: added experimental support for rendering on offline GPUs for Mac OS X host + + + + 3D: fixed white window appearing on entering FullScreen mode on Mac OS X host + + + + 3D: fixed video recording support for 3D data regression (bug #13073) + + + + 3D: fixes for MS Office 2013 support + + + + 3D: several fixes + + + + Bridged Networking: improved IPv6 support when bridging + to a wireless interface + + + + NAT: prevent internal DNS service from stuck in host-resolver mode + when host was switched from one network to another one while host was + sleeping (Mac OS X hosts) + + + + NAT: preserve DF (if possible) and TOS when proxying + outbound UDP datagrams (bugs #9440, #12309) + + + + NAT: don't let multicast datagrams out (bug #7338) + + + + NAT: fixed handling of large incoming UDP datagrams on + Windows hosts (bug #12136) + + + + NAT: fixed handling of the RFC 1533 DHCP PAD option + + + + NAT Network: fixed inbound half-close on Windows hosts + + + + NAT Network: preserve IPv4 DF (if possible), TTL, TOS + and IPv6 Hop Limit when proxying outbound UDP + datagrams + + + + VRDP: fixed a rare crash when using remote audio input + + + + USB: fixed several regressions from 4.3.14 (bug #13320) + + + + Audio: made the HDA sound emulation work with certain Mac OS X guests + (e.g. Mountain Lion) + + + + Windows hosts: fixed startup problems on certain Windows hosts due + to conflicts with anti-virus software (4.3.14 regression; bug #13187) + + + + Windows hosts: fixed 4.3.14 regression whereby AltGr stopped + working for some people (bug #13216) + + + + X11 hosts: made the extra key on Brazilian Thinkpads work + (bug #8745) + + + + X11 hosts: fixed a problem of input focus cycles and immediately + released key presses in full screen mode (bug #13238) + + + + Linux hosts: fixed flooding the kernel log with USB related messages + when passing through certain USB devices to a VM (bug #13085) + + + + Linux guests: stop applications crashing when drm_wait_vblank + is called (bug #13265) + + + + Linux guests: fix a crash in gnome-session (bug #13335) + + + + X11 guests: do not start VBoxClient over an SSH connection + (bug #13107) + + + + X11 guests: added support for X.Org Server 1.16 (bug #13207) + + + + X11 guests: fixed a wrong parameter in the video driver which + caused problems with full-screen X11 clients (bug #2748) + + + + VirtualKD: introduced stub/loader device for speeding up Windows + kernel debugging, details see http://virtualkd.sysprogs.org/ + + + + + + + Version 4.3.14 (2014-07-15) + + This is a maintenance release. The following items were fixed and/or + added: + + + + + VMM: more fixes for MSR emulation on certain hardware (bugs + #12784, #12949, #13034) + + + + VMM: improve MSI handling under rare circumstances (only + relevant for the ICH9 chipset) + + + + VMM: fixed #UD exception for 64-bit guests with the EFER.SCE bit + and the SYSCALL instruction (VT-x only; + 4.3 regression; bug #13008) + + + + VMM: fixed timekeeping after resuming SMP guests + + + + VMM: properly wake up a halted VCPU on NMI/SMI + + + + GUI: fixed a potential crash + + + + GUI: fixed stuck AltGr key on Windows hosts (bug #2537) + + + + GUI: fixed a potential error during the version check + + + + GUI: shortcut change should not require Enter/Return (or other + trigger) to confirm (bugs #12828, #12847, #12937, #13087) + + + + GUI: fixed update check which was broken due to changing the + location of the root certificates (bug #13096) + + + + VBoxManage: fixed typo in showvminfo --machinereadable + (bug #13176) + + + + NAT: fixed inbound half-close (bug #13116) + + + + NAT: fixed slow upload speed under certain conditions + (bug #10034) + + + + NAT Network: fixed potential loss of inbound TCP data + + + + NAT Network: fixed potential infinite stalls of TCP + connections over IPv6 + + + + NAT Network: fixed resets of TCP connections on Windows + hosts + + + + NAT Network: fixed inbound half-close on Mac OS X hosts + + + + NAT Network: fixed socket leak on Solaris hosts + + + + NAT Network: fixed ping of mapped host loopback on Mac OS X + and Solaris hosts, fixed proxying of IMCP errors on Mac OS X + + + + Host-Only Network: fixed SNMP ifConnectorPresent + value on Windows (bug #13143) + + + + Storage: fixed a possible crash with CD/DVD passthrough under + certain circumstances + + + + Storage: fixed a crash when trying to open an inaccessible QED + or QCOW image (bug #12613) + + + + Storage: fixed data corruption or read errors under rare + circumstances + + + + AHCI: fixed a crash under rare circumstances + + + + USB: performance fixes + + + + ICH9: properly reset MSI capability on reset + + + + Keyboard: active modifier keys during suspend were stuck after + resuming the host + + + + 3D: fixed misbehavior with huge guests (i.e. guest more than + 4GB guest memory + + + + 3D: several fixes + + + + API: properly detect the Windows 8.1 guest OS type (bug #13090) + + + + ExtPack: cleanup of dangling uninstallation directories + + + + Linux hosts / guests: compile fix for EL7 (bug #12638) + + + + Linux Additions: made 3D pass-through work with recent versions + of Mesa in the guest (bug #12941) + + + + Linux Additions: Linux 3.16 fixes (bug #13123) + + + + Mac OS X hosts: when scanning for host CD/DVD devices also consider + BlueRay devices + + + + Mac OS X hosts: fixed host shutdown and reboot delay caused by running VBoxSVC + process in some cases. + + + + OS/2 Additions: fixed gengradd.dll library name (bug #12785) + + + + Solaris Additions: fixed permissions of files and directories + located on shared folders + + + + Windows host installer: fixed the need for rebooting Windows after + installation or upgrade, extended logging for NetFlt/NetAdp (un)installation + + + + + + + + Version 4.3.12 (2014-05-16) + + This is a maintenance release. The following items were fixed and/or + added: + + + + + VMM: fixed an occasional Guru Meditation (Mac OS X hosts only; + bugs #12727, #12954) + + + + VMM: fixed a rare condition that would fail to invalidate guest TLB + entries or would invalidate them when not required (Windows hosts only) + + + + VMM: fixed a VERR_NOT_SUPPORTED Guru Meditation + seen with certain guests, e.g. OpenServer 5.0.7 + + + + VMM: more fixes for MSR emulation on certain hardware (bugs #12240, + #12875) + + + + GUI: fixed mouse positioning with mouse integration disabled and + multiple guest screens (Windows hosts only; bug #9059) + + + + GUI: fixed crash in VM manager (bug #12878) + + + + GUI: fixed crash under rare conditions on entering/exiting + full-screen/seamless mode + + + + Shared Clipboard: don't stop working after taking a snapshot + (bug #12700) + + + + AHCI: fixed a crash under rare circumstances + + + + API: fixed a hang during VM shutdown under rare conditions + + + + NAT: fixed generation of malformed ICMP error datagrams (4.3.10 regression) + + + + NAT: fixed potential crash in DNS proxy + + + + NAT Network: don't drop port forwarding rules after some time + + + + NAT: fixed ARP cache corruption and network loss in Windows guest caused + by iSCSI service activity + + + + USB: improved check if a storage device is currently mounted to the host + when the device is about to be attached to the VM (Mac OS X hosts only; #11038) + + + + 3D support: several fixes, including better support for Ubuntu 14.04 + + + + VRDP: fixed a potential crash on client disconnect (bug #12858) + + + + VBoxSVC: fixed a race when a new client is started a few seconds after + the last client terminated (Windows hosts only; bugs #11309, #12509) + + + + VBoxSVC: fixed VirtualBox.xml registry corruption after VM renaming + + + + VBoxSVC: fixed a potential crash caused by incorrect USB device filter + (Mac OS X hosts only; #11038) + + + + Windows hosts: partly support 32-bit COM on 64-bit systems + + + + Windows host installer: implemented merge module (msm) support + + + + Linux hosts: fixed dependency of boot script on older Debian systems + (bug #12262) + + + + Linux guests: fix symbolic link to shared folder helper + (bug #12879) + + + + Linux Additions: don't crash VBoxService during guest execute for + users without a password (bug #12994) + + + + Linux Additions: fixed a bug in guest execution where the guest process + terminated with VERR_INTERRUPTED to the host + + + + + + + + Version 4.3.10 (2014-03-26) + + This is a maintenance release. The following items were fixed and/or + added: + + + + + VMM: more work on improving the emulation of certain MSR registers + on certain host CPUs (e.g. bugs #12734, #12736, #12744, #12748, #12686, + #12770) + + + + VMM: fixed single-stepping for real-mode guests (VT-x without + unrestricted guest execution) and some I/O instructions (bug #12636) + + + + VMM: fixed a potential problem with COW pages if nested paging is + not available + + + + GUI: Mac OS X: experimental native full screen support for + Mountain Lion and Mavericks (bug #12292) + + + + GUI: Mac OS X: removed the mini-toolbar minimize button which + doesn't work under Mac OS X full screen mode anyway + + + + GUI: experimental HID LEDs synchronization for Windows and Mac OS X hosts: + fixed keyboard re-synchronization if the feature is disabled (as done by default; + bug #12758) + + + + GUI: fixed a potential crash when opening the preferences menu + (bug #12862) + + + + OVF: fixed a crash of the VirtualBox Manager when re-starting guest + export (bug #12586) + + + + 3D support: several fixes + + + + HGCM: fixed a problem with saved states which could cause several + guest misbehavior after a VM was started from a saved state + + + + Storage: fixed a bug preventing to compact differential snapshots + under certain conditions + + + + VBoxSVC: fixed a segmentation fault on Linux hosts if a very long path + exists under /dev (bug #12760) + + + + API: fixed guest misbehavior under certain conditions if a storage + medium was attached or removed at VM runtime + + + + Windows installer: make the --silent + parameter work again (bug #12764) + + + + Mac OS X Networking: prevent local traffic (VM-to/from-host) from + leaking to wire (bug #12750) + + + + Windows Additions: fixed the environment for guest processes + (4.3.8 regression; bug #12782) + + + + Windows Additions/WDDM: fixed divide by zero exception with + multiple guest screens under certain conditions + + + + Windows Additions/WDDM: fixed crashes with 2D video + acceleration enabled (4.3.8 regression; bug #12745) + + + + Linux Additions: install correctly on Ubuntu guest systems + with a /usr/lib64 directory (bug #12513) + + + + X11 Additions: fix for the VBoxClient process not exiting + correctly (bug #12348) and consuming too much processor time + + + + + + + Version 4.3.8 (2014-02-25) + + This is a maintenance release. The following items were fixed and/or + added: + + + + VMM: more work on improving the emulation of certain MSR registers (e.g. bugs #12224, #12544) @@ -93,5 +1282,6 @@ VMM: experimental support for SSE 4.1 / SSE 4.2 passthrough, see - the user manual how to enable it (bug #8651) + how to + enable it (bug #8651) @@ -102,5 +1292,5 @@ GUI: experimental HID LEDs synchronization for Windows hosts, see - the user manual + @@ -368,5 +1558,5 @@ - GUI: fixed deleting of inaccessible VMs (4.3 regression, bug + GUI: fixed deleting of inaccessible VMs (4.3 regression; bug #12205) @@ -424,5 +1614,5 @@ Solaris hosts: fixed accessing the host driver from non-global zones - (4.3 regression, bug #12271) + (4.3 regression; bug #12271) @@ -1249,5 +2439,5 @@ Snapshots: fixed a bug which could result in lost medium attachments - (4.2.18 regression, bug #11750) + (4.2.18 regression; bug #11750) @@ -2001,5 +3191,5 @@ Storage: fixed non working online merging of snapshots - (4.2.6 regression, bug #11359) + (4.2.6 regression; bug #11359) @@ -2320,10 +3510,10 @@ GUI: fixed validation warning on global settings / proxy page - (4.2.2 regression, bug #11089) + (4.2.2 regression; bug #11089) GUI: fixed crash with multiple guest screens on certain - conditions (OS X hosts only) + conditions (Mac OS X hosts only) @@ -2347,5 +3537,5 @@ - EFI: fixed video mode selection loss on VM reboot (#10983) + EFI: fixed video mode selection loss on VM reboot (bug #10983) @@ -2613,5 +3803,5 @@ VMM: fixed a potential host crash triggered by shutting down a VM when another VM was running (only affected 32-bit hosts and 64-bit OS X hosts, - 4.1 regression, bug #9897) + 4.1 regression; bug #9897) @@ -2940,5 +4130,5 @@ Windows Additions: fixed guest driver crash of VBoxSF in certain - cases (4.1.10 regression, bug #10408) + cases (4.1.10 regression; bug #10408) @@ -3265,5 +4455,5 @@ NAT: increase maximum number of parallel connections making - connections with port forwarding more robust (#8471) + connections with port forwarding more robust (bug #8471) @@ -3806,5 +4996,5 @@ Windows Vista and 7 guests: WDDM driver fixes and performance enhancements, - fixed WinSAT crashes (#9267) + fixed WinSAT crashes (bug #9267) @@ -3840,6 +5030,6 @@ - GUI: keep the aspect ratio in scale mode (Windows and OSX hosts only; - bug #7822) + GUI: keep the aspect ratio in scale mode (Windows and Mac OS X hosts + only; bug #7822) @@ -7429,5 +8619,5 @@ Linux Additions: make the mouse driver work on Debian 5.0.3 guests - again (3.1.2 regression, bug #5832) + again (3.1.2 regression; bug #5832) @@ -8447,5 +9637,5 @@ BIOS: fixed a bug that caused the OS/2 boot manager to fail - (2.1.0 regression, bug #3911) + (2.1.0 regression; bug #3911) @@ -8650,5 +9840,5 @@ USB: fixed a bug that may have rendered USB device filter settings - inactive (3.0.2 regression, bug #4668) + inactive (3.0.2 regression; bug #4668) @@ -9328,5 +10518,5 @@ Windows Additions: fixed mouse pointer integration of some - Windows guests (2.2.0 regression, bug #3734) + Windows guests (2.2.0 regression; bug #3734) @@ -9372,5 +10562,5 @@ - GUI: HostKey could not be changed (2.2.0 regression, + GUI: HostKey could not be changed (2.2.0 regression; bug #3689) @@ -9409,5 +10599,5 @@ Networking: fixed a deadlock caused by the PCnet network device - emulation (2.2.0 regression, bug #3676) + emulation (2.2.0 regression; bug #3676) @@ -9595,5 +10785,5 @@ - Shared Folders: respect umask settings on Linux, OSX and Solaris + Shared Folders: respect umask settings on Linux, Mac OS X and Solaris hosts when creating files @@ -10116,5 +11306,5 @@ SATA: raw disk partitions were not recognized - (2.1.0 regression, Windows host only, bug #2778) + (2.1.0 regression; Windows host only, bug #2778) Index: /trunk/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.asm =================================================================== --- /trunk/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.asm (revision 55077) +++ /trunk/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.asm (revision 55078) @@ -856,10 +856,10 @@ db 001h, 000h, 002h, 002h, 003h, 003h, 004h, 004h, 005h, 005h, 00eh, 006h, 00fh, 006h, 000h _pktacc: ; 0xf006a LB 0xc - db 000h, 000h, 000h, 000h, 000h, 000h, 08fh, 028h, 09ah, 079h, 062h, 087h + db 000h, 000h, 000h, 000h, 000h, 000h, 08fh, 028h, 05dh, 07bh, 025h, 089h _softrst: ; 0xf0076 LB 0xc - db 000h, 000h, 000h, 000h, 000h, 000h, 077h, 02bh, 091h, 036h, 091h, 036h + db 000h, 000h, 000h, 000h, 000h, 000h, 077h, 02bh, 054h, 038h, 054h, 038h _dskacc: ; 0xf0082 LB 0x2e db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 0d8h, 027h, 052h, 028h, 000h, 000h, 000h, 000h - db 028h, 078h, 0e1h, 078h, 05eh, 086h, 0f2h, 086h, 000h, 000h, 000h, 000h, 000h, 000h, 05fh, 033h + db 0ebh, 079h, 0a4h, 07ah, 021h, 088h, 0b5h, 088h, 000h, 000h, 000h, 000h, 000h, 000h, 05fh, 033h db 032h, 05fh, 000h, 0dah, 00fh, 000h, 000h, 001h, 0f3h, 000h, 000h, 000h, 000h, 000h @@ -871,5 +871,5 @@ db 'bios_printf: unknown format', 00ah, 000h, 000h db 'ata-detect: Failed to detect ATA device', 00ah, 000h - db 'ata%d-%d: PCHS=%u/%d/%d LCHS=%u/%u/%u', 00ah, 000h + db 'ata%d-%d: PCHS=%u/%u/%u LCHS=%u/%u/%u', 00ah, 000h db 'ata-detect: Failed to detect ATAPI device', 00ah, 000h db ' slave', 000h @@ -968,5 +968,5 @@ db '%s: SCSI_READ_CAPACITY failed', 00ah, 000h db 'Disk %d has an unsupported sector size of %u', 00ah, 000h - db 'SCSI %d-ID#%d: LCHS=%u/%u/%u %ld sectors', 00ah, 000h + db 'SCSI %d-ID#%d: LCHS=%u/%u/%u %lu sectors', 00ah, 000h db 'SCSI %d-ID#%d: CD/DVD-ROM', 00ah, 000h, 000h db 'ahci_read_sectors', 000h @@ -975,5 +975,5 @@ db 'ahci_cmd_packet', 000h db '%s: DATA_OUT not supported yet', 00ah, 000h - db 'AHCI %d-P#%d: PCHS=%u/%d/%d LCHS=%u/%u/%u %ld sectors', 00ah, 000h, 000h + db 'AHCI %d-P#%d: PCHS=%u/%u/%u LCHS=%u/%u/%u %lu sectors', 00ah, 000h, 000h db 'Standby', 000h db 'Suspend', 000h @@ -982,18 +982,18 @@ db 'PCI: Unsupported function AX=%04X BX=%04X called', 00ah, 000h -section CONST2 progbits vstart=0xd90 align=1 ; size=0x3fa class=DATA group=DGROUP -_bios_cvs_version_string: ; 0xf0d90 LB 0x12 - db 'VirtualBox 4.3.53', 000h -_bios_prefix_string: ; 0xf0da2 LB 0x8 +section CONST2 progbits vstart=0xd90 align=1 ; size=0x400 class=DATA group=DGROUP +_bios_cvs_version_string: ; 0xf0d90 LB 0x18 + db 'VirtualBox 5.0.0_BETA1', 000h, 000h +_bios_prefix_string: ; 0xf0da8 LB 0x8 db 'BIOS: ', 000h, 000h -_isotag: ; 0xf0daa LB 0x6 +_isotag: ; 0xf0db0 LB 0x6 db 'CD001', 000h -_eltorito: ; 0xf0db0 LB 0x18 +_eltorito: ; 0xf0db6 LB 0x18 db 'EL TORITO SPECIFICATION', 000h -_drivetypes: ; 0xf0dc8 LB 0x28 +_drivetypes: ; 0xf0dce LB 0x28 db 046h, 06ch, 06fh, 070h, 070h, 079h, 000h, 000h, 000h, 000h, 048h, 061h, 072h, 064h, 020h, 044h db 069h, 073h, 06bh, 000h, 043h, 044h, 02dh, 052h, 04fh, 04dh, 000h, 000h, 000h, 000h, 04ch, 041h db 04eh, 000h, 000h, 000h, 000h, 000h, 000h, 000h -_scan_to_scanascii: ; 0xf0df0 LB 0x37a +_scan_to_scanascii: ; 0xf0df6 LB 0x37a db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 01bh, 001h, 01bh, 001h, 01bh, 001h db 000h, 001h, 000h, 000h, 031h, 002h, 021h, 002h, 000h, 000h, 000h, 078h, 000h, 000h, 032h, 003h @@ -1052,11 +1052,11 @@ db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 085h, 000h, 087h, 000h, 089h, 000h, 08bh, 000h, 000h db 000h, 086h, 000h, 088h, 000h, 08ah, 000h, 08ch, 000h, 000h -_panic_msg_keyb_buffer_full: ; 0xf116a LB 0x20 +_panic_msg_keyb_buffer_full: ; 0xf1170 LB 0x20 db '%s: keyboard input buffer full', 00ah, 000h - ; Padding 0x476 bytes at 0xf118a - times 1142 db 0 + ; Padding 0x470 bytes at 0xf1190 + times 1136 db 0 -section _TEXT progbits vstart=0x1600 align=1 ; size=0x8025 class=CODE group=AUTO +section _TEXT progbits vstart=0x1600 align=1 ; size=0x81e5 class=CODE group=AUTO rom_scan_: ; 0xf1600 LB 0x50 push bp ; 55 @@ -1280,5 +1280,5 @@ push bp ; 55 mov bp, sp ; 89 e5 - mov bx, 00da2h ; bb a2 0d + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 @@ -1309,5 +1309,5 @@ int 010h ; cd 10 jmp short 017c1h ; eb 03 - call 07437h ; e8 76 5c + call 075fah ; e8 39 5e mov sp, bp ; 89 ec pop bp ; 5d @@ -1455,5 +1455,5 @@ mov bx, strict word 0000ah ; bb 0a 00 xor cx, cx ; 31 c9 - call 09530h ; e8 57 7c + call 096f0h ; e8 17 7e mov word [bp-008h], ax ; 89 46 f8 mov cx, dx ; 89 d1 @@ -2418,6 +2418,6 @@ mov dx, ss ; 8c d2 lea ax, [bp-036h] ; 8d 46 ca - call 053f3h ; e8 d6 31 - mov bx, 00da2h ; bb a2 0d + call 055b6h ; e8 99 33 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 @@ -3067,5 +3067,5 @@ cmp byte [bp+00ah], 002h ; 80 7e 0a 02 jne short 028e1h ; 75 1f - mov bx, 00da2h ; bb a2 0d + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 @@ -3829,49 +3829,54 @@ pop bp ; 5d retn ; c3 -_int13_diskette_function: ; 0xf2f2e LB 0x734 +_int13_diskette_function: ; 0xf2f2e LB 0x8f7 push bp ; 55 mov bp, sp ; 89 e5 push si ; 56 push di ; 57 - sub sp, strict byte 00012h ; 83 ec 12 + sub sp, strict byte 00016h ; 83 ec 16 mov bx, word [bp+016h] ; 8b 5e 16 shr bx, 008h ; c1 eb 08 - mov ch, bl ; 88 dd + mov byte [bp-006h], bl ; 88 5e fa mov si, word [bp+016h] ; 8b 76 16 and si, 000ffh ; 81 e6 ff 00 - mov ah, byte [bp+00eh] ; 8a 66 0e + mov al, byte [bp+00eh] ; 8a 46 0e + mov ah, byte [bp+014h] ; 8a 66 14 + mov cl, byte [bp+016h] ; 8a 4e 16 + mov dx, word [bp+014h] ; 8b 56 14 + shr dx, 008h ; c1 ea 08 + mov word [bp-010h], dx ; 89 56 f0 cmp bl, 008h ; 80 fb 08 - jc short 02f85h ; 72 38 + jc short 02f95h ; 72 38 mov dx, word [bp+01ch] ; 8b 56 1c or dl, 001h ; 80 ca 01 cmp bl, 008h ; 80 fb 08 - jbe near 034e1h ; 0f 86 87 05 + jbe near 034ebh ; 0f 86 81 05 cmp bl, 016h ; 80 fb 16 - jc short 02f7bh ; 72 1c + jc short 02f8bh ; 72 1c or si, 00100h ; 81 ce 00 01 cmp bl, 016h ; 80 fb 16 - jbe near 0361dh ; 0f 86 b3 06 + jbe near 0361fh ; 0f 86 a5 06 cmp bl, 018h ; 80 fb 18 - je near 03622h ; 0f 84 b1 06 + je near 036b5h ; 0f 84 34 07 cmp bl, 017h ; 80 fb 17 - je near 03622h ; 0f 84 aa 06 - jmp near 0363fh ; e9 c4 06 + je near 03643h ; 0f 84 bb 06 + jmp near 03802h ; e9 77 08 cmp bl, 015h ; 80 fb 15 - je near 035d7h ; 0f 84 55 06 - jmp near 0363fh ; e9 ba 06 + je near 035dbh ; 0f 84 49 06 + jmp near 03802h ; e9 6d 08 cmp bl, 001h ; 80 fb 01 - jc short 02f9fh ; 72 15 - jbe near 03018h ; 0f 86 8a 00 + jc short 02fafh ; 72 15 + jbe near 03028h ; 0f 86 8a 00 cmp bl, 005h ; 80 fb 05 - je near 0335bh ; 0f 84 c6 03 + je near 03365h ; 0f 84 c0 03 cmp bl, 004h ; 80 fb 04 - jbe near 03036h ; 0f 86 9a 00 - jmp near 0363fh ; e9 a0 06 + jbe near 03046h ; 0f 86 9a 00 + jmp near 03802h ; e9 53 08 test bl, bl ; 84 db - jne near 0363fh ; 0f 85 9a 06 + jne near 03802h ; 0f 85 4d 08 mov al, byte [bp+00eh] ; 8a 46 0e - mov byte [bp-00eh], al ; 88 46 f2 + mov byte [bp-008h], al ; 88 46 f8 cmp AL, strict byte 001h ; 3c 01 - jbe short 02fc3h ; 76 14 + jbe short 02fd3h ; 76 14 mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -3879,17 +3884,17 @@ mov word [bp+016h], ax ; 89 46 16 mov ax, strict word 00001h ; b8 01 00 - call 02bf7h ; e8 37 fc - jmp near 03337h ; e9 74 03 + call 02bf7h ; e8 27 fc + jmp near 03341h ; e9 6e 03 mov ax, strict word 00010h ; b8 10 00 - call 016ach ; e8 e3 e6 - cmp byte [bp-00eh], 000h ; 80 7e f2 00 - jne short 02fd6h ; 75 07 - mov dl, al ; 88 c2 - shr dl, 004h ; c0 ea 04 - jmp short 02fdbh ; eb 05 - mov dl, al ; 88 c2 - and dl, 00fh ; 80 e2 0f - test dl, dl ; 84 d2 - jne short 02fefh ; 75 10 + call 016ach ; e8 d3 e6 + cmp byte [bp-008h], 000h ; 80 7e f8 00 + jne short 02fe6h ; 75 07 + mov cl, al ; 88 c1 + shr cl, 004h ; c0 e9 04 + jmp short 02febh ; eb 05 + mov cl, al ; 88 c1 + and cl, 00fh ; 80 e1 0f + test cl, cl ; 84 c9 + jne short 02fffh ; 75 10 mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -3897,17 +3902,17 @@ mov word [bp+016h], ax ; 89 46 16 mov ax, 00080h ; b8 80 00 - jmp short 02fbdh ; eb ce + jmp short 02fcdh ; eb ce xor bx, bx ; 31 db mov dx, strict word 0003eh ; ba 3e 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 64 e6 + call 0165eh ; e8 54 e6 xor al, al ; 30 c0 mov byte [bp+017h], al ; 88 46 17 xor ah, ah ; 30 e4 - call 02bf7h ; e8 f3 fb + call 02bf7h ; e8 e3 fb and byte [bp+01ch], 0feh ; 80 66 1c fe - movzx ax, byte [bp-00eh] ; 0f b6 46 f2 + movzx ax, byte [bp-008h] ; 0f b6 46 f8 xor dx, dx ; 31 d2 - call 02c0fh ; e8 fe fb + call 02c0fh ; e8 ee fb lea sp, [bp-004h] ; 8d 66 fc pop di ; 5f @@ -3918,5 +3923,5 @@ mov dx, 00441h ; ba 41 04 xor ax, ax ; 31 c0 - call 01650h ; e8 2c e6 + call 01650h ; e8 1c e6 movzx dx, al ; 0f b6 d0 sal dx, 008h ; c1 e2 08 @@ -3924,34 +3929,30 @@ mov word [bp+016h], si ; 89 76 16 test al, al ; 84 c0 - je short 03011h ; 74 de - jmp near 03337h ; e9 01 03 - mov al, byte [bp+016h] ; 8a 46 16 - mov byte [bp-00ch], al ; 88 46 f4 - mov dx, word [bp+014h] ; 8b 56 14 - shr dx, 008h ; c1 ea 08 - mov byte [bp-006h], dl ; 88 56 fa - mov al, byte [bp+014h] ; 8a 46 14 - mov byte [bp-00ah], al ; 88 46 f6 + je short 03021h ; 74 de + jmp near 03341h ; e9 fb 02 + mov ch, cl ; 88 cd + mov dl, byte [bp-010h] ; 8a 56 f0 + mov byte [bp-00ch], dl ; 88 56 f4 + mov byte [bp-00ah], ah ; 88 66 f6 mov dx, word [bp+012h] ; 8b 56 12 shr dx, 008h ; c1 ea 08 - mov byte [bp-008h], dl ; 88 56 f8 - mov byte [bp-00eh], ah ; 88 66 f2 - cmp ah, 001h ; 80 fc 01 - jnbe short 0306ch ; 77 10 + mov byte [bp-00eh], dl ; 88 56 f2 + mov byte [bp-008h], al ; 88 46 f8 + cmp AL, strict byte 001h ; 3c 01 + jnbe short 0306fh ; 77 0e cmp dl, 001h ; 80 fa 01 - jnbe short 0306ch ; 77 0b - mov al, byte [bp-00ch] ; 8a 46 f4 - test al, al ; 84 c0 - je short 0306ch ; 74 04 - cmp AL, strict byte 048h ; 3c 48 - jbe short 03095h ; 76 29 - mov bx, 00da2h ; bb a2 0d + jnbe short 0306fh ; 77 09 + test cl, cl ; 84 c9 + je short 0306fh ; 74 05 + cmp cl, 048h ; 80 f9 48 + jbe short 03099h ; 76 2a + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 ba e8 + call 01931h ; e8 b7 e8 push 00255h ; 68 55 02 push 0026dh ; 68 6d 02 push strict byte 00004h ; 6a 04 - call 01972h ; e8 f0 e8 + call 01972h ; e8 ed e8 add sp, strict byte 00006h ; 83 c4 06 mov ax, word [bp+016h] ; 8b 46 16 @@ -3960,18 +3961,18 @@ mov word [bp+016h], ax ; 89 46 16 mov ax, strict word 00001h ; b8 01 00 - jmp short 03106h ; eb 71 - movzx ax, byte [bp-00eh] ; 0f b6 46 f2 - call 02f0ah ; e8 6e fe + jmp near 0310fh ; e9 76 00 + movzx ax, byte [bp-008h] ; 0f b6 46 f8 + call 02f0ah ; e8 6a fe test ax, ax ; 85 c0 - je near 03199h ; 0f 84 f7 00 - movzx dx, byte [bp-00eh] ; 0f b6 56 f2 + je near 031a2h ; 0f 84 fc 00 + movzx dx, byte [bp-008h] ; 0f b6 56 f8 mov ax, dx ; 89 d0 - call 02d4fh ; e8 a4 fc + call 02d4fh ; e8 a0 fc test ax, ax ; 85 c0 - jne short 030c8h ; 75 19 + jne short 030cch ; 75 19 mov ax, dx ; 89 d0 - call 02e1ah ; e8 66 fd + call 02e1ah ; e8 62 fd test ax, ax ; 85 c0 - jne short 030c8h ; 75 10 + jne short 030cch ; 75 10 mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -3979,25 +3980,26 @@ mov word [bp+016h], ax ; 89 46 16 mov ax, strict word 0000ch ; b8 0c 00 - jmp short 03106h ; eb 3e - cmp ch, 002h ; 80 fd 02 - jne near 03230h ; 0f 85 61 01 - mov cx, word [bp+006h] ; 8b 4e 06 - shr cx, 00ch ; c1 e9 0c - mov ah, cl ; 88 cc + jmp short 0310fh ; eb 43 + cmp byte [bp-006h], 002h ; 80 7e fa 02 + jne near 03234h ; 0f 85 60 01 + mov ax, word [bp+006h] ; 8b 46 06 + shr ax, 00ch ; c1 e8 0c + mov cl, al ; 88 c1 mov dx, word [bp+006h] ; 8b 56 06 sal dx, 004h ; c1 e2 04 mov bx, word [bp+010h] ; 8b 5e 10 add bx, dx ; 01 d3 - cmp bx, dx ; 39 d3 - jnc short 030e8h ; 73 02 - db 0feh, 0c4h - ; inc ah ; fe c4 - movzx cx, byte [bp-00ch] ; 0f b6 4e f4 - sal cx, 009h ; c1 e1 09 - dec cx ; 49 - mov dx, bx ; 89 da - add dx, cx ; 01 ca + mov word [bp-012h], bx ; 89 5e ee cmp dx, bx ; 39 da - jnc short 03110h ; 73 18 + jbe short 030f0h ; 76 02 + db 0feh, 0c1h + ; inc cl ; fe c1 + movzx bx, ch ; 0f b6 dd + sal bx, 009h ; c1 e3 09 + dec bx ; 4b + mov ax, word [bp-012h] ; 8b 46 ee + add ax, bx ; 01 d8 + cmp ax, word [bp-012h] ; 3b 46 ee + jnc short 03119h ; 73 18 mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -4005,7 +4007,7 @@ mov word [bp+016h], ax ; 89 46 16 mov ax, strict word 00009h ; b8 09 00 - call 02bf7h ; e8 ee fa + call 02bf7h ; e8 e5 fa mov byte [bp+016h], 000h ; c6 46 16 00 - jmp near 03337h ; e9 27 02 + jmp near 03341h ; e9 28 02 mov AL, strict byte 006h ; b0 06 mov dx, strict word 0000ah ; ba 0a 00 @@ -4014,23 +4016,23 @@ mov dx, strict word 0000ch ; ba 0c 00 out DX, AL ; ee + mov al, byte [bp-012h] ; 8a 46 ee + mov dx, strict word 00004h ; ba 04 00 + out DX, AL ; ee + mov ax, word [bp-012h] ; 8b 46 ee + shr ax, 008h ; c1 e8 08 + out DX, AL ; ee + xor al, al ; 30 c0 + mov dx, strict word 0000ch ; ba 0c 00 + out DX, AL ; ee mov al, bl ; 88 d8 - mov dx, strict word 00004h ; ba 04 00 - out DX, AL ; ee - shr bx, 008h ; c1 eb 08 - mov al, bl ; 88 d8 - out DX, AL ; ee - xor al, bl ; 30 d8 - mov dx, strict word 0000ch ; ba 0c 00 - out DX, AL ; ee - mov al, cl ; 88 c8 mov dx, strict word 00005h ; ba 05 00 out DX, AL ; ee - shr cx, 008h ; c1 e9 08 - mov al, cl ; 88 c8 + mov ax, bx ; 89 d8 + shr ax, 008h ; c1 e8 08 out DX, AL ; ee mov AL, strict byte 046h ; b0 46 mov dx, strict word 0000bh ; ba 0b 00 out DX, AL ; ee - mov al, ah ; 88 e0 + mov al, cl ; 88 c8 mov dx, 00081h ; ba 81 00 out DX, AL ; ee @@ -4038,19 +4040,18 @@ mov dx, strict word 0000ah ; ba 0a 00 out DX, AL ; ee - out DX, AL ; ee - movzx ax, byte [bp-00eh] ; 0f b6 46 f2 - call 02cceh ; e8 7a fb + movzx ax, byte [bp-008h] ; 0f b6 46 f8 + call 02cceh ; e8 70 fb mov AL, strict byte 0e6h ; b0 e6 mov dx, 003f5h ; ba f5 03 out DX, AL ; ee + movzx dx, byte [bp-00eh] ; 0f b6 56 f2 + sal dx, 002h ; c1 e2 02 movzx ax, byte [bp-008h] ; 0f b6 46 f8 - sal ax, 002h ; c1 e0 02 - movzx dx, byte [bp-00eh] ; 0f b6 56 f2 or ax, dx ; 09 d0 mov dx, 003f5h ; ba f5 03 out DX, AL ; ee - mov al, byte [bp-006h] ; 8a 46 fa - out DX, AL ; ee - mov al, byte [bp-008h] ; 8a 46 f8 + mov al, byte [bp-00ch] ; 8a 46 f4 + out DX, AL ; ee + mov al, byte [bp-00eh] ; 8a 46 f2 out DX, AL ; ee mov al, byte [bp-00ah] ; 8a 46 f6 @@ -4059,5 +4060,5 @@ out DX, AL ; ee movzx dx, byte [bp-00ah] ; 0f b6 56 f6 - movzx ax, byte [bp-00ch] ; 0f b6 46 f4 + movzx ax, ch ; 0f b6 c5 add ax, dx ; 01 d0 dec ax ; 48 @@ -4068,8 +4069,8 @@ mov AL, strict byte 0ffh ; b0 ff out DX, AL ; ee - call 02c5dh ; e8 cb fa + call 02c5dh ; e8 c2 fa test al, al ; 84 c0 - jne short 031aah ; 75 14 - call 02ca3h ; e8 0a fb + jne short 031b3h ; 75 14 + call 02ca3h ; e8 01 fb mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -4077,5 +4078,5 @@ mov word [bp+016h], ax ; 89 46 16 mov ax, 00080h ; b8 80 00 - jmp near 03106h ; e9 5c ff + jmp near 0310fh ; e9 5c ff mov dx, 003f4h ; ba f4 03 in AL, DX ; ec @@ -4084,27 +4085,27 @@ and AL, strict byte 0c0h ; 24 c0 cmp AL, strict byte 0c0h ; 3c c0 - je short 031c4h ; 74 0e + je short 031cdh ; 74 0e push 00255h ; 68 55 02 push 00288h ; 68 88 02 push strict byte 00007h ; 6a 07 - call 01972h ; e8 b1 e7 + call 01972h ; e8 a8 e7 add sp, strict byte 00006h ; 83 c4 06 xor si, si ; 31 f6 - jmp short 031cdh ; eb 05 + jmp short 031d6h ; eb 05 cmp si, strict byte 00007h ; 83 fe 07 - jnl short 031e5h ; 7d 18 + jnl short 031eeh ; 7d 18 mov dx, 003f5h ; ba f5 03 in AL, DX ; ec db 02ah, 0e4h ; sub ah, ah ; 2a e4 - mov byte [bp+si-016h], al ; 88 42 ea + mov byte [bp+si-01ah], al ; 88 42 e6 movzx bx, al ; 0f b6 d8 lea dx, [si+042h] ; 8d 54 42 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 7c e4 + call 0165eh ; e8 73 e4 inc si ; 46 - jmp short 031c8h ; eb e3 - test byte [bp-016h], 0c0h ; f6 46 ea c0 - je short 031fch ; 74 11 + jmp short 031d1h ; eb e3 + test byte [bp-01ah], 0c0h ; f6 46 e6 c0 + je short 03205h ; 74 11 mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -4112,6 +4113,6 @@ mov word [bp+016h], ax ; 89 46 16 mov ax, strict word 00020h ; b8 20 00 - jmp near 03106h ; e9 0a ff - movzx ax, byte [bp-00ch] ; 0f b6 46 f4 + jmp near 0310fh ; e9 0a ff + movzx ax, ch ; 0f b6 c5 sal ax, 009h ; c1 e0 09 cwd ; 99 @@ -4119,39 +4120,39 @@ ; sub ax, dx ; 2b c2 sar ax, 1 ; d1 f8 + mov cx, ax ; 89 c1 mov si, word [bp+010h] ; 8b 76 10 mov dx, word [bp+006h] ; 8b 56 06 mov di, si ; 89 f7 mov es, dx ; 8e c2 - mov cx, ax ; 89 c1 push DS ; 1e mov ds, dx ; 8e da rep movsw ; f3 a5 pop DS ; 1f - movzx dx, byte [bp-006h] ; 0f b6 56 fa - movzx ax, byte [bp-00eh] ; 0f b6 46 f2 - call 02c0fh ; e8 ea f9 + movzx dx, byte [bp-00ch] ; 0f b6 56 f4 + movzx ax, byte [bp-008h] ; 0f b6 46 f8 + call 02c0fh ; e8 e2 f9 mov byte [bp+017h], 000h ; c6 46 17 00 - and byte [bp+01ch], 0feh ; 80 66 1c fe - jmp near 03011h ; e9 e1 fd - cmp ch, 003h ; 80 fd 03 - jne near 03345h ; 0f 85 0e 01 + jmp near 036aeh ; e9 7a 04 + cmp byte [bp-006h], 003h ; 80 7e fa 03 + jne near 0334fh ; 0f 85 13 01 + mov ax, word [bp+006h] ; 8b 46 06 + shr ax, 00ch ; c1 e8 0c + mov cl, al ; 88 c1 mov dx, word [bp+006h] ; 8b 56 06 - shr dx, 00ch ; c1 ea 0c - mov ah, dl ; 88 d4 - mov cx, word [bp+006h] ; 8b 4e 06 - sal cx, 004h ; c1 e1 04 + sal dx, 004h ; c1 e2 04 mov bx, word [bp+010h] ; 8b 5e 10 - add bx, cx ; 01 cb - cmp bx, cx ; 39 cb - jnc short 03250h ; 73 02 - db 0feh, 0c4h - ; inc ah ; fe c4 - movzx cx, byte [bp-00ch] ; 0f b6 4e f4 - sal cx, 009h ; c1 e1 09 - dec cx ; 49 - mov dx, bx ; 89 da - add dx, cx ; 01 ca + add bx, dx ; 01 d3 + mov word [bp-012h], bx ; 89 5e ee cmp dx, bx ; 39 da - jc near 030f8h ; 0f 82 96 fe + jbe short 03258h ; 76 02 + db 0feh, 0c1h + ; inc cl ; fe c1 + movzx bx, ch ; 0f b6 dd + sal bx, 009h ; c1 e3 09 + dec bx ; 4b + mov ax, word [bp-012h] ; 8b 46 ee + add ax, bx ; 01 d8 + cmp ax, word [bp-012h] ; 3b 46 ee + jc near 03101h ; 0f 82 96 fe mov AL, strict byte 006h ; b0 06 mov dx, strict word 0000ah ; ba 0a 00 @@ -4160,23 +4161,23 @@ mov dx, strict word 0000ch ; ba 0c 00 out DX, AL ; ee + mov al, byte [bp-012h] ; 8a 46 ee + mov dx, strict word 00004h ; ba 04 00 + out DX, AL ; ee + mov ax, word [bp-012h] ; 8b 46 ee + shr ax, 008h ; c1 e8 08 + out DX, AL ; ee + xor al, al ; 30 c0 + mov dx, strict word 0000ch ; ba 0c 00 + out DX, AL ; ee mov al, bl ; 88 d8 - mov dx, strict word 00004h ; ba 04 00 - out DX, AL ; ee - shr bx, 008h ; c1 eb 08 - mov al, bl ; 88 d8 - out DX, AL ; ee - xor al, bl ; 30 d8 - mov dx, strict word 0000ch ; ba 0c 00 - out DX, AL ; ee - mov al, cl ; 88 c8 mov dx, strict word 00005h ; ba 05 00 out DX, AL ; ee - shr cx, 008h ; c1 e9 08 - mov al, cl ; 88 c8 + mov ax, bx ; 89 d8 + shr ax, 008h ; c1 e8 08 out DX, AL ; ee mov AL, strict byte 04ah ; b0 4a mov dx, strict word 0000bh ; ba 0b 00 out DX, AL ; ee - mov al, ah ; 88 e0 + mov al, cl ; 88 c8 mov dx, 00081h ; ba 81 00 out DX, AL ; ee @@ -4184,18 +4185,18 @@ mov dx, strict word 0000ah ; ba 0a 00 out DX, AL ; ee - movzx ax, byte [bp-00eh] ; 0f b6 46 f2 - call 02cceh ; e8 29 fa + movzx ax, byte [bp-008h] ; 0f b6 46 f8 + call 02cceh ; e8 1e fa mov AL, strict byte 0c5h ; b0 c5 mov dx, 003f5h ; ba f5 03 out DX, AL ; ee - movzx dx, byte [bp-008h] ; 0f b6 56 f8 + movzx dx, byte [bp-00eh] ; 0f b6 56 f2 sal dx, 002h ; c1 e2 02 - movzx ax, byte [bp-00eh] ; 0f b6 46 f2 + movzx ax, byte [bp-008h] ; 0f b6 46 f8 or ax, dx ; 09 d0 mov dx, 003f5h ; ba f5 03 out DX, AL ; ee - mov al, byte [bp-006h] ; 8a 46 fa - out DX, AL ; ee - mov al, byte [bp-008h] ; 8a 46 f8 + mov al, byte [bp-00ch] ; 8a 46 f4 + out DX, AL ; ee + mov al, byte [bp-00eh] ; 8a 46 f2 out DX, AL ; ee mov al, byte [bp-00ah] ; 8a 46 f6 @@ -4204,5 +4205,5 @@ out DX, AL ; ee movzx dx, byte [bp-00ah] ; 0f b6 56 f6 - movzx ax, byte [bp-00ch] ; 0f b6 46 f4 + movzx ax, ch ; 0f b6 c5 add ax, dx ; 01 d0 dec ax ; 48 @@ -4213,7 +4214,7 @@ mov AL, strict byte 0ffh ; b0 ff out DX, AL ; ee - call 02c5dh ; e8 7a f9 + call 02c5dh ; e8 70 f9 test al, al ; 84 c0 - je near 03196h ; 0f 84 ad fe + je near 0319fh ; 0f 84 ac fe mov dx, 003f4h ; ba f4 03 in AL, DX ; ec @@ -4222,61 +4223,59 @@ and AL, strict byte 0c0h ; 24 c0 cmp AL, strict byte 0c0h ; 3c c0 - je short 03303h ; 74 0e + je short 0330dh ; 74 0e push 00255h ; 68 55 02 push 00288h ; 68 88 02 push strict byte 00007h ; 6a 07 - call 01972h ; e8 72 e6 + call 01972h ; e8 68 e6 add sp, strict byte 00006h ; 83 c4 06 xor si, si ; 31 f6 - jmp short 0330ch ; eb 05 + jmp short 03316h ; eb 05 cmp si, strict byte 00007h ; 83 fe 07 - jnl short 03324h ; 7d 18 + jnl short 0332eh ; 7d 18 mov dx, 003f5h ; ba f5 03 in AL, DX ; ec db 02ah, 0e4h ; sub ah, ah ; 2a e4 - mov byte [bp+si-016h], al ; 88 42 ea + mov byte [bp+si-01ah], al ; 88 42 e6 movzx bx, al ; 0f b6 d8 lea dx, [si+042h] ; 8d 54 42 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 3d e3 + call 0165eh ; e8 33 e3 inc si ; 46 - jmp short 03307h ; eb e3 - test byte [bp-016h], 0c0h ; f6 46 ea c0 - je near 0321ah ; 0f 84 ee fe - test byte [bp-015h], 002h ; f6 46 eb 02 - je short 0333eh ; 74 0c + jmp short 03311h ; eb e3 + test byte [bp-01ah], 0c0h ; f6 46 e6 c0 + je near 03222h ; 0f 84 ec fe + test byte [bp-019h], 002h ; f6 46 e7 02 + je short 03348h ; 74 0c mov word [bp+016h], 00300h ; c7 46 16 00 03 or byte [bp+01ch], 001h ; 80 4e 1c 01 - jmp near 03011h ; e9 d3 fc + jmp near 03021h ; e9 d9 fc mov word [bp+016h], 00100h ; c7 46 16 00 01 - jmp short 03337h ; eb f2 - movzx dx, byte [bp-006h] ; 0f b6 56 fa - movzx ax, byte [bp-00eh] ; 0f b6 46 f2 - call 02c0fh ; e8 bf f8 + jmp short 03341h ; eb f2 + movzx dx, byte [bp-00ch] ; 0f b6 56 f4 + movzx ax, byte [bp-008h] ; 0f b6 46 f8 + call 02c0fh ; e8 b5 f8 and byte [bp+01ch], 0feh ; 80 66 1c fe mov byte [bp+017h], 000h ; c6 46 17 00 - jmp near 03011h ; e9 b6 fc - mov al, byte [bp+016h] ; 8a 46 16 + jmp near 03021h ; e9 bc fc + mov ch, byte [bp+016h] ; 8a 6e 16 + mov ax, word [bp+014h] ; 8b 46 14 + shr ax, 008h ; c1 e8 08 mov byte [bp-00ch], al ; 88 46 f4 - mov dx, word [bp+014h] ; 8b 56 14 + mov dx, word [bp+012h] ; 8b 56 12 shr dx, 008h ; c1 ea 08 - mov byte [bp-006h], dl ; 88 56 fa - mov ax, word [bp+012h] ; 8b 46 12 - shr ax, 008h ; c1 e8 08 - mov byte [bp-008h], al ; 88 46 f8 + mov byte [bp-00eh], dl ; 88 56 f2 mov bl, byte [bp+00eh] ; 8a 5e 0e - mov byte [bp-00eh], bl ; 88 5e f2 + mov byte [bp-008h], bl ; 88 5e f8 cmp bl, 001h ; 80 fb 01 - jnbe short 03392h ; 77 14 - cmp AL, strict byte 001h ; 3c 01 - jnbe short 03392h ; 77 10 - cmp dl, 04fh ; 80 fa 4f - jnbe short 03392h ; 77 0b - mov al, byte [bp-00ch] ; 8a 46 f4 - test al, al ; 84 c0 - je short 03392h ; 74 04 - cmp AL, strict byte 012h ; 3c 12 - jbe short 033a7h ; 76 15 + jnbe short 03397h ; 77 12 + cmp dl, 001h ; 80 fa 01 + jnbe short 03397h ; 77 0d + cmp AL, strict byte 04fh ; 3c 4f + jnbe short 03397h ; 77 09 + test ch, ch ; 84 ed + je short 03397h ; 74 05 + cmp ch, 012h ; 80 fd 12 + jbe short 033ach ; 76 15 mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -4284,37 +4283,38 @@ mov word [bp+016h], ax ; 89 46 16 mov ax, strict word 00001h ; b8 01 00 - call 02bf7h ; e8 54 f8 + call 02bf7h ; e8 4f f8 or byte [bp+01ch], 001h ; 80 4e 1c 01 - movzx ax, byte [bp-00eh] ; 0f b6 46 f2 - call 02f0ah ; e8 5c fb + movzx ax, byte [bp-008h] ; 0f b6 46 f8 + call 02f0ah ; e8 57 fb test ax, ax ; 85 c0 - je near 02fdfh ; 0f 84 2b fc - movzx dx, byte [bp-00eh] ; 0f b6 56 f2 + je near 02fefh ; 0f 84 36 fc + movzx dx, byte [bp-008h] ; 0f b6 56 f8 mov ax, dx ; 89 d0 - call 02d4fh ; e8 92 f9 + call 02d4fh ; e8 8d f9 test ax, ax ; 85 c0 - jne short 033cch ; 75 0b + jne short 033d1h ; 75 0b mov ax, dx ; 89 d0 - call 02e1ah ; e8 54 fa + call 02e1ah ; e8 4f fa test ax, ax ; 85 c0 - je near 030b8h ; 0f 84 ec fc - mov cx, word [bp+006h] ; 8b 4e 06 - shr cx, 00ch ; c1 e9 0c - mov ah, cl ; 88 cc + je near 030bch ; 0f 84 eb fc + mov ax, word [bp+006h] ; 8b 46 06 + shr ax, 00ch ; c1 e8 0c + mov cl, al ; 88 c1 mov dx, word [bp+006h] ; 8b 56 06 sal dx, 004h ; c1 e2 04 mov bx, word [bp+010h] ; 8b 5e 10 add bx, dx ; 01 d3 - cmp bx, dx ; 39 d3 - jnc short 033e5h ; 73 02 - db 0feh, 0c4h - ; inc ah ; fe c4 - movzx cx, byte [bp-00ch] ; 0f b6 4e f4 - sal cx, 002h ; c1 e1 02 - dec cx ; 49 - mov dx, bx ; 89 da - add dx, cx ; 01 ca + mov word [bp-012h], bx ; 89 5e ee cmp dx, bx ; 39 da - jc near 030f8h ; 0f 82 01 fd + jbe short 033edh ; 76 02 + db 0feh, 0c1h + ; inc cl ; fe c1 + movzx bx, ch ; 0f b6 dd + sal bx, 002h ; c1 e3 02 + dec bx ; 4b + mov ax, word [bp-012h] ; 8b 46 ee + add ax, bx ; 01 d8 + cmp ax, word [bp-012h] ; 3b 46 ee + jc near 03101h ; 0f 82 01 fd mov AL, strict byte 006h ; b0 06 mov dx, strict word 0000ah ; ba 0a 00 @@ -4323,23 +4323,23 @@ mov dx, strict word 0000ch ; ba 0c 00 out DX, AL ; ee + mov al, byte [bp-012h] ; 8a 46 ee + mov dx, strict word 00004h ; ba 04 00 + out DX, AL ; ee + mov ax, word [bp-012h] ; 8b 46 ee + shr ax, 008h ; c1 e8 08 + out DX, AL ; ee + xor al, al ; 30 c0 + mov dx, strict word 0000ch ; ba 0c 00 + out DX, AL ; ee mov al, bl ; 88 d8 - mov dx, strict word 00004h ; ba 04 00 - out DX, AL ; ee - shr bx, 008h ; c1 eb 08 - mov al, bl ; 88 d8 - out DX, AL ; ee - xor al, bl ; 30 d8 - mov dx, strict word 0000ch ; ba 0c 00 - out DX, AL ; ee - mov al, cl ; 88 c8 mov dx, strict word 00005h ; ba 05 00 out DX, AL ; ee - shr cx, 008h ; c1 e9 08 - mov al, cl ; 88 c8 + mov ax, bx ; 89 d8 + shr ax, 008h ; c1 e8 08 out DX, AL ; ee mov AL, strict byte 04ah ; b0 4a mov dx, strict word 0000bh ; ba 0b 00 out DX, AL ; ee - mov al, ah ; 88 e0 + mov al, cl ; 88 c8 mov dx, 00081h ; ba 81 00 out DX, AL ; ee @@ -4347,16 +4347,16 @@ mov dx, strict word 0000ah ; ba 0a 00 out DX, AL ; ee - movzx ax, byte [bp-00eh] ; 0f b6 46 f2 - call 02cceh ; e8 94 f8 + movzx ax, byte [bp-008h] ; 0f b6 46 f8 + call 02cceh ; e8 89 f8 mov AL, strict byte 00fh ; b0 0f mov dx, 003f5h ; ba f5 03 out DX, AL ; ee + movzx bx, byte [bp-00eh] ; 0f b6 5e f2 + sal bx, 002h ; c1 e3 02 movzx ax, byte [bp-008h] ; 0f b6 46 f8 - sal ax, 002h ; c1 e0 02 - movzx bx, byte [bp-00eh] ; 0f b6 5e f2 or bx, ax ; 09 c3 mov al, bl ; 88 d8 out DX, AL ; ee - mov al, byte [bp-006h] ; 8a 46 fa + mov al, byte [bp-00ch] ; 8a 46 f4 out DX, AL ; ee mov AL, strict byte 04dh ; b0 4d @@ -4366,15 +4366,15 @@ mov AL, strict byte 002h ; b0 02 out DX, AL ; ee - mov al, byte [bp-00ch] ; 8a 46 f4 - out DX, AL ; ee - xor al, al ; 30 c0 + mov al, ch ; 88 e8 + out DX, AL ; ee + xor al, ch ; 30 e8 out DX, AL ; ee mov AL, strict byte 0f6h ; b0 f6 out DX, AL ; ee - call 02c5dh ; e8 f3 f7 + call 02c5dh ; e8 e9 f7 test al, al ; 84 c0 - jne short 03474h ; 75 06 - call 02ca3h ; e8 32 f8 - jmp near 02fdfh ; e9 6b fb + jne short 0347eh ; 75 06 + call 02ca3h ; e8 28 f8 + jmp near 02fefh ; e9 71 fb mov dx, 003f4h ; ba f4 03 in AL, DX ; ec @@ -4383,45 +4383,45 @@ and AL, strict byte 0c0h ; 24 c0 cmp AL, strict byte 0c0h ; 3c c0 - je short 0348eh ; 74 0e + je short 03498h ; 74 0e push 00255h ; 68 55 02 push 00288h ; 68 88 02 push strict byte 00007h ; 6a 07 - call 01972h ; e8 e7 e4 + call 01972h ; e8 dd e4 add sp, strict byte 00006h ; 83 c4 06 xor si, si ; 31 f6 - jmp short 03497h ; eb 05 + jmp short 034a1h ; eb 05 cmp si, strict byte 00007h ; 83 fe 07 - jnl short 034afh ; 7d 18 + jnl short 034b9h ; 7d 18 mov dx, 003f5h ; ba f5 03 in AL, DX ; ec db 02ah, 0e4h ; sub ah, ah ; 2a e4 - mov byte [bp+si-016h], al ; 88 42 ea + mov byte [bp+si-01ah], al ; 88 42 e6 movzx bx, al ; 0f b6 d8 lea dx, [si+042h] ; 8d 54 42 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 b2 e1 + call 0165eh ; e8 a8 e1 inc si ; 46 - jmp short 03492h ; eb e3 - test byte [bp-016h], 0c0h ; f6 46 ea c0 - je short 034cbh ; 74 16 - test byte [bp-015h], 002h ; f6 46 eb 02 - jne near 03332h ; 0f 85 75 fe + jmp short 0349ch ; eb e3 + test byte [bp-01ah], 0c0h ; f6 46 e6 c0 + je short 034d5h ; 74 16 + test byte [bp-019h], 002h ; f6 46 e7 02 + jne near 0333ch ; 0f 85 75 fe push 00255h ; 68 55 02 push 0029ch ; 68 9c 02 push strict byte 00007h ; 6a 07 - call 01972h ; e8 aa e4 + call 01972h ; e8 a0 e4 add sp, strict byte 00006h ; 83 c4 06 xor al, al ; 30 c0 mov byte [bp+017h], al ; 88 46 17 xor ah, ah ; 30 e4 - call 02bf7h ; e8 22 f7 - movzx ax, byte [bp-00eh] ; 0f b6 46 f2 + call 02bf7h ; e8 18 f7 + movzx ax, byte [bp-008h] ; 0f b6 46 f8 xor dx, dx ; 31 d2 - call 02c0fh ; e8 31 f7 - jmp near 03229h ; e9 48 fd - mov byte [bp-00eh], ah ; 88 66 f2 - cmp ah, 001h ; 80 fc 01 - jbe short 03509h ; 76 20 + call 02c0fh ; e8 27 f7 + jmp near 036aeh ; e9 c3 01 + mov byte [bp-008h], al ; 88 46 f8 + cmp AL, strict byte 001h ; 3c 01 + jbe short 0350fh ; 76 1d xor ax, ax ; 31 c0 mov word [bp+016h], ax ; 89 46 16 @@ -4431,113 +4431,112 @@ mov word [bp+006h], ax ; 89 46 06 mov word [bp+008h], ax ; 89 46 08 + movzx ax, ch ; 0f b6 c5 + mov word [bp+012h], ax ; 89 46 12 + jmp near 0362ch ; e9 1d 01 + mov ax, strict word 00010h ; b8 10 00 + call 016ach ; e8 97 e1 + mov cl, al ; 88 c1 + xor ch, ch ; 30 ed + test AL, strict byte 0f0h ; a8 f0 + je short 0351fh ; 74 02 + mov CH, strict byte 001h ; b5 01 + test cl, 00fh ; f6 c1 0f + je short 03526h ; 74 02 + db 0feh, 0c5h + ; inc ch ; fe c5 + cmp byte [bp-008h], 000h ; 80 7e f8 00 + jne short 03531h ; 75 05 + shr cl, 004h ; c0 e9 04 + jmp short 03534h ; eb 03 + and cl, 00fh ; 80 e1 0f + mov byte [bp+011h], 000h ; c6 46 11 00 movzx ax, cl ; 0f b6 c1 - mov word [bp+012h], ax ; 89 46 12 - mov word [bp+01ch], dx ; 89 56 1c - jmp near 03011h ; e9 08 fb - mov ax, strict word 00010h ; b8 10 00 - call 016ach ; e8 9d e1 - mov dl, al ; 88 c2 - xor cl, cl ; 30 c9 - test AL, strict byte 0f0h ; a8 f0 - je short 03519h ; 74 02 - mov CL, strict byte 001h ; b1 01 - test dl, 00fh ; f6 c2 0f - je short 03520h ; 74 02 - db 0feh, 0c1h - ; inc cl ; fe c1 - cmp byte [bp-00eh], 000h ; 80 7e f2 00 - jne short 0352bh ; 75 05 - shr dl, 004h ; c0 ea 04 - jmp short 0352eh ; eb 03 - and dl, 00fh ; 80 e2 0f - mov byte [bp+011h], 000h ; c6 46 11 00 - movzx ax, dl ; 0f b6 c2 mov word [bp+010h], ax ; 89 46 10 mov word [bp+016h], strict word 00000h ; c7 46 16 00 00 - mov bx, word [bp+012h] ; 8b 5e 12 - xor bl, bl ; 30 db - movzx ax, cl ; 0f b6 c1 - or bx, ax ; 09 c3 - mov word [bp+012h], bx ; 89 5e 12 - mov ax, bx ; 89 d8 - xor ah, bh ; 30 fc + mov ax, word [bp+012h] ; 8b 46 12 + xor al, al ; 30 c0 + movzx dx, ch ; 0f b6 d5 + or ax, dx ; 09 d0 + mov word [bp+012h], ax ; 89 46 12 + xor ah, ah ; 30 e4 or ah, 001h ; 80 cc 01 mov word [bp+012h], ax ; 89 46 12 - cmp dl, 003h ; 80 fa 03 - jc short 0356eh ; 72 15 - jbe short 03595h ; 76 3a - cmp dl, 005h ; 80 fa 05 - jc short 0359ch ; 72 3c - jbe short 035a3h ; 76 41 - cmp dl, 00fh ; 80 fa 0f - je short 035b1h ; 74 4a - cmp dl, 00eh ; 80 fa 0e - je short 035aah ; 74 3e - jmp short 035b8h ; eb 4a - cmp dl, 002h ; 80 fa 02 - je short 0358eh ; 74 1b - cmp dl, 001h ; 80 fa 01 - je short 03587h ; 74 0f - test dl, dl ; 84 d2 - jne short 035b8h ; 75 3c + cmp cl, 003h ; 80 f9 03 + jc short 03572h ; 72 15 + jbe short 03599h ; 76 3a + cmp cl, 005h ; 80 f9 05 + jc short 035a0h ; 72 3c + jbe short 035a7h ; 76 41 + cmp cl, 00fh ; 80 f9 0f + je short 035b5h ; 74 4a + cmp cl, 00eh ; 80 f9 0e + je short 035aeh ; 74 3e + jmp short 035bch ; eb 4a + cmp cl, 002h ; 80 f9 02 + je short 03592h ; 74 1b + cmp cl, 001h ; 80 f9 01 + je short 0358bh ; 74 0f + test cl, cl ; 84 c9 + jne short 035bch ; 75 3c mov word [bp+014h], strict word 00000h ; c7 46 14 00 00 mov byte [bp+013h], 000h ; c6 46 13 00 - jmp short 035c6h ; eb 3f + jmp short 035cah ; eb 3f mov word [bp+014h], 02709h ; c7 46 14 09 27 - jmp short 035c6h ; eb 38 + jmp short 035cah ; eb 38 mov word [bp+014h], 04f0fh ; c7 46 14 0f 4f - jmp short 035c6h ; eb 31 + jmp short 035cah ; eb 31 mov word [bp+014h], 04f09h ; c7 46 14 09 4f - jmp short 035c6h ; eb 2a + jmp short 035cah ; eb 2a mov word [bp+014h], 04f12h ; c7 46 14 12 4f - jmp short 035c6h ; eb 23 + jmp short 035cah ; eb 23 mov word [bp+014h], 04f24h ; c7 46 14 24 4f - jmp short 035c6h ; eb 1c + jmp short 035cah ; eb 1c mov word [bp+014h], 0fe3fh ; c7 46 14 3f fe - jmp short 035c6h ; eb 15 + jmp short 035cah ; eb 15 mov word [bp+014h], 0feffh ; c7 46 14 ff fe - jmp short 035c6h ; eb 0e + jmp short 035cah ; eb 0e push 00255h ; 68 55 02 push 002adh ; 68 ad 02 push strict byte 00007h ; 6a 07 - call 01972h ; e8 af e3 + call 01972h ; e8 ab e3 add sp, strict byte 00006h ; 83 c4 06 mov word [bp+006h], 0f000h ; c7 46 06 00 f0 - movzx ax, dl ; 0f b6 c2 - call 03662h ; e8 91 00 + movzx ax, cl ; 0f b6 c1 + call 03825h ; e8 50 02 mov word [bp+008h], ax ; 89 46 08 - jmp near 03229h ; e9 52 fc - mov byte [bp-00eh], ah ; 88 66 f2 - cmp ah, 001h ; 80 fc 01 - jbe short 035e5h ; 76 06 + jmp near 036aeh ; e9 d3 00 + mov byte [bp-008h], al ; 88 46 f8 + cmp AL, strict byte 001h ; 3c 01 + jbe short 035e7h ; 76 05 mov word [bp+016h], si ; 89 76 16 - jmp near 03503h ; e9 1e ff + jmp short 0362ch ; eb 45 mov ax, strict word 00010h ; b8 10 00 - call 016ach ; e8 c1 e0 - cmp byte [bp-00eh], 000h ; 80 7e f2 00 - jne short 035f8h ; 75 07 - mov dl, al ; 88 c2 - shr dl, 004h ; c0 ea 04 - jmp short 035fdh ; eb 05 - mov dl, al ; 88 c2 - and dl, 00fh ; 80 e2 0f + call 016ach ; e8 bf e0 + cmp byte [bp-008h], 000h ; 80 7e f8 00 + jne short 035fah ; 75 07 + mov cl, al ; 88 c1 + shr cl, 004h ; c0 e9 04 + jmp short 035ffh ; eb 05 + mov cl, al ; 88 c1 + and cl, 00fh ; 80 e1 0f and byte [bp+01ch], 0feh ; 80 66 1c fe - mov bx, word [bp+016h] ; 8b 5e 16 - xor bh, bh ; 30 ff - test dl, dl ; 84 d2 - je short 03617h ; 74 0d - cmp dl, 001h ; 80 fa 01 - jbe short 03614h ; 76 05 - or bh, 002h ; 80 cf 02 - jmp short 03617h ; eb 03 - or bh, 001h ; 80 cf 01 - mov word [bp+016h], bx ; 89 5e 16 - jmp near 03011h ; e9 f4 f9 - cmp ah, 001h ; 80 fc 01 - jbe short 0362eh ; 76 0c + mov dx, word [bp+016h] ; 8b 56 16 + xor dh, dh ; 30 f6 + test cl, cl ; 84 c9 + je short 03619h ; 74 0d + cmp cl, 001h ; 80 f9 01 + jbe short 03616h ; 76 05 + or dh, 002h ; 80 ce 02 + jmp short 03619h ; eb 03 + or dh, 001h ; 80 ce 01 + mov word [bp+016h], dx ; 89 56 16 + jmp near 03021h ; e9 02 fa + cmp AL, strict byte 001h ; 3c 01 + jbe short 03632h ; 76 0f mov word [bp+016h], si ; 89 76 16 mov ax, strict word 00001h ; b8 01 00 - call 02bf7h ; e8 cc f5 - jmp near 03503h ; e9 d5 fe + call 02bf7h ; e8 cb f5 + mov word [bp+01ch], dx ; 89 56 1c + jmp near 03021h ; e9 ef f9 mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -4545,9 +4544,173 @@ mov word [bp+016h], ax ; 89 46 16 mov ax, strict word 00006h ; b8 06 00 - jmp near 02fbdh ; e9 7e f9 - mov bx, 00da2h ; bb a2 0d + jmp near 02fcdh ; e9 8a f9 + mov byte [bp-008h], al ; 88 46 f8 + mov bl, cl ; 88 cb + cmp AL, strict byte 001h ; 3c 01 + jnbe short 03623h ; 77 d7 + movzx ax, byte [bp-008h] ; 0f b6 46 f8 + call 02f0ah ; e8 b7 f8 + test ax, ax ; 85 c0 + je near 02fefh ; 0f 84 96 f9 + cmp byte [bp-008h], 000h ; 80 7e f8 00 + db 00fh, 095h, 0c0h + ; setne al ; 0f 95 c0 + movzx dx, al ; 0f b6 d0 + add dx, 00090h ; 81 c2 90 00 + mov word [bp-012h], dx ; 89 56 ee + mov ax, strict word 00040h ; b8 40 00 + call 01650h ; e8 e0 df + and AL, strict byte 00fh ; 24 0f + cmp bl, 002h ; 80 fb 02 + jc short 03686h ; 72 0f + jbe short 03692h ; 76 19 + cmp bl, 004h ; 80 fb 04 + je short 0368eh ; 74 10 + cmp bl, 003h ; 80 fb 03 + je short 03696h ; 74 13 + jmp near 02fbfh ; e9 39 f9 + cmp bl, 001h ; 80 fb 01 + je short 0368eh ; 74 03 + jmp near 02fbfh ; e9 31 f9 + or AL, strict byte 090h ; 0c 90 + jmp short 03698h ; eb 06 + or AL, strict byte 070h ; 0c 70 + jmp short 03698h ; eb 02 + or AL, strict byte 010h ; 0c 10 + movzx bx, al ; 0f b6 d8 + mov dx, word [bp-012h] ; 8b 56 ee + mov ax, strict word 00040h ; b8 40 00 + call 0165eh ; e8 ba df + xor al, al ; 30 c0 + mov byte [bp+017h], al ; 88 46 17 + xor ah, ah ; 30 e4 + call 02bf7h ; e8 49 f5 + and byte [bp+01ch], 0feh ; 80 66 1c fe + jmp near 03021h ; e9 6c f9 + mov byte [bp-008h], al ; 88 46 f8 + mov ch, ah ; 88 e5 + and ch, 03fh ; 80 e5 3f + movzx bx, ah ; 0f b6 dc + sar bx, 006h ; c1 fb 06 + sal bx, 008h ; c1 e3 08 + add bx, word [bp-010h] ; 03 5e f0 + mov byte [bp-00ch], bl ; 88 5e f4 + cmp AL, strict byte 001h ; 3c 01 + jnbe near 03623h ; 0f 87 51 ff + movzx ax, byte [bp-008h] ; 0f b6 46 f8 + call 02f0ah ; e8 31 f8 + test ax, ax ; 85 c0 + je near 02fefh ; 0f 84 10 f9 + movzx dx, byte [bp-008h] ; 0f b6 56 f8 + mov ax, dx ; 89 d0 + call 02d4fh ; e8 67 f6 + test ax, ax ; 85 c0 + jne short 03706h ; 75 1a + mov ax, dx ; 89 d0 + call 02e1ah ; e8 29 f7 + test ax, ax ; 85 c0 + jne short 03706h ; 75 11 + mov ax, word [bp+016h] ; 8b 46 16 + xor ah, ah ; 30 e4 + or ah, 00ch ; 80 cc 0c + mov word [bp+016h], ax ; 89 46 16 + mov ax, strict word 0000ch ; b8 0c 00 + jmp near 02fcdh ; e9 c7 f8 + mov ax, strict word 00010h ; b8 10 00 + call 016ach ; e8 a0 df + cmp byte [bp-008h], 000h ; 80 7e f8 00 + jne short 03719h ; 75 07 + mov cl, al ; 88 c1 + shr cl, 004h ; c0 e9 04 + jmp short 0371eh ; eb 05 + mov cl, al ; 88 c1 + and cl, 00fh ; 80 e1 0f + cmp byte [bp-008h], 000h ; 80 7e f8 00 + db 00fh, 095h, 0c0h + ; setne al ; 0f 95 c0 + movzx dx, al ; 0f b6 d0 + add dx, 00090h ; 81 c2 90 00 + mov word [bp-012h], dx ; 89 56 ee + mov ax, strict word 00040h ; b8 40 00 + call 01650h ; e8 1b df + and AL, strict byte 00fh ; 24 0f + cmp cl, 003h ; 80 f9 03 + jc short 0375ah ; 72 1e + mov dl, al ; 88 c2 + or dl, 090h ; 80 ca 90 + cmp cl, 003h ; 80 f9 03 + jbe short 03798h ; 76 52 + mov ah, al ; 88 c4 + or ah, 010h ; 80 cc 10 + cmp cl, 005h ; 80 f9 05 + je near 037bdh ; 0f 84 6b 00 + cmp cl, 004h ; 80 f9 04 + je short 037a7h ; 74 50 + jmp near 037d8h ; e9 7e 00 + cmp cl, 002h ; 80 f9 02 + je short 0377ah ; 74 1b + cmp cl, 001h ; 80 f9 01 + jne near 037d8h ; 0f 85 72 00 + cmp byte [bp-00ch], 027h ; 80 7e f4 27 + jne near 037d8h ; 0f 85 6a 00 + cmp ch, 009h ; 80 fd 09 + jne near 037d8h ; 0f 85 63 00 + or AL, strict byte 090h ; 0c 90 + jmp near 037d8h ; e9 5e 00 + cmp byte [bp-00ch], 027h ; 80 7e f4 27 + jne short 03789h ; 75 09 + cmp ch, 009h ; 80 fd 09 + jne short 03789h ; 75 04 + or AL, strict byte 070h ; 0c 70 + jmp short 037d8h ; eb 4f + cmp byte [bp-00ch], 04fh ; 80 7e f4 4f + jne short 037d8h ; 75 49 + cmp ch, 00fh ; 80 fd 0f + jne short 037d8h ; 75 44 + or AL, strict byte 010h ; 0c 10 + jmp short 037d8h ; eb 40 + cmp byte [bp-00ch], 04fh ; 80 7e f4 4f + jne short 037d8h ; 75 3a + cmp ch, 009h ; 80 fd 09 + jne short 037d8h ; 75 35 + mov al, dl ; 88 d0 + jmp short 037d8h ; eb 31 + cmp byte [bp-00ch], 04fh ; 80 7e f4 4f + jne short 037d8h ; 75 2b + cmp ch, 009h ; 80 fd 09 + jne short 037b4h ; 75 02 + jmp short 037a3h ; eb ef + cmp ch, 012h ; 80 fd 12 + jne short 037d8h ; 75 1f + mov al, ah ; 88 e0 + jmp short 037d8h ; eb 1b + cmp byte [bp-00ch], 04fh ; 80 7e f4 4f + jne short 037d8h ; 75 15 + cmp ch, 009h ; 80 fd 09 + jne short 037cah ; 75 02 + jmp short 037a3h ; eb d9 + cmp ch, 012h ; 80 fd 12 + jne short 037d1h ; 75 02 + jmp short 037b9h ; eb e8 + cmp ch, 024h ; 80 fd 24 + jne short 037d8h ; 75 02 + or AL, strict byte 0d0h ; 0c d0 + movzx dx, al ; 0f b6 d0 + sar dx, 004h ; c1 fa 04 + test dl, 001h ; f6 c2 01 + je near 036f5h ; 0f 84 10 ff + movzx bx, al ; 0f b6 d8 + mov dx, word [bp-012h] ; 8b 56 ee + mov ax, strict word 00040h ; b8 40 00 + call 0165eh ; e8 6d de + mov word [bp+006h], 0f000h ; c7 46 06 00 f0 + movzx ax, cl ; 0f b6 c1 + call 03825h ; e8 29 00 + mov word [bp+008h], ax ; 89 46 08 + jmp near 036a4h ; e9 a2 fe + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 e7 e2 + call 01931h ; e8 24 e1 mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 @@ -4556,8 +4719,8 @@ push 002c2h ; 68 c2 02 push strict byte 00004h ; 6a 04 - call 01972h ; e8 16 e3 + call 01972h ; e8 53 e1 add sp, strict byte 00008h ; 83 c4 08 - jmp near 02fafh ; e9 4d f9 -get_floppy_dpt_: ; 0xf3662 LB 0x2f + jmp near 02fbfh ; e9 9a f7 +get_floppy_dpt_: ; 0xf3825 LB 0x2f push bx ; 53 push dx ; 52 @@ -4566,16 +4729,16 @@ mov dl, al ; 88 c2 xor ax, ax ; 31 c0 - jmp short 03673h ; eb 06 + jmp short 03836h ; eb 06 inc ax ; 40 cmp ax, strict word 00007h ; 3d 07 00 - jnc short 0368ah ; 73 17 + jnc short 0384dh ; 73 17 mov bx, ax ; 89 c3 add bx, ax ; 01 c3 cmp dl, byte [word bx+0005bh] ; 3a 97 5b 00 - jne short 0366dh ; 75 f0 + jne short 03830h ; 75 f0 movzx ax, byte [word bx+0005ch] ; 0f b6 87 5c 00 imul ax, ax, strict byte 0000dh ; 6b c0 0d add ax, strict word 00000h ; 05 00 00 - jmp short 0368dh ; eb 03 + jmp short 03850h ; eb 03 mov ax, strict word 00041h ; b8 41 00 pop bp ; 5d @@ -4583,5 +4746,5 @@ pop bx ; 5b retn ; c3 -dummy_soft_reset_: ; 0xf3691 LB 0x7 +dummy_soft_reset_: ; 0xf3854 LB 0x7 push bp ; 55 mov bp, sp ; 89 e5 @@ -4589,39 +4752,39 @@ pop bp ; 5d retn ; c3 -_cdemu_init: ; 0xf3698 LB 0x18 +_cdemu_init: ; 0xf385b LB 0x18 push bp ; 55 mov bp, sp ; 89 e5 mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 c8 df + call 0166ch ; e8 05 de xor bx, bx ; 31 db mov dx, 00322h ; ba 22 03 - call 0165eh ; e8 b2 df + call 0165eh ; e8 ef dd mov sp, bp ; 89 ec pop bp ; 5d retn ; c3 -_cdemu_isactive: ; 0xf36b0 LB 0x16 +_cdemu_isactive: ; 0xf3873 LB 0x16 push bp ; 55 mov bp, sp ; 89 e5 mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 b0 df + call 0166ch ; e8 ed dd mov dx, 00322h ; ba 22 03 - call 01650h ; e8 8e df + call 01650h ; e8 cb dd mov sp, bp ; 89 ec pop bp ; 5d retn ; c3 -_cdemu_emulated_drive: ; 0xf36c6 LB 0x16 +_cdemu_emulated_drive: ; 0xf3889 LB 0x16 push bp ; 55 mov bp, sp ; 89 e5 mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 9a df + call 0166ch ; e8 d7 dd mov dx, 00324h ; ba 24 03 - call 01650h ; e8 78 df + call 01650h ; e8 b5 dd mov sp, bp ; 89 ec pop bp ; 5d retn ; c3 -_int13_eltorito: ; 0xf36dc LB 0x189 +_int13_eltorito: ; 0xf389f LB 0x189 push bp ; 55 mov bp, sp ; 89 e5 @@ -4630,5 +4793,5 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 82 df + call 0166ch ; e8 bf dd mov si, 00322h ; be 22 03 mov di, ax ; 89 c7 @@ -4636,26 +4799,26 @@ shr ax, 008h ; c1 e8 08 cmp ax, strict word 0004bh ; 3d 4b 00 - jc short 03704h ; 72 0a - jbe short 0372ah ; 76 2e + jc short 038c7h ; 72 0a + jbe short 038edh ; 76 2e cmp ax, strict word 0004dh ; 3d 4d 00 - jbe short 0370bh ; 76 0a - jmp near 03829h ; e9 25 01 + jbe short 038ceh ; 76 0a + jmp near 039ech ; e9 25 01 cmp ax, strict word 0004ah ; 3d 4a 00 - jne near 03829h ; 0f 85 1e 01 - mov bx, 00da2h ; bb a2 0d + jne near 039ech ; 0f 85 1e 01 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 1b e2 + call 01931h ; e8 58 e0 push word [bp+016h] ; ff 76 16 push 002dch ; 68 dc 02 push 002ebh ; 68 eb 02 push strict byte 00004h ; 6a 04 - call 01972h ; e8 4e e2 + call 01972h ; e8 8b e0 add sp, strict byte 00008h ; 83 c4 08 - jmp near 03844h ; e9 1a 01 + jmp near 03a07h ; e9 1a 01 mov dx, word [bp+00ah] ; 8b 56 0a mov ax, word [bp+004h] ; 8b 46 04 mov bx, strict word 00013h ; bb 13 00 - call 0165eh ; e8 28 df + call 0165eh ; e8 65 dd mov es, di ; 8e c7 movzx bx, byte [es:si+001h] ; 26 0f b6 5c 01 @@ -4663,5 +4826,5 @@ inc dx ; 42 mov ax, word [bp+004h] ; 8b 46 04 - call 0165eh ; e8 17 df + call 0165eh ; e8 54 dd mov es, di ; 8e c7 movzx bx, byte [es:si+002h] ; 26 0f b6 5c 02 @@ -4670,5 +4833,5 @@ inc dx ; 42 mov ax, word [bp+004h] ; 8b 46 04 - call 0165eh ; e8 05 df + call 0165eh ; e8 42 dd mov es, di ; 8e c7 movzx bx, byte [es:si+003h] ; 26 0f b6 5c 03 @@ -4676,5 +4839,5 @@ add dx, strict byte 00003h ; 83 c2 03 mov ax, word [bp+004h] ; 8b 46 04 - call 0165eh ; e8 f2 de + call 0165eh ; e8 2f dd mov es, di ; 8e c7 mov bx, word [es:si+008h] ; 26 8b 5c 08 @@ -4683,5 +4846,5 @@ add dx, strict byte 00004h ; 83 c2 04 mov ax, word [bp+004h] ; 8b 46 04 - call 0169ah ; e8 18 df + call 0169ah ; e8 55 dd mov es, di ; 8e c7 mov bx, word [es:si+004h] ; 26 8b 5c 04 @@ -4689,5 +4852,5 @@ add dx, strict byte 00008h ; 83 c2 08 mov ax, word [bp+004h] ; 8b 46 04 - call 0167ah ; e8 e6 de + call 0167ah ; e8 23 dd mov es, di ; 8e c7 mov bx, word [es:si+006h] ; 26 8b 5c 06 @@ -4695,5 +4858,5 @@ add dx, strict byte 0000ah ; 83 c2 0a mov ax, word [bp+004h] ; 8b 46 04 - call 0167ah ; e8 d4 de + call 0167ah ; e8 11 dd mov es, di ; 8e c7 mov bx, word [es:si+00ch] ; 26 8b 5c 0c @@ -4701,5 +4864,5 @@ add dx, strict byte 0000ch ; 83 c2 0c mov ax, word [bp+004h] ; 8b 46 04 - call 0167ah ; e8 c2 de + call 0167ah ; e8 ff dc mov es, di ; 8e c7 mov bx, word [es:si+00eh] ; 26 8b 5c 0e @@ -4707,5 +4870,5 @@ add dx, strict byte 0000eh ; 83 c2 0e mov ax, word [bp+004h] ; 8b 46 04 - call 0167ah ; e8 b0 de + call 0167ah ; e8 ed dc mov es, di ; 8e c7 movzx bx, byte [es:si+012h] ; 26 0f b6 5c 12 @@ -4713,5 +4876,5 @@ add dx, strict byte 00010h ; 83 c2 10 mov ax, word [bp+004h] ; 8b 46 04 - call 0165eh ; e8 81 de + call 0165eh ; e8 be dc mov es, di ; 8e c7 movzx bx, byte [es:si+014h] ; 26 0f b6 5c 14 @@ -4719,5 +4882,5 @@ add dx, strict byte 00011h ; 83 c2 11 mov ax, word [bp+004h] ; 8b 46 04 - call 0165eh ; e8 6e de + call 0165eh ; e8 ab dc mov es, di ; 8e c7 movzx bx, byte [es:si+010h] ; 26 0f b6 5c 10 @@ -4725,7 +4888,7 @@ add dx, strict byte 00012h ; 83 c2 12 mov ax, word [bp+004h] ; 8b 46 04 - call 0165eh ; e8 5b de + call 0165eh ; e8 98 dc test byte [bp+016h], 0ffh ; f6 46 16 ff - jne short 0380fh ; 75 06 + jne short 039d2h ; 75 06 mov es, di ; 8e c7 mov byte [es:si], 000h ; 26 c6 04 00 @@ -4734,5 +4897,5 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 40 de + call 0165eh ; e8 7d dc and byte [bp+01ch], 0feh ; 80 66 1c fe lea sp, [bp-004h] ; 8d 66 fc @@ -4741,8 +4904,8 @@ pop bp ; 5d retn ; c3 - mov bx, 00da2h ; bb a2 0d + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 fd e0 + call 01931h ; e8 3a df mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 @@ -4750,5 +4913,5 @@ push 002dch ; 68 dc 02 push 00313h ; 68 13 03 - jmp near 0371fh ; e9 db fe + jmp near 038e2h ; e9 db fe mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -4760,8 +4923,8 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 ff dd + call 0165eh ; e8 3c dc or byte [bp+01ch], 001h ; 80 4e 1c 01 - jmp short 03822h ; eb bd -device_is_cdrom_: ; 0xf3865 LB 0x35 + jmp short 039e5h ; eb bd +device_is_cdrom_: ; 0xf3a28 LB 0x35 push bp ; 55 mov bp, sp ; 89 e5 @@ -4771,9 +4934,9 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 f7 dd + call 0166ch ; e8 34 dc cmp bl, 010h ; 80 fb 10 - jc short 0387eh ; 72 04 + jc short 03a41h ; 72 04 xor ax, ax ; 31 c0 - jmp short 03893h ; eb 15 + jmp short 03a56h ; eb 15 xor bh, bh ; 30 ff imul bx, bx, strict byte 00018h ; 6b db 18 @@ -4781,5 +4944,5 @@ add bx, 00122h ; 81 c3 22 01 cmp byte [es:bx+01fh], 005h ; 26 80 7f 1f 05 - jne short 0387ah ; 75 ea + jne short 03a3dh ; 75 ea mov ax, strict word 00001h ; b8 01 00 lea sp, [bp-004h] ; 8d 66 fc @@ -4788,5 +4951,5 @@ pop bp ; 5d retn ; c3 -cdrom_boot_: ; 0xf389a LB 0x416 +cdrom_boot_: ; 0xf3a5d LB 0x416 push bp ; 55 mov bp, sp ; 89 e5 @@ -4799,5 +4962,5 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 bd dd + call 0166ch ; e8 fa db mov word [bp-018h], ax ; 89 46 e8 mov si, 00322h ; be 22 03 @@ -4806,21 +4969,21 @@ mov word [bp-012h], ax ; 89 46 ee mov byte [bp-00ch], 000h ; c6 46 f4 00 - jmp short 038cfh ; eb 09 + jmp short 03a92h ; eb 09 inc byte [bp-00ch] ; fe 46 f4 cmp byte [bp-00ch], 010h ; 80 7e f4 10 - jnc short 038dah ; 73 0b + jnc short 03a9dh ; 73 0b movzx ax, byte [bp-00ch] ; 0f b6 46 f4 - call 03865h ; e8 8f ff + call 03a28h ; e8 8f ff test ax, ax ; 85 c0 - je short 038c6h ; 74 ec + je short 03a89h ; 74 ec cmp byte [bp-00ch], 010h ; 80 7e f4 10 - jc short 038e6h ; 72 06 + jc short 03aa9h ; 72 06 mov ax, strict word 00002h ; b8 02 00 - jmp near 03c4dh ; e9 67 03 + jmp near 03e10h ; e9 67 03 mov cx, strict word 0000ch ; b9 0c 00 xor bx, bx ; 31 db mov dx, ss ; 8c d2 lea ax, [bp-026h] ; 8d 46 da - call 0959ah ; e8 a7 5c + call 0975ah ; e8 a4 5c mov word [bp-026h], strict word 00028h ; c7 46 da 28 00 mov ax, strict word 00011h ; b8 11 00 @@ -4838,8 +5001,8 @@ ; mov dword [es:bx+00ah], strict dword 008000001h ; 66 26 c7 47 0a 01 00 00 08 mov byte [bp-00eh], 000h ; c6 46 f2 00 - jmp short 0392bh ; eb 09 + jmp short 03aeeh ; eb 09 inc byte [bp-00eh] ; fe 46 f2 cmp byte [bp-00eh], 004h ; 80 7e f2 04 - jnbe short 03962h ; 77 37 + jnbe short 03b25h ; 77 37 movzx di, byte [bp-00ch] ; 0f b6 7e f4 imul di, di, strict byte 00018h ; 6b ff 18 @@ -4861,33 +5024,33 @@ call word [word di+0006ah] ; ff 95 6a 00 test ax, ax ; 85 c0 - jne short 03922h ; 75 c0 + jne short 03ae5h ; 75 c0 test ax, ax ; 85 c0 - je short 0396ch ; 74 06 + je short 03b2fh ; 74 06 mov ax, strict word 00003h ; b8 03 00 - jmp near 03c4dh ; e9 e1 02 + jmp near 03e10h ; e9 e1 02 cmp byte [bp-00826h], 000h ; 80 be da f7 00 - je short 03979h ; 74 06 + je short 03b3ch ; 74 06 mov ax, strict word 00004h ; b8 04 00 - jmp near 03c4dh ; e9 d4 02 + jmp near 03e10h ; e9 d4 02 xor di, di ; 31 ff - jmp short 03983h ; eb 06 + jmp short 03b46h ; eb 06 inc di ; 47 cmp di, strict byte 00005h ; 83 ff 05 - jnc short 03993h ; 73 10 + jnc short 03b56h ; 73 10 mov al, byte [bp+di-00825h] ; 8a 83 db f7 - cmp al, byte [di+00daah] ; 3a 85 aa 0d - je short 0397dh ; 74 f0 + cmp al, byte [di+00db0h] ; 3a 85 b0 0d + je short 03b40h ; 74 f0 mov ax, strict word 00005h ; b8 05 00 - jmp near 03c4dh ; e9 ba 02 + jmp near 03e10h ; e9 ba 02 xor di, di ; 31 ff - jmp short 0399dh ; eb 06 + jmp short 03b60h ; eb 06 inc di ; 47 cmp di, strict byte 00017h ; 83 ff 17 - jnc short 039adh ; 73 10 + jnc short 03b70h ; 73 10 mov al, byte [bp+di-0081fh] ; 8a 83 e1 f7 - cmp al, byte [di+00db0h] ; 3a 85 b0 0d - je short 03997h ; 74 f0 + cmp al, byte [di+00db6h] ; 3a 85 b6 0d + je short 03b5ah ; 74 f0 mov ax, strict word 00006h ; b8 06 00 - jmp near 03c4dh ; e9 a0 02 + jmp near 03e10h ; e9 a0 02 mov ax, word [bp-007dfh] ; 8b 86 21 f8 mov dx, word [bp-007ddh] ; 8b 96 23 f8 @@ -4920,36 +5083,36 @@ call word [word di+0006ah] ; ff 95 6a 00 test ax, ax ; 85 c0 - je short 03a0ah ; 74 06 + je short 03bcdh ; 74 06 mov ax, strict word 00007h ; b8 07 00 - jmp near 03c4dh ; e9 43 02 + jmp near 03e10h ; e9 43 02 cmp byte [bp-00826h], 001h ; 80 be da f7 01 - je short 03a17h ; 74 06 + je short 03bdah ; 74 06 mov ax, strict word 00008h ; b8 08 00 - jmp near 03c4dh ; e9 36 02 + jmp near 03e10h ; e9 36 02 cmp byte [bp-00825h], 000h ; 80 be db f7 00 - je short 03a24h ; 74 06 + je short 03be7h ; 74 06 mov ax, strict word 00009h ; b8 09 00 - jmp near 03c4dh ; e9 29 02 + jmp near 03e10h ; e9 29 02 cmp byte [bp-00808h], 055h ; 80 be f8 f7 55 - je short 03a31h ; 74 06 + je short 03bf4h ; 74 06 mov ax, strict word 0000ah ; b8 0a 00 - jmp near 03c4dh ; e9 1c 02 + jmp near 03e10h ; e9 1c 02 cmp byte [bp-00807h], 0aah ; 80 be f9 f7 aa - jne short 03a2bh ; 75 f3 + jne short 03beeh ; 75 f3 cmp byte [bp-00806h], 088h ; 80 be fa f7 88 - je short 03a45h ; 74 06 + je short 03c08h ; 74 06 mov ax, strict word 0000bh ; b8 0b 00 - jmp near 03c4dh ; e9 08 02 + jmp near 03e10h ; e9 08 02 mov al, byte [bp-00805h] ; 8a 86 fb f7 mov es, [bp-010h] ; 8e 46 f0 mov byte [es:si+001h], al ; 26 88 44 01 cmp byte [bp-00805h], 000h ; 80 be fb f7 00 - jne short 03a5eh ; 75 07 + jne short 03c21h ; 75 07 mov byte [es:si+002h], 0e0h ; 26 c6 44 02 e0 - jmp short 03a71h ; eb 13 + jmp short 03c34h ; eb 13 cmp byte [bp-00805h], 004h ; 80 be fb f7 04 - jnc short 03a6ch ; 73 07 + jnc short 03c2fh ; 73 07 mov byte [es:si+002h], 000h ; 26 c6 44 02 00 - jmp short 03a71h ; eb 05 + jmp short 03c34h ; eb 05 mov byte [es:si+002h], 080h ; 26 c6 44 02 80 movzx di, byte [bp-00ch] ; 0f b6 7e f4 @@ -4969,5 +5132,5 @@ mov word [bp-016h], ax ; 89 46 ea test ax, ax ; 85 c0 - jne short 03a9fh ; 75 05 + jne short 03c62h ; 75 05 mov word [bp-016h], 007c0h ; c7 46 ea c0 07 mov ax, word [bp-016h] ; 8b 46 ea @@ -4978,9 +5141,9 @@ mov word [es:si+00eh], di ; 26 89 7c 0e test di, di ; 85 ff - je short 03ac1h ; 74 06 + je short 03c84h ; 74 06 cmp di, 00400h ; 81 ff 00 04 - jbe short 03ac7h ; 76 06 + jbe short 03c8ah ; 76 06 mov ax, strict word 0000ch ; b8 0c 00 - jmp near 03c4dh ; e9 86 01 + jmp near 03e10h ; e9 86 01 mov ax, word [bp-007feh] ; 8b 86 02 f8 mov dx, word [bp-007fch] ; 8b 96 04 f8 @@ -5022,5 +5185,5 @@ sal ax, 1 ; d1 e0 rcl di, 1 ; d1 d7 - loop 03b35h ; e2 fa + loop 03cf8h ; e2 fa push di ; 57 push ax ; 50 @@ -5035,33 +5198,33 @@ mov word [es:bx+01ch], strict word 00000h ; 26 c7 47 1c 00 00 test ax, ax ; 85 c0 - je short 03b65h ; 74 06 + je short 03d28h ; 74 06 mov ax, strict word 0000dh ; b8 0d 00 - jmp near 03c4dh ; e9 e8 00 + jmp near 03e10h ; e9 e8 00 mov es, [bp-010h] ; 8e 46 f0 mov al, byte [es:si+001h] ; 26 8a 44 01 cmp AL, strict byte 002h ; 3c 02 - jc short 03b7dh ; 72 0d - jbe short 03b95h ; 76 23 + jc short 03d40h ; 72 0d + jbe short 03d58h ; 76 23 cmp AL, strict byte 004h ; 3c 04 - je short 03babh ; 74 35 + je short 03d6eh ; 74 35 cmp AL, strict byte 003h ; 3c 03 - je short 03ba0h ; 74 26 - jmp near 03bf6h ; e9 79 00 + je short 03d63h ; 74 26 + jmp near 03db9h ; e9 79 00 cmp AL, strict byte 001h ; 3c 01 - jne short 03bf6h ; 75 75 + jne short 03db9h ; 75 75 mov es, [bp-010h] ; 8e 46 f0 db 066h, 026h, 0c7h, 044h, 012h, 050h, 000h, 00fh, 000h ; mov dword [es:si+012h], strict dword 0000f0050h ; 66 26 c7 44 12 50 00 0f 00 mov word [es:si+010h], strict word 00002h ; 26 c7 44 10 02 00 - jmp short 03bf6h ; eb 61 + jmp short 03db9h ; eb 61 db 066h, 026h, 0c7h, 044h, 012h, 050h, 000h, 012h, 000h ; mov dword [es:si+012h], strict dword 000120050h ; 66 26 c7 44 12 50 00 12 00 - jmp short 03b8dh ; eb ed + jmp short 03d50h ; eb ed db 066h, 026h, 0c7h, 044h, 012h, 050h, 000h, 024h, 000h ; mov dword [es:si+012h], strict dword 000240050h ; 66 26 c7 44 12 50 00 24 00 - jmp short 03b8dh ; eb e2 + jmp short 03d50h ; eb e2 mov dx, 001c4h ; ba c4 01 mov ax, word [bp-016h] ; 8b 46 ea - call 01650h ; e8 9c da + call 01650h ; e8 d9 d8 and AL, strict byte 03fh ; 24 3f xor ah, ah ; 30 e4 @@ -5070,10 +5233,10 @@ mov dx, 001c4h ; ba c4 01 mov ax, word [bp-016h] ; 8b 46 ea - call 01650h ; e8 88 da + call 01650h ; e8 c5 d8 movzx bx, al ; 0f b6 d8 sal bx, 002h ; c1 e3 02 mov dx, 001c5h ; ba c5 01 mov ax, word [bp-016h] ; 8b 46 ea - call 01650h ; e8 79 da + call 01650h ; e8 b6 d8 xor ah, ah ; 30 e4 add ax, bx ; 01 d8 @@ -5083,5 +5246,5 @@ mov dx, 001c3h ; ba c3 01 mov ax, word [bp-016h] ; 8b 46 ea - call 01650h ; e8 64 da + call 01650h ; e8 a1 d8 xor ah, ah ; 30 e4 inc ax ; 40 @@ -5090,18 +5253,18 @@ mov es, [bp-010h] ; 8e 46 f0 cmp byte [es:si+001h], 000h ; 26 80 7c 01 00 - je short 03c34h ; 74 34 + je short 03df7h ; 74 34 cmp byte [es:si+002h], 000h ; 26 80 7c 02 00 - jne short 03c1dh ; 75 16 + jne short 03de0h ; 75 16 mov dx, strict word 00010h ; ba 10 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 40 da + call 01650h ; e8 7d d8 or AL, strict byte 041h ; 0c 41 movzx bx, al ; 0f b6 d8 mov dx, strict word 00010h ; ba 10 00 mov ax, strict word 00040h ; b8 40 00 - jmp short 03c31h ; eb 14 + jmp short 03df4h ; eb 14 mov dx, 002c0h ; ba c0 02 mov ax, word [bp-018h] ; 8b 46 e8 - call 01650h ; e8 2a da + call 01650h ; e8 67 d8 db 0feh, 0c0h ; inc al ; fe c0 @@ -5109,8 +5272,8 @@ mov dx, 002c0h ; ba c0 02 mov ax, word [bp-018h] ; 8b 46 e8 - call 0165eh ; e8 2a da + call 0165eh ; e8 67 d8 mov es, [bp-010h] ; 8e 46 f0 cmp byte [es:si+001h], 000h ; 26 80 7c 01 00 - je short 03c42h ; 74 04 + je short 03e05h ; 74 04 mov byte [es:si], 001h ; 26 c6 04 01 mov es, [bp-010h] ; 8e 46 f0 @@ -5126,10 +5289,10 @@ retn ; c3 db 050h, 04eh, 049h, 048h, 047h, 046h, 045h, 044h, 043h, 042h, 041h, 018h, 016h, 015h, 014h, 011h - db 010h, 00dh, 00ch, 00bh, 00ah, 009h, 008h, 005h, 004h, 003h, 002h, 001h, 000h, 048h, 040h, 056h - db 03dh, 0a0h, 03dh, 0c8h, 03dh, 095h, 03dh, 0c8h, 03dh, 095h, 03dh, 09eh, 03fh, 07bh, 03dh, 048h - db 040h, 048h, 040h, 07bh, 03dh, 07bh, 03dh, 07bh, 03dh, 07bh, 03dh, 07bh, 03dh, 03fh, 040h, 07bh - db 03dh, 048h, 040h, 048h, 040h, 048h, 040h, 048h, 040h, 048h, 040h, 048h, 040h, 048h, 040h, 048h - db 040h, 048h, 040h, 048h, 040h, 048h, 040h, 048h, 040h -_int13_cdemu: ; 0xf3cb0 LB 0x434 + db 010h, 00dh, 00ch, 00bh, 00ah, 009h, 008h, 005h, 004h, 003h, 002h, 001h, 000h, 00bh, 042h, 019h + db 03fh, 063h, 03fh, 08bh, 03fh, 058h, 03fh, 08bh, 03fh, 058h, 03fh, 061h, 041h, 03eh, 03fh, 00bh + db 042h, 00bh, 042h, 03eh, 03fh, 03eh, 03fh, 03eh, 03fh, 03eh, 03fh, 03eh, 03fh, 002h, 042h, 03eh + db 03fh, 00bh, 042h, 00bh, 042h, 00bh, 042h, 00bh, 042h, 00bh, 042h, 00bh, 042h, 00bh, 042h, 00bh + db 042h, 00bh, 042h, 00bh, 042h, 00bh, 042h, 00bh, 042h +_int13_cdemu: ; 0xf3e73 LB 0x434 push bp ; 55 mov bp, sp ; 89 e5 @@ -5139,5 +5302,5 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 ab d9 + call 0166ch ; e8 e8 d7 mov di, 00322h ; bf 22 03 mov cx, ax ; 89 c1 @@ -5155,17 +5318,17 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 6e d9 + call 0165eh ; e8 ab d7 mov es, cx ; 8e c1 cmp byte [es:di], 000h ; 26 80 3d 00 - je short 03d06h ; 74 0e + je short 03ec9h ; 74 0e movzx dx, byte [es:di+002h] ; 26 0f b6 55 02 mov ax, word [bp+012h] ; 8b 46 12 xor ah, ah ; 30 e4 cmp dx, ax ; 39 c2 - je short 03d2fh ; 74 29 - mov bx, 00da2h ; bb a2 0d + je short 03ef2h ; 74 29 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 20 dc + call 01931h ; e8 5d da mov ax, word [bp+012h] ; 8b 46 12 xor ah, ah ; 30 e4 @@ -5177,19 +5340,19 @@ push 00338h ; 68 38 03 push strict byte 00004h ; 6a 04 - call 01972h ; e8 49 dc + call 01972h ; e8 86 da add sp, strict byte 0000ah ; 83 c4 0a - jmp near 04068h ; e9 39 03 + jmp near 0422bh ; e9 39 03 mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 cmp ax, strict word 00050h ; 3d 50 00 - jnbe near 04048h ; 0f 87 0c 03 + jnbe near 0420bh ; 0f 87 0c 03 push CS ; 0e pop ES ; 07 mov cx, strict word 0001eh ; b9 1e 00 - mov di, 03c57h ; bf 57 3c + mov di, 03e1ah ; bf 1a 3e repne scasb ; f2 ae sal cx, 1 ; d1 e1 mov di, cx ; 89 cf - mov ax, word [cs:di+03c74h] ; 2e 8b 85 74 3c + mov ax, word [cs:di+03e37h] ; 2e 8b 85 37 3e mov bx, word [bp+016h] ; 8b 5e 16 xor bh, bh ; 30 ff @@ -5202,5 +5365,5 @@ add bx, bx ; 01 db cmp word [word bx+0006ah], strict byte 00000h ; 83 bf 6a 00 00 - je near 03d7bh ; 0f 84 08 00 + je near 03f3eh ; 0f 84 08 00 movzx ax, byte [bp-006h] ; 0f b6 46 fa call word [word bx+00076h] ; ff 97 76 00 @@ -5209,5 +5372,5 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 d4 d8 + call 0165eh ; e8 11 d7 and byte [bp+01ch], 0feh ; 80 66 1c fe lea sp, [bp-004h] ; 8d 66 fc @@ -5219,8 +5382,8 @@ xor ah, ah ; 30 e4 or ah, 003h ; 80 cc 03 - jmp near 04070h ; e9 d0 02 + jmp near 04233h ; e9 d0 02 mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 a7 d8 + call 01650h ; e8 e4 d6 mov cl, al ; 88 c1 movzx ax, cl ; 0f b6 c1 @@ -5231,8 +5394,8 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 9d d8 + call 0165eh ; e8 da d6 test cl, cl ; 84 c9 - je short 03d7fh ; 74 ba - jmp near 04084h ; e9 bc 02 + je short 03f42h ; 74 ba + jmp near 04247h ; e9 bc 02 mov es, [bp-008h] ; 8e 46 f8 mov di, word [es:si+014h] ; 26 8b 7c 14 @@ -5258,17 +5421,17 @@ mov word [bp-00ah], cx ; 89 4e f6 test cx, cx ; 85 c9 - jne short 03e15h ; 75 03 - jmp near 03d7bh ; e9 66 ff + jne short 03fd8h ; 75 03 + jmp near 03f3eh ; e9 66 ff cmp di, word [bp-010h] ; 3b 7e f0 - jc near 04068h ; 0f 82 4c 02 + jc near 0422bh ; 0f 82 4c 02 cmp ax, dx ; 39 d0 - jnc near 04068h ; 0f 83 46 02 + jnc near 0422bh ; 0f 83 46 02 cmp si, bx ; 39 de - jnc near 04068h ; 0f 83 40 02 + jnc near 0422bh ; 0f 83 40 02 mov dx, word [bp+016h] ; 8b 56 16 shr dx, 008h ; c1 ea 08 cmp dx, strict byte 00004h ; 83 fa 04 - jne short 03e36h ; 75 03 - jmp near 03d7bh ; e9 45 ff + jne short 03ff9h ; 75 03 + jmp near 03f3eh ; e9 45 ff mov dx, word [bp+010h] ; 8b 56 10 shr dx, 004h ; c1 ea 04 @@ -5281,5 +5444,5 @@ xor dl, dl ; 30 d2 xor cx, cx ; 31 c9 - call 09569h ; e8 15 57 + call 09729h ; e8 12 57 xor bx, bx ; 31 db add ax, si ; 01 f0 @@ -5287,5 +5450,5 @@ mov bx, di ; 89 fb xor cx, cx ; 31 c9 - call 09569h ; e8 08 57 + call 09729h ; e8 05 57 mov bx, ax ; 89 c3 mov ax, word [bp-010h] ; 8b 46 f0 @@ -5322,5 +5485,5 @@ mov dx, ss ; 8c d2 lea ax, [bp-02eh] ; 8d 46 d2 - call 0959ah ; e8 e2 56 + call 0975ah ; e8 df 56 mov word [bp-02eh], strict word 00028h ; c7 46 d2 28 00 mov ax, word [bp-014h] ; 8b 46 ec @@ -5370,5 +5533,5 @@ sal si, 1 ; d1 e6 rcl di, 1 ; d1 d7 - loop 03f38h ; e2 fa + loop 040fbh ; e2 fa push di ; 57 push si ; 56 @@ -5385,9 +5548,9 @@ ; mov dword [es:bx+01ah], strict dword 000000000h ; 66 26 c7 47 1a 00 00 00 00 test al, al ; 84 c0 - je near 03d7bh ; 0f 84 13 fe - mov bx, 00da2h ; bb a2 0d + je near 03f3eh ; 0f 84 13 fe + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 be d9 + call 01931h ; e8 fb d7 movzx ax, dl ; 0f b6 c2 push ax ; 50 @@ -5398,5 +5561,5 @@ push 0036eh ; 68 6e 03 push strict byte 00004h ; 6a 04 - call 01972h ; e8 e9 d9 + call 01972h ; e8 26 d8 add sp, strict byte 0000ah ; 83 c4 0a mov ax, word [bp+016h] ; 8b 46 16 @@ -5405,5 +5568,5 @@ mov word [bp+016h], ax ; 89 46 16 mov byte [bp+016h], 000h ; c6 46 16 00 - jmp near 04073h ; e9 d5 00 + jmp near 04236h ; e9 d5 00 mov es, [bp-008h] ; 8e 46 f8 mov di, word [es:si+014h] ; 26 8b 7c 14 @@ -5444,31 +5607,31 @@ mov word [bp+010h], ax ; 89 46 10 cmp dl, 003h ; 80 fa 03 - je short 04022h ; 74 1a + je short 041e5h ; 74 1a cmp dl, 002h ; 80 fa 02 - je short 0401eh ; 74 11 + je short 041e1h ; 74 11 cmp dl, 001h ; 80 fa 01 - jne short 04026h ; 75 14 + jne short 041e9h ; 75 14 mov ax, word [bp+010h] ; 8b 46 10 xor al, al ; 30 c0 or AL, strict byte 002h ; 0c 02 mov word [bp+010h], ax ; 89 46 10 - jmp short 04026h ; eb 08 + jmp short 041e9h ; eb 08 or AL, strict byte 004h ; 0c 04 - jmp short 04019h ; eb f7 + jmp short 041dch ; eb f7 or AL, strict byte 005h ; 0c 05 - jmp short 04019h ; eb f3 + jmp short 041dch ; eb f3 mov es, [bp-008h] ; 8e 46 f8 cmp byte [es:si+001h], 004h ; 26 80 7c 01 04 - jnc near 03d7bh ; 0f 83 49 fd + jnc near 03f3eh ; 0f 83 49 fd mov word [bp+008h], 0efc7h ; c7 46 08 c7 ef mov word [bp+006h], 0f000h ; c7 46 06 00 f0 - jmp near 03d7bh ; e9 3c fd + jmp near 03f3eh ; e9 3c fd or bh, 003h ; 80 cf 03 mov word [bp+016h], bx ; 89 5e 16 - jmp near 03d7fh ; e9 37 fd - mov bx, 00da2h ; bb a2 0d + jmp near 03f42h ; e9 37 fd + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 de d8 + call 01931h ; e8 1b d7 mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 @@ -5477,5 +5640,5 @@ push 0038fh ; 68 8f 03 push strict byte 00004h ; 6a 04 - call 01972h ; e8 0d d9 + call 01972h ; e8 4a d7 add sp, strict byte 00008h ; 83 c4 08 mov ax, word [bp+016h] ; 8b 46 16 @@ -5488,14 +5651,14 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 da d5 + call 0165eh ; e8 17 d4 or byte [bp+01ch], 001h ; 80 4e 1c 01 - jmp near 03d8eh ; e9 03 fd + jmp near 03f51h ; e9 03 fd db 050h, 04eh, 049h, 048h, 047h, 046h, 045h, 044h, 043h, 042h, 041h, 018h, 016h, 015h, 014h, 011h - db 010h, 00dh, 00ch, 00bh, 00ah, 009h, 008h, 005h, 004h, 003h, 002h, 001h, 000h, 029h, 046h, 0a5h - db 043h, 091h, 041h, 029h, 046h, 086h, 041h, 029h, 046h, 086h, 041h, 029h, 046h, 0a5h, 043h, 029h - db 046h, 029h, 046h, 0a5h, 043h, 0a5h, 043h, 0a5h, 043h, 0a5h, 043h, 0a5h, 043h, 0bbh, 041h, 0a5h - db 043h, 029h, 046h, 0c4h, 041h, 0d7h, 041h, 086h, 041h, 0d7h, 041h, 005h, 043h, 0bfh, 043h, 0d7h - db 041h, 0e6h, 043h, 0e2h, 045h, 0eah, 045h, 029h, 046h -_int13_cdrom: ; 0xf40e4 LB 0x562 + db 010h, 00dh, 00ch, 00bh, 00ah, 009h, 008h, 005h, 004h, 003h, 002h, 001h, 000h, 0ech, 047h, 068h + db 045h, 054h, 043h, 0ech, 047h, 049h, 043h, 0ech, 047h, 049h, 043h, 0ech, 047h, 068h, 045h, 0ech + db 047h, 0ech, 047h, 068h, 045h, 068h, 045h, 068h, 045h, 068h, 045h, 068h, 045h, 07eh, 043h, 068h + db 045h, 0ech, 047h, 087h, 043h, 09ah, 043h, 049h, 043h, 09ah, 043h, 0c8h, 044h, 082h, 045h, 09ah + db 043h, 0a9h, 045h, 0a5h, 047h, 0adh, 047h, 0ech, 047h +_int13_cdrom: ; 0xf42a7 LB 0x562 push bp ; 55 mov bp, sp ; 89 e5 @@ -5505,5 +5668,5 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 77 d5 + call 0166ch ; e8 b4 d3 mov word [bp-01ah], ax ; 89 46 e6 mov si, 00122h ; be 22 01 @@ -5512,11 +5675,11 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 55 d5 + call 0165eh ; e8 92 d3 mov ax, word [bp+010h] ; 8b 46 10 xor ah, ah ; 30 e4 cmp ax, 000e0h ; 3d e0 00 - jc short 04118h ; 72 05 + jc short 042dbh ; 72 05 cmp ax, 000f0h ; 3d f0 00 - jc short 04136h ; 72 1e + jc short 042f9h ; 72 1e mov ax, word [bp+010h] ; 8b 46 10 xor ah, ah ; 30 e4 @@ -5528,7 +5691,7 @@ push 003cbh ; 68 cb 03 push strict byte 00004h ; 6a 04 - call 01972h ; e8 42 d8 + call 01972h ; e8 7f d6 add sp, strict byte 0000ah ; 83 c4 0a - jmp near 04606h ; e9 d0 04 + jmp near 047c9h ; e9 d0 04 mov ax, word [bp+010h] ; 8b 46 10 xor ah, ah ; 30 e4 @@ -5539,5 +5702,5 @@ mov byte [bp-008h], dl ; 88 56 f8 cmp dl, 010h ; 80 fa 10 - jc short 0415fh ; 72 10 + jc short 04322h ; 72 10 push ax ; 50 mov ax, word [bp+018h] ; 8b 46 18 @@ -5546,17 +5709,17 @@ push 003bfh ; 68 bf 03 push 003f6h ; 68 f6 03 - jmp short 0412bh ; eb cc + jmp short 042eeh ; eb cc mov ax, word [bp+018h] ; 8b 46 18 shr ax, 008h ; c1 e8 08 cmp ax, strict word 00050h ; 3d 50 00 - jnbe near 04629h ; 0f 87 bd 04 + jnbe near 047ech ; 0f 87 bd 04 push CS ; 0e pop ES ; 07 mov cx, strict word 0001eh ; b9 1e 00 - mov di, 0408bh ; bf 8b 40 + mov di, 0424eh ; bf 4e 42 repne scasb ; f2 ae sal cx, 1 ; d1 e1 mov di, cx ; 89 cf - mov ax, word [cs:di+040a8h] ; 2e 8b 85 a8 40 + mov ax, word [cs:di+0426bh] ; 2e 8b 85 6b 42 mov bx, word [bp+018h] ; 8b 5e 18 xor bh, bh ; 30 ff @@ -5565,8 +5728,8 @@ xor ah, ah ; 30 e4 or ah, 003h ; 80 cc 03 - jmp near 0460eh ; e9 7d 04 + jmp near 047d1h ; e9 7d 04 mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 b6 d4 + call 01650h ; e8 f3 d2 mov cl, al ; 88 c1 movzx ax, cl ; 0f b6 c1 @@ -5577,16 +5740,16 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 ac d4 + call 0165eh ; e8 e9 d2 test cl, cl ; 84 c9 - je near 043a9h ; 0f 84 f1 01 - jmp near 04622h ; e9 67 04 + je near 0456ch ; 0f 84 f1 01 + jmp near 047e5h ; e9 67 04 or bh, 002h ; 80 cf 02 mov word [bp+018h], bx ; 89 5e 18 - jmp near 04611h ; e9 4d 04 + jmp near 047d4h ; e9 4d 04 mov word [bp+012h], 0aa55h ; c7 46 12 55 aa or bh, 030h ; 80 cf 30 mov word [bp+018h], bx ; 89 5e 18 mov word [bp+016h], strict word 00007h ; c7 46 16 07 00 - jmp near 043a9h ; e9 d2 01 + jmp near 0456ch ; e9 d2 01 mov bx, word [bp+00ch] ; 8b 5e 0c mov es, [bp+006h] ; 8e 46 06 @@ -5603,5 +5766,5 @@ mov di, word [es:bx+00eh] ; 26 8b 7f 0e or di, ax ; 09 c7 - je short 0421fh ; 74 18 + je short 043e2h ; 74 18 mov ax, word [bp+018h] ; 8b 46 18 shr ax, 008h ; c1 e8 08 @@ -5610,7 +5773,7 @@ push 00428h ; 68 28 04 push strict byte 00007h ; 6a 07 - call 01972h ; e8 59 d7 + call 01972h ; e8 96 d5 add sp, strict byte 00008h ; 83 c4 08 - jmp near 04606h ; e9 e7 03 + jmp near 047c9h ; e9 e7 03 les bx, [bp-014h] ; c4 5e ec mov ax, word [es:bx+008h] ; 26 8b 47 08 @@ -5622,12 +5785,12 @@ mov word [bp-016h], ax ; 89 46 ea cmp ax, strict word 00044h ; 3d 44 00 - je near 043a5h ; 0f 84 66 01 + je near 04568h ; 0f 84 66 01 cmp ax, strict word 00047h ; 3d 47 00 - je near 043a5h ; 0f 84 5f 01 + je near 04568h ; 0f 84 5f 01 mov cx, strict word 0000ch ; b9 0c 00 xor bx, bx ; 31 db mov dx, ss ; 8c d2 lea ax, [bp-02ch] ; 8d 46 d4 - call 0959ah ; e8 47 53 + call 0975ah ; e8 44 53 mov word [bp-02ch], strict word 00028h ; c7 46 d4 28 00 mov ax, word [bp-018h] ; 8b 46 e8 @@ -5657,5 +5820,5 @@ sal ax, 1 ; d1 e0 rcl bx, 1 ; d1 d3 - loop 0429dh ; e2 fa + loop 04460h ; e2 fa push bx ; 53 push ax ; 50 @@ -5673,13 +5836,13 @@ shr di, 1 ; d1 ef rcr ax, 1 ; d1 d8 - loop 042c7h ; e2 fa + loop 0448ah ; e2 fa les bx, [bp-014h] ; c4 5e ec mov word [es:bx+002h], ax ; 26 89 47 02 test dl, dl ; 84 d2 - je near 043a5h ; 0f 84 cb 00 - mov bx, 00da2h ; bb a2 0d + je near 04568h ; 0f 84 cb 00 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 4c d6 + call 01931h ; e8 89 d4 movzx ax, dl ; 0f b6 c2 push ax ; 50 @@ -5688,12 +5851,12 @@ push 00451h ; 68 51 04 push strict byte 00004h ; 6a 04 - call 01972h ; e8 7b d6 + call 01972h ; e8 b8 d4 add sp, strict byte 0000ah ; 83 c4 0a mov ax, word [bp+018h] ; 8b 46 18 xor ah, ah ; 30 e4 or ah, 00ch ; 80 cc 0c - jmp near 0460eh ; e9 09 03 + jmp near 047d1h ; e9 09 03 cmp bx, strict byte 00002h ; 83 fb 02 - jnbe near 04606h ; 0f 87 fa 02 + jnbe near 047c9h ; 0f 87 fa 02 movzx ax, byte [bp-008h] ; 0f b6 46 f8 imul ax, ax, strict byte 00018h ; 6b c0 18 @@ -5703,11 +5866,11 @@ mov al, byte [es:di+021h] ; 26 8a 45 21 cmp bx, strict byte 00002h ; 83 fb 02 - je short 04396h ; 74 73 + je short 04559h ; 74 73 cmp bx, strict byte 00001h ; 83 fb 01 - je short 04363h ; 74 3b + je short 04526h ; 74 3b test bx, bx ; 85 db - jne near 043a5h ; 0f 85 77 00 + jne near 04568h ; 0f 85 77 00 cmp AL, strict byte 0ffh ; 3c ff - jne short 04344h ; 75 12 + jne short 04507h ; 75 12 mov ax, word [bp+018h] ; 8b 46 18 xor ah, ah ; 30 e4 @@ -5716,5 +5879,5 @@ xor al, al ; 30 c0 or AL, strict byte 001h ; 0c 01 - jmp near 0460eh ; e9 ca 02 + jmp near 047d1h ; e9 ca 02 movzx dx, byte [bp-008h] ; 0f b6 56 f8 imul dx, dx, strict byte 00018h ; 6b d2 18 @@ -5728,11 +5891,11 @@ or AL, strict byte 001h ; 0c 01 mov word [bp+018h], ax ; 89 46 18 - jmp near 043a5h ; e9 42 00 + jmp near 04568h ; e9 42 00 test al, al ; 84 c0 - jne short 04373h ; 75 0c + jne short 04536h ; 75 0c or bh, 0b0h ; 80 cf b0 mov word [bp+018h], bx ; 89 5e 18 mov byte [bp+018h], al ; 88 46 18 - jmp near 04611h ; e9 9e 02 + jmp near 047d4h ; e9 9e 02 movzx dx, byte [bp-008h] ; 0f b6 56 f8 imul dx, dx, strict byte 00018h ; 6b d2 18 @@ -5749,5 +5912,5 @@ xor al, al ; 30 c0 or ax, dx ; 09 d0 - jmp short 0435dh ; eb c7 + jmp short 04520h ; eb c7 test al, al ; 84 c0 db 00fh, 095h, 0c0h @@ -5761,5 +5924,5 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 aa d2 + call 0165eh ; e8 e7 d0 and byte [bp+01eh], 0feh ; 80 66 1e fe lea sp, [bp-004h] ; 8d 66 fc @@ -5774,12 +5937,12 @@ mov al, byte [es:si+021h] ; 26 8a 44 21 test al, al ; 84 c0 - je short 043d9h ; 74 06 + je short 0459ch ; 74 06 or bh, 0b1h ; 80 cf b1 - jmp near 041beh ; e9 e5 fd - je short 043a5h ; 74 ca + jmp near 04381h ; e9 e5 fd + je short 04568h ; 74 ca mov ax, word [bp+018h] ; 8b 46 18 xor ah, ah ; 30 e4 or ah, 0b1h ; 80 cc b1 - jmp near 0460eh ; e9 28 02 + jmp near 047d1h ; e9 28 02 mov dx, word [bp+00ch] ; 8b 56 0c mov cx, word [bp+006h] ; 8b 4e 06 @@ -5791,6 +5954,6 @@ mov word [bp-00eh], ax ; 89 46 f2 cmp ax, strict word 0001ah ; 3d 1a 00 - jc near 04606h ; 0f 82 04 02 - jc short 04453h ; 72 4f + jc near 047c9h ; 0f 82 04 02 + jc short 04616h ; 72 4f movzx ax, byte [bp-008h] ; 0f b6 46 f8 imul ax, ax, strict byte 00018h ; 6b c0 18 @@ -5815,5 +5978,5 @@ ; mov dword [es:di+014h], strict dword 0ffffffffh ; 66 26 c7 45 14 ff ff ff ff cmp word [bp-00eh], strict byte 0001eh ; 83 7e f2 1e - jc near 0452ah ; 0f 82 cf 00 + jc near 046edh ; 0f 82 cf 00 mov es, [bp-00ah] ; 8e 46 f6 mov word [es:bx], strict word 0001eh ; 26 c7 07 1e 00 @@ -5867,20 +6030,20 @@ xor cl, cl ; 30 c9 xor ch, ch ; 30 ed - jmp short 0450dh ; eb 05 + jmp short 046d0h ; eb 05 cmp ch, 00fh ; 80 fd 0f - jnc short 04520h ; 73 13 + jnc short 046e3h ; 73 13 movzx dx, ch ; 0f b6 d5 add dx, 00312h ; 81 c2 12 03 mov ax, word [bp-01ah] ; 8b 46 e6 - call 01650h ; e8 36 d1 + call 01650h ; e8 73 cf add cl, al ; 00 c1 db 0feh, 0c5h ; inc ch ; fe c5 - jmp short 04508h ; eb e8 + jmp short 046cbh ; eb e8 neg cl ; f6 d9 mov es, [bp-00ch] ; 8e 46 f4 mov byte [es:si+001ffh], cl ; 26 88 8c ff 01 cmp word [bp-00eh], strict byte 00042h ; 83 7e f2 42 - jc near 043a5h ; 0f 82 73 fe + jc near 04568h ; 0f 82 73 fe movzx ax, byte [bp-008h] ; 0f b6 46 f8 cwd ; 99 @@ -5900,5 +6063,5 @@ mov word [es:bx+022h], strict word 00000h ; 26 c7 47 22 00 00 test al, al ; 84 c0 - jne short 04573h ; 75 09 + jne short 04736h ; 75 09 db 066h, 026h, 0c7h, 047h, 024h, 049h, 053h, 041h, 020h ; mov dword [es:bx+024h], strict dword 020415349h ; 66 26 c7 47 24 49 53 41 20 @@ -5909,5 +6072,5 @@ ; mov dword [es:bx+02ch], strict dword 020202020h ; 66 26 c7 47 2c 20 20 20 20 test al, al ; 84 c0 - jne short 0459fh ; 75 13 + jne short 04762h ; 75 13 mov word [es:bx+030h], dx ; 26 89 57 30 db 066h, 026h, 0c7h, 047h, 032h, 000h, 000h, 000h, 000h @@ -5924,7 +6087,7 @@ xor al, al ; 30 c0 mov AH, strict byte 01eh ; b4 1e - jmp short 045c7h ; eb 05 + jmp short 0478ah ; eb 05 cmp ah, 040h ; 80 fc 40 - jnc short 045d6h ; 73 0f + jnc short 04799h ; 73 0f movzx si, ah ; 0f b6 f4 mov es, [bp-00ah] ; 8e 46 f6 @@ -5933,21 +6096,21 @@ db 0feh, 0c4h ; inc ah ; fe c4 - jmp short 045c2h ; eb ec + jmp short 04785h ; eb ec neg al ; f6 d8 mov es, [bp-00ah] ; 8e 46 f6 mov byte [es:bx+041h], al ; 26 88 47 41 - jmp near 043a5h ; e9 c3 fd + jmp near 04568h ; e9 c3 fd or bh, 006h ; 80 cf 06 mov word [bp+018h], bx ; 89 5e 18 - jmp short 04622h ; eb 38 + jmp short 047e5h ; eb 38 cmp bx, strict byte 00006h ; 83 fb 06 - je near 043a5h ; 0f 84 b4 fd + je near 04568h ; 0f 84 b4 fd cmp bx, strict byte 00001h ; 83 fb 01 - jc short 04606h ; 72 10 - jbe near 043a5h ; 0f 86 ab fd + jc short 047c9h ; 72 10 + jbe near 04568h ; 0f 86 ab fd cmp bx, strict byte 00003h ; 83 fb 03 - jc short 04606h ; 72 07 + jc short 047c9h ; 72 07 cmp bx, strict byte 00004h ; 83 fb 04 - jbe near 043a5h ; 0f 86 9f fd + jbe near 04568h ; 0f 86 9f fd mov ax, word [bp+018h] ; 8b 46 18 xor ah, ah ; 30 e4 @@ -5959,11 +6122,11 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 3c d0 + call 0165eh ; e8 79 ce or byte [bp+01eh], 001h ; 80 4e 1e 01 - jmp near 043b8h ; e9 8f fd - mov bx, 00da2h ; bb a2 0d + jmp near 0457bh ; e9 8f fd + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 fd d2 + call 01931h ; e8 3a d1 mov ax, word [bp+018h] ; 8b 46 18 shr ax, 008h ; c1 e8 08 @@ -5972,34 +6135,34 @@ push 00313h ; 68 13 03 push strict byte 00004h ; 6a 04 - jmp near 04216h ; e9 d0 fb -print_boot_device_: ; 0xf4646 LB 0x4b + jmp near 043d9h ; e9 d0 fb +print_boot_device_: ; 0xf4809 LB 0x4b push bp ; 55 mov bp, sp ; 89 e5 push cx ; 51 test al, al ; 84 c0 - je short 04653h ; 74 05 + je short 04816h ; 74 05 mov dx, strict word 00002h ; ba 02 00 - jmp short 0466dh ; eb 1a + jmp short 04830h ; eb 1a test dl, dl ; 84 d2 - je short 0465ch ; 74 05 + je short 0481fh ; 74 05 mov dx, strict word 00003h ; ba 03 00 - jmp short 0466dh ; eb 11 + jmp short 04830h ; eb 11 test bl, 080h ; f6 c3 80 - jne short 04665h ; 75 04 + jne short 04828h ; 75 04 xor dh, dh ; 30 f6 - jmp short 0466dh ; eb 08 + jmp short 04830h ; eb 08 test bl, 080h ; f6 c3 80 - je short 0468bh ; 74 21 + je short 0484eh ; 74 21 mov dx, strict word 00001h ; ba 01 00 - mov bx, 00da2h ; bb a2 0d + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 b9 d2 + call 01931h ; e8 f6 d0 imul dx, dx, strict byte 0000ah ; 6b d2 0a - add dx, 00dc8h ; 81 c2 c8 0d + add dx, 00dceh ; 81 c2 ce 0d push dx ; 52 push 00474h ; 68 74 04 push strict byte 00004h ; 6a 04 - call 01972h ; e8 ea d2 + call 01972h ; e8 27 d1 add sp, strict byte 00006h ; 83 c4 06 lea sp, [bp-002h] ; 8d 66 fe @@ -6007,5 +6170,5 @@ pop bp ; 5d retn ; c3 -print_boot_failure_: ; 0xf4691 LB 0x93 +print_boot_failure_: ; 0xf4854 LB 0x93 push bp ; 55 mov bp, sp ; 89 e5 @@ -6016,51 +6179,51 @@ movzx si, ah ; 0f b6 f4 test al, al ; 84 c0 - je short 046beh ; 74 1b - mov bx, 00da2h ; bb a2 0d + je short 04881h ; 74 1b + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 83 d2 - push 00ddch ; 68 dc 0d + call 01931h ; e8 c0 d0 + push 00de2h ; 68 e2 0d push 00488h ; 68 88 04 push strict byte 00004h ; 6a 04 - call 01972h ; e8 b9 d2 + call 01972h ; e8 f6 d0 add sp, strict byte 00006h ; 83 c4 06 - jmp short 04702h ; eb 44 + jmp short 048c5h ; eb 44 test dl, dl ; 84 d2 - je short 046d2h ; 74 10 - mov bx, 00da2h ; bb a2 0d + je short 04895h ; 74 10 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 64 d2 - push 00de6h ; 68 e6 0d - jmp short 046b1h ; eb df + call 01931h ; e8 a1 d0 + push 00dech ; 68 ec 0d + jmp short 04874h ; eb df test bl, 080h ; f6 c3 80 - je short 046e8h ; 74 11 - mov bx, 00da2h ; bb a2 0d + je short 048abh ; 74 11 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 4f d2 + call 01931h ; e8 8c d0 push si ; 56 - push 00dd2h ; 68 d2 0d - jmp short 046f7h ; eb 0f - mov bx, 00da2h ; bb a2 0d + push 00dd8h ; 68 d8 0d + jmp short 048bah ; eb 0f + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 3e d2 + call 01931h ; e8 7b d0 push si ; 56 - push 00dc8h ; 68 c8 0d + push 00dceh ; 68 ce 0d push 0049dh ; 68 9d 04 push strict byte 00004h ; 6a 04 - call 01972h ; e8 73 d2 + call 01972h ; e8 b0 d0 add sp, strict byte 00008h ; 83 c4 08 cmp byte [bp+004h], 001h ; 80 7e 04 01 - jne short 0471ch ; 75 14 + jne short 048dfh ; 75 14 test dh, dh ; 84 f6 - jne short 04711h ; 75 05 + jne short 048d4h ; 75 05 push 004b5h ; 68 b5 04 - jmp short 04714h ; eb 03 + jmp short 048d7h ; eb 03 push 004dfh ; 68 df 04 push strict byte 00007h ; 6a 07 - call 01972h ; e8 59 d2 + call 01972h ; e8 96 d0 add sp, strict byte 00004h ; 83 c4 04 lea sp, [bp-002h] ; 8d 66 fe @@ -6068,5 +6231,5 @@ pop bp ; 5d retn 00002h ; c2 02 00 -print_cdromboot_failure_: ; 0xf4724 LB 0x27 +print_cdromboot_failure_: ; 0xf48e7 LB 0x27 push bp ; 55 mov bp, sp ; 89 e5 @@ -6075,12 +6238,12 @@ push dx ; 52 mov dx, ax ; 89 c2 - mov bx, 00da2h ; bb a2 0d + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 fa d1 + call 01931h ; e8 37 d0 push dx ; 52 push 00514h ; 68 14 05 push strict byte 00004h ; 6a 04 - call 01972h ; e8 32 d2 + call 01972h ; e8 6f d0 add sp, strict byte 00006h ; 83 c4 06 lea sp, [bp-006h] ; 8d 66 fa @@ -6090,5 +6253,5 @@ pop bp ; 5d retn ; c3 -_int19_function: ; 0xf474b LB 0x256 +_int19_function: ; 0xf490e LB 0x256 push bp ; 55 mov bp, sp ; 89 e5 @@ -6098,13 +6261,13 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 10 cf + call 0166ch ; e8 4d cd mov bx, ax ; 89 c3 mov word [bp-00eh], ax ; 89 46 f2 mov byte [bp-008h], 000h ; c6 46 f8 00 mov ax, strict word 0003dh ; b8 3d 00 - call 016ach ; e8 41 cf + call 016ach ; e8 7e cd movzx si, al ; 0f b6 f0 mov ax, strict word 00038h ; b8 38 00 - call 016ach ; e8 38 cf + call 016ach ; e8 75 cd and AL, strict byte 0f0h ; 24 f0 xor ah, ah ; 30 e4 @@ -6112,5 +6275,5 @@ or si, ax ; 09 c6 mov ax, strict word 0003ch ; b8 3c 00 - call 016ach ; e8 29 cf + call 016ach ; e8 66 cd and AL, strict byte 00fh ; 24 0f xor ah, ah ; 30 e4 @@ -6119,30 +6282,30 @@ mov dx, 00339h ; ba 39 03 mov ax, bx ; 89 d8 - call 01650h ; e8 bc ce + call 01650h ; e8 f9 cc test al, al ; 84 c0 - je short 047a3h ; 74 0b + je short 04966h ; 74 0b mov dx, 00339h ; ba 39 03 mov ax, bx ; 89 d8 - call 01650h ; e8 b0 ce + call 01650h ; e8 ed cc movzx si, al ; 0f b6 f0 cmp byte [bp+004h], 001h ; 80 7e 04 01 - jne short 047b9h ; 75 10 + jne short 0497ch ; 75 10 mov ax, strict word 0003ch ; b8 3c 00 - call 016ach ; e8 fd ce + call 016ach ; e8 3a cd and AL, strict byte 0f0h ; 24 f0 xor ah, ah ; 30 e4 sar ax, 004h ; c1 f8 04 - call 0765bh ; e8 a2 2e + call 0781eh ; e8 a2 2e cmp byte [bp+004h], 002h ; 80 7e 04 02 - jne short 047c2h ; 75 03 + jne short 04985h ; 75 03 shr si, 004h ; c1 ee 04 cmp byte [bp+004h], 003h ; 80 7e 04 03 - jne short 047cbh ; 75 03 + jne short 0498eh ; 75 03 shr si, 008h ; c1 ee 08 cmp byte [bp+004h], 004h ; 80 7e 04 04 - jne short 047d4h ; 75 03 + jne short 04997h ; 75 03 shr si, 00ch ; c1 ee 0c cmp si, strict byte 00010h ; 83 fe 10 - jnc short 047ddh ; 73 04 + jnc short 049a0h ; 73 04 mov byte [bp-008h], 001h ; c6 46 f8 01 xor al, al ; 30 c0 @@ -6150,8 +6313,8 @@ mov byte [bp-00ah], al ; 88 46 f6 mov byte [bp-00ch], al ; 88 46 f4 - mov bx, 00da2h ; bb a2 0d + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 3e d1 + call 01931h ; e8 7b cf push si ; 56 movzx ax, byte [bp+004h] ; 0f b6 46 04 @@ -6159,39 +6322,39 @@ push 00534h ; 68 34 05 push strict byte 00004h ; 6a 04 - call 01972h ; e8 71 d1 + call 01972h ; e8 ae cf add sp, strict byte 00008h ; 83 c4 08 and si, strict byte 0000fh ; 83 e6 0f cmp si, strict byte 00002h ; 83 fe 02 - jc short 0481ah ; 72 0e - jbe short 04829h ; 76 1b + jc short 049ddh ; 72 0e + jbe short 049ech ; 76 1b cmp si, strict byte 00004h ; 83 fe 04 - je short 04847h ; 74 34 + je short 04a0ah ; 74 34 cmp si, strict byte 00003h ; 83 fe 03 - je short 0483dh ; 74 25 - jmp short 04874h ; eb 5a + je short 04a00h ; 74 25 + jmp short 04a37h ; eb 5a cmp si, strict byte 00001h ; 83 fe 01 - jne short 04874h ; 75 55 + jne short 04a37h ; 75 55 xor al, al ; 30 c0 mov byte [bp-006h], al ; 88 46 fa mov byte [bp-00ah], al ; 88 46 f6 - jmp short 0488ch ; eb 63 + jmp short 04a4fh ; eb 63 mov dx, 00338h ; ba 38 03 mov ax, word [bp-00eh] ; 8b 46 f2 - call 01650h ; e8 1e ce + call 01650h ; e8 5b cc add AL, strict byte 080h ; 04 80 mov byte [bp-006h], al ; 88 46 fa mov byte [bp-00ah], 000h ; c6 46 f6 00 - jmp short 0488ch ; eb 4f + jmp short 04a4fh ; eb 4f mov byte [bp-006h], 000h ; c6 46 fa 00 mov byte [bp-00ah], 001h ; c6 46 f6 01 - jmp short 04851h ; eb 0a + jmp short 04a14h ; eb 0a mov byte [bp-00ch], 001h ; c6 46 f4 01 cmp byte [bp-00ah], 000h ; 80 7e f6 00 - je short 0488ch ; 74 3b - call 0389ah ; e8 46 f0 + je short 04a4fh ; 74 3b + call 03a5dh ; e8 46 f0 mov bx, ax ; 89 c3 test AL, strict byte 0ffh ; a8 ff - je short 0487bh ; 74 21 - call 04724h ; e8 c7 fe + je short 04a3eh ; 74 21 + call 048e7h ; e8 c7 fe movzx ax, byte [bp-008h] ; 0f b6 46 f8 push ax ; 50 @@ -6200,45 +6363,45 @@ movzx ax, byte [bp-00ah] ; 0f b6 46 f6 mov cx, strict word 00001h ; b9 01 00 - call 04691h ; e8 1d fe + call 04854h ; e8 1d fe xor ax, ax ; 31 c0 xor dx, dx ; 31 d2 - jmp near 0499ah ; e9 1f 01 + jmp near 04b5dh ; e9 1f 01 mov dx, 0032eh ; ba 2e 03 mov ax, word [bp-00eh] ; 8b 46 f2 - call 0166ch ; e8 e8 cd + call 0166ch ; e8 25 cc mov di, ax ; 89 c7 shr bx, 008h ; c1 eb 08 mov byte [bp-006h], bl ; 88 5e fa cmp byte [bp-00ch], 001h ; 80 7e f4 01 - jne near 04908h ; 0f 85 74 00 + jne near 04acbh ; 0f 85 74 00 xor si, si ; 31 f6 mov ax, 0e200h ; b8 00 e2 mov es, ax ; 8e c0 cmp word [es:si], 0aa55h ; 26 81 3c 55 aa - jne short 0485dh ; 75 bb + jne short 04a20h ; 75 bb mov cx, ax ; 89 c1 mov si, word [es:si+01ah] ; 26 8b 74 1a cmp word [es:si+002h], 0506eh ; 26 81 7c 02 6e 50 - jne short 0485dh ; 75 ad + jne short 04a20h ; 75 ad cmp word [es:si], 05024h ; 26 81 3c 24 50 - jne short 0485dh ; 75 a6 + jne short 04a20h ; 75 a6 mov di, word [es:si+00eh] ; 26 8b 7c 0e mov dx, word [es:di] ; 26 8b 15 mov ax, word [es:di+002h] ; 26 8b 45 02 cmp ax, 06568h ; 3d 68 65 - jne short 048e6h ; 75 1f + jne short 04aa9h ; 75 1f cmp dx, 07445h ; 81 fa 45 74 - jne short 048e6h ; 75 19 + jne short 04aa9h ; 75 19 movzx bx, byte [bp-006h] ; 0f b6 5e fa movzx dx, byte [bp-00ch] ; 0f b6 56 f4 movzx ax, byte [bp-00ah] ; 0f b6 46 f6 - call 04646h ; e8 6a fd + call 04809h ; e8 6a fd mov word [bp-012h], strict word 00006h ; c7 46 ee 06 00 mov word [bp-010h], cx ; 89 4e f0 - jmp short 04902h ; eb 1c + jmp short 04ac5h ; eb 1c movzx bx, byte [bp-006h] ; 0f b6 5e fa movzx dx, byte [bp-00ch] ; 0f b6 56 f4 movzx ax, byte [bp-00ah] ; 0f b6 46 f6 - call 04646h ; e8 51 fd + call 04809h ; e8 51 fd sti ; fb mov word [bp-010h], cx ; 89 4e f0 @@ -6247,9 +6410,9 @@ mov word [bp-012h], ax ; 89 46 ee call far [bp-012h] ; ff 5e ee - jmp near 0485dh ; e9 55 ff + jmp near 04a20h ; e9 55 ff cmp byte [bp-00ah], 000h ; 80 7e f6 00 - jne short 04934h ; 75 26 + jne short 04af7h ; 75 26 cmp byte [bp-00ch], 000h ; 80 7e f4 00 - jne short 04934h ; 75 20 + jne short 04af7h ; 75 20 mov di, 007c0h ; bf c0 07 mov es, di ; 8e c7 @@ -6264,27 +6427,27 @@ sbb ax, strict byte 00000h ; 83 d8 00 test ax, ax ; 85 c0 - jne near 0485dh ; 0f 85 29 ff + jne near 04a20h ; 0f 85 29 ff cmp byte [bp-006h], 000h ; 80 7e fa 00 db 00fh, 094h, 0c1h ; sete cl ; 0f 94 c1 cmp byte [bp-00ah], 000h ; 80 7e f6 00 - je short 04943h ; 74 02 + je short 04b06h ; 74 02 mov CL, strict byte 001h ; b1 01 xor dx, dx ; 31 d2 mov ax, di ; 89 f8 - call 0166ch ; e8 22 cd + call 0166ch ; e8 5f cb mov bx, ax ; 89 c3 mov dx, strict word 00002h ; ba 02 00 mov ax, di ; 89 f8 - call 0166ch ; e8 18 cd + call 0166ch ; e8 55 cb cmp bx, ax ; 39 c3 - je short 04969h ; 74 11 + je short 04b2ch ; 74 11 test cl, cl ; 84 c9 - jne short 0497fh ; 75 23 + jne short 04b42h ; 75 23 mov dx, 001feh ; ba fe 01 mov ax, di ; 89 f8 - call 0166ch ; e8 08 cd + call 0166ch ; e8 45 cb cmp ax, 0aa55h ; 3d 55 aa - je short 0497fh ; 74 16 + je short 04b42h ; 74 16 movzx ax, byte [bp-008h] ; 0f b6 46 f8 push ax ; 50 @@ -6293,9 +6456,9 @@ movzx ax, byte [bp-00ah] ; 0f b6 46 f6 xor cx, cx ; 31 c9 - jmp near 04871h ; e9 f2 fe + jmp near 04a34h ; e9 f2 fe movzx bx, byte [bp-006h] ; 0f b6 5e fa movzx dx, byte [bp-00ch] ; 0f b6 56 f4 movzx ax, byte [bp-00ah] ; 0f b6 46 f6 - call 04646h ; e8 b8 fc + call 04809h ; e8 b8 fc movzx bx, byte [bp-006h] ; 0f b6 5e fa xor dx, dx ; 31 d2 @@ -6308,5 +6471,5 @@ pop bp ; 5d retn ; c3 -keyboard_panic_: ; 0xf49a1 LB 0x13 +keyboard_panic_: ; 0xf4b64 LB 0x13 push bp ; 55 mov bp, sp ; 89 e5 @@ -6314,10 +6477,10 @@ push 00554h ; 68 54 05 push strict byte 00007h ; 6a 07 - call 01972h ; e8 c5 cf + call 01972h ; e8 02 ce add sp, strict byte 00006h ; 83 c4 06 mov sp, bp ; 89 ec pop bp ; 5d retn ; c3 -_keyboard_init: ; 0xf49b4 LB 0x26a +_keyboard_init: ; 0xf4b77 LB 0x26a push bp ; 55 mov bp, sp ; 89 e5 @@ -6331,16 +6494,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 002h ; a8 02 - je short 049d7h ; 74 0d + je short 04b9ah ; 74 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 049d7h ; 76 08 + jbe short 04b9ah ; 76 08 xor al, al ; 30 c0 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 049c0h ; eb e9 + jmp short 04b83h ; eb e9 test bx, bx ; 85 db - jne short 049e0h ; 75 05 + jne short 04ba3h ; 75 05 xor ax, ax ; 31 c0 - call 049a1h ; e8 c1 ff + call 04b64h ; e8 c1 ff mov bx, strict word 0ffffh ; bb ff ff mov dx, strict word 00064h ; ba 64 00 @@ -6349,16 +6512,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 049fah ; 75 0d + jne short 04bbdh ; 75 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 049fah ; 76 08 + jbe short 04bbdh ; 76 08 mov AL, strict byte 001h ; b0 01 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 049e3h ; eb e9 + jmp short 04ba6h ; eb e9 test bx, bx ; 85 db - jne short 04a04h ; 75 06 + jne short 04bc7h ; 75 06 mov ax, strict word 00001h ; b8 01 00 - call 049a1h ; e8 9d ff + call 04b64h ; e8 9d ff mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -6366,7 +6529,7 @@ ; sub ah, ah ; 2a e4 cmp ax, strict word 00055h ; 3d 55 00 - je short 04a15h ; 74 06 + je short 04bd8h ; 74 06 mov ax, 003dfh ; b8 df 03 - call 049a1h ; e8 8c ff + call 04b64h ; e8 8c ff mov AL, strict byte 0abh ; b0 ab mov dx, strict word 00064h ; ba 64 00 @@ -6378,16 +6541,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 002h ; a8 02 - je short 04a35h ; 74 0d + je short 04bf8h ; 74 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 04a35h ; 76 08 + jbe short 04bf8h ; 76 08 mov AL, strict byte 010h ; b0 10 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04a1eh ; eb e9 + jmp short 04be1h ; eb e9 test bx, bx ; 85 db - jne short 04a3fh ; 75 06 + jne short 04c02h ; 75 06 mov ax, strict word 0000ah ; b8 0a 00 - call 049a1h ; e8 62 ff + call 04b64h ; e8 62 ff mov bx, strict word 0ffffh ; bb ff ff mov dx, strict word 00064h ; ba 64 00 @@ -6396,16 +6559,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 04a59h ; 75 0d + jne short 04c1ch ; 75 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 04a59h ; 76 08 + jbe short 04c1ch ; 76 08 mov AL, strict byte 011h ; b0 11 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04a42h ; eb e9 + jmp short 04c05h ; eb e9 test bx, bx ; 85 db - jne short 04a63h ; 75 06 + jne short 04c26h ; 75 06 mov ax, strict word 0000bh ; b8 0b 00 - call 049a1h ; e8 3e ff + call 04b64h ; e8 3e ff mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -6413,7 +6576,7 @@ ; sub ah, ah ; 2a e4 test ax, ax ; 85 c0 - je short 04a73h ; 74 06 + je short 04c36h ; 74 06 mov ax, 003e0h ; b8 e0 03 - call 049a1h ; e8 2e ff + call 04b64h ; e8 2e ff mov AL, strict byte 0ffh ; b0 ff mov dx, strict word 00060h ; ba 60 00 @@ -6425,16 +6588,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 002h ; a8 02 - je short 04a93h ; 74 0d + je short 04c56h ; 74 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 04a93h ; 76 08 + jbe short 04c56h ; 76 08 mov AL, strict byte 020h ; b0 20 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04a7ch ; eb e9 + jmp short 04c3fh ; eb e9 test bx, bx ; 85 db - jne short 04a9dh ; 75 06 + jne short 04c60h ; 75 06 mov ax, strict word 00014h ; b8 14 00 - call 049a1h ; e8 04 ff + call 04b64h ; e8 04 ff mov bx, strict word 0ffffh ; bb ff ff mov dx, strict word 00064h ; ba 64 00 @@ -6443,16 +6606,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 04ab7h ; 75 0d + jne short 04c7ah ; 75 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 04ab7h ; 76 08 + jbe short 04c7ah ; 76 08 mov AL, strict byte 021h ; b0 21 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04aa0h ; eb e9 + jmp short 04c63h ; eb e9 test bx, bx ; 85 db - jne short 04ac1h ; 75 06 + jne short 04c84h ; 75 06 mov ax, strict word 00015h ; b8 15 00 - call 049a1h ; e8 e0 fe + call 04b64h ; e8 e0 fe mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -6460,7 +6623,7 @@ ; sub ah, ah ; 2a e4 cmp ax, 000fah ; 3d fa 00 - je short 04ad2h ; 74 06 + je short 04c95h ; 74 06 mov ax, 003e1h ; b8 e1 03 - call 049a1h ; e8 cf fe + call 04b64h ; e8 cf fe mov dx, strict word 00064h ; ba 64 00 in AL, DX ; ec @@ -6468,9 +6631,9 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 04ae4h ; 75 08 + jne short 04ca7h ; 75 08 mov AL, strict byte 031h ; b0 31 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04ad2h ; eb ee + jmp short 04c95h ; eb ee mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -6478,12 +6641,12 @@ ; sub ah, ah ; 2a e4 cmp ax, 000aah ; 3d aa 00 - je short 04afdh ; 74 0e + je short 04cc0h ; 74 0e in AL, DX ; ec db 02ah, 0e4h ; sub ah, ah ; 2a e4 cmp ax, 000aah ; 3d aa 00 - je short 04afdh ; 74 06 + je short 04cc0h ; 74 06 mov ax, 003e2h ; b8 e2 03 - call 049a1h ; e8 a4 fe + call 04b64h ; e8 a4 fe mov AL, strict byte 0f5h ; b0 f5 mov dx, strict word 00060h ; ba 60 00 @@ -6495,16 +6658,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 002h ; a8 02 - je short 04b1dh ; 74 0d + je short 04ce0h ; 74 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 04b1dh ; 76 08 + jbe short 04ce0h ; 76 08 mov AL, strict byte 040h ; b0 40 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04b06h ; eb e9 + jmp short 04cc9h ; eb e9 test bx, bx ; 85 db - jne short 04b27h ; 75 06 + jne short 04ceah ; 75 06 mov ax, strict word 00028h ; b8 28 00 - call 049a1h ; e8 7a fe + call 04b64h ; e8 7a fe mov bx, strict word 0ffffh ; bb ff ff mov dx, strict word 00064h ; ba 64 00 @@ -6513,16 +6676,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 04b41h ; 75 0d + jne short 04d04h ; 75 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 04b41h ; 76 08 + jbe short 04d04h ; 76 08 mov AL, strict byte 041h ; b0 41 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04b2ah ; eb e9 + jmp short 04cedh ; eb e9 test bx, bx ; 85 db - jne short 04b4bh ; 75 06 + jne short 04d0eh ; 75 06 mov ax, strict word 00029h ; b8 29 00 - call 049a1h ; e8 56 fe + call 04b64h ; e8 56 fe mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -6530,7 +6693,7 @@ ; sub ah, ah ; 2a e4 cmp ax, 000fah ; 3d fa 00 - je short 04b5ch ; 74 06 + je short 04d1fh ; 74 06 mov ax, 003e3h ; b8 e3 03 - call 049a1h ; e8 45 fe + call 04b64h ; e8 45 fe mov AL, strict byte 060h ; b0 60 mov dx, strict word 00064h ; ba 64 00 @@ -6542,16 +6705,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 002h ; a8 02 - je short 04b7ch ; 74 0d + je short 04d3fh ; 74 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 04b7ch ; 76 08 + jbe short 04d3fh ; 76 08 mov AL, strict byte 050h ; b0 50 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04b65h ; eb e9 + jmp short 04d28h ; eb e9 test bx, bx ; 85 db - jne short 04b86h ; 75 06 + jne short 04d49h ; 75 06 mov ax, strict word 00032h ; b8 32 00 - call 049a1h ; e8 1b fe + call 04b64h ; e8 1b fe mov AL, strict byte 065h ; b0 65 mov dx, strict word 00060h ; ba 60 00 @@ -6563,16 +6726,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 002h ; a8 02 - je short 04ba6h ; 74 0d + je short 04d69h ; 74 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 04ba6h ; 76 08 + jbe short 04d69h ; 76 08 mov AL, strict byte 060h ; b0 60 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04b8fh ; eb e9 + jmp short 04d52h ; eb e9 test bx, bx ; 85 db - jne short 04bb0h ; 75 06 + jne short 04d73h ; 75 06 mov ax, strict word 0003ch ; b8 3c 00 - call 049a1h ; e8 f1 fd + call 04b64h ; e8 f1 fd mov AL, strict byte 0f4h ; b0 f4 mov dx, strict word 00060h ; ba 60 00 @@ -6584,16 +6747,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 002h ; a8 02 - je short 04bd0h ; 74 0d + je short 04d93h ; 74 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 04bd0h ; 76 08 + jbe short 04d93h ; 76 08 mov AL, strict byte 070h ; b0 70 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04bb9h ; eb e9 + jmp short 04d7ch ; eb e9 test bx, bx ; 85 db - jne short 04bdah ; 75 06 + jne short 04d9dh ; 75 06 mov ax, strict word 00046h ; b8 46 00 - call 049a1h ; e8 c7 fd + call 04b64h ; e8 c7 fd mov bx, strict word 0ffffh ; bb ff ff mov dx, strict word 00064h ; ba 64 00 @@ -6602,16 +6765,16 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 04bf4h ; 75 0d + jne short 04db7h ; 75 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 04bf4h ; 76 08 + jbe short 04db7h ; 76 08 mov AL, strict byte 071h ; b0 71 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 04bddh ; eb e9 + jmp short 04da0h ; eb e9 test bx, bx ; 85 db - jne short 04bfeh ; 75 06 + jne short 04dc1h ; 75 06 mov ax, strict word 00046h ; b8 46 00 - call 049a1h ; e8 a3 fd + call 04b64h ; e8 a3 fd mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -6619,16 +6782,16 @@ ; sub ah, ah ; 2a e4 cmp ax, 000fah ; 3d fa 00 - je short 04c0fh ; 74 06 + je short 04dd2h ; 74 06 mov ax, 003e4h ; b8 e4 03 - call 049a1h ; e8 92 fd + call 04b64h ; e8 92 fd mov AL, strict byte 0a8h ; b0 a8 mov dx, strict word 00064h ; ba 64 00 out DX, AL ; ee xor ax, ax ; 31 c0 - call 05ef3h ; e8 d9 12 + call 060b6h ; e8 d9 12 mov sp, bp ; 89 ec pop bp ; 5d retn ; c3 -enqueue_key_: ; 0xf4c1e LB 0x93 +enqueue_key_: ; 0xf4de1 LB 0x93 push bp ; 55 mov bp, sp ; 89 e5 @@ -6642,30 +6805,30 @@ mov dx, strict word 0001ah ; ba 1a 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 38 ca + call 0166ch ; e8 75 c8 mov di, ax ; 89 c7 mov dx, strict word 0001ch ; ba 1c 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 2d ca + call 0166ch ; e8 6a c8 mov si, ax ; 89 c6 lea cx, [si+002h] ; 8d 4c 02 cmp cx, strict byte 0003eh ; 83 f9 3e - jc short 04c4ch ; 72 03 + jc short 04e0fh ; 72 03 mov cx, strict word 0001eh ; b9 1e 00 cmp cx, di ; 39 f9 - jne short 04c54h ; 75 04 + jne short 04e17h ; 75 04 xor ax, ax ; 31 c0 - jmp short 04c79h ; eb 25 + jmp short 04e3ch ; eb 25 xor bh, bh ; 30 ff mov dx, si ; 89 f2 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 00 ca + call 0165eh ; e8 3d c8 movzx bx, byte [bp-00ah] ; 0f b6 5e f6 lea dx, [si+001h] ; 8d 54 01 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 f3 c9 + call 0165eh ; e8 30 c8 mov bx, cx ; 89 cb mov dx, strict word 0001ch ; ba 1c 00 mov ax, strict word 00040h ; b8 40 00 - call 0167ah ; e8 04 ca + call 0167ah ; e8 41 c8 mov ax, strict word 00001h ; b8 01 00 lea sp, [bp-008h] ; 8d 66 f8 @@ -6685,24 +6848,23 @@ cmp bh, byte [bx+si] ; 3a 38 sub bl, byte [ss:di] ; 36 2a 1d - sbb AL, strict byte 04fh ; 1c 4f - db 082h, 04dh, 04ah, 04dh - ; or byte [di+04ah], 04dh ; 82 4d 4a 4d - dec dx ; 4a - dec bp ; 4d - adc byte [bp+020h], cl ; 10 4e 20 - dec bp ; 4d - mov cs, [bp-020h] ; 8e 4e e0 + fist word [bx+si+045h] ; df 50 45 + dec di ; 4f + or ax, 00d4fh ; 0d 4f 0d + dec di ; 4f + ror word [bx-01dh], CL ; d3 4f e3 dec si ; 4e - add cl, byte [bx-037h] ; 02 4f c9 - dec bp ; 4d - dec dx ; 4a - dec bp ; 4d - dec dx ; 4a - dec bp ; 4d + push cx ; 51 + push ax ; 50 + mov word [0c550h], ax ; a3 50 c5 + push ax ; 50 + mov [bx+00dh], cs ; 8c 4f 0d dec di ; 4f - dec si ; 4e - cmp AL, strict byte 04dh ; 3c 4d - ror word [bp-005h], 04eh ; c1 4e fb 4e -_int09_function: ; 0xf4cb1 LB 0x3c7 + or ax, 0124fh ; 0d 4f 12 + push ax ; 50 + dec word [bp-07ch] ; ff 4e 84 + push ax ; 50 + db 0beh + push ax ; 50 +_int09_function: ; 0xf4e74 LB 0x3c7 push bp ; 55 mov bp, sp ; 89 e5 @@ -6712,27 +6874,27 @@ mov byte [bp-008h], al ; 88 46 f8 test al, al ; 84 c0 - jne short 04cdbh ; 75 19 - mov bx, 00da2h ; bb a2 0d + jne short 04e9eh ; 75 19 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 64 cc + call 01931h ; e8 a1 ca push 00567h ; 68 67 05 push strict byte 00004h ; 6a 04 - call 01972h ; e8 9d cc + call 01972h ; e8 da ca add sp, strict byte 00004h ; 83 c4 04 - jmp near 05072h ; e9 97 03 + jmp near 05235h ; e9 97 03 mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 6c c9 + call 01650h ; e8 a9 c7 mov byte [bp-010h], al ; 88 46 f0 mov byte [bp-00ah], al ; 88 46 f6 mov dx, strict word 00018h ; ba 18 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 5d c9 + call 01650h ; e8 9a c7 mov byte [bp-00eh], al ; 88 46 f2 mov byte [bp-004h], al ; 88 46 fc mov dx, 00096h ; ba 96 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 4e c9 + call 01650h ; e8 8b c7 mov byte [bp-006h], al ; 88 46 fa mov byte [bp-00ch], al ; 88 46 f4 @@ -6741,9 +6903,9 @@ pop ES ; 07 mov cx, strict word 00010h ; b9 10 00 - mov di, 04c82h ; bf 82 4c + mov di, 04e45h ; bf 45 4e repne scasb ; f2 ae sal cx, 1 ; d1 e1 mov di, cx ; 89 cf - mov ax, word [cs:di+04c91h] ; 2e 8b 85 91 4c + mov ax, word [cs:di+04e54h] ; 2e 8b 85 54 4e jmp ax ; ff e0 xor byte [bp-00ah], 040h ; 80 76 f6 40 @@ -6751,15 +6913,15 @@ mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 2d c9 + call 0165eh ; e8 6a c7 or byte [bp-004h], 040h ; 80 4e fc 40 movzx bx, byte [bp-004h] ; 0f b6 5e fc - jmp near 04ed4h ; e9 98 01 + jmp near 05097h ; e9 98 01 mov al, byte [bp-00eh] ; 8a 46 f2 and AL, strict byte 0bfh ; 24 bf mov byte [bp-004h], al ; 88 46 fc movzx bx, al ; 0f b6 d8 - jmp near 04ed4h ; e9 8a 01 + jmp near 05097h ; e9 8a 01 test byte [bp-00ch], 002h ; f6 46 f4 02 - jne near 05054h ; 0f 85 02 03 + jne near 05217h ; 0f 85 02 03 mov al, byte [bp-008h] ; 8a 46 f8 and AL, strict byte 07fh ; 24 7f @@ -6770,17 +6932,17 @@ inc dx ; 42 test byte [bp-008h], 080h ; f6 46 f8 80 - je short 04d6fh ; 74 09 + je short 04f32h ; 74 09 mov al, dl ; 88 d0 not al ; f6 d0 and byte [bp-00ah], al ; 20 46 f6 - jmp short 04d72h ; eb 03 + jmp short 04f35h ; eb 03 or byte [bp-00ah], dl ; 08 56 f6 movzx bx, byte [bp-00ah] ; 0f b6 5e f6 mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 df c8 - jmp near 05054h ; e9 d2 02 + call 0165eh ; e8 1c c7 + jmp near 05217h ; e9 d2 02 test byte [bp-006h], 001h ; f6 46 fa 01 - jne near 05054h ; 0f 85 ca 02 + jne near 05217h ; 0f 85 ca 02 mov al, byte [bp-010h] ; 8a 46 f0 or AL, strict byte 004h ; 0c 04 @@ -6789,13 +6951,13 @@ mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 c0 c8 + call 0165eh ; e8 fd c6 mov al, byte [bp-006h] ; 8a 46 fa test AL, strict byte 002h ; a8 02 - je short 04db2h ; 74 0d + je short 04f75h ; 74 0d or AL, strict byte 004h ; 0c 04 mov byte [bp-00ch], al ; 88 46 f4 movzx bx, al ; 0f b6 d8 mov dx, 00096h ; ba 96 00 - jmp short 04dc0h ; eb 0e + jmp short 04f83h ; eb 0e mov al, byte [bp-00eh] ; 8a 46 f2 or AL, strict byte 001h ; 0c 01 @@ -6804,8 +6966,8 @@ mov dx, strict word 00018h ; ba 18 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 98 c8 - jmp near 05054h ; e9 8b 02 + call 0165eh ; e8 d5 c6 + jmp near 05217h ; e9 8b 02 test byte [bp-006h], 001h ; f6 46 fa 01 - jne near 05054h ; 0f 85 83 02 + jne near 05217h ; 0f 85 83 02 mov al, byte [bp-010h] ; 8a 46 f0 and AL, strict byte 0fbh ; 24 fb @@ -6814,13 +6976,13 @@ mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 79 c8 + call 0165eh ; e8 b6 c6 mov al, byte [bp-006h] ; 8a 46 fa test AL, strict byte 002h ; a8 02 - je short 04df9h ; 74 0d + je short 04fbch ; 74 0d and AL, strict byte 0fbh ; 24 fb mov byte [bp-00ch], al ; 88 46 f4 movzx bx, al ; 0f b6 d8 mov dx, 00096h ; ba 96 00 - jmp short 04e07h ; eb 0e + jmp short 04fcah ; eb 0e mov al, byte [bp-00eh] ; 8a 46 f2 and AL, strict byte 0feh ; 24 fe @@ -6829,6 +6991,6 @@ mov dx, strict word 00018h ; ba 18 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 51 c8 - jmp near 05054h ; e9 44 02 + call 0165eh ; e8 8e c6 + jmp near 05217h ; e9 44 02 mov al, byte [bp-010h] ; 8a 46 f0 or AL, strict byte 008h ; 0c 08 @@ -6837,13 +6999,13 @@ mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 3a c8 + call 0165eh ; e8 77 c6 mov al, byte [bp-006h] ; 8a 46 fa test AL, strict byte 002h ; a8 02 - je short 04e38h ; 74 0d + je short 04ffbh ; 74 0d or AL, strict byte 008h ; 0c 08 mov byte [bp-00ch], al ; 88 46 f4 movzx bx, al ; 0f b6 d8 mov dx, 00096h ; ba 96 00 - jmp short 04e46h ; eb 0e + jmp short 05009h ; eb 0e mov al, byte [bp-00eh] ; 8a 46 f2 or AL, strict byte 002h ; 0c 02 @@ -6852,6 +7014,6 @@ mov dx, strict word 00018h ; ba 18 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 12 c8 - jmp near 05054h ; e9 05 02 + call 0165eh ; e8 4f c6 + jmp near 05217h ; e9 05 02 mov al, byte [bp-010h] ; 8a 46 f0 and AL, strict byte 0f7h ; 24 f7 @@ -6860,13 +7022,13 @@ mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 fb c7 + call 0165eh ; e8 38 c6 mov al, byte [bp-006h] ; 8a 46 fa test AL, strict byte 002h ; a8 02 - je short 04e77h ; 74 0d + je short 0503ah ; 74 0d and AL, strict byte 0f7h ; 24 f7 mov byte [bp-00ch], al ; 88 46 f4 movzx bx, al ; 0f b6 d8 mov dx, 00096h ; ba 96 00 - jmp short 04e85h ; eb 0e + jmp short 05048h ; eb 0e mov al, byte [bp-00eh] ; 8a 46 f2 and AL, strict byte 0fdh ; 24 fd @@ -6875,8 +7037,8 @@ mov dx, strict word 00018h ; ba 18 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 d3 c7 - jmp near 05054h ; e9 c6 01 + call 0165eh ; e8 10 c6 + jmp near 05217h ; e9 c6 01 test byte [bp-006h], 003h ; f6 46 fa 03 - jne near 05054h ; 0f 85 be 01 + jne near 05217h ; 0f 85 be 01 mov al, byte [bp-00eh] ; 8a 46 f2 or AL, strict byte 020h ; 0c 20 @@ -6885,5 +7047,5 @@ mov dx, strict word 00018h ; ba 18 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 b4 c7 + call 0165eh ; e8 f1 c5 mov al, byte [bp-010h] ; 8a 46 f0 xor AL, strict byte 020h ; 34 20 @@ -6892,8 +7054,8 @@ mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 a0 c7 - jmp near 05054h ; e9 93 01 + call 0165eh ; e8 dd c5 + jmp near 05217h ; e9 93 01 test byte [bp-006h], 003h ; f6 46 fa 03 - jne near 05054h ; 0f 85 8b 01 + jne near 05217h ; 0f 85 8b 01 mov al, byte [bp-00eh] ; 8a 46 f2 and AL, strict byte 0dfh ; 24 df @@ -6902,6 +7064,6 @@ mov dx, strict word 00018h ; ba 18 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 81 c7 - jmp near 05054h ; e9 74 01 + call 0165eh ; e8 be c5 + jmp near 05217h ; e9 74 01 mov al, byte [bp-00eh] ; 8a 46 f2 or AL, strict byte 010h ; 0c 10 @@ -6910,36 +7072,36 @@ mov dx, strict word 00018h ; ba 18 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 6a c7 + call 0165eh ; e8 a7 c5 mov al, byte [bp-010h] ; 8a 46 f0 xor AL, strict byte 010h ; 34 10 - jmp short 04eafh ; eb b4 + jmp short 05072h ; eb b4 mov al, byte [bp-00eh] ; 8a 46 f2 and AL, strict byte 0efh ; 24 ef - jmp short 04eceh ; eb cc + jmp short 05091h ; eb cc mov al, byte [bp-010h] ; 8a 46 f0 and AL, strict byte 00ch ; 24 0c cmp AL, strict byte 00ch ; 3c 0c - jne short 04f1ch ; 75 11 + jne short 050dfh ; 75 11 mov bx, 01234h ; bb 34 12 mov dx, strict word 00072h ; ba 72 00 mov ax, strict word 00040h ; b8 40 00 - call 0167ah ; e8 63 c7 + call 0167ah ; e8 a0 c5 jmp far 0f000h:0e05bh ; ea 5b e0 00 f0 mov al, byte [bp-008h] ; 8a 46 f8 test AL, strict byte 080h ; a8 80 - je short 04f5ah ; 74 37 + je short 0511dh ; 74 37 cmp AL, strict byte 0fah ; 3c fa - jne short 04f37h ; 75 10 + jne short 050fah ; 75 10 mov dx, 00097h ; ba 97 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 20 c7 + call 01650h ; e8 5d c5 mov dl, al ; 88 c2 or dl, 010h ; 80 ca 10 - jmp short 04f4bh ; eb 14 + jmp short 0510eh ; eb 14 cmp AL, strict byte 0feh ; 3c fe - jne near 05054h ; 0f 85 17 01 + jne near 05217h ; 0f 85 17 01 mov dx, 00097h ; ba 97 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 0a c7 + call 01650h ; e8 47 c5 mov dl, al ; 88 c2 or dl, 020h ; 80 ca 20 @@ -6947,95 +7109,95 @@ mov dx, 00097h ; ba 97 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 07 c7 - jmp near 05054h ; e9 fa 00 + call 0165eh ; e8 44 c5 + jmp near 05217h ; e9 fa 00 cmp byte [bp-008h], 058h ; 80 7e f8 58 - jbe short 04f7eh ; 76 1e - mov bx, 00da2h ; bb a2 0d + jbe short 05141h ; 76 1e + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 c6 c9 + call 01931h ; e8 03 c8 movzx ax, byte [bp-008h] ; 0f b6 46 f8 push ax ; 50 push 00581h ; 68 81 05 push strict byte 00004h ; 6a 04 - call 01972h ; e8 fa c9 + call 01972h ; e8 37 c8 add sp, strict byte 00006h ; 83 c4 06 - jmp near 05072h ; e9 f4 00 + jmp near 05235h ; e9 f4 00 mov al, byte [bp-00ah] ; 8a 46 f6 test AL, strict byte 008h ; a8 08 - je short 04f97h ; 74 12 + je short 0515ah ; 74 12 movzx bx, byte [bp-008h] ; 0f b6 5e f8 imul bx, bx, strict byte 0000ah ; 6b db 0a - mov dl, byte [bx+00df6h] ; 8a 97 f6 0d - mov ax, word [bx+00df6h] ; 8b 87 f6 0d - jmp near 05025h ; e9 8e 00 + mov dl, byte [bx+00dfch] ; 8a 97 fc 0d + mov ax, word [bx+00dfch] ; 8b 87 fc 0d + jmp near 051e8h ; e9 8e 00 test AL, strict byte 004h ; a8 04 - je short 04fadh ; 74 12 + je short 05170h ; 74 12 movzx bx, byte [bp-008h] ; 0f b6 5e f8 imul bx, bx, strict byte 0000ah ; 6b db 0a - mov dl, byte [bx+00df4h] ; 8a 97 f4 0d - mov ax, word [bx+00df4h] ; 8b 87 f4 0d - jmp near 05025h ; e9 78 00 + mov dl, byte [bx+00dfah] ; 8a 97 fa 0d + mov ax, word [bx+00dfah] ; 8b 87 fa 0d + jmp near 051e8h ; e9 78 00 mov al, byte [bp-00ch] ; 8a 46 f4 and AL, strict byte 002h ; 24 02 test al, al ; 84 c0 - jbe short 04fcbh ; 76 15 + jbe short 0518eh ; 76 15 mov al, byte [bp-008h] ; 8a 46 f8 cmp AL, strict byte 047h ; 3c 47 - jc short 04fcbh ; 72 0e + jc short 0518eh ; 72 0e cmp AL, strict byte 053h ; 3c 53 - jnbe short 04fcbh ; 77 0a + jnbe short 0518eh ; 77 0a mov DL, strict byte 0e0h ; b2 e0 movzx bx, al ; 0f b6 d8 imul bx, bx, strict byte 0000ah ; 6b db 0a - jmp short 05021h ; eb 56 + jmp short 051e4h ; eb 56 test byte [bp-00ah], 003h ; f6 46 f6 03 - je short 04fffh ; 74 2e + je short 051c2h ; 74 2e movzx bx, byte [bp-008h] ; 0f b6 5e f8 imul bx, bx, strict byte 0000ah ; 6b db 0a - movzx ax, byte [bx+00df8h] ; 0f b6 87 f8 0d + movzx ax, byte [bx+00dfeh] ; 0f b6 87 fe 0d movzx dx, byte [bp-00ah] ; 0f b6 56 f6 test dx, ax ; 85 c2 - je short 04fefh ; 74 0a - mov dl, byte [bx+00df0h] ; 8a 97 f0 0d - mov ax, word [bx+00df0h] ; 8b 87 f0 0d - jmp short 04ff7h ; eb 08 - mov dl, byte [bx+00df2h] ; 8a 97 f2 0d - mov ax, word [bx+00df2h] ; 8b 87 f2 0d + je short 051b2h ; 74 0a + mov dl, byte [bx+00df6h] ; 8a 97 f6 0d + mov ax, word [bx+00df6h] ; 8b 87 f6 0d + jmp short 051bah ; eb 08 + mov dl, byte [bx+00df8h] ; 8a 97 f8 0d + mov ax, word [bx+00df8h] ; 8b 87 f8 0d shr ax, 008h ; c1 e8 08 mov byte [bp-008h], al ; 88 46 f8 - jmp short 0502bh ; eb 2c + jmp short 051eeh ; eb 2c movzx bx, byte [bp-008h] ; 0f b6 5e f8 imul bx, bx, strict byte 0000ah ; 6b db 0a - movzx ax, byte [bx+00df8h] ; 0f b6 87 f8 0d + movzx ax, byte [bx+00dfeh] ; 0f b6 87 fe 0d movzx dx, byte [bp-00ah] ; 0f b6 56 f6 test dx, ax ; 85 c2 - je short 0501dh ; 74 0a - mov dl, byte [bx+00df2h] ; 8a 97 f2 0d - mov ax, word [bx+00df2h] ; 8b 87 f2 0d - jmp short 05025h ; eb 08 - mov dl, byte [bx+00df0h] ; 8a 97 f0 0d - mov ax, word [bx+00df0h] ; 8b 87 f0 0d + je short 051e0h ; 74 0a + mov dl, byte [bx+00df8h] ; 8a 97 f8 0d + mov ax, word [bx+00df8h] ; 8b 87 f8 0d + jmp short 051e8h ; eb 08 + mov dl, byte [bx+00df6h] ; 8a 97 f6 0d + mov ax, word [bx+00df6h] ; 8b 87 f6 0d shr ax, 008h ; c1 e8 08 mov byte [bp-008h], al ; 88 46 f8 cmp byte [bp-008h], 000h ; 80 7e f8 00 - jne short 0504bh ; 75 1a + jne short 0520eh ; 75 1a test dl, dl ; 84 d2 - jne short 0504bh ; 75 16 - mov bx, 00da2h ; bb a2 0d + jne short 0520eh ; 75 16 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 f1 c8 + call 01931h ; e8 2e c7 push 005b8h ; 68 b8 05 push strict byte 00004h ; 6a 04 - call 01972h ; e8 2a c9 + call 01972h ; e8 67 c7 add sp, strict byte 00004h ; 83 c4 04 xor dh, dh ; 30 f6 movzx ax, byte [bp-008h] ; 0f b6 46 f8 - call 04c1eh ; e8 ca fb + call 04de1h ; e8 ca fb mov al, byte [bp-008h] ; 8a 46 f8 and AL, strict byte 07fh ; 24 7f cmp AL, strict byte 01dh ; 3c 1d - je short 05061h ; 74 04 + je short 05224h ; 74 04 and byte [bp-00ch], 0feh ; 80 66 f4 fe and byte [bp-00ch], 0fdh ; 80 66 f4 fd @@ -7043,10 +7205,10 @@ mov dx, 00096h ; ba 96 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 ec c5 + call 0165eh ; e8 29 c4 lea sp, [bp-002h] ; 8d 66 fe pop di ; 5f pop bp ; 5d retn ; c3 -dequeue_key_: ; 0xf5078 LB 0x94 +dequeue_key_: ; 0xf523b LB 0x94 push bp ; 55 mov bp, sp ; 89 e5 @@ -7061,18 +7223,18 @@ mov dx, strict word 0001ah ; ba 1a 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 da c5 + call 0166ch ; e8 17 c4 mov bx, ax ; 89 c3 mov dx, strict word 0001ch ; ba 1c 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 cf c5 + call 0166ch ; e8 0c c4 cmp bx, ax ; 39 c3 - je short 050deh ; 74 3d + je short 052a1h ; 74 3d mov dx, bx ; 89 da mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 a7 c5 + call 01650h ; e8 e4 c3 mov cl, al ; 88 c1 lea dx, [bx+001h] ; 8d 57 01 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 9c c5 + call 01650h ; e8 d9 c3 mov es, [bp-008h] ; 8e 46 f8 mov byte [es:si], cl ; 26 88 0c @@ -7080,15 +7242,15 @@ mov byte [es:di], al ; 26 88 05 cmp word [bp+004h], strict byte 00000h ; 83 7e 04 00 - je short 050d9h ; 74 13 + je short 0529ch ; 74 13 inc bx ; 43 inc bx ; 43 cmp bx, strict byte 0003eh ; 83 fb 3e - jc short 050d0h ; 72 03 + jc short 05293h ; 72 03 mov bx, strict word 0001eh ; bb 1e 00 mov dx, strict word 0001ah ; ba 1a 00 mov ax, strict word 00040h ; b8 40 00 - call 0167ah ; e8 a1 c5 + call 0167ah ; e8 de c3 mov ax, strict word 00001h ; b8 01 00 - jmp short 050e0h ; eb 02 + jmp short 052a3h ; eb 02 xor ax, ax ; 31 c0 lea sp, [bp-004h] ; 8d 66 fc @@ -7101,23 +7263,20 @@ or cl, byte [bx+di] ; 0a 09 add ax, 00102h ; 05 02 01 - add byte [bp+si-03fadh], ch ; 00 aa 53 c0 - push cx ; 51 - pop ES ; 07 - push dx ; 52 - push bx ; 53 - push dx ; 52 - arpl word [bp+si-073h], dx ; 63 52 8d - push dx ; 52 - xchg si, ax ; 96 - push dx ; 52 - pop ES ; 07 - push bx ; 53 - cmp byte [bp+di+065h], dl ; 38 53 65 - push bx ; 53 - lahf ; 9f - push bx ; 53 - in ax, DX ; ed - push bx ; 53 -_int16_function: ; 0xf510c LB 0x2e7 + add byte [di+055h], ch ; 00 6d 55 + adc word [bp+di-036h], strict byte 00053h ; 83 53 ca 53 + push SS ; 16 + push sp ; 54 + db 026h, 054h + ; es push sp ; 26 54 + push ax ; 50 + push sp ; 54 + pop cx ; 59 + push sp ; 54 + retf 0fb54h ; ca 54 fb + push sp ; 54 + sub byte [di+062h], dl ; 28 55 62 + push bp ; 55 + mov AL, strict byte 055h ; b0 55 +_int16_function: ; 0xf52cf LB 0x2e7 push bp ; 55 mov bp, sp ; 89 e5 @@ -7126,10 +7285,10 @@ mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 34 c5 + call 01650h ; e8 71 c3 mov cl, al ; 88 c1 mov bh, al ; 88 c7 mov dx, 00097h ; ba 97 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 27 c5 + call 01650h ; e8 64 c3 mov bl, al ; 88 c3 movzx dx, cl ; 0f b6 d1 @@ -7140,5 +7299,5 @@ xor al, dl ; 30 d0 test ax, ax ; 85 c0 - je short 0519eh ; 74 60 + je short 05361h ; 74 60 cli ; fa mov AL, strict byte 0edh ; b0 ed @@ -7150,9 +7309,9 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 05157h ; 75 08 + jne short 0531ah ; 75 08 mov AL, strict byte 021h ; b0 21 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 05145h ; eb ee + jmp short 05308h ; eb ee mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -7160,5 +7319,5 @@ ; sub ah, ah ; 2a e4 cmp ax, 000fah ; 3d fa 00 - jne short 0519dh ; 75 3b + jne short 05360h ; 75 3b and bl, 0c8h ; 80 e3 c8 movzx ax, bh ; 0f b6 c7 @@ -7176,9 +7335,9 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 0518ch ; 75 08 + jne short 0534fh ; 75 08 mov AL, strict byte 021h ; b0 21 mov dx, 00080h ; ba 80 00 out DX, AL ; ee - jmp short 0517ah ; eb ee + jmp short 0533dh ; eb ee mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -7188,18 +7347,18 @@ mov dx, 00097h ; ba 97 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 c1 c4 + call 0165eh ; e8 fe c2 sti ; fb mov ax, word [bp+012h] ; 8b 46 12 shr ax, 008h ; c1 e8 08 cmp ax, 000a2h ; 3d a2 00 - jnbe near 053aah ; 0f 87 ff 01 + jnbe near 0556dh ; 0f 87 ff 01 push CS ; 0e pop ES ; 07 mov cx, strict word 0000ch ; b9 0c 00 - mov di, 050e9h ; bf e9 50 + mov di, 052ach ; bf ac 52 repne scasb ; f2 ae sal cx, 1 ; d1 e1 mov di, cx ; 89 cf - mov ax, word [cs:di+050f4h] ; 2e 8b 85 f4 50 + mov ax, word [cs:di+052b7h] ; 2e 8b 85 b7 52 jmp ax ; ff e0 push strict byte 00001h ; 6a 01 @@ -7208,17 +7367,17 @@ mov dx, ss ; 8c d2 lea ax, [bp-006h] ; 8d 46 fa - call 05078h ; e8 a9 fe + call 0523bh ; e8 a9 fe test ax, ax ; 85 c0 - jne short 051deh ; 75 0b + jne short 053a1h ; 75 0b push 005efh ; 68 ef 05 push strict byte 00007h ; 6a 07 - call 01972h ; e8 97 c7 + call 01972h ; e8 d4 c5 add sp, strict byte 00004h ; 83 c4 04 cmp byte [bp-006h], 000h ; 80 7e fa 00 - je short 051eah ; 74 06 + je short 053adh ; 74 06 cmp byte [bp-008h], 0f0h ; 80 7e f8 f0 - je short 051f0h ; 74 06 + je short 053b3h ; 74 06 cmp byte [bp-008h], 0e0h ; 80 7e f8 e0 - jne short 051f4h ; 75 04 + jne short 053b7h ; 75 04 mov byte [bp-008h], 000h ; c6 46 f8 00 movzx dx, byte [bp-006h] ; 0f b6 56 fa @@ -7227,5 +7386,5 @@ or dx, ax ; 09 c2 mov word [bp+012h], dx ; 89 56 12 - jmp near 053edh ; e9 e6 01 + jmp near 055b0h ; e9 e6 01 or word [bp+01ch], 00200h ; 81 4e 1c 00 02 push strict byte 00000h ; 6a 00 @@ -7234,15 +7393,15 @@ mov dx, ss ; 8c d2 lea ax, [bp-006h] ; 8d 46 fa - call 05078h ; e8 5d fe + call 0523bh ; e8 5d fe test ax, ax ; 85 c0 - jne short 05226h ; 75 07 + jne short 053e9h ; 75 07 or word [bp+01ch], strict byte 00040h ; 83 4e 1c 40 - jmp near 053edh ; e9 c7 01 + jmp near 055b0h ; e9 c7 01 cmp byte [bp-006h], 000h ; 80 7e fa 00 - je short 05232h ; 74 06 + je short 053f5h ; 74 06 cmp byte [bp-008h], 0f0h ; 80 7e f8 f0 - je short 05238h ; 74 06 + je short 053fbh ; 74 06 cmp byte [bp-008h], 0e0h ; 80 7e f8 e0 - jne short 0523ch ; 75 04 + jne short 053ffh ; 75 04 mov byte [bp-008h], 000h ; c6 46 f8 00 movzx dx, byte [bp-006h] ; 0f b6 56 fa @@ -7252,11 +7411,11 @@ mov word [bp+012h], dx ; 89 56 12 and word [bp+01ch], strict byte 0ffbfh ; 83 66 1c bf - jmp near 053edh ; e9 9a 01 + jmp near 055b0h ; e9 9a 01 mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 f4 c3 + call 01650h ; e8 31 c2 mov dx, word [bp+012h] ; 8b 56 12 mov dl, al ; 88 c2 - jmp short 05201h ; eb 9e + jmp short 053c4h ; eb 9e mov al, byte [bp+010h] ; 8a 46 10 movzx dx, al ; 0f b6 d0 @@ -7264,18 +7423,18 @@ shr ax, 008h ; c1 e8 08 xor ah, ah ; 30 e4 - call 04c1eh ; e8 aa f9 + call 04de1h ; e8 aa f9 test ax, ax ; 85 c0 - jne short 05285h ; 75 0d + jne short 05448h ; 75 0d mov ax, word [bp+012h] ; 8b 46 12 xor al, al ; 30 c0 or AL, strict byte 001h ; 0c 01 mov word [bp+012h], ax ; 89 46 12 - jmp near 053edh ; e9 68 01 + jmp near 055b0h ; e9 68 01 and word [bp+012h], 0ff00h ; 81 66 12 00 ff - jmp near 053edh ; e9 60 01 + jmp near 055b0h ; e9 60 01 mov ax, word [bp+012h] ; 8b 46 12 xor al, al ; 30 c0 or AL, strict byte 030h ; 0c 30 - jmp short 0527fh ; eb e9 + jmp short 05442h ; eb e9 mov byte [bp-004h], 002h ; c6 46 fc 02 xor cx, cx ; 31 c9 @@ -7290,15 +7449,15 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 052bdh ; 75 0d + jne short 05480h ; 75 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 052bdh ; 76 08 + jbe short 05480h ; 76 08 mov dx, 00080h ; ba 80 00 in AL, DX ; ec db 02ah, 0e4h ; sub ah, ah ; 2a e4 - jmp short 052a6h ; eb e9 + jmp short 05469h ; eb e9 test bx, bx ; 85 db - jbe short 05301h ; 76 40 + jbe short 054c4h ; 76 40 mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -7306,5 +7465,5 @@ ; sub ah, ah ; 2a e4 cmp ax, 000fah ; 3d fa 00 - jne short 05301h ; 75 35 + jne short 054c4h ; 75 35 mov bx, strict word 0ffffh ; bb ff ff mov dx, strict word 00064h ; ba 64 00 @@ -7313,15 +7472,15 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 052e6h ; 75 0d + jne short 054a9h ; 75 0d dec bx ; 4b test bx, bx ; 85 db - jbe short 052e6h ; 76 08 + jbe short 054a9h ; 76 08 mov dx, 00080h ; ba 80 00 in AL, DX ; ec db 02ah, 0e4h ; sub ah, ah ; 2a e4 - jmp short 052cfh ; eb e9 + jmp short 05492h ; eb e9 test bx, bx ; 85 db - jbe short 052f8h ; 76 0e + jbe short 054bbh ; 76 0e shr cx, 008h ; c1 e9 08 mov dx, strict word 00060h ; ba 60 00 @@ -7333,7 +7492,7 @@ dec byte [bp-004h] ; fe 4e fc cmp byte [bp-004h], 000h ; 80 7e fc 00 - jnbe short 052cch ; 77 cb + jnbe short 0548fh ; 77 cb mov word [bp+00ch], cx ; 89 4e 0c - jmp near 053edh ; e9 e6 00 + jmp near 055b0h ; e9 e6 00 push strict byte 00001h ; 6a 01 mov cx, ss ; 8c d1 @@ -7341,16 +7500,16 @@ mov dx, ss ; 8c d2 lea ax, [bp-006h] ; 8d 46 fa - call 05078h ; e8 62 fd + call 0523bh ; e8 62 fd test ax, ax ; 85 c0 - jne short 05325h ; 75 0b + jne short 054e8h ; 75 0b push 005efh ; 68 ef 05 push strict byte 00007h ; 6a 07 - call 01972h ; e8 50 c6 + call 01972h ; e8 8d c4 add sp, strict byte 00004h ; 83 c4 04 cmp byte [bp-006h], 000h ; 80 7e fa 00 - je near 051f4h ; 0f 84 c7 fe + je near 053b7h ; 0f 84 c7 fe cmp byte [bp-008h], 0f0h ; 80 7e f8 f0 - je near 051f0h ; 0f 84 bb fe - jmp near 051f4h ; e9 bc fe + je near 053b3h ; 0f 84 bb fe + jmp near 053b7h ; e9 bc fe or word [bp+01ch], 00200h ; 81 4e 1c 00 02 push strict byte 00000h ; 6a 00 @@ -7359,15 +7518,15 @@ mov dx, ss ; 8c d2 lea ax, [bp-006h] ; 8d 46 fa - call 05078h ; e8 2c fd + call 0523bh ; e8 2c fd test ax, ax ; 85 c0 - je near 0521fh ; 0f 84 cd fe + je near 053e2h ; 0f 84 cd fe cmp byte [bp-006h], 000h ; 80 7e fa 00 - je near 0523ch ; 0f 84 e2 fe + je near 053ffh ; 0f 84 e2 fe cmp byte [bp-008h], 0f0h ; 80 7e f8 f0 - je near 05238h ; 0f 84 d6 fe - jmp near 0523ch ; e9 d7 fe + je near 053fbh ; 0f 84 d6 fe + jmp near 053ffh ; e9 d7 fe mov dx, strict word 00017h ; ba 17 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 e2 c2 + call 01650h ; e8 1f c1 mov dx, word [bp+012h] ; 8b 56 12 mov dl, al ; 88 c2 @@ -7375,10 +7534,10 @@ mov dx, strict word 00018h ; ba 18 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 d1 c2 + call 01650h ; e8 0e c1 mov bh, al ; 88 c7 and bh, 073h ; 80 e7 73 mov dx, 00096h ; ba 96 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 c3 c2 + call 01650h ; e8 00 c1 and AL, strict byte 00ch ; 24 0c or bh, al ; 08 c7 @@ -7387,13 +7546,13 @@ movzx ax, bh ; 0f b6 c7 sal ax, 008h ; c1 e0 08 - jmp near 051ffh ; e9 60 fe + jmp near 053c2h ; e9 60 fe mov ax, word [bp+012h] ; 8b 46 12 xor ah, ah ; 30 e4 or ah, 080h ; 80 cc 80 - jmp near 0527fh ; e9 d5 fe - mov bx, 00da2h ; bb a2 0d + jmp near 05442h ; e9 d5 fe + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 7c c5 + call 01931h ; e8 b9 c3 mov ax, word [bp+012h] ; 8b 46 12 shr ax, 008h ; c1 e8 08 @@ -7401,10 +7560,10 @@ push 00613h ; 68 13 06 push strict byte 00004h ; 6a 04 - call 01972h ; e8 ae c5 + call 01972h ; e8 eb c3 add sp, strict byte 00006h ; 83 c4 06 - mov bx, 00da2h ; bb a2 0d + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 5f c5 + call 01931h ; e8 9c c3 mov ax, word [bp+00eh] ; 8b 46 0e push ax ; 50 @@ -7417,5 +7576,5 @@ push 0063bh ; 68 3b 06 push strict byte 00004h ; 6a 04 - call 01972h ; e8 88 c5 + call 01972h ; e8 c5 c3 add sp, strict byte 0000ch ; 83 c4 0c lea sp, [bp-002h] ; 8d 66 fe @@ -7423,5 +7582,5 @@ pop bp ; 5d retn ; c3 -set_geom_lba_: ; 0xf53f3 LB 0x9e +set_geom_lba_: ; 0xf55b6 LB 0x9e push si ; 56 push di ; 57 @@ -7435,12 +7594,12 @@ mov di, 000ffh ; bf ff 00 xor bx, bx ; 31 db - jmp short 05414h ; eb 05 + jmp short 055d7h ; eb 05 cmp bx, strict byte 00004h ; 83 fb 04 - jnl short 0542ah ; 7d 16 + jnl short 055edh ; 7d 16 cmp dx, word [bp-002h] ; 3b 56 fe - jnbe short 05420h ; 77 07 - jne short 05423h ; 75 08 + jnbe short 055e3h ; 77 07 + jne short 055e6h ; 75 08 cmp ax, word [bp-004h] ; 3b 46 fc - jc short 05423h ; 72 03 + jc short 055e6h ; 72 03 inc di ; 47 shr di, 1 ; d1 ef @@ -7448,18 +7607,18 @@ rcr ax, 1 ; d1 d8 inc bx ; 43 - jmp short 0540fh ; eb e5 + jmp short 055d2h ; eb e5 mov ax, di ; 89 f8 xor dx, dx ; 31 d2 mov bx, strict word 0003fh ; bb 3f 00 xor cx, cx ; 31 c9 - call 09569h ; e8 33 41 + call 09729h ; e8 30 41 mov bx, ax ; 89 c3 mov cx, dx ; 89 d1 mov ax, word [bp-004h] ; 8b 46 fc mov dx, word [bp-002h] ; 8b 56 fe - call 09530h ; e8 ed 40 + call 096f0h ; e8 ea 40 mov word [es:si+002h], ax ; 26 89 44 02 cmp ax, 00400h ; 3d 00 04 - jbe short 05452h ; 76 06 + jbe short 05615h ; 76 06 mov word [es:si+002h], 00400h ; 26 c7 44 02 00 04 mov word [es:si], di ; 26 89 3c @@ -7469,40 +7628,40 @@ pop si ; 5e retn ; c3 - sbb dx, word [di+041h] ; 1b 55 41 - push bp ; 55 - outsb ; 6e - push bp ; 55 - outsb ; 6e - push bp ; 55 - outsb ; 6e - push bp ; 55 - inc si ; 46 + ficom word [bp+004h] ; de 56 04 push di ; 57 - je short 054c5h ; 74 58 - je short 054c7h ; 74 58 - pop di ; 5f + xor word [bx+031h], dx ; 31 57 31 push di ; 57 - push cx ; 51 - pop ax ; 58 - je short 054cdh ; 74 58 - je short 054cfh ; 74 58 - push cx ; 51 - pop ax ; 58 - push cx ; 51 - pop ax ; 58 - je short 054d5h ; 74 58 - je short 054d7h ; 74 58 - aad 057h ; d5 57 - push cx ; 51 - pop ax ; 58 - je short 054ddh ; 74 58 - je short 054dfh ; 74 58 - push cx ; 51 - pop ax ; 58 - add ax, 07458h ; 05 58 74 - pop ax ; 58 - je short 054e7h ; 74 58 - je short 054e9h ; 74 58 -_int13_harddisk: ; 0xf5491 LB 0x441 + xor word [bx+009h], dx ; 31 57 09 + pop cx ; 59 + aaa ; 37 + pop dx ; 5a + aaa ; 37 + pop dx ; 5a + and bl, byte [bx+di+014h] ; 22 59 14 + pop dx ; 5a + aaa ; 37 + pop dx ; 5a + aaa ; 37 + pop dx ; 5a + adc AL, strict byte 05ah ; 14 5a + adc AL, strict byte 05ah ; 14 5a + aaa ; 37 + pop dx ; 5a + aaa ; 37 + pop dx ; 5a + cbw ; 98 + pop cx ; 59 + adc AL, strict byte 05ah ; 14 5a + aaa ; 37 + pop dx ; 5a + aaa ; 37 + pop dx ; 5a + adc AL, strict byte 05ah ; 14 5a + enter 03759h, 05ah ; c8 59 37 5a + aaa ; 37 + pop dx ; 5a + aaa ; 37 + pop dx ; 5a +_int13_harddisk: ; 0xf5654 LB 0x441 push bp ; 55 mov bp, sp ; 89 e5 @@ -7510,5 +7669,5 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 cc c1 + call 0166ch ; e8 09 c0 mov si, 00122h ; be 22 01 mov word [bp-004h], ax ; 89 46 fc @@ -7516,11 +7675,11 @@ mov dx, 0008eh ; ba 8e 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 ad c1 + call 0165eh ; e8 ea bf mov ax, word [bp+00eh] ; 8b 46 0e xor ah, ah ; 30 e4 cmp ax, 00080h ; 3d 80 00 - jc short 054c0h ; 72 05 + jc short 05683h ; 72 05 cmp ax, 00090h ; 3d 90 00 - jc short 054deh ; 72 1e + jc short 056a1h ; 72 1e mov ax, word [bp+00eh] ; 8b 46 0e xor ah, ah ; 30 e4 @@ -7532,7 +7691,7 @@ push 0066dh ; 68 6d 06 push strict byte 00004h ; 6a 04 - call 01972h ; e8 9a c4 + call 01972h ; e8 d7 c2 add sp, strict byte 0000ah ; 83 c4 0a - jmp near 0588fh ; e9 b1 03 + jmp near 05a52h ; e9 b1 03 mov ax, word [bp+00eh] ; 8b 46 0e xor ah, ah ; 30 e4 @@ -7543,5 +7702,5 @@ mov byte [bp-002h], dl ; 88 56 fe cmp dl, 010h ; 80 fa 10 - jc short 05507h ; 72 10 + jc short 056cah ; 72 10 push ax ; 50 mov ax, word [bp+016h] ; 8b 46 16 @@ -7550,20 +7709,20 @@ push 0065eh ; 68 5e 06 push 00698h ; 68 98 06 - jmp short 054d3h ; eb cc + jmp short 05696h ; eb cc mov bx, word [bp+016h] ; 8b 5e 16 shr bx, 008h ; c1 eb 08 cmp bx, strict byte 00018h ; 83 fb 18 - jnbe near 05874h ; 0f 87 60 03 + jnbe near 05a37h ; 0f 87 60 03 add bx, bx ; 01 db - jmp word [cs:bx+0545fh] ; 2e ff a7 5f 54 + jmp word [cs:bx+05622h] ; 2e ff a7 22 56 cmp byte [bp-002h], 008h ; 80 7e fe 08 - jnc near 0552ah ; 0f 83 07 00 + jnc near 056edh ; 0f 83 07 00 movzx ax, byte [bp-002h] ; 0f b6 46 fe - call 01c71h ; e8 47 c7 + call 01c71h ; e8 84 c5 mov byte [bp+017h], 000h ; c6 46 17 00 xor bx, bx ; 31 db mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 25 c1 + call 0165eh ; e8 62 bf and byte [bp+01ch], 0feh ; 80 66 1c fe mov sp, bp ; 89 ec @@ -7572,5 +7731,5 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 06 c1 + call 01650h ; e8 43 bf mov cl, al ; 88 c1 mov dx, word [bp+016h] ; 8b 56 16 @@ -7583,8 +7742,8 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 f7 c0 + call 0165eh ; e8 34 bf test cl, cl ; 84 c9 - je short 0552eh ; 74 c3 - jmp near 058abh ; e9 3d 03 + je short 056f1h ; 74 c3 + jmp near 05a6eh ; e9 3d 03 mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -7606,11 +7765,11 @@ mov ax, word [bp-00ch] ; 8b 46 f4 cmp ax, 00080h ; 3d 80 00 - jnbe short 055a9h ; 77 04 + jnbe short 0576ch ; 77 04 test ax, ax ; 85 c0 - jne short 055cch ; 75 23 - mov bx, 00da2h ; bb a2 0d + jne short 0578fh ; 75 23 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 7d c3 + call 01931h ; e8 ba c1 mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 @@ -7619,7 +7778,7 @@ push 006cah ; 68 ca 06 push strict byte 00004h ; 6a 04 - call 01972h ; e8 ac c3 + call 01972h ; e8 e9 c1 add sp, strict byte 00008h ; 83 c4 08 - jmp near 0588fh ; e9 c3 02 + jmp near 05a52h ; e9 c3 02 movzx ax, byte [bp-002h] ; 0f b6 46 fe imul ax, ax, strict byte 00018h ; 6b c0 18 @@ -7632,14 +7791,14 @@ mov word [bp-00ah], dx ; 89 56 f6 cmp di, ax ; 39 c7 - jnc short 055f9h ; 73 0c + jnc short 057bch ; 73 0c cmp cx, word [bp-008h] ; 3b 4e f8 - jbe short 055f9h ; 76 07 + jbe short 057bch ; 76 07 mov ax, word [bp-006h] ; 8b 46 fa cmp ax, dx ; 39 d0 - jbe short 05627h ; 76 2e - mov bx, 00da2h ; bb a2 0d + jbe short 057eah ; 76 2e + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 2d c3 + call 01931h ; e8 6a c1 push dword [bp-008h] ; 66 ff 76 f8 push di ; 57 @@ -7653,12 +7812,12 @@ push 006f2h ; 68 f2 06 push strict byte 00004h ; 6a 04 - call 01972h ; e8 51 c3 + call 01972h ; e8 8e c1 add sp, strict byte 00010h ; 83 c4 10 - jmp near 0588fh ; e9 68 02 + jmp near 05a52h ; e9 68 02 mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 cmp ax, strict word 00004h ; 3d 04 00 - jne short 05635h ; 75 03 - jmp near 0552ah ; e9 f5 fe + jne short 057f8h ; 75 03 + jmp near 056edh ; e9 f5 fe movzx bx, byte [bp-002h] ; 0f b6 5e fe imul bx, bx, strict byte 00018h ; 6b db 18 @@ -7666,15 +7825,15 @@ add bx, si ; 01 f3 cmp cx, word [es:bx+02ch] ; 26 3b 4f 2c - jne short 05656h ; 75 0f + jne short 05819h ; 75 0f mov ax, word [es:bx+030h] ; 26 8b 47 30 cmp ax, word [bp-00ah] ; 3b 46 f6 - jne short 05656h ; 75 06 + jne short 05819h ; 75 06 cmp byte [bp-002h], 008h ; 80 7e fe 08 - jc short 05686h ; 72 30 + jc short 05849h ; 72 30 mov ax, di ; 89 f8 xor dx, dx ; 31 d2 mov bx, cx ; 89 cb xor cx, cx ; 31 c9 - call 09569h ; e8 08 3f + call 09729h ; e8 05 3f xor bx, bx ; 31 db add ax, word [bp-008h] ; 03 46 f8 @@ -7682,5 +7841,5 @@ mov bx, word [bp-00ah] ; 8b 5e f6 xor cx, cx ; 31 c9 - call 09569h ; e8 f9 3e + call 09729h ; e8 f6 3e xor bx, bx ; 31 db add ax, word [bp-006h] ; 03 46 fa @@ -7735,9 +7894,9 @@ mov word [bp+016h], bx ; 89 5e 16 test dl, dl ; 84 d2 - je near 0552ah ; 0f 84 13 fe - mov bx, 00da2h ; bb a2 0d + je near 056edh ; 0f 84 13 fe + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 0f c2 + call 01931h ; e8 4c c0 movzx ax, dl ; 0f b6 c2 push ax ; 50 @@ -7748,19 +7907,19 @@ push 00739h ; 68 39 07 push strict byte 00004h ; 6a 04 - call 01972h ; e8 3a c2 + call 01972h ; e8 77 c0 add sp, strict byte 0000ah ; 83 c4 0a mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 or ah, 00ch ; 80 cc 0c - jmp near 05897h ; e9 51 01 - mov bx, 00da2h ; bb a2 0d + jmp near 05a5ah ; e9 51 01 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 e0 c1 + call 01931h ; e8 1d c0 push 0075ah ; 68 5a 07 push strict byte 00004h ; 6a 04 - call 01972h ; e8 19 c2 + call 01972h ; e8 56 c0 add sp, strict byte 00004h ; 83 c4 04 - jmp near 0552ah ; e9 cb fd + jmp near 056edh ; e9 cb fd movzx ax, byte [bp-002h] ; 0f b6 46 fe imul ax, ax, strict byte 00018h ; 6b c0 18 @@ -7805,5 +7964,5 @@ or dx, ax ; 09 c2 mov word [bp+012h], dx ; 89 56 12 - jmp near 0552ah ; e9 55 fd + jmp near 056edh ; e9 55 fd movzx ax, byte [bp-002h] ; 0f b6 46 fe cwd ; 99 @@ -7821,10 +7980,10 @@ and AL, strict byte 0c0h ; 24 c0 cmp AL, strict byte 040h ; 3c 40 - jne short 057fah ; 75 03 - jmp near 0552ah ; e9 30 fd + jne short 059bdh ; 75 03 + jmp near 056edh ; e9 30 fd mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 or ah, 0aah ; 80 cc aa - jmp near 05897h ; e9 92 00 + jmp near 05a5ah ; e9 92 00 movzx ax, byte [bp-002h] ; 0f b6 46 fe imul ax, ax, strict byte 00018h ; 6b c0 18 @@ -7840,8 +7999,8 @@ mov bx, word [bp-008h] ; 8b 5e f8 xor cx, cx ; 31 c9 - call 09569h ; e8 3a 3d + call 09729h ; e8 37 3d mov bx, word [bp-006h] ; 8b 5e fa xor cx, cx ; 31 c9 - call 09569h ; e8 32 3d + call 09729h ; e8 2f 3d mov word [bp-010h], ax ; 89 46 f0 mov word [bp-00eh], dx ; 89 56 f2 @@ -7852,9 +8011,9 @@ or ah, 003h ; 80 cc 03 mov word [bp+016h], ax ; 89 46 16 - jmp near 0552eh ; e9 dd fc - mov bx, 00da2h ; bb a2 0d + jmp near 056f1h ; e9 dd fc + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 d5 c0 + call 01931h ; e8 12 bf mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 @@ -7863,11 +8022,11 @@ push 00774h ; 68 74 07 push strict byte 00004h ; 6a 04 - call 01972h ; e8 04 c1 + call 01972h ; e8 41 bf add sp, strict byte 00008h ; 83 c4 08 - jmp near 0552ah ; e9 b6 fc - mov bx, 00da2h ; bb a2 0d + jmp near 056edh ; e9 b6 fc + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 b2 c0 + call 01931h ; e8 ef be mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 @@ -7875,5 +8034,5 @@ push 0065eh ; 68 5e 06 push 007a7h ; 68 a7 07 - jmp near 055c1h ; e9 32 fd + jmp near 05784h ; e9 32 fd mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -7885,23 +8044,34 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 b3 bd + call 0165eh ; e8 f0 bb or byte [bp+01ch], 001h ; 80 4e 1c 01 - jmp near 0553dh ; e9 8b fc - insw ; 6d - pop cx ; 59 - test word [bx+di-07bh], bx ; 85 59 85 - pop cx ; 59 - test word [bx+di+034h], bx ; 85 59 34 - pop bp ; 5d - enter 0855ah, 059h ; c8 5a 85 59 - into ; ce - pop dx ; 5a - xor AL, strict byte 05dh ; 34 5d - sbb word [di-07dh], strict byte 0005dh ; 83 5d 83 5d - sbb word [di-07dh], strict byte 0005dh ; 83 5d 83 5d - dec bx ; 4b - pop bp ; 5d - sbb word [di-07dh], strict byte 0005dh ; 83 5d 83 5d -_int13_harddisk_ext: ; 0xf58d2 LB 0x4cc + jmp near 05700h ; e9 8b fc + xor byte [bp+di+048h], bl ; 30 5b 48 + pop bx ; 5b + dec ax ; 48 + pop bx ; 5b + dec ax ; 48 + pop bx ; 5b + neg word [bp-075h] ; f7 5e 8b + pop sp ; 5c + dec ax ; 48 + pop bx ; 5b + xchg cx, ax ; 91 + pop sp ; 5c + neg word [bp+046h] ; f7 5e 46 + pop di ; 5f + inc si ; 46 + pop di ; 5f + inc si ; 46 + pop di ; 5f + inc si ; 46 + pop di ; 5f + push CS ; 0e + pop di ; 5f + inc si ; 46 + pop di ; 5f + inc si ; 46 + pop di ; 5f +_int13_harddisk_ext: ; 0xf5a95 LB 0x4cc push bp ; 55 mov bp, sp ; 89 e5 @@ -7909,9 +8079,9 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 8b bd + call 0166ch ; e8 c8 bb mov word [bp-014h], ax ; 89 46 ec mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 7f bd + call 0166ch ; e8 bc bb mov si, 00122h ; be 22 01 mov word [bp-026h], ax ; 89 46 da @@ -7919,11 +8089,11 @@ mov dx, 0008eh ; ba 8e 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 60 bd + call 0165eh ; e8 9d bb mov ax, word [bp+00eh] ; 8b 46 0e xor ah, ah ; 30 e4 cmp ax, 00080h ; 3d 80 00 - jc short 0590dh ; 72 05 + jc short 05ad0h ; 72 05 cmp ax, 00090h ; 3d 90 00 - jc short 0592bh ; 72 1e + jc short 05aeeh ; 72 1e mov ax, word [bp+00eh] ; 8b 46 0e xor ah, ah ; 30 e4 @@ -7935,7 +8105,7 @@ push 0066dh ; 68 6d 06 push strict byte 00004h ; 6a 04 - call 01972h ; e8 4d c0 + call 01972h ; e8 8a be add sp, strict byte 0000ah ; 83 c4 0a - jmp near 05d61h ; e9 36 04 + jmp near 05f24h ; e9 36 04 mov ax, word [bp+00eh] ; 8b 46 0e xor ah, ah ; 30 e4 @@ -7945,5 +8115,5 @@ mov cl, byte [es:bx+0011fh] ; 26 8a 8f 1f 01 cmp cl, 010h ; 80 f9 10 - jc short 05951h ; 72 10 + jc short 05b14h ; 72 10 push ax ; 50 mov ax, word [bp+016h] ; 8b 46 16 @@ -7952,14 +8122,14 @@ push 007d5h ; 68 d5 07 push 00698h ; 68 98 06 - jmp short 05920h ; eb cf + jmp short 05ae3h ; eb cf mov bx, word [bp+016h] ; 8b 5e 16 shr bx, 008h ; c1 eb 08 sub bx, strict byte 00041h ; 83 eb 41 cmp bx, strict byte 0000fh ; 83 fb 0f - jnbe near 05d83h ; 0f 87 22 04 + jnbe near 05f46h ; 0f 87 22 04 add bx, bx ; 01 db mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 - jmp word [cs:bx+058b2h] ; 2e ff a7 b2 58 + jmp word [cs:bx+05a75h] ; 2e ff a7 75 5a mov word [bp+010h], 0aa55h ; c7 46 10 55 aa mov ax, word [bp+016h] ; 8b 46 16 @@ -7968,5 +8138,5 @@ mov word [bp+016h], ax ; 89 46 16 mov word [bp+014h], strict word 00007h ; c7 46 14 07 00 - jmp near 05d38h ; e9 b3 03 + jmp near 05efbh ; e9 b3 03 mov bx, word [bp+00ah] ; 8b 5e 0a mov es, [bp+004h] ; 8e 46 04 @@ -7983,5 +8153,5 @@ mov ax, word [es:bx+00eh] ; 26 8b 47 0e or ax, word [bp-00ah] ; 0b 46 f6 - je short 059c6h ; 74 11 + je short 05b89h ; 74 11 mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 @@ -7990,5 +8160,5 @@ push 007e8h ; 68 e8 07 push strict byte 00007h ; 6a 07 - jmp short 05a10h ; eb 4a + jmp short 05bd3h ; eb 4a mov es, [bp-010h] ; 8e 46 f0 mov ax, word [es:di+008h] ; 26 8b 45 08 @@ -8002,13 +8172,13 @@ mov ch, byte [es:bx+01eh] ; 26 8a 6f 1e cmp ax, word [es:bx+034h] ; 26 3b 47 34 - jnbe short 059f6h ; 77 0b - jne short 05a19h ; 75 2c + jnbe short 05bb9h ; 77 0b + jne short 05bdch ; 75 2c mov dx, word [bp-00ah] ; 8b 56 f6 cmp dx, word [es:bx+032h] ; 26 3b 57 32 - jc short 05a19h ; 72 23 - mov bx, 00da2h ; bb a2 0d + jc short 05bdch ; 72 23 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 30 bf + call 01931h ; e8 6d bd mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 @@ -8017,14 +8187,14 @@ push 00811h ; 68 11 08 push strict byte 00004h ; 6a 04 - call 01972h ; e8 5f bf + call 01972h ; e8 9c bd add sp, strict byte 00008h ; 83 c4 08 - jmp near 05d61h ; e9 48 03 + jmp near 05f24h ; e9 48 03 mov dx, word [bp+016h] ; 8b 56 16 shr dx, 008h ; c1 ea 08 mov word [bp-00ch], dx ; 89 56 f4 cmp dx, strict byte 00044h ; 83 fa 44 - je near 05d34h ; 0f 84 0b 03 + je near 05ef7h ; 0f 84 0b 03 cmp dx, strict byte 00047h ; 83 fa 47 - je near 05d34h ; 0f 84 04 03 + je near 05ef7h ; 0f 84 04 03 mov es, [bp-026h] ; 8e 46 da db 066h, 026h, 0c7h, 044h, 014h, 000h, 000h, 000h, 000h @@ -8058,9 +8228,9 @@ mov word [es:di+002h], ax ; 26 89 45 02 test dl, dl ; 84 d2 - je near 05d34h ; 0f 84 97 02 - mov bx, 00da2h ; bb a2 0d + je near 05ef7h ; 0f 84 97 02 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 89 be + call 01931h ; e8 c6 bc movzx ax, dl ; 0f b6 c2 push ax ; 50 @@ -8069,12 +8239,12 @@ push 00739h ; 68 39 07 push strict byte 00004h ; 6a 04 - call 01972h ; e8 b8 be + call 01972h ; e8 f5 bc add sp, strict byte 0000ah ; 83 c4 0a mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 or ah, 00ch ; 80 cc 0c - jmp near 05d69h ; e9 a1 02 + jmp near 05f2ch ; e9 a1 02 or ah, 0b2h ; 80 cc b2 - jmp near 05d69h ; e9 9b 02 + jmp near 05f2ch ; e9 9b 02 mov bx, word [bp+00ah] ; 8b 5e 0a mov ax, word [bp+004h] ; 8b 46 04 @@ -8086,6 +8256,6 @@ mov word [bp-00eh], ax ; 89 46 f2 cmp ax, strict word 0001ah ; 3d 1a 00 - jc near 05d61h ; 0f 82 76 02 - jc near 05b72h ; 0f 82 83 00 + jc near 05f24h ; 0f 82 76 02 + jc near 05d35h ; 0f 82 83 00 movzx ax, cl ; 0f b6 c1 imul ax, ax, strict byte 00018h ; 6b c0 18 @@ -8125,5 +8295,5 @@ ; mov dword [es:di+014h], strict dword 000000000h ; 66 26 c7 45 14 00 00 00 00 cmp word [bp-00eh], strict byte 0001eh ; 83 7e f2 1e - jc near 05c7eh ; 0f 82 04 01 + jc near 05e41h ; 0f 82 04 01 mov es, [bp-004h] ; 8e 46 fc mov word [es:bx], strict word 0001eh ; 26 c7 07 1e 00 @@ -8151,7 +8321,7 @@ mov al, byte [es:di+023h] ; 26 8a 45 23 test al, al ; 84 c0 - jne short 05bd0h ; 75 04 + jne short 05d93h ; 75 04 xor dx, dx ; 31 d2 - jmp short 05bd3h ; eb 03 + jmp short 05d96h ; eb 03 mov dx, strict word 00008h ; ba 08 00 or dl, 010h ; 80 ca 10 @@ -8168,7 +8338,7 @@ or word [bp-008h], dx ; 09 56 f8 cmp AL, strict byte 003h ; 3c 03 - jne short 05bf9h ; 75 05 + jne short 05dbch ; 75 05 mov ax, strict word 00003h ; b8 03 00 - jmp short 05bfbh ; eb 02 + jmp short 05dbeh ; eb 02 xor ax, ax ; 31 c0 or word [bp-008h], ax ; 09 46 f8 @@ -8195,19 +8365,19 @@ xor ch, ch ; 30 ed mov byte [bp-002h], ch ; 88 6e fe - jmp short 05c5fh ; eb 06 + jmp short 05e22h ; eb 06 cmp byte [bp-002h], 00fh ; 80 7e fe 0f - jnc short 05c74h ; 73 15 + jnc short 05e37h ; 73 15 movzx dx, byte [bp-002h] ; 0f b6 56 fe add dx, 00312h ; 81 c2 12 03 mov ax, word [bp-014h] ; 8b 46 ec - call 01650h ; e8 e3 b9 + call 01650h ; e8 20 b8 add ch, al ; 00 c5 inc byte [bp-002h] ; fe 46 fe - jmp short 05c59h ; eb e5 + jmp short 05e1ch ; eb e5 neg ch ; f6 dd mov es, [bp-026h] ; 8e 46 da mov byte [es:si+001ffh], ch ; 26 88 ac ff 01 cmp word [bp-00eh], strict byte 00042h ; 83 7e f2 42 - jc near 05d34h ; 0f 82 ae 00 + jc near 05ef7h ; 0f 82 ae 00 movzx ax, cl ; 0f b6 c1 cwd ; 99 @@ -8227,5 +8397,5 @@ mov word [es:bx+022h], strict word 00000h ; 26 c7 47 22 00 00 test al, al ; 84 c0 - jne short 05cc6h ; 75 09 + jne short 05e89h ; 75 09 db 066h, 026h, 0c7h, 047h, 024h, 049h, 053h, 041h, 020h ; mov dword [es:bx+024h], strict dword 020415349h ; 66 26 c7 47 24 49 53 41 20 @@ -8236,5 +8406,5 @@ ; mov dword [es:bx+02ch], strict dword 020202020h ; 66 26 c7 47 2c 20 20 20 20 test al, al ; 84 c0 - jne short 05cf2h ; 75 13 + jne short 05eb5h ; 75 13 mov word [es:bx+030h], dx ; 26 89 57 30 db 066h, 026h, 0c7h, 047h, 032h, 000h, 000h, 000h, 000h @@ -8251,15 +8421,15 @@ xor cl, cl ; 30 c9 mov CH, strict byte 01eh ; b5 1e - jmp short 05d19h ; eb 05 + jmp short 05edch ; eb 05 cmp ch, 040h ; 80 fd 40 - jnc short 05d2bh ; 73 12 + jnc short 05eeeh ; 73 12 movzx dx, ch ; 0f b6 d5 add dx, word [bp+00ah] ; 03 56 0a mov ax, word [bp+004h] ; 8b 46 04 - call 01650h ; e8 2b b9 + call 01650h ; e8 68 b7 add cl, al ; 00 c1 db 0feh, 0c5h ; inc ch ; fe c5 - jmp short 05d14h ; eb e9 + jmp short 05ed7h ; eb e9 neg cl ; f6 d9 mov es, [bp-004h] ; 8e 46 fc @@ -8269,5 +8439,5 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 1b b9 + call 0165eh ; e8 58 b7 and byte [bp+01ch], 0feh ; 80 66 1c fe mov sp, bp ; 89 ec @@ -8275,12 +8445,12 @@ retn ; c3 cmp ax, strict word 00006h ; 3d 06 00 - je short 05d34h ; 74 e4 + je short 05ef7h ; 74 e4 cmp ax, strict word 00001h ; 3d 01 00 - jc short 05d61h ; 72 0c - jbe short 05d34h ; 76 dd + jc short 05f24h ; 72 0c + jbe short 05ef7h ; 76 dd cmp ax, strict word 00003h ; 3d 03 00 - jc short 05d61h ; 72 05 + jc short 05f24h ; 72 05 cmp ax, strict word 00004h ; 3d 04 00 - jbe short 05d34h ; 76 d3 + jbe short 05ef7h ; 76 d3 mov ax, word [bp+016h] ; 8b 46 16 xor ah, ah ; 30 e4 @@ -8292,11 +8462,11 @@ mov dx, strict word 00074h ; ba 74 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 e1 b8 + call 0165eh ; e8 1e b7 or byte [bp+01ch], 001h ; 80 4e 1c 01 - jmp short 05d47h ; eb c4 - mov bx, 00da2h ; bb a2 0d + jmp short 05f0ah ; eb c4 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 a3 bb + call 01931h ; e8 e0 b9 mov ax, word [bp+016h] ; 8b 46 16 shr ax, 008h ; c1 e8 08 @@ -8304,6 +8474,6 @@ push 007d5h ; 68 d5 07 push 007a7h ; 68 a7 07 - jmp near 05a0eh ; e9 70 fc -_int14_function: ; 0xf5d9e LB 0x155 + jmp near 05bd1h ; e9 70 fc +_int14_function: ; 0xf5f61 LB 0x155 push bp ; 55 mov bp, sp ; 89 e5 @@ -8313,5 +8483,5 @@ add dx, dx ; 01 d2 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 be b8 + call 0166ch ; e8 fb b6 mov si, ax ; 89 c6 mov bx, ax ; 89 c3 @@ -8319,21 +8489,21 @@ add dx, strict byte 0007ch ; 83 c2 7c mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 92 b8 + call 01650h ; e8 cf b6 mov cl, al ; 88 c1 cmp word [bp+00eh], strict byte 00004h ; 83 7e 0e 04 - jnc near 05ee9h ; 0f 83 21 01 + jnc near 060ach ; 0f 83 21 01 test si, si ; 85 f6 - jbe near 05ee9h ; 0f 86 1b 01 + jbe near 060ach ; 0f 86 1b 01 mov al, byte [bp+013h] ; 8a 46 13 cmp AL, strict byte 001h ; 3c 01 - jc short 05de6h ; 72 11 - jbe short 05e3ah ; 76 63 + jc short 05fa9h ; 72 11 + jbe short 05ffdh ; 76 63 cmp AL, strict byte 003h ; 3c 03 - je near 05ed2h ; 0f 84 f5 00 + je near 06095h ; 0f 84 f5 00 cmp AL, strict byte 002h ; 3c 02 - je near 05e88h ; 0f 84 a5 00 - jmp near 05ee3h ; e9 fd 00 + je near 0604bh ; 0f 84 a5 00 + jmp near 060a6h ; e9 fd 00 test al, al ; 84 c0 - jne near 05ee3h ; 0f 85 f7 00 + jne near 060a6h ; 0f 85 f7 00 lea dx, [bx+003h] ; 8d 57 03 in AL, DX ; ec @@ -8367,5 +8537,5 @@ ; sub ah, ah ; 2a e4 mov byte [bp+012h], al ; 88 46 12 - jmp near 05ec4h ; e9 97 00 + jmp near 06087h ; e9 97 00 mov AL, strict byte 017h ; b0 17 mov dx, bx ; 89 da @@ -8374,8 +8544,8 @@ mov AL, strict byte 004h ; b0 04 out DX, AL ; ee - jmp short 05e0fh ; eb d5 + jmp short 05fd2h ; eb d5 mov dx, strict word 0006ch ; ba 6c 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 29 b8 + call 0166ch ; e8 66 b6 mov si, ax ; 89 c6 lea dx, [bx+005h] ; 8d 57 05 @@ -8385,18 +8555,18 @@ and ax, strict word 00060h ; 25 60 00 cmp ax, strict word 00060h ; 3d 60 00 - je short 05e6ah ; 74 17 + je short 0602dh ; 74 17 test cl, cl ; 84 c9 - je short 05e6ah ; 74 13 + je short 0602dh ; 74 13 mov dx, strict word 0006ch ; ba 6c 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 0c b8 + call 0166ch ; e8 49 b6 cmp ax, si ; 39 f0 - je short 05e45h ; 74 e1 + je short 06008h ; 74 e1 mov si, ax ; 89 c6 db 0feh, 0c9h ; dec cl ; fe c9 - jmp short 05e45h ; eb db + jmp short 06008h ; eb db test cl, cl ; 84 c9 - je short 05e74h ; 74 06 + je short 06037h ; 74 06 mov al, byte [bp+012h] ; 8a 46 12 mov dx, bx ; 89 da @@ -8408,11 +8578,11 @@ mov byte [bp+013h], al ; 88 46 13 test cl, cl ; 84 c9 - jne short 05ec4h ; 75 43 + jne short 06087h ; 75 43 or AL, strict byte 080h ; 0c 80 mov byte [bp+013h], al ; 88 46 13 - jmp short 05ec4h ; eb 3c + jmp short 06087h ; eb 3c mov dx, strict word 0006ch ; ba 6c 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 db b7 + call 0166ch ; e8 18 b6 mov si, ax ; 89 c6 lea dx, [bx+005h] ; 8d 57 05 @@ -8421,18 +8591,18 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 05eb4h ; 75 17 + jne short 06077h ; 75 17 test cl, cl ; 84 c9 - je short 05eb4h ; 74 13 + je short 06077h ; 74 13 mov dx, strict word 0006ch ; ba 6c 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 c2 b7 + call 0166ch ; e8 ff b5 cmp ax, si ; 39 f0 - je short 05e93h ; 74 e5 + je short 06056h ; 74 e5 mov si, ax ; 89 c6 db 0feh, 0c9h ; dec cl ; fe c9 - jmp short 05e93h ; eb df + jmp short 06056h ; eb df test cl, cl ; 84 c9 - je short 05ecah ; 74 12 + je short 0608dh ; 74 12 mov byte [bp+013h], 000h ; c6 46 13 00 mov dx, bx ; 89 da @@ -8442,10 +8612,10 @@ mov byte [bp+012h], al ; 88 46 12 and byte [bp+01ch], 0feh ; 80 66 1c fe - jmp short 05eedh ; eb 23 + jmp short 060b0h ; eb 23 lea dx, [bx+005h] ; 8d 57 05 in AL, DX ; ec db 02ah, 0e4h ; sub ah, ah ; 2a e4 - jmp short 05e83h ; eb b1 + jmp short 06046h ; eb b1 lea dx, [si+005h] ; 8d 54 05 in AL, DX ; ec @@ -8457,7 +8627,7 @@ db 02ah, 0e4h ; sub ah, ah ; 2a e4 - jmp short 05ec1h ; eb de + jmp short 06084h ; eb de or byte [bp+01ch], 001h ; 80 4e 1c 01 - jmp short 05eedh ; eb 04 + jmp short 060b0h ; eb 04 or byte [bp+01ch], 001h ; 80 4e 1c 01 lea sp, [bp-002h] ; 8d 66 fe @@ -8465,5 +8635,5 @@ pop bp ; 5d retn ; c3 -set_enable_a20_: ; 0xf5ef3 LB 0x2c +set_enable_a20_: ; 0xf60b6 LB 0x2c push bp ; 55 mov bp, sp ; 89 e5 @@ -8478,8 +8648,8 @@ mov cl, al ; 88 c1 test bx, bx ; 85 db - je short 05f0ch ; 74 05 + je short 060cfh ; 74 05 or AL, strict byte 002h ; 0c 02 out DX, AL ; ee - jmp short 05f0fh ; eb 03 + jmp short 060d2h ; eb 03 and AL, strict byte 0fdh ; 24 fd out DX, AL ; ee @@ -8494,5 +8664,5 @@ pop bp ; 5d retn ; c3 -set_e820_range_: ; 0xf5f1f LB 0x8c +set_e820_range_: ; 0xf60e2 LB 0x8c push si ; 56 push bp ; 55 @@ -8523,8 +8693,8 @@ retn 0000ah ; c2 0a 00 db 0ech, 0e9h, 0d8h, 0c1h, 0c0h, 0bfh, 091h, 090h, 089h, 088h, 087h, 083h, 052h, 04fh, 041h, 024h - db 000h, 04ah, 064h, 0eah, 05fh, 0fdh, 05fh, 092h, 060h, 098h, 060h, 09dh, 060h, 0a2h, 060h, 044h - db 061h, 0e1h, 062h, 007h, 063h, 08bh, 060h, 08bh, 060h, 0d4h, 063h, 0fch, 063h, 00fh, 064h, 01eh - db 064h, 092h, 060h, 025h, 064h -_int15_function: ; 0xf5fab LB 0x4cd + db 000h, 00dh, 066h, 0adh, 061h, 0c0h, 061h, 055h, 062h, 05bh, 062h, 060h, 062h, 065h, 062h, 007h + db 063h, 0a4h, 064h, 0cah, 064h, 04eh, 062h, 04eh, 062h, 097h, 065h, 0bfh, 065h, 0d2h, 065h, 0e1h + db 065h, 055h, 062h, 0e8h, 065h +_int15_function: ; 0xf616e LB 0x4cd push bp ; 55 mov bp, sp ; 89 e5 @@ -8536,13 +8706,13 @@ shr ax, 008h ; c1 e8 08 cmp ax, 000ech ; 3d ec 00 - jnbe near 0644ah ; 0f 87 8b 04 + jnbe near 0660dh ; 0f 87 8b 04 push CS ; 0e pop ES ; 07 mov cx, strict word 00012h ; b9 12 00 - mov di, 05f76h ; bf 76 5f + mov di, 06139h ; bf 39 61 repne scasb ; f2 ae sal cx, 1 ; d1 e1 mov di, cx ; 89 cf - mov si, word [cs:di+05f87h] ; 2e 8b b5 87 5f + mov si, word [cs:di+0614ah] ; 2e 8b b5 4a 61 mov ax, word [bp+012h] ; 8b 46 12 xor ah, ah ; 30 e4 @@ -8557,28 +8727,28 @@ xor ah, ah ; 30 e4 cmp ax, 000c0h ; 3d c0 00 - jne near 0644ah ; 0f 85 54 04 + jne near 0660dh ; 0f 85 54 04 or byte [bp+018h], 001h ; 80 4e 18 01 - jmp near 063f3h ; e9 f6 03 + jmp near 065b6h ; e9 f6 03 mov dx, ax ; 89 c2 cmp ax, strict word 00001h ; 3d 01 00 - jc short 06012h ; 72 0e - jbe short 06026h ; 76 20 + jc short 061d5h ; 72 0e + jbe short 061e9h ; 76 20 cmp ax, strict word 00003h ; 3d 03 00 - je short 06053h ; 74 48 + je short 06216h ; 74 48 cmp ax, strict word 00002h ; 3d 02 00 - je short 06036h ; 74 26 - jmp short 06060h ; eb 4e + je short 061f9h ; 74 26 + jmp short 06223h ; eb 4e test ax, ax ; 85 c0 - jne short 06060h ; 75 4a + jne short 06223h ; 75 4a xor ax, ax ; 31 c0 - call 05ef3h ; e8 d8 fe + call 060b6h ; e8 d8 fe and byte [bp+018h], 0feh ; 80 66 18 fe mov byte [bp+013h], 000h ; c6 46 13 00 - jmp near 0608bh ; e9 65 00 + jmp near 0624eh ; e9 65 00 mov ax, strict word 00001h ; b8 01 00 - call 05ef3h ; e8 c7 fe + call 060b6h ; e8 c7 fe and byte [bp+018h], 0feh ; 80 66 18 fe mov byte [bp+013h], dh ; 88 76 13 - jmp near 0608bh ; e9 55 00 + jmp near 0624eh ; e9 55 00 mov dx, 00092h ; ba 92 00 in AL, DX ; ec @@ -8592,13 +8762,13 @@ and byte [bp+018h], 0feh ; 80 66 18 fe mov byte [bp+013h], ah ; 88 66 13 - jmp near 0608bh ; e9 38 00 + jmp near 0624eh ; e9 38 00 and byte [bp+018h], 0feh ; 80 66 18 fe mov byte [bp+013h], ah ; 88 66 13 mov word [bp+00ch], ax ; 89 46 0c - jmp near 0608bh ; e9 2b 00 - mov bx, 00da2h ; bb a2 0d + jmp near 0624eh ; e9 2b 00 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 c6 b8 + call 01931h ; e8 03 b7 mov ax, word [bp+012h] ; 8b 46 12 xor ah, ah ; 30 e4 @@ -8606,5 +8776,5 @@ push 00836h ; 68 36 08 push strict byte 00004h ; 6a 04 - call 01972h ; e8 f9 b8 + call 01972h ; e8 36 b7 add sp, strict byte 00006h ; 83 c4 06 or byte [bp+018h], 001h ; 80 4e 18 01 @@ -8619,36 +8789,36 @@ retn ; c3 mov word [bp+018h], bx ; 89 5e 18 - jmp near 0613eh ; e9 a6 00 + jmp near 06301h ; e9 a6 00 mov word [bp+018h], bx ; 89 5e 18 - jmp short 0608bh ; eb ee + jmp short 0624eh ; eb ee mov word [bp+018h], cx ; 89 4e 18 - jmp short 06088h ; eb e6 + jmp short 0624bh ; eb e6 test byte [bp+012h], 0ffh ; f6 46 12 ff - je short 06114h ; 74 6c + je short 062d7h ; 74 6c mov dx, 000a0h ; ba a0 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 9f b5 + call 01650h ; e8 dc b3 test AL, strict byte 001h ; a8 01 - jne near 063eah ; 0f 85 33 03 + jne near 065adh ; 0f 85 33 03 mov bx, strict word 00001h ; bb 01 00 mov dx, 000a0h ; ba a0 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 9b b5 + call 0165eh ; e8 d8 b3 mov bx, word [bp+014h] ; 8b 5e 14 mov dx, 00098h ; ba 98 00 mov ax, strict word 00040h ; b8 40 00 - call 0167ah ; e8 ab b5 + call 0167ah ; e8 e8 b3 mov bx, word [bp+00ch] ; 8b 5e 0c mov dx, 0009ah ; ba 9a 00 mov ax, strict word 00040h ; b8 40 00 - call 0167ah ; e8 9f b5 + call 0167ah ; e8 dc b3 mov bx, word [bp+00eh] ; 8b 5e 0e mov dx, 0009ch ; ba 9c 00 mov ax, strict word 00040h ; b8 40 00 - call 0167ah ; e8 93 b5 + call 0167ah ; e8 d0 b3 mov bx, word [bp+010h] ; 8b 5e 10 mov dx, 0009eh ; ba 9e 00 mov ax, strict word 00040h ; b8 40 00 - call 0167ah ; e8 87 b5 + call 0167ah ; e8 c4 b3 and byte [bp+018h], 0feh ; 80 66 18 fe mov dx, 000a1h ; ba a1 00 @@ -8659,21 +8829,21 @@ out DX, AL ; ee mov ax, strict word 0000bh ; b8 0b 00 - call 016ach ; e8 a6 b5 + call 016ach ; e8 e3 b3 or AL, strict byte 040h ; 0c 40 movzx dx, al ; 0f b6 d0 mov ax, strict word 0000bh ; b8 0b 00 - call 016c9h ; e8 b8 b5 - jmp near 0608bh ; e9 77 ff + call 016c9h ; e8 f5 b3 + jmp near 0624eh ; e9 77 ff cmp ax, strict word 00001h ; 3d 01 00 - jne short 06132h ; 75 19 + jne short 062f5h ; 75 19 xor bx, bx ; 31 db mov dx, 000a0h ; ba a0 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 3a b5 + call 0165eh ; e8 77 b3 and byte [bp+018h], 0feh ; 80 66 18 fe mov ax, strict word 0000bh ; b8 0b 00 - call 016ach ; e8 7e b5 + call 016ach ; e8 bb b3 and AL, strict byte 0bfh ; 24 bf - jmp short 06108h ; eb d6 + jmp short 062cbh ; eb d6 mov word [bp+018h], bx ; 89 5e 18 mov ax, dx ; 89 d0 @@ -8683,8 +8853,8 @@ or dx, ax ; 09 c2 mov word [bp+012h], dx ; 89 56 12 - jmp near 0608bh ; e9 47 ff + jmp near 0624eh ; e9 47 ff cli ; fa mov ax, strict word 00001h ; b8 01 00 - call 05ef3h ; e8 a8 fd + call 060b6h ; e8 a8 fd mov di, ax ; 89 c7 mov ax, word [bp+014h] ; 8b 46 14 @@ -8696,5 +8866,5 @@ mov byte [bp-006h], dl ; 88 56 fa cmp cx, ax ; 39 c1 - jnc short 0616ah ; 73 05 + jnc short 0632dh ; 73 05 db 0feh, 0c2h ; inc dl ; fe c2 @@ -8704,50 +8874,50 @@ mov ax, word [bp+014h] ; 8b 46 14 mov bx, strict word 0002fh ; bb 2f 00 - call 0167ah ; e8 01 b5 + call 0167ah ; e8 3e b3 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0000ah ; 83 c2 0a mov ax, word [bp+014h] ; 8b 46 14 mov bx, cx ; 89 cb - call 0167ah ; e8 f3 b4 + call 0167ah ; e8 30 b3 movzx bx, byte [bp-006h] ; 0f b6 5e fa mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0000ch ; 83 c2 0c mov ax, word [bp+014h] ; 8b 46 14 - call 0165eh ; e8 c7 b4 + call 0165eh ; e8 04 b3 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0000dh ; 83 c2 0d mov ax, word [bp+014h] ; 8b 46 14 mov bx, 00093h ; bb 93 00 - call 0165eh ; e8 b8 b4 + call 0165eh ; e8 f5 b2 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0000eh ; 83 c2 0e mov ax, word [bp+014h] ; 8b 46 14 xor bx, bx ; 31 db - call 0167ah ; e8 c6 b4 + call 0167ah ; e8 03 b3 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 00020h ; 83 c2 20 mov ax, word [bp+014h] ; 8b 46 14 mov bx, strict word 0ffffh ; bb ff ff - call 0167ah ; e8 b7 b4 + call 0167ah ; e8 f4 b2 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 00022h ; 83 c2 22 mov ax, word [bp+014h] ; 8b 46 14 xor bx, bx ; 31 db - call 0167ah ; e8 a9 b4 + call 0167ah ; e8 e6 b2 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 00024h ; 83 c2 24 mov ax, word [bp+014h] ; 8b 46 14 mov bx, strict word 0000fh ; bb 0f 00 - call 0165eh ; e8 7e b4 + call 0165eh ; e8 bb b2 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 00025h ; 83 c2 25 mov ax, word [bp+014h] ; 8b 46 14 mov bx, 0009bh ; bb 9b 00 - call 0165eh ; e8 6f b4 + call 0165eh ; e8 ac b2 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 00026h ; 83 c2 26 mov ax, word [bp+014h] ; 8b 46 14 xor bx, bx ; 31 db - call 0167ah ; e8 7d b4 + call 0167ah ; e8 ba b2 mov ax, ss ; 8c d0 mov cx, ax ; 89 c1 @@ -8759,25 +8929,25 @@ mov ax, word [bp+014h] ; 8b 46 14 mov bx, strict word 0ffffh ; bb ff ff - call 0167ah ; e8 61 b4 + call 0167ah ; e8 9e b2 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0002ah ; 83 c2 2a mov ax, word [bp+014h] ; 8b 46 14 mov bx, cx ; 89 cb - call 0167ah ; e8 53 b4 + call 0167ah ; e8 90 b2 movzx bx, byte [bp-008h] ; 0f b6 5e f8 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0002ch ; 83 c2 2c mov ax, word [bp+014h] ; 8b 46 14 - call 0165eh ; e8 27 b4 + call 0165eh ; e8 64 b2 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0002dh ; 83 c2 2d mov ax, word [bp+014h] ; 8b 46 14 mov bx, 00093h ; bb 93 00 - call 0165eh ; e8 18 b4 + call 0165eh ; e8 55 b2 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0002eh ; 83 c2 2e mov ax, word [bp+014h] ; 8b 46 14 xor bx, bx ; 31 db - call 0167ah ; e8 26 b4 + call 0167ah ; e8 63 b2 mov si, word [bp+006h] ; 8b 76 06 mov es, [bp+014h] ; 8e 46 14 @@ -8790,5 +8960,5 @@ mov word [00467h], sp ; 89 26 67 04 mov [00469h], ss ; 8c 16 69 04 - call 06270h ; e8 00 00 + call 06433h ; e8 00 00 pop di ; 5f add di, strict byte 0001bh ; 83 c7 1b @@ -8813,5 +8983,5 @@ cld ; fc rep movsw ; f3 a5 - call 062a4h ; e8 00 00 + call 06467h ; e8 00 00 pop ax ; 58 push 0f000h ; 68 00 f0 @@ -8834,51 +9004,51 @@ pop DS ; 1f mov ax, di ; 89 f8 - call 05ef3h ; e8 1e fc + call 060b6h ; e8 1e fc sti ; fb mov byte [bp+013h], 000h ; c6 46 13 00 and byte [bp+018h], 0feh ; 80 66 18 fe - jmp near 0608bh ; e9 aa fd + jmp near 0624eh ; e9 aa fd mov ax, strict word 00031h ; b8 31 00 - call 016ach ; e8 c5 b3 + call 016ach ; e8 02 b2 xor ah, ah ; 30 e4 mov dx, ax ; 89 c2 sal dx, 008h ; c1 e2 08 mov ax, strict word 00030h ; b8 30 00 - call 016ach ; e8 b8 b3 + call 016ach ; e8 f5 b1 xor ah, ah ; 30 e4 or dx, ax ; 09 c2 mov word [bp+012h], dx ; 89 56 12 cmp dx, strict byte 0ffc0h ; 83 fa c0 - jbe short 062dah ; 76 da + jbe short 0649dh ; 76 da mov word [bp+012h], strict word 0ffc0h ; c7 46 12 c0 ff - jmp short 062dah ; eb d3 + jmp short 0649dh ; eb d3 cli ; fa mov ax, strict word 00001h ; b8 01 00 - call 05ef3h ; e8 e5 fb + call 060b6h ; e8 e5 fb mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 00038h ; 83 c2 38 mov ax, word [bp+014h] ; 8b 46 14 mov bx, strict word 0ffffh ; bb ff ff - call 0167ah ; e8 5d b3 + call 0167ah ; e8 9a b1 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0003ah ; 83 c2 3a mov ax, word [bp+014h] ; 8b 46 14 xor bx, bx ; 31 db - call 0167ah ; e8 4f b3 + call 0167ah ; e8 8c b1 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0003ch ; 83 c2 3c mov ax, word [bp+014h] ; 8b 46 14 mov bx, strict word 0000fh ; bb 0f 00 - call 0165eh ; e8 24 b3 + call 0165eh ; e8 61 b1 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0003dh ; 83 c2 3d mov ax, word [bp+014h] ; 8b 46 14 mov bx, 0009bh ; bb 9b 00 - call 0165eh ; e8 15 b3 + call 0165eh ; e8 52 b1 mov dx, word [bp+006h] ; 8b 56 06 add dx, strict byte 0003eh ; 83 c2 3e mov ax, word [bp+014h] ; 8b 46 14 xor bx, bx ; 31 db - call 0167ah ; e8 23 b3 + call 0167ah ; e8 60 b1 mov AL, strict byte 011h ; b0 11 mov dx, strict word 00020h ; ba 20 00 @@ -8910,5 +9080,5 @@ out DX, AL ; ee mov si, word [bp+006h] ; 8b 76 06 - call 06398h ; e8 00 00 + call 0655bh ; e8 00 00 pop di ; 5f add di, strict byte 00018h ; 83 c7 18 @@ -8938,12 +9108,12 @@ push cx ; 51 retf ; cb - jmp near 0608bh ; e9 b7 fc - mov bx, 00da2h ; bb a2 0d + jmp near 0624eh ; e9 b7 fc + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 52 b5 + call 01931h ; e8 8f b3 push 00876h ; 68 76 08 push strict byte 00004h ; 6a 04 - call 01972h ; e8 8b b5 + call 01972h ; e8 c8 b3 add sp, strict byte 00004h ; 83 c4 04 or byte [bp+018h], 001h ; 80 4e 18 01 @@ -8952,44 +9122,50 @@ or ah, 086h ; 80 cc 86 mov word [bp+012h], ax ; 89 46 12 - jmp near 0608bh ; e9 8f fc + jmp near 0624eh ; e9 8f fc mov word [bp+018h], cx ; 89 4e 18 mov word [bp+012h], ax ; 89 46 12 mov word [bp+00ch], 0e6f5h ; c7 46 0c f5 e6 mov word [bp+014h], 0f000h ; c7 46 14 00 f0 - jmp near 0608bh ; e9 7c fc + jmp near 0624eh ; e9 7c fc mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 54 b2 + call 0166ch ; e8 91 b0 mov word [bp+014h], ax ; 89 46 14 - jmp near 062dah ; e9 bc fe + jmp near 0649dh ; e9 bc fe push 008a5h ; 68 a5 08 push strict byte 00008h ; 6a 08 - jmp short 063e4h ; eb bf + jmp short 065a7h ; eb bf test byte [bp+012h], 0ffh ; f6 46 12 ff - jne short 0644ah ; 75 1f + jne short 0660dh ; 75 1f mov word [bp+012h], ax ; 89 46 12 mov ax, word [bp+00ch] ; 8b 46 0c xor ah, ah ; 30 e4 cmp ax, strict word 00001h ; 3d 01 00 - jc short 06443h ; 72 0b + jc short 06606h ; 72 0b cmp ax, strict word 00003h ; 3d 03 00 - jnbe short 06443h ; 77 06 + jnbe short 06606h ; 77 06 mov word [bp+018h], cx ; 89 4e 18 - jmp near 0608bh ; e9 48 fc + jmp near 0624eh ; e9 48 fc or byte [bp+018h], 001h ; 80 4e 18 01 - jmp near 0608bh ; e9 41 fc - mov bx, 00da2h ; bb a2 0d + jmp near 0624eh ; e9 41 fc + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 dc b4 + call 01931h ; e8 19 b3 push word [bp+00ch] ; ff 76 0c push word [bp+012h] ; ff 76 12 push 008bch ; 68 bc 08 push strict byte 00004h ; 6a 04 - call 01972h ; e8 0f b5 + call 01972h ; e8 4c b3 add sp, strict byte 00008h ; 83 c4 08 - jmp short 063eah ; eb 82 - db 021h, 066h, 043h, 066h, 066h, 066h, 088h, 066h, 0a8h, 066h, 0c9h, 066h, 008h, 067h, 034h, 067h -_int15_function32: ; 0xf6478 LB 0x37e + jmp short 065adh ; eb 82 + in AL, strict byte 067h ; e4 67 + push ES ; 06 + push 06829h ; 68 29 68 + dec bx ; 4b + push 0686bh ; 68 6b 68 + mov [bx+si-035h], gs ; 8c 68 cb + push 068f7h ; 68 f7 68 +_int15_function32: ; 0xf663b LB 0x37e push bp ; 55 mov bp, sp ; 89 e5 @@ -9003,9 +9179,9 @@ xor ah, ah ; 30 e4 cmp dx, 000e8h ; 81 fa e8 00 - je near 06545h ; 0f 84 ad 00 + je near 06708h ; 0f 84 ad 00 cmp dx, 000d0h ; 81 fa d0 00 - je short 064e0h ; 74 42 + je short 066a3h ; 74 42 cmp dx, 00086h ; 81 fa 86 00 - jne near 067c6h ; 0f 85 20 03 + jne near 06989h ; 0f 85 20 03 sti ; fb mov ax, word [bp+01ch] ; 8b 46 1c @@ -9026,31 +9202,31 @@ db 066h, 00bh, 0c9h ; or ecx, ecx ; 66 0b c9 - je near 064ddh ; 0f 84 0e 00 + je near 066a0h ; 0f 84 0e 00 in AL, strict byte 061h ; e4 61 and AL, strict byte 010h ; 24 10 db 03ah, 0c4h ; cmp al, ah ; 3a c4 - je short 064cfh ; 74 f8 + je short 06692h ; 74 f8 db 08ah, 0e0h ; mov ah, al ; 8a e0 dec ecx ; 66 49 - jne short 064cfh ; 75 f2 - jmp near 067f0h ; e9 10 03 + jne short 06692h ; 75 f2 + jmp near 069b3h ; e9 10 03 cmp ax, strict word 0004fh ; 3d 4f 00 - jne near 067c6h ; 0f 85 df 02 + jne near 06989h ; 0f 85 df 02 cmp word [bp+016h], 05052h ; 81 7e 16 52 50 - jne near 067c6h ; 0f 85 d6 02 + jne near 06989h ; 0f 85 d6 02 cmp word [bp+014h], 04f43h ; 81 7e 14 43 4f - jne near 067c6h ; 0f 85 cd 02 + jne near 06989h ; 0f 85 cd 02 cmp word [bp+01eh], 04d4fh ; 81 7e 1e 4f 4d - jne near 067c6h ; 0f 85 c4 02 + jne near 06989h ; 0f 85 c4 02 cmp word [bp+01ch], 04445h ; 81 7e 1c 45 44 - jne near 067c6h ; 0f 85 bb 02 + jne near 06989h ; 0f 85 bb 02 mov ax, word [bp+00ah] ; 8b 46 0a or ax, word [bp+008h] ; 0b 46 08 - jne near 067c6h ; 0f 85 b1 02 + jne near 06989h ; 0f 85 b1 02 mov ax, word [bp+006h] ; 8b 46 06 or ax, word [bp+004h] ; 0b 46 04 - jne near 067c6h ; 0f 85 a7 02 + jne near 06989h ; 0f 85 a7 02 mov word [bp+028h], bx ; 89 5e 28 mov ax, word [bp+014h] ; 8b 46 14 @@ -9063,16 +9239,16 @@ mov word [bp+006h], ax ; 89 46 06 mov dword [bp+020h], strict dword 049413332h ; 66 c7 46 20 32 33 41 49 - jmp near 067f0h ; e9 ab 02 + jmp near 069b3h ; e9 ab 02 cmp ax, strict word 00020h ; 3d 20 00 - je short 06554h ; 74 0a + je short 06717h ; 74 0a cmp ax, strict word 00001h ; 3d 01 00 - je near 0677bh ; 0f 84 2a 02 - jmp near 067c6h ; e9 72 02 + je near 0693eh ; 0f 84 2a 02 + jmp near 06989h ; e9 72 02 cmp word [bp+01ah], 0534dh ; 81 7e 1a 4d 53 - jne near 067c6h ; 0f 85 69 02 + jne near 06989h ; 0f 85 69 02 cmp word [bp+018h], 04150h ; 81 7e 18 50 41 - jne near 067c6h ; 0f 85 60 02 + jne near 06989h ; 0f 85 60 02 mov ax, strict word 00035h ; b8 35 00 - call 016ach ; e8 40 b1 + call 016ach ; e8 7d af movzx bx, al ; 0f b6 d8 xor dx, dx ; 31 d2 @@ -9080,7 +9256,7 @@ sal bx, 1 ; d1 e3 rcl dx, 1 ; d1 d2 - loop 06574h ; e2 fa + loop 06737h ; e2 fa mov ax, strict word 00034h ; b8 34 00 - call 016ach ; e8 2c b1 + call 016ach ; e8 69 af xor ah, ah ; 30 e4 mov dx, bx ; 89 da @@ -9090,10 +9266,10 @@ adc dx, 00100h ; 81 d2 00 01 cmp dx, 00100h ; 81 fa 00 01 - jc short 0659ah ; 72 06 - jne short 065c7h ; 75 31 + jc short 0675dh ; 72 06 + jne short 0678ah ; 75 31 test bx, bx ; 85 db - jnbe short 065c7h ; 77 2d + jnbe short 0678ah ; 77 2d mov ax, strict word 00031h ; b8 31 00 - call 016ach ; e8 0c b1 + call 016ach ; e8 49 af movzx bx, al ; 0f b6 d8 xor dx, dx ; 31 d2 @@ -9101,7 +9277,7 @@ sal bx, 1 ; d1 e3 rcl dx, 1 ; d1 d2 - loop 065a8h ; e2 fa + loop 0676bh ; e2 fa mov ax, strict word 00030h ; b8 30 00 - call 016ach ; e8 f8 b0 + call 016ach ; e8 35 af xor ah, ah ; 30 e4 or bx, ax ; 09 c3 @@ -9109,9 +9285,9 @@ sal bx, 1 ; d1 e3 rcl dx, 1 ; d1 d2 - loop 065bbh ; e2 fa + loop 0677eh ; e2 fa add bx, strict byte 00000h ; 83 c3 00 adc dx, strict byte 00010h ; 83 d2 10 mov ax, strict word 00062h ; b8 62 00 - call 016ach ; e8 df b0 + call 016ach ; e8 1c af xor ah, ah ; 30 e4 mov word [bp-00ah], ax ; 89 46 f6 @@ -9121,7 +9297,7 @@ sal word [bp-00ah], 1 ; d1 66 f6 rcl word [bp-008h], 1 ; d1 56 f8 - loop 065dah ; e2 f8 + loop 0679dh ; e2 f8 mov ax, strict word 00061h ; b8 61 00 - call 016ach ; e8 c4 b0 + call 016ach ; e8 01 af xor ah, ah ; 30 e4 or word [bp-00ah], ax ; 09 46 f6 @@ -9130,10 +9306,10 @@ mov word [bp-00ah], strict word 00000h ; c7 46 f6 00 00 mov ax, strict word 00063h ; b8 63 00 - call 016ach ; e8 ae b0 + call 016ach ; e8 eb ae mov byte [bp-004h], al ; 88 46 fc mov byte [bp-006h], al ; 88 46 fa mov ax, word [bp+014h] ; 8b 46 14 cmp ax, strict word 00007h ; 3d 07 00 - jnbe near 067c6h ; 0f 87 b8 01 + jnbe near 06989h ; 0f 87 b8 01 mov si, ax ; 89 c6 add si, ax ; 01 c6 @@ -9142,5 +9318,5 @@ mov ax, dx ; 89 d0 adc ax, strict word 0ffffh ; 15 ff ff - jmp word [cs:si+06468h] ; 2e ff a4 68 64 + jmp word [cs:si+0662bh] ; 2e ff a4 2b 66 push strict byte 00001h ; 6a 01 push dword 000000000h ; 66 6a 00 @@ -9151,7 +9327,7 @@ xor bx, bx ; 31 db xor cx, cx ; 31 c9 - call 05f1fh ; e8 e7 f8 + call 060e2h ; e8 e7 f8 mov dword [bp+014h], strict dword 000000001h ; 66 c7 46 14 01 00 00 00 - jmp near 06765h ; e9 22 01 + jmp near 06928h ; e9 22 01 push strict byte 00002h ; 6a 02 push dword 000000000h ; 66 6a 00 @@ -9162,7 +9338,7 @@ mov bx, 0fc00h ; bb 00 fc mov cx, strict word 00009h ; b9 09 00 - call 05f1fh ; e8 c4 f8 + call 060e2h ; e8 c4 f8 mov dword [bp+014h], strict dword 000000002h ; 66 c7 46 14 02 00 00 00 - jmp near 06765h ; e9 ff 00 + jmp near 06928h ; e9 ff 00 push strict byte 00002h ; 6a 02 push dword 000000000h ; 66 6a 00 @@ -9173,7 +9349,7 @@ xor bx, bx ; 31 db mov cx, strict word 0000fh ; b9 0f 00 - call 05f1fh ; e8 a2 f8 + call 060e2h ; e8 a2 f8 mov dword [bp+014h], strict dword 000000003h ; 66 c7 46 14 03 00 00 00 - jmp near 06765h ; e9 dd 00 + jmp near 06928h ; e9 dd 00 push strict byte 00001h ; 6a 01 push dword 000000000h ; 66 6a 00 @@ -9184,7 +9360,7 @@ xor bx, bx ; 31 db mov cx, strict word 00010h ; b9 10 00 - call 05f1fh ; e8 82 f8 + call 060e2h ; e8 82 f8 mov dword [bp+014h], strict dword 000000004h ; 66 c7 46 14 04 00 00 00 - jmp near 06765h ; e9 bd 00 + jmp near 06928h ; e9 bd 00 push strict byte 00003h ; 6a 03 push dword 000000000h ; 66 6a 00 @@ -9196,7 +9372,7 @@ mov cx, ax ; 89 c1 mov ax, si ; 89 f0 - call 05f1fh ; e8 61 f8 + call 060e2h ; e8 61 f8 mov dword [bp+014h], strict dword 000000005h ; 66 c7 46 14 05 00 00 00 - jmp near 06765h ; e9 9c 00 + jmp near 06928h ; e9 9c 00 push strict byte 00002h ; 6a 02 push dword 000000000h ; 66 6a 00 @@ -9206,17 +9382,17 @@ xor bx, bx ; 31 db mov cx, strict word 0fffch ; b9 fc ff - call 05f1fh ; e8 40 f8 + call 060e2h ; e8 40 f8 cmp byte [bp-004h], 000h ; 80 7e fc 00 - jne short 066ech ; 75 07 + jne short 068afh ; 75 07 mov ax, word [bp-008h] ; 8b 46 f8 test ax, ax ; 85 c0 - je short 06700h ; 74 14 + je short 068c3h ; 74 14 mov dword [bp+014h], strict dword 000000007h ; 66 c7 46 14 07 00 00 00 - jmp short 06765h ; eb 6f + jmp short 06928h ; eb 6f mov dword [bp+014h], strict dword 000000006h ; 66 c7 46 14 06 00 00 00 - jmp short 06765h ; eb 65 + jmp short 06928h ; eb 65 mov word [bp+014h], ax ; 89 46 14 mov word [bp+016h], ax ; 89 46 16 - jmp short 06765h ; eb 5d + jmp short 06928h ; eb 5d push strict byte 00002h ; 6a 02 push dword 000000000h ; 66 6a 00 @@ -9226,18 +9402,18 @@ xor bx, bx ; 31 db xor cx, cx ; 31 c9 - call 05f1fh ; e8 02 f8 + call 060e2h ; e8 02 f8 cmp byte [bp-004h], 000h ; 80 7e fc 00 - jne short 0672ah ; 75 07 + jne short 068edh ; 75 07 mov ax, word [bp-008h] ; 8b 46 f8 test ax, ax ; 85 c0 - je short 0672ch ; 74 02 - jmp short 066ech ; eb c0 + je short 068efh ; 74 02 + jmp short 068afh ; eb c0 mov word [bp+014h], ax ; 89 46 14 mov word [bp+016h], ax ; 89 46 16 - jmp short 06765h ; eb 31 + jmp short 06928h ; eb 31 cmp byte [bp-004h], 000h ; 80 7e fc 00 - jne short 06740h ; 75 06 + jne short 06903h ; 75 06 cmp word [bp-008h], strict byte 00000h ; 83 7e f8 00 - je short 06765h ; 74 25 + je short 06928h ; 74 25 push strict byte 00001h ; 6a 01 mov al, byte [bp-006h] ; 8a 46 fa @@ -9252,5 +9428,5 @@ xor bx, bx ; 31 db xor cx, cx ; 31 c9 - call 05f1fh ; e8 c2 f7 + call 060e2h ; e8 c2 f7 xor ax, ax ; 31 c0 mov word [bp+014h], ax ; 89 46 14 @@ -9259,24 +9435,24 @@ mov dword [bp+01ch], strict dword 000000014h ; 66 c7 46 1c 14 00 00 00 and byte [bp+028h], 0feh ; 80 66 28 fe - jmp short 067f0h ; eb 75 + jmp short 069b3h ; eb 75 mov word [bp+028h], bx ; 89 5e 28 mov ax, strict word 00031h ; b8 31 00 - call 016ach ; e8 28 af + call 016ach ; e8 65 ad movzx dx, al ; 0f b6 d0 sal dx, 008h ; c1 e2 08 mov ax, strict word 00030h ; b8 30 00 - call 016ach ; e8 1c af + call 016ach ; e8 59 ad xor ah, ah ; 30 e4 or dx, ax ; 09 c2 mov word [bp+01ch], dx ; 89 56 1c cmp dx, 03c00h ; 81 fa 00 3c - jbe short 067a2h ; 76 05 + jbe short 06965h ; 76 05 mov word [bp+01ch], 03c00h ; c7 46 1c 00 3c mov ax, strict word 00035h ; b8 35 00 - call 016ach ; e8 04 af + call 016ach ; e8 41 ad movzx dx, al ; 0f b6 d0 sal dx, 008h ; c1 e2 08 mov ax, strict word 00034h ; b8 34 00 - call 016ach ; e8 f8 ae + call 016ach ; e8 35 ad xor ah, ah ; 30 e4 or dx, ax ; 09 c2 @@ -9285,14 +9461,14 @@ mov word [bp+020h], ax ; 89 46 20 mov word [bp+014h], dx ; 89 56 14 - jmp short 067f0h ; eb 2a - mov bx, 00da2h ; bb a2 0d + jmp short 069b3h ; eb 2a + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 60 b1 + call 01931h ; e8 9d af push word [bp+014h] ; ff 76 14 push word [bp+020h] ; ff 76 20 push 008bch ; 68 bc 08 push strict byte 00004h ; 6a 04 - call 01972h ; e8 93 b1 + call 01972h ; e8 d0 af add sp, strict byte 00008h ; 83 c4 08 or byte [bp+028h], 001h ; 80 4e 28 01 @@ -9305,5 +9481,5 @@ pop bp ; 5d retn ; c3 -_inv_op_handler: ; 0xf67f6 LB 0x195 +_inv_op_handler: ; 0xf69b9 LB 0x195 push bp ; 55 mov bp, sp ; 89 e5 @@ -9314,9 +9490,9 @@ les bx, [bp+018h] ; c4 5e 18 cmp byte [es:bx], 0f0h ; 26 80 3f f0 - jne short 0680ch ; 75 06 + jne short 069cfh ; 75 06 inc word [bp+018h] ; ff 46 18 - jmp near 06984h ; e9 78 01 + jmp near 06b47h ; e9 78 01 cmp word [es:bx], 0050fh ; 26 81 3f 0f 05 - jne near 06980h ; 0f 85 6b 01 + jne near 06b43h ; 0f 85 6b 01 mov si, 00800h ; be 00 08 xor ax, ax ; 31 c0 @@ -9346,9 +9522,9 @@ sal ax, 1 ; d1 e0 rcl dx, 1 ; d1 d2 - loop 06865h ; e2 fa + loop 06a28h ; e2 fa cmp bx, dx ; 39 d3 - jne short 06873h ; 75 04 + jne short 06a36h ; 75 04 cmp di, ax ; 39 c7 - je short 06878h ; 74 05 + je short 06a3bh ; 74 05 mov word [bp-008h], strict word 00001h ; c7 46 f8 01 00 mov es, [bp-006h] ; 8e 46 fa @@ -9360,9 +9536,9 @@ sal ax, 1 ; d1 e0 rcl dx, 1 ; d1 d2 - loop 0688dh ; e2 fa + loop 06a50h ; e2 fa cmp di, dx ; 39 d7 - jne short 0689bh ; 75 04 + jne short 06a5eh ; 75 04 cmp bx, ax ; 39 c3 - je short 0689fh ; 74 04 + je short 06a62h ; 74 04 or byte [bp-008h], 002h ; 80 4e f8 02 push strict byte 00000h ; 6a 00 @@ -9414,8 +9590,8 @@ mov ax, strict word 00008h ; b8 08 00 test cx, strict word 00001h ; f7 c1 01 00 - je near 0693dh ; 0f 84 02 00 + je near 06b00h ; 0f 84 02 00 mov es, ax ; 8e c0 test cx, strict word 00002h ; f7 c1 02 00 - je near 06965h ; 0f 84 20 00 + je near 06b28h ; 0f 84 20 00 mov bx, word [word ss:00000h] ; 36 8b 1e 00 00 mov word [word ss:00008h], bx ; 36 89 1e 08 00 @@ -9434,8 +9610,8 @@ mov ss, [word ss:00020h] ; 36 8e 16 20 00 iret ; cf - jmp short 06984h ; eb 04 + jmp short 06b47h ; eb 04 sti ; fb hlt ; f4 - jmp short 06981h ; eb fd + jmp short 06b44h ; eb fd lea sp, [bp-004h] ; 8d 66 fc pop di ; 5f @@ -9443,5 +9619,5 @@ pop bp ; 5d retn ; c3 -init_rtc_: ; 0xf698b LB 0x28 +init_rtc_: ; 0xf6b4e LB 0x28 push bp ; 55 mov bp, sp ; 89 e5 @@ -9449,17 +9625,17 @@ mov dx, strict word 00026h ; ba 26 00 mov ax, strict word 0000ah ; b8 0a 00 - call 016c9h ; e8 31 ad + call 016c9h ; e8 6e ab mov dx, strict word 00002h ; ba 02 00 mov ax, strict word 0000bh ; b8 0b 00 - call 016c9h ; e8 28 ad + call 016c9h ; e8 65 ab mov ax, strict word 0000ch ; b8 0c 00 - call 016ach ; e8 05 ad + call 016ach ; e8 42 ab mov ax, strict word 0000dh ; b8 0d 00 - call 016ach ; e8 ff ac + call 016ach ; e8 3c ab lea sp, [bp-002h] ; 8d 66 fe pop dx ; 5a pop bp ; 5d retn ; c3 -rtc_updating_: ; 0xf69b3 LB 0x21 +rtc_updating_: ; 0xf6b76 LB 0x21 push bp ; 55 mov bp, sp ; 89 e5 @@ -9467,11 +9643,11 @@ mov dx, 061a8h ; ba a8 61 dec dx ; 4a - je short 069cbh ; 74 0e + je short 06b8eh ; 74 0e mov ax, strict word 0000ah ; b8 0a 00 - call 016ach ; e8 e9 ac + call 016ach ; e8 26 ab test AL, strict byte 080h ; a8 80 - jne short 069bah ; 75 f3 + jne short 06b7dh ; 75 f3 xor ax, ax ; 31 c0 - jmp short 069ceh ; eb 03 + jmp short 06b91h ; eb 03 mov ax, strict word 00001h ; b8 01 00 lea sp, [bp-002h] ; 8d 66 fe @@ -9479,5 +9655,5 @@ pop bp ; 5d retn ; c3 -_int70_function: ; 0xf69d4 LB 0xbe +_int70_function: ; 0xf6b97 LB 0xbe push bp ; 55 mov bp, sp ; 89 e5 @@ -9485,57 +9661,57 @@ push ax ; 50 mov ax, strict word 0000bh ; b8 0b 00 - call 016ach ; e8 cd ac + call 016ach ; e8 0a ab mov dl, al ; 88 c2 mov byte [bp-004h], al ; 88 46 fc mov ax, strict word 0000ch ; b8 0c 00 - call 016ach ; e8 c2 ac + call 016ach ; e8 ff aa mov dh, al ; 88 c6 test dl, 060h ; f6 c2 60 - je near 06a79h ; 0f 84 86 00 + je near 06c3ch ; 0f 84 86 00 test AL, strict byte 020h ; a8 20 - je short 069fbh ; 74 04 + je short 06bbeh ; 74 04 sti ; fb int 04ah ; cd 4a cli ; fa test dh, 040h ; f6 c6 40 - je near 06a79h ; 0f 84 77 00 + je near 06c3ch ; 0f 84 77 00 mov dx, 000a0h ; ba a0 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 45 ac + call 01650h ; e8 82 aa test al, al ; 84 c0 - je short 06a79h ; 74 6a + je short 06c3ch ; 74 6a mov dx, 0009ch ; ba 9c 00 mov ax, strict word 00040h ; b8 40 00 - call 01688h ; e8 70 ac + call 01688h ; e8 ad aa test dx, dx ; 85 d2 - jne short 06a65h ; 75 49 + jne short 06c28h ; 75 49 cmp ax, 003d1h ; 3d d1 03 - jnc short 06a65h ; 73 44 + jnc short 06c28h ; 73 44 mov dx, 00098h ; ba 98 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 42 ac + call 0166ch ; e8 7f aa mov si, ax ; 89 c6 mov dx, 0009ah ; ba 9a 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 37 ac + call 0166ch ; e8 74 aa mov cx, ax ; 89 c1 xor bx, bx ; 31 db mov dx, 000a0h ; ba a0 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 1c ac + call 0165eh ; e8 59 aa mov al, byte [bp-004h] ; 8a 46 fc and AL, strict byte 037h ; 24 37 movzx dx, al ; 0f b6 d0 mov ax, strict word 0000bh ; b8 0b 00 - call 016c9h ; e8 79 ac + call 016c9h ; e8 b6 aa mov dx, cx ; 89 ca mov ax, si ; 89 f0 - call 01650h ; e8 f9 ab + call 01650h ; e8 36 aa or AL, strict byte 080h ; 0c 80 movzx bx, al ; 0f b6 d8 mov dx, cx ; 89 ca mov ax, si ; 89 f0 - call 0165eh ; e8 fb ab - jmp short 06a79h ; eb 14 + call 0165eh ; e8 38 aa + jmp short 06c3ch ; eb 14 mov bx, ax ; 89 c3 add bx, 0fc2fh ; 81 c3 2f fc @@ -9544,18 +9720,22 @@ mov dx, 0009ch ; ba 9c 00 mov ax, strict word 00040h ; b8 40 00 - call 0169ah ; e8 21 ac - call 0e030h ; e8 b4 75 + call 0169ah ; e8 5e aa + call 0e030h ; e8 f1 73 lea sp, [bp-002h] ; 8d 66 fe pop si ; 5e pop bp ; 5d retn ; c3 - test ax, 0d26ah ; a9 6a d2 - push strict byte 0fff7h ; 6a f7 - push strict byte 00029h ; 6a 29 - imul di, word [bx+si+06bh], strict byte 0ffb0h ; 6b 78 6b b0 - imul si, bx, strict byte 0006bh ; 6b f3 6b - dec dx ; 4a insb ; 6c -_int1a_function: ; 0xf6a92 LB 0x1c8 + insb ; 6c + xchg bp, ax ; 95 + insb ; 6c + mov dx, 0ec6ch ; ba 6c ec + insb ; 6c + cmp bp, word [di+073h] ; 3b 6d 73 + insw ; 6d + mov DH, strict byte 06dh ; b6 6d + db 00dh + outsb ; 6e +_int1a_function: ; 0xf6c55 LB 0x1c8 push bp ; 55 mov bp, sp ; 89 e5 @@ -9563,8 +9743,8 @@ mov al, byte [bp+013h] ; 8a 46 13 cmp AL, strict byte 007h ; 3c 07 - jnbe near 06aceh ; 0f 87 2f 00 + jnbe near 06c91h ; 0f 87 2f 00 movzx bx, al ; 0f b6 d8 add bx, bx ; 01 db - jmp word [cs:bx+06a82h] ; 2e ff a7 82 6a + jmp word [cs:bx+06c45h] ; 2e ff a7 45 6c cli ; fa mov bx, 0046eh ; bb 6e 04 @@ -9597,39 +9777,39 @@ sti ; fb mov byte [bp+013h], 000h ; c6 46 13 00 - jmp short 06aceh ; eb d7 - call 069b3h ; e8 b9 fe + jmp short 06c91h ; eb d7 + call 06b76h ; e8 b9 fe test ax, ax ; 85 c0 - je short 06b00h ; 74 02 - jmp short 06aceh ; eb ce + je short 06cc3h ; 74 02 + jmp short 06c91h ; eb ce xor ax, ax ; 31 c0 - call 016ach ; e8 a7 ab + call 016ach ; e8 e4 a9 mov byte [bp+00fh], al ; 88 46 0f mov ax, strict word 00002h ; b8 02 00 - call 016ach ; e8 9e ab + call 016ach ; e8 db a9 mov byte [bp+010h], al ; 88 46 10 mov ax, strict word 00004h ; b8 04 00 - call 016ach ; e8 95 ab + call 016ach ; e8 d2 a9 mov bl, al ; 88 c3 mov byte [bp+011h], al ; 88 46 11 mov ax, strict word 0000bh ; b8 0b 00 - call 016ach ; e8 8a ab + call 016ach ; e8 c7 a9 and AL, strict byte 001h ; 24 01 mov byte [bp+00eh], al ; 88 46 0e - jmp short 06b6eh ; eb 45 - call 069b3h ; e8 87 fe + jmp short 06d31h ; eb 45 + call 06b76h ; e8 87 fe test ax, ax ; 85 c0 - je short 06b33h ; 74 03 - call 0698bh ; e8 58 fe + je short 06cf6h ; 74 03 + call 06b4eh ; e8 58 fe movzx dx, byte [bp+00fh] ; 0f b6 56 0f xor ax, ax ; 31 c0 - call 016c9h ; e8 8d ab + call 016c9h ; e8 ca a9 movzx dx, byte [bp+010h] ; 0f b6 56 10 mov ax, strict word 00002h ; b8 02 00 - call 016c9h ; e8 83 ab + call 016c9h ; e8 c0 a9 movzx dx, byte [bp+011h] ; 0f b6 56 11 mov ax, strict word 00004h ; b8 04 00 - call 016c9h ; e8 79 ab + call 016c9h ; e8 b6 a9 mov ax, strict word 0000bh ; b8 0b 00 - call 016ach ; e8 56 ab + call 016ach ; e8 93 a9 mov bl, al ; 88 c3 and bl, 060h ; 80 e3 60 @@ -9640,69 +9820,69 @@ movzx dx, bl ; 0f b6 d3 mov ax, strict word 0000bh ; b8 0b 00 - call 016c9h ; e8 5b ab + call 016c9h ; e8 98 a9 mov byte [bp+013h], 000h ; c6 46 13 00 mov byte [bp+012h], bl ; 88 5e 12 - jmp near 06aceh ; e9 56 ff + jmp near 06c91h ; e9 56 ff mov byte [bp+013h], 000h ; c6 46 13 00 - call 069b3h ; e8 34 fe + call 06b76h ; e8 34 fe test ax, ax ; 85 c0 - je short 06b86h ; 74 03 - jmp near 06aceh ; e9 48 ff + je short 06d49h ; 74 03 + jmp near 06c91h ; e9 48 ff mov ax, strict word 00009h ; b8 09 00 - call 016ach ; e8 20 ab + call 016ach ; e8 5d a9 mov byte [bp+010h], al ; 88 46 10 mov ax, strict word 00008h ; b8 08 00 - call 016ach ; e8 17 ab + call 016ach ; e8 54 a9 mov byte [bp+00fh], al ; 88 46 0f mov ax, strict word 00007h ; b8 07 00 - call 016ach ; e8 0e ab + call 016ach ; e8 4b a9 mov byte [bp+00eh], al ; 88 46 0e mov ax, strict word 00032h ; b8 32 00 - call 016ach ; e8 05 ab + call 016ach ; e8 42 a9 mov byte [bp+011h], al ; 88 46 11 mov byte [bp+012h], al ; 88 46 12 - jmp near 06aceh ; e9 1e ff - call 069b3h ; e8 00 fe + jmp near 06c91h ; e9 1e ff + call 06b76h ; e8 00 fe test ax, ax ; 85 c0 - je short 06bbdh ; 74 06 - call 0698bh ; e8 d1 fd - jmp near 06aceh ; e9 11 ff + je short 06d80h ; 74 06 + call 06b4eh ; e8 d1 fd + jmp near 06c91h ; e9 11 ff movzx dx, byte [bp+010h] ; 0f b6 56 10 mov ax, strict word 00009h ; b8 09 00 - call 016c9h ; e8 02 ab + call 016c9h ; e8 3f a9 movzx dx, byte [bp+00fh] ; 0f b6 56 0f mov ax, strict word 00008h ; b8 08 00 - call 016c9h ; e8 f8 aa + call 016c9h ; e8 35 a9 movzx dx, byte [bp+00eh] ; 0f b6 56 0e mov ax, strict word 00007h ; b8 07 00 - call 016c9h ; e8 ee aa + call 016c9h ; e8 2b a9 movzx dx, byte [bp+011h] ; 0f b6 56 11 mov ax, strict word 00032h ; b8 32 00 - call 016c9h ; e8 e4 aa + call 016c9h ; e8 21 a9 mov ax, strict word 0000bh ; b8 0b 00 - call 016ach ; e8 c1 aa + call 016ach ; e8 fe a8 mov bl, al ; 88 c3 and bl, 07fh ; 80 e3 7f - jmp near 06b65h ; e9 72 ff + jmp near 06d28h ; e9 72 ff mov ax, strict word 0000bh ; b8 0b 00 - call 016ach ; e8 b3 aa + call 016ach ; e8 f0 a8 mov bl, al ; 88 c3 mov word [bp+012h], strict word 00000h ; c7 46 12 00 00 test AL, strict byte 020h ; a8 20 - je short 06c07h ; 74 03 - jmp near 06aceh ; e9 c7 fe - call 069b3h ; e8 a9 fd + je short 06dcah ; 74 03 + jmp near 06c91h ; e9 c7 fe + call 06b76h ; e8 a9 fd test ax, ax ; 85 c0 - je short 06c11h ; 74 03 - call 0698bh ; e8 7a fd + je short 06dd4h ; 74 03 + call 06b4eh ; e8 7a fd movzx dx, byte [bp+00fh] ; 0f b6 56 0f mov ax, strict word 00001h ; b8 01 00 - call 016c9h ; e8 ae aa + call 016c9h ; e8 eb a8 movzx dx, byte [bp+010h] ; 0f b6 56 10 mov ax, strict word 00003h ; b8 03 00 - call 016c9h ; e8 a4 aa + call 016c9h ; e8 e1 a8 movzx dx, byte [bp+011h] ; 0f b6 56 11 mov ax, strict word 00005h ; b8 05 00 - call 016c9h ; e8 9a aa + call 016c9h ; e8 d7 a8 mov dx, 000a1h ; ba a1 00 in AL, DX ; ec @@ -9716,13 +9896,13 @@ movzx dx, al ; 0f b6 d0 mov ax, strict word 0000bh ; b8 0b 00 - call 016c9h ; e8 82 aa - jmp near 06aceh ; e9 84 fe + call 016c9h ; e8 bf a8 + jmp near 06c91h ; e9 84 fe mov ax, strict word 0000bh ; b8 0b 00 - call 016ach ; e8 5c aa + call 016ach ; e8 99 a8 mov bl, al ; 88 c3 and AL, strict byte 057h ; 24 57 movzx dx, al ; 0f b6 d0 - jmp near 06b68h ; e9 0e ff -send_to_mouse_ctrl_: ; 0xf6c5a LB 0x34 + jmp near 06d2bh ; e9 0e ff +send_to_mouse_ctrl_: ; 0xf6e1d LB 0x34 push bp ; 55 mov bp, sp ; 89 e5 @@ -9735,9 +9915,9 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 002h ; a8 02 - je short 06c79h ; 74 0e + je short 06e3ch ; 74 0e push 008f6h ; 68 f6 08 - push 0116ah ; 68 6a 11 + push 01170h ; 68 70 11 push strict byte 00007h ; 6a 07 - call 01972h ; e8 fc ac + call 01972h ; e8 39 ab add sp, strict byte 00006h ; 83 c4 06 mov AL, strict byte 0d4h ; b0 d4 @@ -9753,5 +9933,5 @@ pop bp ; 5d retn ; c3 -get_mouse_data_: ; 0xf6c8e LB 0x3b +get_mouse_data_: ; 0xf6e51 LB 0x3b push bp ; 55 mov bp, sp ; 89 e5 @@ -9767,13 +9947,13 @@ and ax, strict word 00021h ; 25 21 00 cmp ax, strict word 00021h ; 3d 21 00 - je short 06cafh ; 74 07 + je short 06e72h ; 74 07 test cx, cx ; 85 c9 - je short 06cafh ; 74 03 + je short 06e72h ; 74 03 dec cx ; 49 - jmp short 06c9ah ; eb eb + jmp short 06e5dh ; eb eb test cx, cx ; 85 c9 - jne short 06cb7h ; 75 04 + jne short 06e7ah ; 75 04 mov AL, strict byte 001h ; b0 01 - jmp short 06cc2h ; eb 0b + jmp short 06e85h ; eb 0b mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -9787,5 +9967,5 @@ pop bp ; 5d retn ; c3 -set_kbd_command_byte_: ; 0xf6cc9 LB 0x32 +set_kbd_command_byte_: ; 0xf6e8c LB 0x32 push bp ; 55 mov bp, sp ; 89 e5 @@ -9798,9 +9978,9 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 002h ; a8 02 - je short 06ce8h ; 74 0e + je short 06eabh ; 74 0e push 00900h ; 68 00 09 - push 0116ah ; 68 6a 11 + push 01170h ; 68 70 11 push strict byte 00007h ; 6a 07 - call 01972h ; e8 8d ac + call 01972h ; e8 ca aa add sp, strict byte 00006h ; 83 c4 06 mov AL, strict byte 060h ; b0 60 @@ -9815,5 +9995,5 @@ pop bp ; 5d retn ; c3 -_int74_function: ; 0xf6cfb LB 0xca +_int74_function: ; 0xf6ebe LB 0xca push bp ; 55 mov bp, sp ; 89 e5 @@ -9821,5 +10001,5 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 62 a9 + call 0166ch ; e8 9f a7 mov cx, ax ; 89 c1 mov word [bp+004h], strict word 00000h ; c7 46 04 00 00 @@ -9830,5 +10010,5 @@ and AL, strict byte 021h ; 24 21 cmp AL, strict byte 021h ; 3c 21 - jne near 06db1h ; 0f 85 92 00 + jne near 06f74h ; 0f 85 92 00 mov dx, strict word 00060h ; ba 60 00 in AL, DX ; ec @@ -9838,12 +10018,12 @@ mov dx, strict word 00026h ; ba 26 00 mov ax, cx ; 89 c8 - call 01650h ; e8 21 a9 + call 01650h ; e8 5e a7 mov byte [bp-006h], al ; 88 46 fa mov dx, strict word 00027h ; ba 27 00 mov ax, cx ; 89 c8 - call 01650h ; e8 16 a9 + call 01650h ; e8 53 a7 mov byte [bp-008h], al ; 88 46 f8 test AL, strict byte 080h ; a8 80 - je short 06db1h ; 74 70 + je short 06f74h ; 74 70 mov al, byte [bp-008h] ; 8a 46 f8 and AL, strict byte 007h ; 24 07 @@ -9856,21 +10036,21 @@ add dx, strict byte 00028h ; 83 c2 28 mov ax, cx ; 89 c8 - call 0165eh ; e8 00 a9 + call 0165eh ; e8 3d a7 mov al, byte [bp-004h] ; 8a 46 fc cmp al, byte [bp-002h] ; 3a 46 fe - jc short 06da2h ; 72 3c + jc short 06f65h ; 72 3c mov dx, strict word 00028h ; ba 28 00 mov ax, cx ; 89 c8 - call 01650h ; e8 e2 a8 + call 01650h ; e8 1f a7 xor ah, ah ; 30 e4 mov word [bp+00ch], ax ; 89 46 0c mov dx, strict word 00029h ; ba 29 00 mov ax, cx ; 89 c8 - call 01650h ; e8 d5 a8 + call 01650h ; e8 12 a7 xor ah, ah ; 30 e4 mov word [bp+00ah], ax ; 89 46 0a mov dx, strict word 0002ah ; ba 2a 00 mov ax, cx ; 89 c8 - call 01650h ; e8 c8 a8 + call 01650h ; e8 05 a7 xor ah, ah ; 30 e4 mov word [bp+008h], ax ; 89 46 08 @@ -9879,24 +10059,26 @@ mov byte [bp-006h], ah ; 88 66 fa test byte [bp-008h], 080h ; f6 46 f8 80 - je short 06da5h ; 74 0a + je short 06f68h ; 74 0a mov word [bp+004h], strict word 00001h ; c7 46 04 01 00 - jmp short 06da5h ; eb 03 + jmp short 06f68h ; eb 03 inc byte [bp-006h] ; fe 46 fa movzx bx, byte [bp-006h] ; 0f b6 5e fa mov dx, strict word 00026h ; ba 26 00 mov ax, cx ; 89 c8 - call 0165eh ; e8 ad a8 + call 0165eh ; e8 ea a6 mov sp, bp ; 89 ec pop bp ; 5d retn ; c3 - or word [bp+07fh], bp ; 09 6e 7f - outsb ; 6e - add ch, byte [bx-06dh] ; 02 6f 93 + int3 ; cc outsw ; 6f - add word [bx+si+055h], si ; 01 70 55 - outsb ; 6e - sub word [bx+si-012h], si ; 29 70 ee - db 070h -_int15_function_mouse: ; 0xf6dc5 LB 0x38b + inc dx ; 42 + jo short 06f42h ; 70 c5 + jo short 06fd5h ; 70 56 + jno short 06f45h ; 71 c4 + jno short 06f9bh ; 71 18 + jo short 06f71h ; 70 ec + jno short 06f38h ; 71 b1 + db 072h +_int15_function_mouse: ; 0xf6f88 LB 0x38b push bp ; 55 mov bp, sp ; 89 e5 @@ -9905,31 +10087,31 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 97 a8 + call 0166ch ; e8 d4 a6 mov cx, ax ; 89 c1 cmp byte [bp+012h], 007h ; 80 7e 12 07 - jbe short 06de8h ; 76 0b + jbe short 06fabh ; 76 0b or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 001h ; c6 46 13 01 - jmp near 0714ah ; e9 62 03 + jmp near 0730dh ; e9 62 03 mov ax, strict word 00065h ; b8 65 00 - call 06cc9h ; e8 db fe + call 06e8ch ; e8 db fe and word [bp+018h], strict byte 0fffeh ; 83 66 18 fe mov byte [bp+013h], 000h ; c6 46 13 00 mov al, byte [bp+012h] ; 8a 46 12 cmp AL, strict byte 007h ; 3c 07 - jnbe near 07131h ; 0f 87 32 03 + jnbe near 072f4h ; 0f 87 32 03 movzx si, al ; 0f b6 f0 add si, si ; 01 f6 - jmp word [cs:si+06db5h] ; 2e ff a4 b5 6d + jmp word [cs:si+06f78h] ; 2e ff a4 78 6f cmp byte [bp+00dh], 001h ; 80 7e 0d 01 - jnbe near 0713ch ; 0f 87 2b 03 + jnbe near 072ffh ; 0f 87 2b 03 mov dx, strict word 00027h ; ba 27 00 mov ax, cx ; 89 c8 - call 01650h ; e8 37 a8 + call 01650h ; e8 74 a6 test AL, strict byte 080h ; a8 80 - jne short 06e28h ; 75 0b + jne short 06febh ; 75 0b or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 005h ; c6 46 13 05 - jmp near 07144h ; e9 1c 03 + jmp near 07307h ; e9 1c 03 cmp byte [bp+00dh], 000h ; 80 7e 0d 00 db 00fh, 094h, 0c0h @@ -9937,24 +10119,24 @@ add AL, strict byte 0f4h ; 04 f4 xor ah, ah ; 30 e4 - call 06c5ah ; e8 24 fe + call 06e1dh ; e8 24 fe test al, al ; 84 c0 - jne near 070cah ; 0f 85 8e 02 + jne near 0728dh ; 0f 85 8e 02 mov dx, ss ; 8c d2 lea ax, [bp-008h] ; 8d 46 f8 - call 06c8eh ; e8 4a fe + call 06e51h ; e8 4a fe test al, al ; 84 c0 - je near 07144h ; 0f 84 fa 02 + je near 07307h ; 0f 84 fa 02 cmp byte [bp-008h], 0fah ; 80 7e f8 fa - jne near 070cah ; 0f 85 78 02 - jmp near 07144h ; e9 ef 02 + jne near 0728dh ; 0f 85 78 02 + jmp near 07307h ; e9 ef 02 mov al, byte [bp+00dh] ; 8a 46 0d cmp AL, strict byte 001h ; 3c 01 - jc short 06e60h ; 72 04 + jc short 07023h ; 72 04 cmp AL, strict byte 008h ; 3c 08 - jbe short 06e63h ; 76 03 - jmp near 06ff6h ; e9 93 01 + jbe short 07026h ; 76 03 + jmp near 071b9h ; e9 93 01 mov dx, strict word 00027h ; ba 27 00 mov ax, cx ; 89 c8 - call 01650h ; e8 e5 a7 + call 01650h ; e8 22 a6 mov ah, byte [bp+00dh] ; 8a 66 0d db 0feh, 0cch @@ -9965,194 +10147,194 @@ mov dx, strict word 00027h ; ba 27 00 mov ax, cx ; 89 c8 - call 0165eh ; e8 df a7 + call 0165eh ; e8 1c a6 mov dx, strict word 00026h ; ba 26 00 mov ax, cx ; 89 c8 - call 01650h ; e8 c9 a7 + call 01650h ; e8 06 a6 and AL, strict byte 0f8h ; 24 f8 movzx bx, al ; 0f b6 d8 mov dx, strict word 00026h ; ba 26 00 mov ax, cx ; 89 c8 - call 0165eh ; e8 ca a7 + call 0165eh ; e8 07 a6 mov ax, 000ffh ; b8 ff 00 - call 06c5ah ; e8 c0 fd + call 06e1dh ; e8 c0 fd test al, al ; 84 c0 - jne near 070cah ; 0f 85 2a 02 + jne near 0728dh ; 0f 85 2a 02 mov dx, ss ; 8c d2 lea ax, [bp-004h] ; 8d 46 fc - call 06c8eh ; e8 e6 fd + call 06e51h ; e8 e6 fd mov cl, al ; 88 c1 cmp byte [bp-004h], 0feh ; 80 7e fc fe - jne short 06ebbh ; 75 0b + jne short 0707eh ; 75 0b or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 004h ; c6 46 13 04 - jmp near 07144h ; e9 89 02 + jmp near 07307h ; e9 89 02 cmp byte [bp-004h], 0fah ; 80 7e fc fa - je short 06ed1h ; 74 10 + je short 07094h ; 74 10 movzx ax, byte [bp-004h] ; 0f b6 46 fc push ax ; 50 push 0090bh ; 68 0b 09 push strict byte 00007h ; 6a 07 - call 01972h ; e8 a4 aa + call 01972h ; e8 e1 a8 add sp, strict byte 00006h ; 83 c4 06 test cl, cl ; 84 c9 - jne near 070cah ; 0f 85 f3 01 + jne near 0728dh ; 0f 85 f3 01 mov dx, ss ; 8c d2 lea ax, [bp-008h] ; 8d 46 f8 - call 06c8eh ; e8 af fd + call 06e51h ; e8 af fd test al, al ; 84 c0 - jne near 070cah ; 0f 85 e5 01 + jne near 0728dh ; 0f 85 e5 01 mov dx, ss ; 8c d2 lea ax, [bp-006h] ; 8d 46 fa - call 06c8eh ; e8 a1 fd + call 06e51h ; e8 a1 fd test al, al ; 84 c0 - jne near 070cah ; 0f 85 d7 01 + jne near 0728dh ; 0f 85 d7 01 mov al, byte [bp-008h] ; 8a 46 f8 mov byte [bp+00ch], al ; 88 46 0c mov al, byte [bp-006h] ; 8a 46 fa mov byte [bp+00dh], al ; 88 46 0d - jmp near 07144h ; e9 42 02 + jmp near 07307h ; e9 42 02 mov al, byte [bp+00dh] ; 8a 46 0d cmp AL, strict byte 003h ; 3c 03 - jc short 06f19h ; 72 10 - jbe short 06f37h ; 76 2c + jc short 070dch ; 72 10 + jbe short 070fah ; 76 2c cmp AL, strict byte 006h ; 3c 06 - je short 06f49h ; 74 3a + je short 0710ch ; 74 3a cmp AL, strict byte 005h ; 3c 05 - je short 06f43h ; 74 30 + je short 07106h ; 74 30 cmp AL, strict byte 004h ; 3c 04 - je short 06f3dh ; 74 26 - jmp short 06f4fh ; eb 36 + je short 07100h ; 74 26 + jmp short 07112h ; eb 36 cmp AL, strict byte 002h ; 3c 02 - je short 06f31h ; 74 14 + je short 070f4h ; 74 14 cmp AL, strict byte 001h ; 3c 01 - je short 06f2bh ; 74 0a + je short 070eeh ; 74 0a test al, al ; 84 c0 - jne short 06f4fh ; 75 2a + jne short 07112h ; 75 2a mov byte [bp-008h], 00ah ; c6 46 f8 0a - jmp short 06f53h ; eb 28 + jmp short 07116h ; eb 28 mov byte [bp-008h], 014h ; c6 46 f8 14 - jmp short 06f53h ; eb 22 + jmp short 07116h ; eb 22 mov byte [bp-008h], 028h ; c6 46 f8 28 - jmp short 06f53h ; eb 1c + jmp short 07116h ; eb 1c mov byte [bp-008h], 03ch ; c6 46 f8 3c - jmp short 06f53h ; eb 16 + jmp short 07116h ; eb 16 mov byte [bp-008h], 050h ; c6 46 f8 50 - jmp short 06f53h ; eb 10 + jmp short 07116h ; eb 10 mov byte [bp-008h], 064h ; c6 46 f8 64 - jmp short 06f53h ; eb 0a + jmp short 07116h ; eb 0a mov byte [bp-008h], 0c8h ; c6 46 f8 c8 - jmp short 06f53h ; eb 04 + jmp short 07116h ; eb 04 mov byte [bp-008h], 000h ; c6 46 f8 00 cmp byte [bp-008h], 000h ; 80 7e f8 00 - jbe short 06f88h ; 76 2f + jbe short 0714bh ; 76 2f mov ax, 000f3h ; b8 f3 00 - call 06c5ah ; e8 fb fc + call 06e1dh ; e8 fb fc test al, al ; 84 c0 - jne short 06f7dh ; 75 1a + jne short 07140h ; 75 1a mov dx, ss ; 8c d2 lea ax, [bp-006h] ; 8d 46 fa - call 06c8eh ; e8 23 fd + call 06e51h ; e8 23 fd movzx ax, byte [bp-008h] ; 0f b6 46 f8 - call 06c5ah ; e8 e8 fc + call 06e1dh ; e8 e8 fc mov dx, ss ; 8c d2 lea ax, [bp-006h] ; 8d 46 fa - call 06c8eh ; e8 14 fd - jmp near 07144h ; e9 c7 01 + call 06e51h ; e8 14 fd + jmp near 07307h ; e9 c7 01 or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 003h ; c6 46 13 03 - jmp near 07144h ; e9 bc 01 + jmp near 07307h ; e9 bc 01 or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 002h ; c6 46 13 02 - jmp near 07144h ; e9 b1 01 + jmp near 07307h ; e9 b1 01 cmp byte [bp+00dh], 004h ; 80 7e 0d 04 - jnc short 06ff6h ; 73 5d + jnc short 071b9h ; 73 5d mov ax, 000e8h ; b8 e8 00 - call 06c5ah ; e8 bb fc + call 06e1dh ; e8 bb fc test al, al ; 84 c0 - jne short 06febh ; 75 48 + jne short 071aeh ; 75 48 mov dx, ss ; 8c d2 lea ax, [bp-008h] ; 8d 46 f8 - call 06c8eh ; e8 e3 fc + call 06e51h ; e8 e3 fc cmp byte [bp-008h], 0fah ; 80 7e f8 fa - je short 06fc1h ; 74 10 + je short 07184h ; 74 10 movzx ax, byte [bp-008h] ; 0f b6 46 f8 push ax ; 50 push 00936h ; 68 36 09 push strict byte 00007h ; 6a 07 - call 01972h ; e8 b4 a9 + call 01972h ; e8 f1 a7 add sp, strict byte 00006h ; 83 c4 06 movzx ax, byte [bp+00dh] ; 0f b6 46 0d - call 06c5ah ; e8 92 fc + call 06e1dh ; e8 92 fc mov dx, ss ; 8c d2 lea ax, [bp-008h] ; 8d 46 f8 - call 06c8eh ; e8 be fc + call 06e51h ; e8 be fc cmp byte [bp-008h], 0fah ; 80 7e f8 fa - je near 07144h ; 0f 84 6c 01 + je near 07307h ; 0f 84 6c 01 movzx ax, byte [bp-008h] ; 0f b6 46 f8 push ax ; 50 push 00936h ; 68 36 09 push strict byte 00007h ; 6a 07 - call 01972h ; e8 8d a9 + call 01972h ; e8 ca a7 add sp, strict byte 00006h ; 83 c4 06 - jmp near 07144h ; e9 59 01 + jmp near 07307h ; e9 59 01 or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 003h ; c6 46 13 03 - jmp near 07144h ; e9 4e 01 + jmp near 07307h ; e9 4e 01 or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 002h ; c6 46 13 02 - jmp near 07144h ; e9 43 01 + jmp near 07307h ; e9 43 01 mov ax, 000f2h ; b8 f2 00 - call 06c5ah ; e8 53 fc + call 06e1dh ; e8 53 fc test al, al ; 84 c0 - jne short 0701eh ; 75 13 + jne short 071e1h ; 75 13 mov dx, ss ; 8c d2 lea ax, [bp-008h] ; 8d 46 f8 - call 06c8eh ; e8 7b fc + call 06e51h ; e8 7b fc mov dx, ss ; 8c d2 lea ax, [bp-006h] ; 8d 46 fa - call 06c8eh ; e8 73 fc - jmp near 06ef9h ; e9 db fe + call 06e51h ; e8 73 fc + jmp near 070bch ; e9 db fe or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 003h ; c6 46 13 03 - jmp near 07144h ; e9 1b 01 + jmp near 07307h ; e9 1b 01 mov al, byte [bp+00dh] ; 8a 46 0d test al, al ; 84 c0 - jbe short 07037h ; 76 07 + jbe short 071fah ; 76 07 cmp AL, strict byte 002h ; 3c 02 - jbe short 070a0h ; 76 6c - jmp near 070d4h ; e9 9d 00 + jbe short 07263h ; 76 6c + jmp near 07297h ; e9 9d 00 mov ax, 000e9h ; b8 e9 00 - call 06c5ah ; e8 1d fc + call 06e1dh ; e8 1d fc test al, al ; 84 c0 - jne near 070cah ; 0f 85 87 00 + jne near 0728dh ; 0f 85 87 00 mov dx, ss ; 8c d2 lea ax, [bp-008h] ; 8d 46 f8 - call 06c8eh ; e8 43 fc + call 06e51h ; e8 43 fc mov cl, al ; 88 c1 cmp byte [bp-008h], 0fah ; 80 7e f8 fa - je short 07063h ; 74 10 + je short 07226h ; 74 10 movzx ax, byte [bp-008h] ; 0f b6 46 f8 push ax ; 50 push 00936h ; 68 36 09 push strict byte 00007h ; 6a 07 - call 01972h ; e8 12 a9 + call 01972h ; e8 4f a7 add sp, strict byte 00006h ; 83 c4 06 test cl, cl ; 84 c9 - jne short 070cah ; 75 63 + jne short 0728dh ; 75 63 mov dx, ss ; 8c d2 lea ax, [bp-008h] ; 8d 46 f8 - call 06c8eh ; e8 1f fc + call 06e51h ; e8 1f fc test al, al ; 84 c0 - jne short 070cah ; 75 57 + jne short 0728dh ; 75 57 mov dx, ss ; 8c d2 lea ax, [bp-006h] ; 8d 46 fa - call 06c8eh ; e8 13 fc + call 06e51h ; e8 13 fc test al, al ; 84 c0 - jne short 070cah ; 75 4b + jne short 0728dh ; 75 4b mov dx, ss ; 8c d2 lea ax, [bp-004h] ; 8d 46 fc - call 06c8eh ; e8 07 fc + call 06e51h ; e8 07 fc test al, al ; 84 c0 - jne short 070cah ; 75 3f + jne short 0728dh ; 75 3f mov al, byte [bp-008h] ; 8a 46 f8 mov byte [bp+00ch], al ; 88 46 0c @@ -10161,74 +10343,74 @@ mov al, byte [bp-004h] ; 8a 46 fc mov byte [bp+00eh], al ; 88 46 0e - jmp near 07144h ; e9 a4 00 + jmp near 07307h ; e9 a4 00 cmp AL, strict byte 001h ; 3c 01 - jne short 070a9h ; 75 05 + jne short 0726ch ; 75 05 mov ax, 000e6h ; b8 e6 00 - jmp short 070ach ; eb 03 + jmp short 0726fh ; eb 03 mov ax, 000e7h ; b8 e7 00 - call 06c5ah ; e8 ab fb + call 06e1dh ; e8 ab fb mov cl, al ; 88 c1 test cl, cl ; 84 c9 - jne short 070c4h ; 75 0f + jne short 07287h ; 75 0f mov dx, ss ; 8c d2 lea ax, [bp-008h] ; 8d 46 f8 - call 06c8eh ; e8 d1 fb + call 06e51h ; e8 d1 fb cmp byte [bp-008h], 0fah ; 80 7e f8 fa db 00fh, 095h, 0c1h ; setne cl ; 0f 95 c1 test cl, cl ; 84 c9 - je near 07144h ; 0f 84 7a 00 + je near 07307h ; 0f 84 7a 00 or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 003h ; c6 46 13 03 - jmp short 07144h ; eb 70 + jmp short 07307h ; eb 70 movzx ax, byte [bp+00dh] ; 0f b6 46 0d push ax ; 50 push 00962h ; 68 62 09 push strict byte 00007h ; 6a 07 - call 01972h ; e8 91 a8 + call 01972h ; e8 ce a6 add sp, strict byte 00006h ; 83 c4 06 or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 001h ; c6 46 13 01 - jmp short 07144h ; eb 56 + jmp short 07307h ; eb 56 mov si, word [bp+00ch] ; 8b 76 0c mov bx, si ; 89 f3 mov dx, strict word 00022h ; ba 22 00 mov ax, cx ; 89 c8 - call 0167ah ; e8 7f a5 + call 0167ah ; e8 bc a3 mov bx, word [bp+014h] ; 8b 5e 14 mov dx, strict word 00024h ; ba 24 00 mov ax, cx ; 89 c8 - call 0167ah ; e8 74 a5 + call 0167ah ; e8 b1 a3 mov dx, strict word 00027h ; ba 27 00 mov ax, cx ; 89 c8 - call 01650h ; e8 42 a5 + call 01650h ; e8 7f a3 mov ah, al ; 88 c4 test si, si ; 85 f6 - jne short 07122h ; 75 0e + jne short 072e5h ; 75 0e cmp word [bp+014h], strict byte 00000h ; 83 7e 14 00 - jne short 07122h ; 75 08 + jne short 072e5h ; 75 08 test AL, strict byte 080h ; a8 80 - je short 07124h ; 74 06 + je short 072e7h ; 74 06 and AL, strict byte 07fh ; 24 7f - jmp short 07124h ; eb 02 + jmp short 072e7h ; eb 02 or AL, strict byte 080h ; 0c 80 movzx bx, al ; 0f b6 d8 mov dx, strict word 00027h ; ba 27 00 mov ax, cx ; 89 c8 - call 0165eh ; e8 2f a5 - jmp short 07144h ; eb 13 + call 0165eh ; e8 6c a3 + jmp short 07307h ; eb 13 push 0097ch ; 68 7c 09 push strict byte 00007h ; 6a 07 - call 01972h ; e8 39 a8 + call 01972h ; e8 76 a6 add sp, strict byte 00004h ; 83 c4 04 or word [bp+018h], strict byte 00001h ; 83 4e 18 01 mov byte [bp+013h], 001h ; c6 46 13 01 mov ax, strict word 00047h ; b8 47 00 - call 06cc9h ; e8 7f fb + call 06e8ch ; e8 7f fb lea sp, [bp-002h] ; 8d 66 fe pop si ; 5e pop bp ; 5d retn ; c3 -_int17_function: ; 0xf7150 LB 0xb3 +_int17_function: ; 0xf7313 LB 0xb3 push bp ; 55 mov bp, sp ; 89 e5 @@ -10240,22 +10422,22 @@ add dx, strict byte 00008h ; 83 c2 08 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 08 a5 + call 0166ch ; e8 45 a3 mov bx, ax ; 89 c3 mov si, ax ; 89 c6 cmp byte [bp+013h], 003h ; 80 7e 13 03 - jnc near 071f9h ; 0f 83 89 00 + jnc near 073bch ; 0f 83 89 00 mov ax, word [bp+00eh] ; 8b 46 0e cmp ax, strict word 00003h ; 3d 03 00 - jnc near 071f9h ; 0f 83 7f 00 + jnc near 073bch ; 0f 83 7f 00 test bx, bx ; 85 db - jbe near 071f9h ; 0f 86 79 00 + jbe near 073bch ; 0f 86 79 00 mov dx, ax ; 89 c2 add dx, strict byte 00078h ; 83 c2 78 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 c5 a4 + call 01650h ; e8 02 a3 movzx cx, al ; 0f b6 c8 sal cx, 008h ; c1 e1 08 cmp byte [bp+013h], 000h ; 80 7e 13 00 - jne short 071c4h ; 75 2d + jne short 07387h ; 75 2d mov al, byte [bp+012h] ; 8a 46 12 mov dx, bx ; 89 da @@ -10277,11 +10459,11 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 040h ; a8 40 - je short 071c4h ; 74 07 + je short 07387h ; 74 07 test cx, cx ; 85 c9 - je short 071c4h ; 74 03 + je short 07387h ; 74 03 dec cx ; 49 - jmp short 071b3h ; eb ef + jmp short 07376h ; eb ef cmp byte [bp+013h], 001h ; 80 7e 13 01 - jne short 071e0h ; 75 16 + jne short 073a3h ; 75 16 lea dx, [si+002h] ; 8d 54 02 in AL, DX ; ec @@ -10302,8 +10484,8 @@ mov byte [bp+013h], al ; 88 46 13 test cx, cx ; 85 c9 - jne short 071f3h ; 75 04 + jne short 073b6h ; 75 04 or byte [bp+013h], 001h ; 80 4e 13 01 and byte [bp+01ch], 0feh ; 80 66 1c fe - jmp short 071fdh ; eb 04 + jmp short 073c0h ; eb 04 or byte [bp+01ch], 001h ; 80 4e 1c 01 lea sp, [bp-002h] ; 8d 66 fe @@ -10311,5 +10493,5 @@ pop bp ; 5d retn ; c3 -wait_: ; 0xf7203 LB 0xb2 +wait_: ; 0xf73c6 LB 0xb2 push bp ; 55 mov bp, sp ; 89 e5 @@ -10329,5 +10511,5 @@ mov dx, 0046ch ; ba 6c 04 xor ax, ax ; 31 c0 - call 01688h ; e8 62 a4 + call 01688h ; e8 9f a2 mov word [bp-00eh], ax ; 89 46 f2 mov bx, dx ; 89 d3 @@ -10335,20 +10517,20 @@ mov dx, 0046ch ; ba 6c 04 xor ax, ax ; 31 c0 - call 01688h ; e8 54 a4 + call 01688h ; e8 91 a2 mov word [bp-012h], ax ; 89 46 ee mov di, dx ; 89 d7 cmp dx, bx ; 39 da - jnbe short 07244h ; 77 07 - jne short 0724bh ; 75 0c + jnbe short 07407h ; 77 07 + jne short 0740eh ; 75 0c cmp ax, word [bp-00eh] ; 3b 46 f2 - jbe short 0724bh ; 76 07 + jbe short 0740eh ; 76 07 sub ax, word [bp-00eh] ; 2b 46 f2 sbb dx, bx ; 19 da - jmp short 07256h ; eb 0b + jmp short 07419h ; eb 0b cmp dx, bx ; 39 da - jc short 07256h ; 72 07 - jne short 0725ah ; 75 09 + jc short 07419h ; 72 07 + jne short 0741dh ; 75 09 cmp ax, word [bp-00eh] ; 3b 46 f2 - jnc short 0725ah ; 73 04 + jnc short 0741dh ; 73 04 sub si, ax ; 29 c6 sbb cx, dx ; 19 d1 @@ -10358,11 +10540,11 @@ mov ax, 00100h ; b8 00 01 int 016h ; cd 16 - je near 07270h ; 0f 84 05 00 + je near 07433h ; 0f 84 05 00 mov AL, strict byte 001h ; b0 01 - jmp near 07272h ; e9 02 00 + jmp near 07435h ; e9 02 00 db 032h, 0c0h ; xor al, al ; 32 c0 test al, al ; 84 c0 - je short 0729ah ; 74 24 + je short 0745dh ; 74 24 db 033h, 0c0h ; xor ax, ax ; 33 c0 @@ -10375,15 +10557,15 @@ push 0099eh ; 68 9e 09 push strict byte 00004h ; 6a 04 - call 01972h ; e8 e5 a6 + call 01972h ; e8 22 a5 add sp, strict byte 00006h ; 83 c4 06 cmp byte [bp-00ch], 000h ; 80 7e f4 00 - je short 0729ah ; 74 04 + je short 0745dh ; 74 04 mov al, dl ; 88 d0 - jmp short 072ach ; eb 12 + jmp short 0746fh ; eb 12 test cx, cx ; 85 c9 - jnle short 0722bh ; 7f 8d - jne short 072a4h ; 75 04 + jnle short 073eeh ; 7f 8d + jne short 07467h ; 75 04 test si, si ; 85 f6 - jnbe short 0722bh ; 77 87 + jnbe short 073eeh ; 77 87 mov ax, word [bp-010h] ; 8b 46 f0 push ax ; 50 @@ -10397,5 +10579,5 @@ pop bp ; 5d retn ; c3 -read_logo_byte_: ; 0xf72b5 LB 0x16 +read_logo_byte_: ; 0xf7478 LB 0x16 push bp ; 55 mov bp, sp ; 89 e5 @@ -10412,5 +10594,5 @@ pop bp ; 5d retn ; c3 -read_logo_word_: ; 0xf72cb LB 0x14 +read_logo_word_: ; 0xf748e LB 0x14 push bp ; 55 mov bp, sp ; 89 e5 @@ -10425,5 +10607,5 @@ pop bp ; 5d retn ; c3 -print_detected_harddisks_: ; 0xf72df LB 0x130 +print_detected_harddisks_: ; 0xf74a2 LB 0x130 push bp ; 55 mov bp, sp ; 89 e5 @@ -10437,5 +10619,5 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 7a a3 + call 0166ch ; e8 b7 a1 mov si, ax ; 89 c6 mov byte [bp-00ch], 000h ; c6 46 f4 00 @@ -10443,21 +10625,21 @@ xor ch, ch ; 30 ed mov dx, 002c0h ; ba c0 02 - call 01650h ; e8 4e a3 + call 01650h ; e8 8b a1 mov byte [bp-00eh], al ; 88 46 f2 xor bl, bl ; 30 db cmp bl, byte [bp-00eh] ; 3a 5e f2 - jnc near 073e1h ; 0f 83 d3 00 + jnc near 075a4h ; 0f 83 d3 00 movzx dx, bl ; 0f b6 d3 add dx, 002c1h ; 81 c2 c1 02 mov ax, si ; 89 f0 - call 01650h ; e8 36 a3 + call 01650h ; e8 73 a1 mov bh, al ; 88 c7 cmp AL, strict byte 00ch ; 3c 0c - jc short 07344h ; 72 24 + jc short 07507h ; 72 24 test cl, cl ; 84 c9 - jne short 07331h ; 75 0d + jne short 074f4h ; 75 0d push 009afh ; 68 af 09 push strict byte 00002h ; 6a 02 - call 01972h ; e8 46 a6 + call 01972h ; e8 83 a4 add sp, strict byte 00004h ; 83 c4 04 mov CL, strict byte 001h ; b1 01 @@ -10467,34 +10649,34 @@ push 009c4h ; 68 c4 09 push strict byte 00002h ; 6a 02 - call 01972h ; e8 34 a6 + call 01972h ; e8 71 a4 add sp, strict byte 00006h ; 83 c4 06 - jmp near 073dch ; e9 98 00 + jmp near 0759fh ; e9 98 00 cmp AL, strict byte 008h ; 3c 08 - jc short 0735bh ; 72 13 + jc short 0751eh ; 72 13 test ch, ch ; 84 ed - jne short 07359h ; 75 0d + jne short 0751ch ; 75 0d push 009d7h ; 68 d7 09 push strict byte 00002h ; 6a 02 - call 01972h ; e8 1e a6 + call 01972h ; e8 5b a4 add sp, strict byte 00004h ; 83 c4 04 mov CH, strict byte 001h ; b5 01 - jmp short 07331h ; eb d6 + jmp short 074f4h ; eb d6 cmp AL, strict byte 004h ; 3c 04 - jnc short 07376h ; 73 17 + jnc short 07539h ; 73 17 cmp byte [bp-00ch], 000h ; 80 7e f4 00 - jne short 07376h ; 75 11 + jne short 07539h ; 75 11 push 009ech ; 68 ec 09 push strict byte 00002h ; 6a 02 - call 01972h ; e8 05 a6 + call 01972h ; e8 42 a4 add sp, strict byte 00004h ; 83 c4 04 mov byte [bp-00ch], 001h ; c6 46 f4 01 - jmp short 0738ch ; eb 16 + jmp short 0754fh ; eb 16 cmp bh, 004h ; 80 ff 04 - jc short 0738ch ; 72 11 + jc short 0754fh ; 72 11 test cl, cl ; 84 c9 - jne short 0738ch ; 75 0d + jne short 0754fh ; 75 0d push 009feh ; 68 fe 09 push strict byte 00002h ; 6a 02 - call 01972h ; e8 eb a5 + call 01972h ; e8 28 a4 add sp, strict byte 00004h ; 83 c4 04 mov CL, strict byte 001h ; b1 01 @@ -10504,8 +10686,8 @@ push 00a12h ; 68 12 0a push strict byte 00002h ; 6a 02 - call 01972h ; e8 d9 a5 + call 01972h ; e8 16 a4 add sp, strict byte 00006h ; 83 c4 06 cmp bh, 004h ; 80 ff 04 - jc short 073a4h ; 72 03 + jc short 07567h ; 72 03 sub bh, 004h ; 80 ef 04 movzx ax, bh ; 0f b6 c7 @@ -10515,10 +10697,10 @@ sar ax, 1 ; d1 f8 test ax, ax ; 85 c0 - je short 073b5h ; 74 05 + je short 07578h ; 74 05 push 00a1ch ; 68 1c 0a - jmp short 073b8h ; eb 03 + jmp short 0757bh ; eb 03 push 00a27h ; 68 27 0a push strict byte 00002h ; 6a 02 - call 01972h ; e8 b5 a5 + call 01972h ; e8 f2 a3 add sp, strict byte 00004h ; 83 c4 04 movzx ax, bh ; 0f b6 c7 @@ -10527,27 +10709,27 @@ idiv di ; f7 ff test dx, dx ; 85 d2 - je short 073d2h ; 74 05 + je short 07595h ; 74 05 push 00a30h ; 68 30 0a - jmp short 073d5h ; eb 03 + jmp short 07598h ; eb 03 push 00a36h ; 68 36 0a push di ; 57 - call 01972h ; e8 99 a5 + call 01972h ; e8 d6 a3 add sp, strict byte 00004h ; 83 c4 04 db 0feh, 0c3h ; inc bl ; fe c3 - jmp near 07307h ; e9 26 ff + jmp near 074cah ; e9 26 ff cmp byte [bp-00ch], 000h ; 80 7e f4 00 - jne short 073fah ; 75 13 + jne short 075bdh ; 75 13 test cl, cl ; 84 c9 - jne short 073fah ; 75 0f + jne short 075bdh ; 75 0f test ch, ch ; 84 ed - jne short 073fah ; 75 0b + jne short 075bdh ; 75 0b push 00a3dh ; 68 3d 0a push strict byte 00002h ; 6a 02 - call 01972h ; e8 7b a5 + call 01972h ; e8 b8 a3 add sp, strict byte 00004h ; 83 c4 04 push 00a51h ; 68 51 0a push strict byte 00002h ; 6a 02 - call 01972h ; e8 70 a5 + call 01972h ; e8 ad a3 add sp, strict byte 00004h ; 83 c4 04 lea sp, [bp-00ah] ; 8d 66 f6 @@ -10559,5 +10741,5 @@ pop bp ; 5d retn ; c3 -get_boot_drive_: ; 0xf740f LB 0x28 +get_boot_drive_: ; 0xf75d2 LB 0x28 push bp ; 55 mov bp, sp ; 89 e5 @@ -10567,10 +10749,10 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 4d a2 + call 0166ch ; e8 8a a0 mov dx, 002c0h ; ba c0 02 - call 01650h ; e8 2b a2 + call 01650h ; e8 68 a0 sub bl, 002h ; 80 eb 02 cmp bl, al ; 38 c3 - jc short 0742eh ; 72 02 + jc short 075f1h ; 72 02 mov BL, strict byte 0ffh ; b3 ff mov al, bl ; 88 d8 @@ -10580,5 +10762,5 @@ pop bp ; 5d retn ; c3 -show_logo_: ; 0xf7437 LB 0x224 +show_logo_: ; 0xf75fa LB 0x224 push bp ; 55 mov bp, sp ; 89 e5 @@ -10591,5 +10773,5 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 21 a2 + call 0166ch ; e8 5e a0 mov si, ax ; 89 c6 xor cl, cl ; 30 c9 @@ -10602,7 +10784,7 @@ out strict byte 040h, AL ; e6 40 movzx ax, dl ; 0f b6 c2 - call 072cbh ; e8 68 fe + call 0748eh ; e8 68 fe cmp ax, 066bbh ; 3d bb 66 - jne near 0753bh ; 0f 85 d1 00 + jne near 076feh ; 0f 85 d1 00 push SS ; 16 pop ES ; 07 @@ -10612,9 +10794,9 @@ mov word [es:di], bx ; 26 89 1d cmp ax, strict word 0004fh ; 3d 4f 00 - jne near 0753bh ; 0f 85 bd 00 + jne near 076feh ; 0f 85 bd 00 mov al, dl ; 88 d0 add AL, strict byte 004h ; 04 04 xor ah, ah ; 30 e4 - call 072b5h ; e8 2e fe + call 07478h ; e8 2e fe mov ch, al ; 88 c5 mov byte [bp-00ch], al ; 88 46 f4 @@ -10622,5 +10804,5 @@ add AL, strict byte 005h ; 04 05 xor ah, ah ; 30 e4 - call 072b5h ; e8 20 fe + call 07478h ; e8 20 fe mov dh, al ; 88 c6 mov byte [bp-010h], al ; 88 46 f0 @@ -10628,5 +10810,5 @@ add AL, strict byte 002h ; 04 02 xor ah, ah ; 30 e4 - call 072cbh ; e8 28 fe + call 0748eh ; e8 28 fe mov bx, ax ; 89 c3 mov word [bp-014h], ax ; 89 46 ec @@ -10634,22 +10816,22 @@ add AL, strict byte 006h ; 04 06 xor ah, ah ; 30 e4 - call 072b5h ; e8 04 fe + call 07478h ; e8 04 fe mov byte [bp-012h], al ; 88 46 ee test ch, ch ; 84 ed - jne short 074c2h ; 75 0a + jne short 07685h ; 75 0a test dh, dh ; 84 f6 - jne short 074c2h ; 75 06 + jne short 07685h ; 75 06 test bx, bx ; 85 db - je near 0753bh ; 0f 84 79 00 + je near 076feh ; 0f 84 79 00 mov bx, 00142h ; bb 42 01 mov ax, 04f02h ; b8 02 4f int 010h ; cd 10 cmp byte [bp-00ch], 000h ; 80 7e f4 00 - je short 074f3h ; 74 23 + je short 076b6h ; 74 23 xor bx, bx ; 31 db - jmp short 074dah ; eb 06 + jmp short 0769dh ; eb 06 inc bx ; 43 cmp bx, strict byte 00010h ; 83 fb 10 - jnbe short 074fah ; 77 20 + jnbe short 076bdh ; 77 20 mov ax, bx ; 89 d8 or ah, 002h ; 80 cc 02 @@ -10658,30 +10840,30 @@ xor dx, dx ; 31 d2 mov ax, strict word 00001h ; b8 01 00 - call 07203h ; e8 18 fd + call 073c6h ; e8 18 fd cmp AL, strict byte 086h ; 3c 86 - jne short 074d4h ; 75 e5 + jne short 07697h ; 75 e5 mov CL, strict byte 001h ; b1 01 - jmp short 074fah ; eb 07 + jmp short 076bdh ; eb 07 mov ax, 00210h ; b8 10 02 mov dx, 003b8h ; ba b8 03 out DX, ax ; ef test cl, cl ; 84 c9 - jne short 07510h ; 75 12 + jne short 076d3h ; 75 12 mov ax, word [bp-014h] ; 8b 46 ec shr ax, 004h ; c1 e8 04 mov dx, strict word 00001h ; ba 01 00 - call 07203h ; e8 f9 fc + call 073c6h ; e8 f9 fc cmp AL, strict byte 086h ; 3c 86 - jne short 07510h ; 75 02 + jne short 076d3h ; 75 02 mov CL, strict byte 001h ; b1 01 cmp byte [bp-010h], 000h ; 80 7e f0 00 - je short 0753bh ; 74 25 + je short 076feh ; 74 25 test cl, cl ; 84 c9 - jne short 0753bh ; 75 21 + jne short 076feh ; 75 21 mov bx, strict word 00010h ; bb 10 00 - jmp short 07524h ; eb 05 + jmp short 076e7h ; eb 05 dec bx ; 4b test bx, bx ; 85 db - jbe short 0753bh ; 76 17 + jbe short 076feh ; 76 17 mov ax, bx ; 89 d8 or ah, 002h ; 80 cc 02 @@ -10690,39 +10872,39 @@ xor dx, dx ; 31 d2 mov ax, strict word 00001h ; b8 01 00 - call 07203h ; e8 ce fc + call 073c6h ; e8 ce fc cmp AL, strict byte 086h ; 3c 86 - jne short 0751fh ; 75 e6 + jne short 076e2h ; 75 e6 mov CL, strict byte 001h ; b1 01 xor bx, bx ; 31 db mov dx, 00339h ; ba 39 03 mov ax, si ; 89 f0 - call 0165eh ; e8 19 a1 + call 0165eh ; e8 56 9f mov AL, strict byte 003h ; b0 03 mov AH, strict byte 000h ; b4 00 int 010h ; cd 10 cmp byte [bp-012h], 000h ; 80 7e ee 00 - je near 0763ch ; 0f 84 e9 00 + je near 077ffh ; 0f 84 e9 00 cmp byte [bp-00ch], 000h ; 80 7e f4 00 - jne short 07589h ; 75 30 + jne short 0774ch ; 75 30 cmp byte [bp-010h], 000h ; 80 7e f0 00 - jne short 07589h ; 75 2a + jne short 0774ch ; 75 2a cmp word [bp-014h], strict byte 00000h ; 83 7e ec 00 - jne short 07589h ; 75 24 + jne short 0774ch ; 75 24 cmp byte [bp-012h], 002h ; 80 7e ee 02 - jne short 07576h ; 75 0b + jne short 07739h ; 75 0b push 00a53h ; 68 53 0a push strict byte 00002h ; 6a 02 - call 01972h ; e8 ff a3 + call 01972h ; e8 3c a2 add sp, strict byte 00004h ; 83 c4 04 test cl, cl ; 84 c9 - jne short 07589h ; 75 0f + jne short 0774ch ; 75 0f mov dx, strict word 00001h ; ba 01 00 mov ax, 000c0h ; b8 c0 00 - call 07203h ; e8 80 fc + call 073c6h ; e8 80 fc cmp AL, strict byte 086h ; 3c 86 - jne short 07589h ; 75 02 + jne short 0774ch ; 75 02 mov CL, strict byte 001h ; b1 01 test cl, cl ; 84 c9 - je near 0763ch ; 0f 84 ad 00 + je near 077ffh ; 0f 84 ad 00 mov byte [bp-00eh], 000h ; c6 46 f2 00 mov ax, 00100h ; b8 00 01 @@ -10743,52 +10925,52 @@ push 00a75h ; 68 75 0a push strict byte 00002h ; 6a 02 - call 01972h ; e8 ba a3 + call 01972h ; e8 f7 a1 add sp, strict byte 00004h ; 83 c4 04 - call 072dfh ; e8 21 fd + call 074a2h ; e8 21 fd push 00ab9h ; 68 b9 0a push strict byte 00002h ; 6a 02 - call 01972h ; e8 ac a3 + call 01972h ; e8 e9 a1 add sp, strict byte 00004h ; 83 c4 04 mov dx, strict word 00001h ; ba 01 00 mov ax, strict word 00040h ; b8 40 00 - call 07203h ; e8 31 fc + call 073c6h ; e8 31 fc mov bl, al ; 88 c3 test al, al ; 84 c0 - je short 075c9h ; 74 f1 + je short 0778ch ; 74 f1 cmp AL, strict byte 030h ; 3c 30 - je short 0762ah ; 74 4e + je short 077edh ; 74 4e cmp bl, 002h ; 80 fb 02 - jc short 07603h ; 72 22 + jc short 077c6h ; 72 22 cmp bl, 009h ; 80 fb 09 - jnbe short 07603h ; 77 1d + jnbe short 077c6h ; 77 1d movzx ax, bl ; 0f b6 c3 - call 0740fh ; e8 23 fe + call 075d2h ; e8 23 fe cmp AL, strict byte 0ffh ; 3c ff - jne short 075f2h ; 75 02 - jmp short 075c9h ; eb d7 + jne short 077b5h ; 75 02 + jmp short 0778ch ; eb d7 movzx bx, al ; 0f b6 d8 mov dx, 00338h ; ba 38 03 mov ax, si ; 89 f0 - call 0165eh ; e8 61 a0 + call 0165eh ; e8 9e 9e mov byte [bp-00eh], 002h ; c6 46 f2 02 - jmp short 0762ah ; eb 27 + jmp short 077edh ; eb 27 cmp bl, 02eh ; 80 fb 2e - je short 07618h ; 74 10 + je short 077dbh ; 74 10 cmp bl, 026h ; 80 fb 26 - je short 0761eh ; 74 11 + je short 077e1h ; 74 11 cmp bl, 021h ; 80 fb 21 - jne short 07624h ; 75 12 + jne short 077e7h ; 75 12 mov byte [bp-00eh], 001h ; c6 46 f2 01 - jmp short 0762ah ; eb 12 + jmp short 077edh ; eb 12 mov byte [bp-00eh], 003h ; c6 46 f2 03 - jmp short 0762ah ; eb 0c + jmp short 077edh ; eb 0c mov byte [bp-00eh], 004h ; c6 46 f2 04 - jmp short 0762ah ; eb 06 + jmp short 077edh ; eb 06 cmp byte [bp-00eh], 000h ; 80 7e f2 00 - je short 075c9h ; 74 9f + je short 0778ch ; 74 9f movzx bx, byte [bp-00eh] ; 0f b6 5e f2 mov dx, 00339h ; ba 39 03 mov ax, si ; 89 f0 - call 0165eh ; e8 28 a0 + call 0165eh ; e8 65 9e mov AL, strict byte 003h ; b0 03 mov AH, strict byte 000h ; b4 00 @@ -10803,5 +10985,5 @@ push DS ; 1e mov ds, ax ; 8e d8 - call 0edbfh ; e8 71 77 + call 0edbfh ; e8 ae 75 pop DS ; 1f popad ; 66 61 @@ -10814,5 +10996,5 @@ pop bp ; 5d retn ; c3 -delay_boot_: ; 0xf765b LB 0x67 +delay_boot_: ; 0xf781e LB 0x67 push bp ; 55 mov bp, sp ; 89 e5 @@ -10821,5 +11003,5 @@ mov dx, ax ; 89 c2 test ax, ax ; 85 c0 - je short 076bbh ; 74 55 + je short 0787eh ; 74 55 mov AL, strict byte 034h ; b0 34 out strict byte 043h, AL ; e6 43 @@ -10831,22 +11013,22 @@ push 00b03h ; 68 03 0b push strict byte 00002h ; 6a 02 - call 01972h ; e8 f7 a2 + call 01972h ; e8 34 a1 add sp, strict byte 00006h ; 83 c4 06 mov bx, dx ; 89 d3 test bx, bx ; 85 db - jbe short 0769bh ; 76 17 + jbe short 0785eh ; 76 17 push bx ; 53 push 00b21h ; 68 21 0b push strict byte 00002h ; 6a 02 - call 01972h ; e8 e5 a2 + call 01972h ; e8 22 a1 add sp, strict byte 00006h ; 83 c4 06 xor dx, dx ; 31 d2 mov ax, strict word 00040h ; b8 40 00 - call 07203h ; e8 6b fb + call 073c6h ; e8 6b fb dec bx ; 4b - jmp short 07680h ; eb e5 + jmp short 07843h ; eb e5 push 00a51h ; 68 51 0a push strict byte 00002h ; 6a 02 - call 01972h ; e8 cf a2 + call 01972h ; e8 0c a1 add sp, strict byte 00004h ; 83 c4 04 mov AL, strict byte 034h ; b0 34 @@ -10859,5 +11041,5 @@ push DS ; 1e mov ds, ax ; 8e d8 - call 0edbfh ; e8 07 77 + call 0edbfh ; e8 44 75 pop DS ; 1f popad ; 66 61 @@ -10867,5 +11049,5 @@ pop bp ; 5d retn ; c3 -scsi_cmd_data_in_: ; 0xf76c2 LB 0xb2 +scsi_cmd_data_in_: ; 0xf7885 LB 0xb2 push bp ; 55 mov bp, sp ; 89 e5 @@ -10883,5 +11065,5 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 076d8h ; 75 f7 + jne short 0789bh ; 75 f7 mov ax, bx ; 89 d8 mov dx, word [bp+00ch] ; 8b 56 0c @@ -10889,5 +11071,5 @@ shr dx, 1 ; d1 ea rcr ax, 1 ; d1 d8 - loop 076e9h ; e2 fa + loop 078ach ; e2 fa and ax, 000f0h ; 25 f0 00 movzx cx, byte [bp+004h] ; 0f b6 4e 04 @@ -10907,5 +11089,5 @@ shr dx, 1 ; d1 ea rcr ax, 1 ; d1 d8 - loop 0770fh ; e2 fa + loop 078d2h ; e2 fa mov dx, si ; 89 f2 out DX, AL ; ee @@ -10913,5 +11095,5 @@ movzx ax, byte [bp+004h] ; 0f b6 46 04 cmp cx, ax ; 39 c1 - jnc short 07730h ; 73 0e + jnc short 078f3h ; 73 0e les di, [bp-00ah] ; c4 7e f6 add di, cx ; 01 cf @@ -10920,5 +11102,5 @@ out DX, AL ; ee inc cx ; 41 - jmp short 0771ah ; eb ea + jmp short 078ddh ; eb ea mov dx, si ; 89 f2 in AL, DX ; ec @@ -10926,10 +11108,10 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 07730h ; 75 f7 + jne short 078f3h ; 75 f7 lea dx, [si+001h] ; 8d 54 01 cmp word [bp+00ch], strict byte 00000h ; 83 7e 0c 00 - jne short 07748h ; 75 06 + jne short 0790bh ; 75 06 cmp bx, 08000h ; 81 fb 00 80 - jbe short 07762h ; 76 1a + jbe short 07925h ; 76 1a mov cx, 08000h ; b9 00 80 les di, [bp+006h] ; c4 7e 06 @@ -10940,5 +11122,5 @@ add ax, 00800h ; 05 00 08 mov word [bp+008h], ax ; 89 46 08 - jmp short 07739h ; eb d7 + jmp short 078fch ; eb d7 mov cx, bx ; 89 d9 les di, [bp+006h] ; c4 7e 06 @@ -10950,5 +11132,5 @@ pop bp ; 5d retn 0000ah ; c2 0a 00 -scsi_cmd_data_out_: ; 0xf7774 LB 0xb4 +scsi_cmd_data_out_: ; 0xf7937 LB 0xb4 push bp ; 55 mov bp, sp ; 89 e5 @@ -10966,5 +11148,5 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 0778ah ; 75 f7 + jne short 0794dh ; 75 f7 mov ax, bx ; 89 d8 mov dx, word [bp+00ch] ; 8b 56 0c @@ -10972,5 +11154,5 @@ shr dx, 1 ; d1 ea rcr ax, 1 ; d1 d8 - loop 0779bh ; e2 fa + loop 0795eh ; e2 fa and ax, 000f0h ; 25 f0 00 movzx cx, byte [bp+004h] ; 0f b6 4e 04 @@ -10990,5 +11172,5 @@ shr dx, 1 ; d1 ea rcr ax, 1 ; d1 d8 - loop 077c1h ; e2 fa + loop 07984h ; e2 fa mov dx, di ; 89 fa out DX, AL ; ee @@ -10996,5 +11178,5 @@ movzx ax, byte [bp+004h] ; 0f b6 46 04 cmp cx, ax ; 39 c1 - jnc short 077e2h ; 73 0e + jnc short 079a5h ; 73 0e les si, [bp-00ah] ; c4 76 f6 add si, cx ; 01 ce @@ -11003,10 +11185,10 @@ out DX, AL ; ee inc cx ; 41 - jmp short 077cch ; eb ea + jmp short 0798fh ; eb ea lea dx, [di+001h] ; 8d 55 01 cmp word [bp+00ch], strict byte 00000h ; 83 7e 0c 00 - jne short 077f1h ; 75 06 + jne short 079b4h ; 75 06 cmp bx, 08000h ; 81 fb 00 80 - jbe short 0780ch ; 76 1b + jbe short 079cfh ; 76 1b mov cx, 08000h ; b9 00 80 les si, [bp+006h] ; c4 76 06 @@ -11018,5 +11200,5 @@ add ax, 00800h ; 05 00 08 mov word [bp+008h], ax ; 89 46 08 - jmp short 077e2h ; eb d6 + jmp short 079a5h ; eb d6 mov cx, bx ; 89 d9 les si, [bp+006h] ; c4 76 06 @@ -11028,5 +11210,5 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 07814h ; 75 f7 + jne short 079d7h ; 75 f7 xor ax, ax ; 31 c0 lea sp, [bp-004h] ; 8d 66 fc @@ -11035,5 +11217,5 @@ pop bp ; 5d retn 0000ah ; c2 0a 00 -@scsi_read_sectors: ; 0xf7828 LB 0xb9 +@scsi_read_sectors: ; 0xf79eb LB 0xb9 push bp ; 55 mov bp, sp ; 89 e5 @@ -11046,5 +11228,5 @@ sub bl, 008h ; 80 eb 08 cmp bl, 004h ; 80 fb 04 - jbe short 07854h ; 76 12 + jbe short 07a17h ; 76 12 movzx ax, bl ; 0f b6 c3 push ax ; 50 @@ -11052,5 +11234,5 @@ push 00b38h ; 68 38 0b push strict byte 00007h ; 6a 07 - call 01972h ; e8 21 a1 + call 01972h ; e8 5e 9f add sp, strict byte 00008h ; 83 c4 08 mov es, [bp+006h] ; 8e 46 06 @@ -11079,5 +11261,5 @@ sal word [bp-008h], 1 ; d1 66 f8 rcl word [bp-006h], 1 ; d1 56 fa - loop 0789dh ; e2 f8 + loop 07a60h ; e2 f8 push dword [bp-008h] ; 66 ff 76 f8 db 066h, 026h, 0ffh, 074h, 004h @@ -11087,8 +11269,8 @@ mov cx, ss ; 8c d1 lea bx, [bp-012h] ; 8d 5e ee - call 076c2h ; e8 08 fe + call 07885h ; e8 08 fe mov ah, al ; 88 c4 test al, al ; 84 c0 - jne short 078d5h ; 75 15 + jne short 07a98h ; 75 15 mov es, [bp+006h] ; 8e 46 06 mov word [es:si+014h], di ; 26 89 7c 14 @@ -11103,5 +11285,5 @@ pop bp ; 5d retn 00004h ; c2 04 00 -@scsi_write_sectors: ; 0xf78e1 LB 0xb9 +@scsi_write_sectors: ; 0xf7aa4 LB 0xb9 push bp ; 55 mov bp, sp ; 89 e5 @@ -11114,5 +11296,5 @@ sub bl, 008h ; 80 eb 08 cmp bl, 004h ; 80 fb 04 - jbe short 0790dh ; 76 12 + jbe short 07ad0h ; 76 12 movzx ax, bl ; 0f b6 c3 push ax ; 50 @@ -11120,5 +11302,5 @@ push 00b38h ; 68 38 0b push strict byte 00007h ; 6a 07 - call 01972h ; e8 68 a0 + call 01972h ; e8 a5 9e add sp, strict byte 00008h ; 83 c4 08 mov es, [bp+006h] ; 8e 46 06 @@ -11147,5 +11329,5 @@ sal word [bp-008h], 1 ; d1 66 f8 rcl word [bp-006h], 1 ; d1 56 fa - loop 07956h ; e2 f8 + loop 07b19h ; e2 f8 push dword [bp-008h] ; 66 ff 76 f8 db 066h, 026h, 0ffh, 074h, 004h @@ -11155,8 +11337,8 @@ mov cx, ss ; 8c d1 lea bx, [bp-012h] ; 8d 5e ee - call 07774h ; e8 01 fe + call 07937h ; e8 01 fe mov ah, al ; 88 c4 test al, al ; 84 c0 - jne short 0798eh ; 75 15 + jne short 07b51h ; 75 15 mov es, [bp+006h] ; 8e 46 06 mov word [es:si+014h], di ; 26 89 7c 14 @@ -11171,5 +11353,5 @@ pop bp ; 5d retn 00004h ; c2 04 00 -scsi_cmd_packet_: ; 0xf799a LB 0x166 +scsi_cmd_packet_: ; 0xf7b5d LB 0x166 push bp ; 55 mov bp, sp ; 89 e5 @@ -11183,20 +11365,20 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 b6 9c + call 0166ch ; e8 f3 9a mov si, 00122h ; be 22 01 mov word [bp-00eh], ax ; 89 46 f2 cmp byte [bp+00ah], 002h ; 80 7e 0a 02 - jne short 079e1h ; 75 1f - mov bx, 00da2h ; bb a2 0d + jne short 07ba4h ; 75 1f + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 64 9f + call 01931h ; e8 a1 9d push 00b6ah ; 68 6a 0b push 00b7ah ; 68 7a 0b push strict byte 00004h ; 6a 04 - call 01972h ; e8 9a 9f + call 01972h ; e8 d7 9d add sp, strict byte 00006h ; 83 c4 06 mov dx, strict word 00001h ; ba 01 00 - jmp near 07af5h ; e9 14 01 + jmp near 07cb8h ; e9 14 01 sub di, strict byte 00008h ; 83 ef 08 sal di, 002h ; c1 e7 02 @@ -11212,5 +11394,5 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 079fdh ; 75 f7 + jne short 07bc0h ; 75 f7 xor ax, ax ; 31 c0 mov dx, word [bp+006h] ; 8b 56 06 @@ -11228,5 +11410,5 @@ shr dx, 1 ; d1 ea rcr ax, 1 ; d1 d8 - loop 07a28h ; e2 fa + loop 07bebh ; e2 fa and ax, 000f0h ; 25 f0 00 movzx cx, byte [bp-006h] ; 0f b6 4e fa @@ -11246,5 +11428,5 @@ shr dx, 1 ; d1 ea rcr ax, 1 ; d1 d8 - loop 07a4fh ; e2 fa + loop 07c12h ; e2 fa mov dx, bx ; 89 da out DX, AL ; ee @@ -11252,5 +11434,5 @@ movzx ax, byte [bp-006h] ; 0f b6 46 fa cmp cx, ax ; 39 c1 - jnc short 07a70h ; 73 0e + jnc short 07c33h ; 73 0e les di, [bp-00ch] ; c4 7e f4 add di, cx ; 01 cf @@ -11259,5 +11441,5 @@ out DX, AL ; ee inc cx ; 41 - jmp short 07a5ah ; eb ea + jmp short 07c1dh ; eb ea mov dx, bx ; 89 da in AL, DX ; ec @@ -11265,7 +11447,7 @@ ; sub ah, ah ; 2a e4 test AL, strict byte 001h ; a8 01 - jne short 07a70h ; 75 f7 + jne short 07c33h ; 75 f7 test AL, strict byte 002h ; a8 02 - je short 07a8bh ; 74 0e + je short 07c4eh ; 74 0e lea dx, [bx+003h] ; 8d 57 03 xor al, al ; 30 c0 @@ -11275,12 +11457,12 @@ ; sub ah, ah ; 2a e4 mov dx, strict word 00003h ; ba 03 00 - jmp short 07af5h ; eb 6a + jmp short 07cb8h ; eb 6a mov ax, word [bp+004h] ; 8b 46 04 test ax, ax ; 85 c0 - je short 07a9ah ; 74 08 + je short 07c5dh ; 74 08 lea dx, [bx+001h] ; 8d 57 01 mov cx, ax ; 89 c1 in AL, DX ; ec - loop 07a97h ; e2 fd + loop 07c5ah ; e2 fd mov ax, word [bp+006h] ; 8b 46 06 mov es, [bp-00eh] ; 8e 46 f2 @@ -11290,7 +11472,7 @@ lea ax, [bx+001h] ; 8d 47 01 cmp word [bp+008h], strict byte 00000h ; 83 7e 08 00 - jne short 07abbh ; 75 07 + jne short 07c7eh ; 75 07 cmp word [bp+006h], 08000h ; 81 7e 06 00 80 - jbe short 07ad8h ; 76 1d + jbe short 07c9bh ; 76 1d mov dx, ax ; 89 c2 mov cx, 08000h ; b9 00 80 @@ -11302,5 +11484,5 @@ add ax, 00800h ; 05 00 08 mov word [bp+00eh], ax ; 89 46 0e - jmp short 07aabh ; eb d3 + jmp short 07c6eh ; eb d3 mov dx, ax ; 89 c2 mov cx, word [bp+006h] ; 8b 4e 06 @@ -11309,8 +11491,8 @@ mov es, [bp-00eh] ; 8e 46 f2 cmp word [es:si+01ch], strict byte 00000h ; 26 83 7c 1c 00 - je short 07af3h ; 74 07 + je short 07cb6h ; 74 07 mov cx, word [es:si+01ch] ; 26 8b 4c 1c in AL, DX ; ec - loop 07af0h ; e2 fd + loop 07cb3h ; e2 fd xor dx, dx ; 31 d2 mov ax, dx ; 89 d0 @@ -11320,5 +11502,5 @@ pop bp ; 5d retn 0000ch ; c2 0c 00 -scsi_enumerate_attached_devices_: ; 0xf7b00 LB 0x3e5 +scsi_enumerate_attached_devices_: ; 0xf7cc3 LB 0x3e5 push bp ; 55 mov bp, sp ; 89 e5 @@ -11332,17 +11514,17 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 56 9b + call 0166ch ; e8 93 99 mov si, 00122h ; be 22 01 mov word [bp-01ah], ax ; 89 46 e6 mov word [bp-010h], strict word 00000h ; c7 46 f0 00 00 - jmp near 07e73h ; e9 4f 03 + jmp near 08036h ; e9 4f 03 mov es, [bp-01ah] ; 8e 46 e6 cmp byte [es:si+001e8h], 004h ; 26 80 bc e8 01 04 - jnc near 07edbh ; 0f 83 aa 03 + jnc near 0809eh ; 0f 83 aa 03 mov cx, strict word 0000ah ; b9 0a 00 xor bx, bx ; 31 db mov dx, ss ; 8c d2 lea ax, [bp-026h] ; 8d 46 da - call 0959ah ; e8 5c 1a + call 0975ah ; e8 59 1a mov byte [bp-026h], 025h ; c6 46 da 25 push dword 000000008h ; 66 6a 08 @@ -11355,11 +11537,11 @@ lea bx, [bp-026h] ; 8d 5e da mov ax, word [bp-00228h] ; 8b 86 d8 fd - call 076c2h ; e8 65 fb + call 07885h ; e8 65 fb test al, al ; 84 c0 - je short 07b6fh ; 74 0e + je short 07d32h ; 74 0e push 00b9ah ; 68 9a 0b push 00bd3h ; 68 d3 0b push strict byte 00007h ; 6a 07 - call 01972h ; e8 06 9e + call 01972h ; e8 43 9c add sp, strict byte 00006h ; 83 c4 06 movzx ax, byte [bp-00225h] ; 0f b6 86 db fd @@ -11373,5 +11555,5 @@ sal ax, 1 ; d1 e0 rcl dx, 1 ; d1 d2 - loop 07b8ah ; e2 fa + loop 07d4dh ; e2 fa or bx, ax ; 09 c3 or dx, di ; 09 fa @@ -11390,5 +11572,5 @@ sal ax, 1 ; d1 e0 rcl dx, 1 ; d1 d2 - loop 07bbch ; e2 fa + loop 07d7fh ; e2 fa or ax, bx ; 09 d8 or dx, di ; 09 fa @@ -11397,11 +11579,11 @@ mov word [bp-016h], ax ; 89 46 ea test dx, dx ; 85 d2 - jne short 07bd9h ; 75 05 + jne short 07d9ch ; 75 05 cmp ax, 00200h ; 3d 00 02 - je short 07bf9h ; 74 20 - mov bx, 00da2h ; bb a2 0d + je short 07dbch ; 74 20 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 4d 9d + call 01931h ; e8 8a 9b push dx ; 52 push word [bp-016h] ; ff 76 ea @@ -11409,26 +11591,26 @@ push 00bf2h ; 68 f2 0b push strict byte 00004h ; 6a 04 - call 01972h ; e8 7f 9d + call 01972h ; e8 bc 9b add sp, strict byte 0000ah ; 83 c4 0a - jmp near 07e6ah ; e9 71 02 + jmp near 0802dh ; e9 71 02 mov es, [bp-01ah] ; 8e 46 e6 mov al, byte [es:si+001e8h] ; 26 8a 84 e8 01 mov byte [bp-00ch], al ; 88 46 f4 cmp AL, strict byte 001h ; 3c 01 - jc short 07c14h ; 72 0c - jbe short 07c1ch ; 76 12 + jc short 07dd7h ; 72 0c + jbe short 07ddfh ; 76 12 cmp AL, strict byte 003h ; 3c 03 - je short 07c24h ; 74 16 + je short 07de7h ; 74 16 cmp AL, strict byte 002h ; 3c 02 - je short 07c20h ; 74 0e - jmp short 07c70h ; eb 5c + je short 07de3h ; 74 0e + jmp short 07e33h ; eb 5c test al, al ; 84 c0 - jne short 07c70h ; 75 58 + jne short 07e33h ; 75 58 mov BL, strict byte 090h ; b3 90 - jmp short 07c26h ; eb 0a + jmp short 07de9h ; eb 0a mov BL, strict byte 098h ; b3 98 - jmp short 07c26h ; eb 06 + jmp short 07de9h ; eb 06 mov BL, strict byte 0a0h ; b3 a0 - jmp short 07c26h ; eb 02 + jmp short 07de9h ; eb 02 mov BL, strict byte 0a8h ; b3 a8 mov al, bl ; 88 d8 @@ -11436,17 +11618,17 @@ movzx cx, al ; 0f b6 c8 mov ax, cx ; 89 c8 - call 016ach ; e8 7a 9a + call 016ach ; e8 b7 98 test al, al ; 84 c0 - je short 07c70h ; 74 3a + je short 07e33h ; 74 3a mov al, bl ; 88 d8 db 0feh, 0c0h ; inc al ; fe c0 xor ah, ah ; 30 e4 - call 016ach ; e8 6d 9a + call 016ach ; e8 aa 98 xor ah, ah ; 30 e4 mov dx, ax ; 89 c2 sal dx, 008h ; c1 e2 08 movzx ax, bl ; 0f b6 c3 - call 016ach ; e8 60 9a + call 016ach ; e8 9d 98 xor ah, ah ; 30 e4 add ax, dx ; 01 d0 @@ -11457,24 +11639,24 @@ add AL, strict byte 002h ; 04 02 xor ah, ah ; 30 e4 - call 016ach ; e8 4d 9a + call 016ach ; e8 8a 98 xor ah, ah ; 30 e4 mov word [bp-014h], ax ; 89 46 ec mov ax, cx ; 89 c8 - call 016ach ; e8 43 9a + call 016ach ; e8 80 98 xor ah, ah ; 30 e4 mov word [bp-01ch], ax ; 89 46 e4 - jmp short 07cb5h ; eb 45 + jmp short 07e78h ; eb 45 mov ax, word [bp-018h] ; 8b 46 e8 cmp ax, strict word 00040h ; 3d 40 00 - jnbe short 07c7ah ; 77 02 - jne short 07c86h ; 75 0c + jnbe short 07e3dh ; 77 02 + jne short 07e49h ; 75 0c mov word [bp-014h], 000ffh ; c7 46 ec ff 00 mov word [bp-01ch], strict word 0003fh ; c7 46 e4 3f 00 - jmp short 07c9eh ; eb 18 + jmp short 07e61h ; eb 18 cmp ax, strict word 00020h ; 3d 20 00 - jnbe short 07c8dh ; 77 02 - jne short 07c94h ; 75 07 + jnbe short 07e50h ; 77 02 + jne short 07e57h ; 75 07 mov word [bp-014h], 00080h ; c7 46 ec 80 00 - jmp short 07c99h ; eb 05 + jmp short 07e5ch ; eb 05 mov word [bp-014h], strict word 00040h ; c7 46 ec 40 00 mov word [bp-01ch], strict word 00020h ; c7 46 e4 20 00 @@ -11484,5 +11666,5 @@ mov dx, word [bp-018h] ; 8b 56 e8 xor cx, cx ; 31 c9 - call 09530h ; e8 80 18 + call 096f0h ; e8 7d 18 mov di, ax ; 89 c7 mov word [bp-012h], dx ; 89 56 ee @@ -11511,14 +11693,14 @@ mov word [es:bx+02ah], ax ; 26 89 47 2a cmp word [bp-012h], strict byte 00000h ; 83 7e ee 00 - jne short 07d11h ; 75 06 + jne short 07ed4h ; 75 06 cmp di, 00400h ; 81 ff 00 04 - jbe short 07d19h ; 76 08 + jbe short 07edch ; 76 08 mov word [es:bx+028h], 00400h ; 26 c7 47 28 00 04 - jmp short 07d1dh ; eb 04 + jmp short 07ee0h ; eb 04 mov word [es:bx+028h], di ; 26 89 7f 28 - mov bx, 00da2h ; bb a2 0d + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 09 9c + call 01931h ; e8 46 9a push word [bp-018h] ; ff 76 e8 push word [bp-00eh] ; ff 76 f2 @@ -11531,5 +11713,5 @@ push 00c20h ; 68 20 0c push strict byte 00004h ; 6a 04 - call 01972h ; e8 2d 9c + call 01972h ; e8 6a 9a add sp, strict byte 00012h ; 83 c4 12 movzx ax, dl ; 0f b6 c2 @@ -11543,9 +11725,9 @@ mov word [es:bx+030h], ax ; 26 89 47 30 cmp word [bp-012h], strict byte 00000h ; 83 7e ee 00 - jne short 07d6fh ; 75 06 + jne short 07f32h ; 75 06 cmp di, 00400h ; 81 ff 00 04 - jbe short 07d77h ; 76 08 + jbe short 07f3ah ; 76 08 mov word [es:bx+02eh], 00400h ; 26 c7 47 2e 00 04 - jmp short 07d7bh ; eb 04 + jmp short 07f3eh ; eb 04 mov word [es:bx+02eh], di ; 26 89 7f 2e movzx ax, dl ; 0f b6 c2 @@ -11569,5 +11751,5 @@ mov dx, strict word 00075h ; ba 75 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 95 98 + call 01650h ; e8 d2 96 db 0feh, 0c0h ; inc al ; fe c0 @@ -11575,14 +11757,14 @@ mov dx, strict word 00075h ; ba 75 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 95 98 + call 0165eh ; e8 d2 96 inc byte [bp-00ch] ; fe 46 f4 mov al, byte [bp-00ch] ; 8a 46 f4 mov es, [bp-01ah] ; 8e 46 e6 mov byte [es:si+001e8h], al ; 26 88 84 e8 01 - jmp near 07e6ah ; e9 90 00 - mov bx, 00da2h ; bb a2 0d + jmp near 0802dh ; e9 90 00 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 4c 9b + call 01931h ; e8 89 99 push word [bp-010h] ; ff 76 f0 movzx ax, byte [bp-00ch] ; 0f b6 46 f4 @@ -11590,5 +11772,5 @@ push 00c4ah ; 68 4a 0c push strict byte 00004h ; 6a 04 - call 01972h ; e8 7d 9b + call 01972h ; e8 ba 99 add sp, strict byte 00008h ; 83 c4 08 mov dl, byte [bp-00ch] ; 8a 56 f4 @@ -11629,5 +11811,5 @@ inc word [bp-010h] ; ff 46 f0 cmp word [bp-010h], strict byte 00010h ; 83 7e f0 10 - jnl short 07edbh ; 7d 68 + jnl short 0809eh ; 7d 68 mov byte [bp-026h], 012h ; c6 46 da 12 xor al, al ; 30 c0 @@ -11646,23 +11828,23 @@ lea bx, [bp-026h] ; 8d 5e da mov ax, word [bp-00228h] ; 8b 86 d8 fd - call 076c2h ; e8 1e f8 + call 07885h ; e8 1e f8 test al, al ; 84 c0 - je short 07eb6h ; 74 0e + je short 08079h ; 74 0e push 00b9ah ; 68 9a 0b push 00bbah ; 68 ba 0b push strict byte 00007h ; 6a 07 - call 01972h ; e8 bf 9a + call 01972h ; e8 fc 98 add sp, strict byte 00006h ; 83 c4 06 test byte [bp-00226h], 0e0h ; f6 86 da fd e0 - jne short 07ec6h ; 75 09 + jne short 08089h ; 75 09 test byte [bp-00226h], 01fh ; f6 86 da fd 1f - je near 07b24h ; 0f 84 5e fc + je near 07ce7h ; 0f 84 5e fc test byte [bp-00226h], 0e0h ; f6 86 da fd e0 - jne short 07e6ah ; 75 9d + jne short 0802dh ; 75 9d mov al, byte [bp-00226h] ; 8a 86 da fd and AL, strict byte 01fh ; 24 1f cmp AL, strict byte 005h ; 3c 05 - je near 07ddah ; 0f 84 01 ff - jmp short 07e6ah ; eb 8f + je near 07f9dh ; 0f 84 01 ff + jmp short 0802dh ; eb 8f lea sp, [bp-00ah] ; 8d 66 f6 pop di ; 5f @@ -11673,10 +11855,10 @@ pop bp ; 5d retn ; c3 -_scsi_init: ; 0xf7ee5 LB 0x66 +_scsi_init: ; 0xf80a8 LB 0x66 push bp ; 55 mov bp, sp ; 89 e5 mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 7b 97 + call 0166ch ; e8 b8 95 mov bx, 00122h ; bb 22 01 mov es, ax ; 8e c0 @@ -11689,10 +11871,10 @@ ; sub ah, ah ; 2a e4 cmp AL, strict byte 055h ; 3c 55 - jne short 07f15h ; 75 0c + jne short 080d8h ; 75 0c xor al, al ; 30 c0 mov dx, 00433h ; ba 33 04 out DX, AL ; ee mov ax, 00430h ; b8 30 04 - call 07b00h ; e8 eb fb + call 07cc3h ; e8 eb fb mov AL, strict byte 055h ; b0 55 mov dx, 00436h ; ba 36 04 @@ -11702,10 +11884,10 @@ ; sub ah, ah ; 2a e4 cmp AL, strict byte 055h ; 3c 55 - jne short 07f2eh ; 75 0c + jne short 080f1h ; 75 0c xor al, al ; 30 c0 mov dx, 00437h ; ba 37 04 out DX, AL ; ee mov ax, 00434h ; b8 34 04 - call 07b00h ; e8 d2 fb + call 07cc3h ; e8 d2 fb mov AL, strict byte 055h ; b0 55 mov dx, 0043ah ; ba 3a 04 @@ -11715,14 +11897,14 @@ ; sub ah, ah ; 2a e4 cmp AL, strict byte 055h ; 3c 55 - jne short 07f47h ; 75 0c + jne short 0810ah ; 75 0c xor al, al ; 30 c0 mov dx, 0043bh ; ba 3b 04 out DX, AL ; ee mov ax, 00438h ; b8 38 04 - call 07b00h ; e8 b9 fb + call 07cc3h ; e8 b9 fb mov sp, bp ; 89 ec pop bp ; 5d retn ; c3 -high_bits_save_: ; 0xf7f4b LB 0x17 +high_bits_save_: ; 0xf810e LB 0x17 push bp ; 55 mov bp, sp ; 89 e5 @@ -11736,5 +11918,5 @@ pop bp ; 5d retn ; c3 -high_bits_restore_: ; 0xf7f62 LB 0x17 +high_bits_restore_: ; 0xf8125 LB 0x17 push bp ; 55 mov bp, sp ; 89 e5 @@ -11748,5 +11930,5 @@ pop bp ; 5d retn ; c3 -ahci_ctrl_set_bits_: ; 0xf7f79 LB 0x43 +ahci_ctrl_set_bits_: ; 0xf813c LB 0x43 push bp ; 55 mov bp, sp ; 89 e5 @@ -11786,5 +11968,5 @@ pop bp ; 5d retn ; c3 -ahci_ctrl_clear_bits_: ; 0xf7fbc LB 0x47 +ahci_ctrl_clear_bits_: ; 0xf817f LB 0x47 push bp ; 55 mov bp, sp ; 89 e5 @@ -11826,5 +12008,5 @@ pop bp ; 5d retn ; c3 -ahci_ctrl_is_bit_set_: ; 0xf8003 LB 0x39 +ahci_ctrl_is_bit_set_: ; 0xf81c6 LB 0x39 push bp ; 55 mov bp, sp ; 89 e5 @@ -11848,9 +12030,9 @@ xchg dx, ax ; 92 test dx, di ; 85 fa - jne short 0802fh ; 75 04 + jne short 081f2h ; 75 04 test ax, bx ; 85 d8 - je short 08033h ; 74 04 + je short 081f6h ; 74 04 mov AL, strict byte 001h ; b0 01 - jmp short 08035h ; eb 02 + jmp short 081f8h ; eb 02 xor al, al ; 30 c0 lea sp, [bp-004h] ; 8d 66 fc @@ -11859,5 +12041,5 @@ pop bp ; 5d retn ; c3 -ahci_ctrl_extract_bits_: ; 0xf803c LB 0x1b +ahci_ctrl_extract_bits_: ; 0xf81ff LB 0x1b push si ; 56 push bp ; 55 @@ -11867,12 +12049,12 @@ and dx, cx ; 21 ca movzx cx, byte [bp+006h] ; 0f b6 4e 06 - jcxz 08052h ; e3 06 + jcxz 08215h ; e3 06 shr dx, 1 ; d1 ea rcr ax, 1 ; d1 d8 - loop 0804ch ; e2 fa + loop 0820fh ; e2 fa pop bp ; 5d pop si ; 5e retn 00002h ; c2 02 00 -ahci_addr_to_phys_: ; 0xf8057 LB 0x1e +ahci_addr_to_phys_: ; 0xf821a LB 0x1e push bx ; 53 push cx ; 51 @@ -11885,5 +12067,5 @@ sal ax, 1 ; d1 e0 rcl dx, 1 ; d1 d2 - loop 08065h ; e2 fa + loop 08228h ; e2 fa xor cx, cx ; 31 c9 add ax, bx ; 01 d8 @@ -11893,5 +12075,5 @@ pop bx ; 5b retn ; c3 -ahci_port_cmd_sync_: ; 0xf8075 LB 0xd5 +ahci_port_cmd_sync_: ; 0xf8238 LB 0xd5 push bp ; 55 mov bp, sp ; 89 e5 @@ -11907,5 +12089,5 @@ mov di, word [es:si+00260h] ; 26 8b bc 60 02 cmp AL, strict byte 0ffh ; 3c ff - je near 08142h ; 0f 84 aa 00 + je near 08305h ; 0f 84 aa 00 movzx cx, byte [es:si+00263h] ; 26 0f b6 8c 63 02 xor dx, dx ; 31 d2 @@ -11919,5 +12101,5 @@ lea ax, [si+00080h] ; 8d 84 80 00 mov dx, es ; 8c c2 - call 08057h ; e8 96 ff + call 0821ah ; e8 96 ff mov es, [bp-00ah] ; 8e 46 f6 mov word [es:si+008h], ax ; 26 89 44 08 @@ -11929,5 +12111,5 @@ xor cx, cx ; 31 c9 mov ax, di ; 89 f8 - call 07f79h ; e8 98 fe + call 0813ch ; e8 98 fe lea ax, [si+00138h] ; 8d 84 38 01 cwd ; 99 @@ -11956,12 +12138,12 @@ mov dx, si ; 89 f2 mov ax, di ; 89 f8 - call 08003h ; e8 e2 fe + call 081c6h ; e8 e2 fe test al, al ; 84 c0 - je short 08104h ; 74 df + je short 082c7h ; 74 df mov bx, strict word 00001h ; bb 01 00 xor cx, cx ; 31 c9 mov dx, si ; 89 f2 mov ax, di ; 89 f8 - call 07f79h ; e8 48 fe + call 0813ch ; e8 48 fe mov dx, word [bp-00ch] ; 8b 56 f4 add dx, 00118h ; 81 c2 18 01 @@ -11969,5 +12151,5 @@ xor cx, cx ; 31 c9 mov ax, di ; 89 f8 - call 07fbch ; e8 7a fe + call 0817fh ; e8 7a fe lea sp, [bp-006h] ; 8d 66 fa pop di ; 5f @@ -11976,5 +12158,5 @@ pop bp ; 5d retn ; c3 -ahci_cmd_data_: ; 0xf814a LB 0x1ca +ahci_cmd_data_: ; 0xf830d LB 0x1ca push bp ; 55 mov bp, sp ; 89 e5 @@ -12000,5 +12182,5 @@ mov ax, 00080h ; b8 80 00 mov dx, word [bp-00ah] ; 8b 56 f6 - call 0959ah ; e8 11 14 + call 0975ah ; e8 0e 14 mov es, [bp-00ah] ; 8e 46 f6 mov word [es:si+00080h], 08027h ; 26 c7 84 80 00 27 80 @@ -12016,5 +12198,5 @@ shr bx, 1 ; d1 eb rcr ax, 1 ; d1 d8 - loop 081bch ; e2 fa + loop 0837fh ; e2 fa mov es, [bp-00ah] ; 8e 46 f6 mov byte [es:si+00085h], al ; 26 88 84 85 00 @@ -12041,5 +12223,5 @@ mov bx, word [bp-016h] ; 8b 5e ea xor cx, cx ; 31 c9 - call 09569h ; e8 44 13 + call 09729h ; e8 41 13 push dx ; 52 push ax ; 50 @@ -12049,5 +12231,5 @@ mov ax, 0026ah ; b8 6a 02 mov dx, word [bp-00ah] ; 8b 56 f6 - call 0947fh ; e8 44 12 + call 09642h ; e8 44 12 mov es, [bp-00ah] ; 8e 46 f6 movzx ax, byte [es:si+00263h] ; 26 0f b6 84 63 02 @@ -12069,5 +12251,5 @@ mov es, [bp-012h] ; 8e 46 ee cmp word [es:di+01ch], strict byte 00000h ; 26 83 7d 1c 00 - je short 082b4h ; 74 2c + je short 08477h ; 74 2c mov dx, word [es:di+01ch] ; 26 8b 55 1c dec dx ; 4a @@ -12088,17 +12270,17 @@ movzx dx, byte [es:bx+00263h] ; 26 0f b6 97 63 02 cmp ax, dx ; 39 d0 - jnc short 082ceh ; 73 03 + jnc short 08491h ; 73 03 inc ax ; 40 - jmp short 082beh ; eb f0 + jmp short 08481h ; eb f0 mov al, byte [bp-008h] ; 8a 46 f8 cmp AL, strict byte 035h ; 3c 35 - jne short 082dbh ; 75 06 + jne short 0849eh ; 75 06 mov byte [bp-008h], 040h ; c6 46 f8 40 - jmp short 082efh ; eb 14 + jmp short 084b2h ; eb 14 cmp AL, strict byte 0a0h ; 3c a0 - jne short 082ebh ; 75 0c + jne short 084aeh ; 75 0c or byte [bp-008h], 020h ; 80 4e f8 20 or byte [es:bx+00083h], 001h ; 26 80 8f 83 00 01 - jmp short 082efh ; eb 04 + jmp short 084b2h ; eb 04 mov byte [bp-008h], 000h ; c6 46 f8 00 or byte [bp-008h], 005h ; 80 4e f8 05 @@ -12106,9 +12288,9 @@ mov ax, word [bp-00eh] ; 8b 46 f2 mov dx, word [bp-00ch] ; 8b 56 f4 - call 08075h ; e8 75 fd + call 08238h ; e8 75 fd mov ax, word [bp-00eh] ; 8b 46 f2 add ax, 0026ah ; 05 6a 02 mov dx, word [bp-00ch] ; 8b 56 f4 - call 094f8h ; e8 ec 11 + call 096bbh ; e8 ec 11 lea sp, [bp-006h] ; 8d 66 fa pop di ; 5f @@ -12117,5 +12299,5 @@ pop bp ; 5d retn ; c3 -ahci_port_deinit_current_: ; 0xf8314 LB 0x144 +ahci_port_deinit_current_: ; 0xf84d7 LB 0x144 push bp ; 55 mov bp, sp ; 89 e5 @@ -12132,5 +12314,5 @@ mov byte [bp-00ah], al ; 88 46 f6 cmp AL, strict byte 0ffh ; 3c ff - je near 0844fh ; 0f 84 17 01 + je near 08612h ; 0f 84 17 01 movzx dx, al ; 0f b6 d0 sal dx, 007h ; c1 e2 07 @@ -12139,5 +12321,5 @@ xor cx, cx ; 31 c9 mov ax, si ; 89 f0 - call 07fbch ; e8 70 fc + call 0817fh ; e8 70 fc movzx ax, byte [bp-00ah] ; 0f b6 46 f6 sal ax, 007h ; c1 e0 07 @@ -12148,22 +12330,22 @@ xor cx, cx ; 31 c9 mov ax, si ; 89 f0 - call 08003h ; e8 9d fc + call 081c6h ; e8 9d fc cmp AL, strict byte 001h ; 3c 01 - je short 0834ch ; 74 e2 + je short 0850fh ; 74 e2 mov cx, strict word 00020h ; b9 20 00 xor bx, bx ; 31 db mov ax, di ; 89 f8 mov dx, word [bp-00ch] ; 8b 56 f4 - call 0959ah ; e8 23 12 + call 0975ah ; e8 20 12 lea ax, [di+00080h] ; 8d 85 80 00 mov cx, strict word 00040h ; b9 40 00 xor bx, bx ; 31 db mov dx, word [bp-00ch] ; 8b 56 f4 - call 0959ah ; e8 14 12 + call 0975ah ; e8 11 12 lea ax, [di+00200h] ; 8d 85 00 02 mov cx, strict word 00060h ; b9 60 00 xor bx, bx ; 31 db mov dx, word [bp-00ch] ; 8b 56 f4 - call 0959ah ; e8 05 12 + call 0975ah ; e8 02 12 mov ax, word [bp-00eh] ; 8b 46 f2 add ax, 00108h ; 05 08 01 @@ -12267,5 +12449,5 @@ pop bp ; 5d retn ; c3 -ahci_port_init_: ; 0xf8458 LB 0x206 +ahci_port_init_: ; 0xf861b LB 0x206 push bp ; 55 mov bp, sp ; 89 e5 @@ -12277,5 +12459,5 @@ mov word [bp-00ah], dx ; 89 56 f6 mov byte [bp-008h], bl ; 88 5e f8 - call 08314h ; e8 a8 fe + call 084d7h ; e8 a8 fe movzx dx, bl ; 0f b6 d3 sal dx, 007h ; c1 e2 07 @@ -12285,5 +12467,5 @@ mov bx, strict word 00011h ; bb 11 00 xor cx, cx ; 31 c9 - call 07fbch ; e8 36 fb + call 0817fh ; e8 36 fb movzx di, byte [bp-008h] ; 0f b6 7e f8 sal di, 007h ; c1 e7 07 @@ -12293,17 +12475,17 @@ mov bx, 0c011h ; bb 11 c0 xor cx, cx ; 31 c9 - call 08003h ; e8 62 fb + call 081c6h ; e8 62 fb cmp AL, strict byte 001h ; 3c 01 - je short 08486h ; 74 e1 + je short 08649h ; 74 e1 mov cx, strict word 00020h ; b9 20 00 xor bx, bx ; 31 db mov ax, si ; 89 f0 mov dx, word [bp-00ah] ; 8b 56 f6 - call 0959ah ; e8 e8 10 + call 0975ah ; e8 e5 10 lea ax, [si+00080h] ; 8d 84 80 00 mov cx, strict word 00040h ; b9 40 00 xor bx, bx ; 31 db mov dx, word [bp-00ah] ; 8b 56 f6 - call 0959ah ; e8 d9 10 + call 0975ah ; e8 d6 10 mov ax, si ; 89 f0 add ah, 002h ; 80 c4 02 @@ -12312,5 +12494,5 @@ xor bx, bx ; 31 db mov dx, word [bp-00ah] ; 8b 56 f6 - call 0959ah ; e8 c6 10 + call 0975ah ; e8 c3 10 lea ax, [di+00108h] ; 8d 85 08 01 cwd ; 99 @@ -12326,5 +12508,5 @@ mov ax, word [bp-00ch] ; 8b 46 f4 mov dx, word [bp-00ah] ; 8b 56 f6 - call 08057h ; e8 60 fb + call 0821ah ; e8 60 fb mov es, [bp-00ah] ; 8e 46 f6 mov bx, word [es:si+00260h] ; 26 8b 9c 60 02 @@ -12371,5 +12553,5 @@ mov ax, si ; 89 f0 mov dx, word [bp-00ah] ; 8b 56 f6 - call 08057h ; e8 f4 fa + call 0821ah ; e8 f4 fa mov es, [bp-00ah] ; 8e 46 f6 mov bx, word [es:si+00260h] ; 26 8b 9c 60 02 @@ -12476,5 +12658,5 @@ pop bp ; 5d retn ; c3 -@ahci_read_sectors: ; 0xf865e LB 0x94 +@ahci_read_sectors: ; 0xf8821 LB 0x94 push bp ; 55 mov bp, sp ; 89 e5 @@ -12485,15 +12667,15 @@ sub di, strict byte 0000ch ; 83 ef 0c cmp di, strict byte 00004h ; 83 ff 04 - jbe short 08682h ; 76 0f + jbe short 08845h ; 76 0f push di ; 57 push 00c66h ; 68 66 0c push 00c78h ; 68 78 0c push strict byte 00007h ; 6a 07 - call 01972h ; e8 f3 92 + call 01972h ; e8 30 91 add sp, strict byte 00008h ; 83 c4 08 les bx, [bp+004h] ; c4 5e 04 mov dx, word [es:bx+001eeh] ; 26 8b 97 ee 01 xor ax, ax ; 31 c0 - call 07f4bh ; e8 bc f8 + call 0810eh ; e8 bc f8 mov es, [bp+006h] ; 8e 46 06 add di, bx ; 01 df @@ -12502,9 +12684,9 @@ mov dx, word [es:di+001eeh] ; 26 8b 95 ee 01 xor ax, ax ; 31 c0 - call 08458h ; e8 b1 fd + call 0861bh ; e8 b1 fd mov bx, strict word 00025h ; bb 25 00 mov ax, di ; 89 f8 mov dx, word [bp+006h] ; 8b 56 06 - call 0814ah ; e8 98 fa + call 0830dh ; e8 98 fa mov es, [bp+006h] ; 8e 46 06 mov bx, di ; 89 fb @@ -12526,5 +12708,5 @@ mov dx, word [es:bx+001eeh] ; 26 8b 97 ee 01 xor ax, ax ; 31 c0 - call 07f62h ; e8 7b f8 + call 08125h ; e8 7b f8 xor ax, ax ; 31 c0 lea sp, [bp-004h] ; 8d 66 fc @@ -12533,5 +12715,5 @@ pop bp ; 5d retn 00004h ; c2 04 00 -@ahci_write_sectors: ; 0xf86f2 LB 0x70 +@ahci_write_sectors: ; 0xf88b5 LB 0x70 push bp ; 55 mov bp, sp ; 89 e5 @@ -12543,15 +12725,15 @@ sub bx, strict byte 0000ch ; 83 eb 0c cmp bx, strict byte 00004h ; 83 fb 04 - jbe short 0871ah ; 76 0f + jbe short 088ddh ; 76 0f push bx ; 53 push 00c97h ; 68 97 0c push 00c78h ; 68 78 0c push strict byte 00007h ; 6a 07 - call 01972h ; e8 5b 92 + call 01972h ; e8 98 90 add sp, strict byte 00008h ; 83 c4 08 mov es, cx ; 8e c1 mov dx, word [es:si+001eeh] ; 26 8b 94 ee 01 xor ax, ax ; 31 c0 - call 07f4bh ; e8 25 f8 + call 0810eh ; e8 25 f8 mov es, cx ; 8e c1 add bx, si ; 01 f3 @@ -12559,9 +12741,9 @@ mov dx, word [es:si+001eeh] ; 26 8b 94 ee 01 xor ax, ax ; 31 c0 - call 08458h ; e8 1e fd + call 0861bh ; e8 1e fd mov bx, strict word 00035h ; bb 35 00 mov ax, si ; 89 f0 mov dx, cx ; 89 ca - call 0814ah ; e8 06 fa + call 0830dh ; e8 06 fa mov es, cx ; 8e c1 mov dx, word [es:si+00ah] ; 26 8b 54 0a @@ -12569,5 +12751,5 @@ mov dx, word [es:si+001eeh] ; 26 8b 94 ee 01 xor ax, ax ; 31 c0 - call 07f62h ; e8 0a f8 + call 08125h ; e8 0a f8 xor ax, ax ; 31 c0 lea sp, [bp-002h] ; 8d 66 fe @@ -12575,5 +12757,5 @@ pop bp ; 5d retn 00004h ; c2 04 00 -ahci_cmd_packet_: ; 0xf8762 LB 0x173 +ahci_cmd_packet_: ; 0xf8925 LB 0x173 push bp ; 55 mov bp, sp ; 89 e5 @@ -12587,22 +12769,22 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 ef 8e + call 0166ch ; e8 2c 8d mov si, 00122h ; be 22 01 mov word [bp-008h], ax ; 89 46 f8 cmp byte [bp+00ah], 002h ; 80 7e 0a 02 - jne short 087a8h ; 75 1f - mov bx, 00da2h ; bb a2 0d + jne short 0896bh ; 75 1f + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 9d 91 + call 01931h ; e8 da 8f push 00caah ; 68 aa 0c push 00cbah ; 68 ba 0c push strict byte 00004h ; 6a 04 - call 01972h ; e8 d3 91 + call 01972h ; e8 10 90 add sp, strict byte 00006h ; 83 c4 06 mov ax, strict word 00001h ; b8 01 00 - jmp near 088cch ; e9 24 01 + jmp near 08a8fh ; e9 24 01 test byte [bp+004h], 001h ; f6 46 04 01 - jne short 087a2h ; 75 f4 + jne short 08965h ; 75 f4 mov ax, word [bp+006h] ; 8b 46 06 mov dx, word [bp+008h] ; 8b 56 08 @@ -12610,5 +12792,5 @@ sal ax, 1 ; d1 e0 rcl dx, 1 ; d1 d2 - loop 087b7h ; e2 fa + loop 0897ah ; e2 fa mov es, [bp-008h] ; 8e 46 f8 mov word [es:si], ax ; 26 89 04 @@ -12622,5 +12804,5 @@ mov dx, word [bp+008h] ; 8b 56 08 xor cx, cx ; 31 c9 - call 09530h ; e8 4c 0d + call 096f0h ; e8 49 0d mov word [es:si+00ah], ax ; 26 89 44 0a xor di, di ; 31 ff @@ -12632,5 +12814,5 @@ xor ax, ax ; 31 c0 mov dx, word [bp-00ah] ; 8b 56 f6 - call 07f4bh ; e8 47 f7 + call 0810eh ; e8 47 f7 mov es, [bp-008h] ; 8e 46 f8 mov bx, word [bp-014h] ; 8b 5e ec @@ -12639,5 +12821,5 @@ mov dx, word [es:si+001eeh] ; 26 8b 94 ee 01 xor ax, ax ; 31 c0 - call 08458h ; e8 3c fc + call 0861bh ; e8 3c fc movzx ax, byte [bp-006h] ; 0f b6 46 fa push ax ; 50 @@ -12646,5 +12828,5 @@ mov ax, 000c0h ; b8 c0 00 mov dx, word [bp-00ah] ; 8b 56 f6 - call 095a7h ; e8 77 0d + call 09767h ; e8 74 0d mov es, [bp-008h] ; 8e 46 f8 mov word [es:si+014h], di ; 26 89 7c 14 @@ -12653,5 +12835,5 @@ mov ax, word [es:si+01ah] ; 26 8b 44 1a test ax, ax ; 85 c0 - je short 0886eh ; 74 27 + je short 08a31h ; 74 27 dec ax ; 48 mov es, [bp-00ah] ; 8e 46 f6 @@ -12666,5 +12848,5 @@ mov ax, si ; 89 f0 mov dx, word [bp-008h] ; 8b 56 f8 - call 0814ah ; e8 d1 f8 + call 0830dh ; e8 d1 f8 les bx, [bp-00eh] ; c4 5e f2 mov ax, word [es:bx+004h] ; 26 8b 47 04 @@ -12689,11 +12871,11 @@ mov ax, word [bp-00eh] ; 8b 46 f2 mov dx, word [bp-00ch] ; 8b 56 f4 - call 07f62h ; e8 aa f6 + call 08125h ; e8 aa f6 les bx, [bp-00eh] ; c4 5e f2 mov ax, word [es:bx+006h] ; 26 8b 47 06 or ax, word [es:bx+004h] ; 26 0b 47 04 - jne short 088cah ; 75 05 + jne short 08a8dh ; 75 05 mov ax, strict word 00004h ; b8 04 00 - jmp short 088cch ; eb 02 + jmp short 08a8fh ; eb 02 xor ax, ax ; 31 c0 lea sp, [bp-004h] ; 8d 66 fc @@ -12702,5 +12884,5 @@ pop bp ; 5d retn 0000ch ; c2 0c 00 -ahci_port_detect_device_: ; 0xf88d5 LB 0x451 +ahci_port_detect_device_: ; 0xf8a98 LB 0x451 push bp ; 55 mov bp, sp ; 89 e5 @@ -12714,8 +12896,8 @@ movzx di, bl ; 0f b6 fb mov bx, di ; 89 fb - call 08458h ; e8 69 fb + call 0861bh ; e8 69 fb mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 74 8d + call 0166ch ; e8 b1 8b mov word [bp-010h], 00122h ; c7 46 f0 22 01 mov word [bp-00eh], ax ; 89 46 f2 @@ -12786,7 +12968,7 @@ mov bx, strict word 0000fh ; bb 0f 00 xor cx, cx ; 31 c9 - call 0803ch ; e8 9a f6 + call 081ffh ; e8 9a f6 test ax, ax ; 85 c0 - je near 08d1eh ; 0f 84 76 03 + je near 08ee1h ; 0f 84 76 03 movzx ax, byte [bp-008h] ; 0f b6 46 f8 sal ax, 007h ; c1 e0 07 @@ -12816,7 +12998,7 @@ mov bx, strict word 0000fh ; bb 0f 00 xor cx, cx ; 31 c9 - call 0803ch ; e8 4e f6 + call 081ffh ; e8 4e f6 cmp ax, strict word 00001h ; 3d 01 00 - je short 089a8h ; 74 b5 + je short 08b6bh ; 74 b5 push strict byte 00000h ; 6a 00 mov bx, strict word 0000fh ; bb 0f 00 @@ -12824,7 +13006,7 @@ mov ax, di ; 89 f8 mov dx, word [bp-01ah] ; 8b 56 e6 - call 0803ch ; e8 3a f6 + call 081ffh ; e8 3a f6 cmp ax, strict word 00003h ; 3d 03 00 - jne near 08d1eh ; 0f 85 15 03 + jne near 08ee1h ; 0f 85 15 03 mov ax, word [bp-016h] ; 8b 46 ea add ax, 00130h ; 05 30 01 @@ -12853,5 +13035,5 @@ mov byte [bp-00ch], al ; 88 46 f4 cmp AL, strict byte 004h ; 3c 04 - jnc near 08d1eh ; 0f 83 cf 02 + jnc near 08ee1h ; 0f 83 cf 02 mov dx, word [bp-016h] ; 8b 56 ea add dx, 00118h ; 81 c2 18 01 @@ -12860,5 +13042,5 @@ mov bx, strict word 00010h ; bb 10 00 xor cx, cx ; 31 c9 - call 07f79h ; e8 13 f5 + call 0813ch ; e8 13 f5 mov ax, word [bp-016h] ; 8b 46 ea add ax, 00124h ; 05 24 01 @@ -12884,7 +13066,7 @@ add cl, 00ch ; 80 c1 0c test dx, dx ; 85 d2 - jne near 08c7ah ; 0f 85 d8 01 + jne near 08e3dh ; 0f 85 d8 01 cmp ax, 00101h ; 3d 01 01 - jne near 08c7ah ; 0f 85 d1 01 + jne near 08e3dh ; 0f 85 d1 01 les bx, [bp-010h] ; c4 5e f0 db 066h, 026h, 0c7h, 007h, 000h, 000h, 000h, 000h @@ -12898,5 +13080,5 @@ mov ax, word [bp-010h] ; 8b 46 f0 mov dx, es ; 8c c2 - call 0814ah ; e8 76 f6 + call 0830dh ; e8 76 f6 mov byte [bp-00ah], cl ; 88 4e f6 test byte [bp-00226h], 080h ; f6 86 da fd 80 @@ -12915,7 +13097,7 @@ mov di, word [bp-001ach] ; 8b be 54 fe cmp di, 00fffh ; 81 ff ff 0f - jne short 08b19h ; 75 10 + jne short 08cdch ; 75 10 cmp ax, strict word 0ffffh ; 3d ff ff - jne short 08b19h ; 75 0b + jne short 08cdch ; 75 0b mov ax, word [bp-0015eh] ; 8b 86 a2 fe mov word [bp-014h], ax ; 89 46 ec @@ -12946,19 +13128,19 @@ mov al, byte [bp-00ch] ; 8a 46 f4 cmp AL, strict byte 001h ; 3c 01 - jc short 08b84h ; 72 0c - jbe short 08b8ch ; 76 12 + jc short 08d47h ; 72 0c + jbe short 08d4fh ; 76 12 cmp AL, strict byte 003h ; 3c 03 - je short 08b94h ; 74 16 + je short 08d57h ; 74 16 cmp AL, strict byte 002h ; 3c 02 - je short 08b90h ; 74 0e - jmp short 08bddh ; eb 59 + je short 08d53h ; 74 0e + jmp short 08da0h ; eb 59 test al, al ; 84 c0 - jne short 08bddh ; 75 55 + jne short 08da0h ; 75 55 mov DL, strict byte 040h ; b2 40 - jmp short 08b96h ; eb 0a + jmp short 08d59h ; eb 0a mov DL, strict byte 048h ; b2 48 - jmp short 08b96h ; eb 06 + jmp short 08d59h ; eb 06 mov DL, strict byte 050h ; b2 50 - jmp short 08b96h ; eb 02 + jmp short 08d59h ; eb 02 mov DL, strict byte 058h ; b2 58 mov al, dl ; 88 d0 @@ -12966,17 +13148,17 @@ movzx bx, al ; 0f b6 d8 mov ax, bx ; 89 d8 - call 016ach ; e8 0a 8b + call 016ach ; e8 47 89 test al, al ; 84 c0 - je short 08bddh ; 74 37 + je short 08da0h ; 74 37 mov al, dl ; 88 d0 db 0feh, 0c0h ; inc al ; fe c0 xor ah, ah ; 30 e4 - call 016ach ; e8 fd 8a + call 016ach ; e8 3a 89 xor ah, ah ; 30 e4 mov si, ax ; 89 c6 sal si, 008h ; c1 e6 08 movzx ax, dl ; 0f b6 c2 - call 016ach ; e8 f0 8a + call 016ach ; e8 2d 89 xor ah, ah ; 30 e4 add ax, si ; 01 f0 @@ -12985,21 +13167,21 @@ add AL, strict byte 002h ; 04 02 xor ah, ah ; 30 e4 - call 016ach ; e8 e0 8a + call 016ach ; e8 1d 89 xor ah, ah ; 30 e4 mov word [bp-026h], ax ; 89 46 da mov ax, bx ; 89 d8 - call 016ach ; e8 d6 8a + call 016ach ; e8 13 89 xor ah, ah ; 30 e4 mov word [bp-022h], ax ; 89 46 de - jmp short 08beah ; eb 0d + jmp short 08dadh ; eb 0d mov bx, word [bp-014h] ; 8b 5e ec mov cx, di ; 89 f9 mov dx, ss ; 8c d2 lea ax, [bp-026h] ; 8d 46 da - call 053f3h ; e8 09 c8 - mov bx, 00da2h ; bb a2 0d + call 055b6h ; e8 09 c8 + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 3c 8d + call 01931h ; e8 79 8b push di ; 57 push word [bp-014h] ; ff 76 ec @@ -13018,5 +13200,5 @@ push 00cdah ; 68 da 0c push strict byte 00004h ; 6a 04 - call 01972h ; e8 54 8d + call 01972h ; e8 91 8b add sp, strict byte 00018h ; 83 c4 18 movzx ax, byte [bp-00ah] ; 0f b6 46 f6 @@ -13047,5 +13229,5 @@ mov dx, strict word 00075h ; ba 75 00 mov ax, strict word 00040h ; b8 40 00 - call 01650h ; e8 e7 89 + call 01650h ; e8 24 88 db 0feh, 0c0h ; inc al ; fe c0 @@ -13053,10 +13235,10 @@ mov dx, strict word 00075h ; ba 75 00 mov ax, strict word 00040h ; b8 40 00 - call 0165eh ; e8 e7 89 - jmp near 08d10h ; e9 96 00 + call 0165eh ; e8 24 88 + jmp near 08ed3h ; e9 96 00 cmp dx, 0eb14h ; 81 fa 14 eb - jne near 08d10h ; 0f 85 8e 00 + jne near 08ed3h ; 0f 85 8e 00 cmp ax, 00101h ; 3d 01 01 - jne near 08d10h ; 0f 85 87 00 + jne near 08ed3h ; 0f 85 87 00 les bx, [bp-010h] ; c4 5e f0 db 066h, 026h, 0c7h, 007h, 000h, 000h, 000h, 000h @@ -13070,5 +13252,5 @@ mov ax, word [bp-010h] ; 8b 46 f0 mov dx, es ; 8c c2 - call 0814ah ; e8 96 f4 + call 0830dh ; e8 96 f4 test byte [bp-00226h], 080h ; f6 86 da fd 80 db 00fh, 095h, 0c0h @@ -13109,5 +13291,5 @@ pop bp ; 5d retn ; c3 -ahci_mem_alloc_: ; 0xf8d26 LB 0x43 +ahci_mem_alloc_: ; 0xf8ee9 LB 0x43 push bp ; 55 mov bp, sp ; 89 e5 @@ -13119,7 +13301,7 @@ mov dx, 00413h ; ba 13 04 xor ax, ax ; 31 c0 - call 0166ch ; e8 36 89 + call 0166ch ; e8 73 87 test ax, ax ; 85 c0 - je short 08d5fh ; 74 25 + je short 08f22h ; 74 25 dec ax ; 48 mov bx, ax ; 89 c3 @@ -13128,5 +13310,5 @@ sal ax, 1 ; d1 e0 rcl dx, 1 ; d1 d2 - loop 08d42h ; e2 fa + loop 08f05h ; e2 fa mov si, ax ; 89 c6 mov di, dx ; 89 d7 @@ -13134,8 +13316,8 @@ shr di, 1 ; d1 ef rcr si, 1 ; d1 de - loop 08d4fh ; e2 fa + loop 08f12h ; e2 fa mov dx, 00413h ; ba 13 04 xor ax, ax ; 31 c0 - call 0167ah ; e8 1d 89 + call 0167ah ; e8 5a 87 mov ax, si ; 89 f0 lea sp, [bp-00ah] ; 8d 66 f6 @@ -13147,5 +13329,5 @@ pop bp ; 5d retn ; c3 -ahci_hba_init_: ; 0xf8d69 LB 0x125 +ahci_hba_init_: ; 0xf8f2c LB 0x125 push bp ; 55 mov bp, sp ; 89 e5 @@ -13159,5 +13341,5 @@ mov dx, strict word 0000eh ; ba 0e 00 mov ax, strict word 00040h ; b8 40 00 - call 0166ch ; e8 ed 88 + call 0166ch ; e8 2a 87 mov bx, 00122h ; bb 22 01 mov word [bp-010h], ax ; 89 46 f0 @@ -13176,8 +13358,8 @@ shr eax, 010h ; 66 c1 e8 10 xchg dx, ax ; 92 - call 08d26h ; e8 82 ff + call 08ee9h ; e8 82 ff mov di, ax ; 89 c7 test ax, ax ; 85 c0 - je near 08e6dh ; 0f 84 c1 00 + je near 09030h ; 0f 84 c1 00 mov es, [bp-010h] ; 8e 46 f0 mov word [es:bx+001eeh], di ; 26 89 bf ee 01 @@ -13193,5 +13375,5 @@ mov dx, strict word 00004h ; ba 04 00 mov ax, si ; 89 f0 - call 07f79h ; e8 99 f1 + call 0813ch ; e8 99 f1 mov ax, strict word 00004h ; b8 04 00 xor cx, cx ; 31 c9 @@ -13210,5 +13392,5 @@ xchg dx, ax ; 92 test AL, strict byte 001h ; a8 01 - jne short 08de0h ; 75 de + jne short 08fa3h ; 75 de xor ax, ax ; 31 c0 xor cx, cx ; 31 c9 @@ -13228,33 +13410,33 @@ mov bx, strict word 0001fh ; bb 1f 00 xor cx, cx ; 31 c9 - call 0803ch ; e8 16 f2 + call 081ffh ; e8 16 f2 db 0feh, 0c0h ; inc al ; fe c0 mov byte [bp-00eh], al ; 88 46 f2 mov byte [bp-00ch], 000h ; c6 46 f4 00 - jmp short 08e3ah ; eb 09 + jmp short 08ffdh ; eb 09 inc byte [bp-00ch] ; fe 46 f4 cmp byte [bp-00ch], 020h ; 80 7e f4 20 - jnc short 08e6bh ; 73 31 + jnc short 0902eh ; 73 31 movzx cx, byte [bp-00ch] ; 0f b6 4e f4 mov ax, strict word 00001h ; b8 01 00 xor dx, dx ; 31 d2 - jcxz 08e4bh ; e3 06 + jcxz 0900eh ; e3 06 sal ax, 1 ; d1 e0 rcl dx, 1 ; d1 d2 - loop 08e45h ; e2 fa + loop 09008h ; e2 fa mov bx, ax ; 89 c3 mov cx, dx ; 89 d1 mov dx, strict word 0000ch ; ba 0c 00 mov ax, si ; 89 f0 - call 08003h ; e8 ac f1 + call 081c6h ; e8 ac f1 test al, al ; 84 c0 - je short 08e31h ; 74 d6 + je short 08ff4h ; 74 d6 movzx bx, byte [bp-00ch] ; 0f b6 5e f4 xor ax, ax ; 31 c0 mov dx, di ; 89 fa - call 088d5h ; e8 6f fa + call 08a98h ; e8 6f fa dec byte [bp-00eh] ; fe 4e f2 - jne short 08e31h ; 75 c6 + jne short 08ff4h ; 75 c6 xor ax, ax ; 31 c0 lea sp, [bp-00ah] ; 8d 66 f6 @@ -13266,7 +13448,7 @@ pop bp ; 5d retn ; c3 - db 00bh, 005h, 004h, 003h, 002h, 001h, 000h, 05dh, 08fh, 03bh, 08fh, 041h, 08fh, 047h, 08fh, 04dh - db 08fh, 053h, 08fh, 059h, 08fh, 05dh, 08fh -_ahci_init: ; 0xf8e8e LB 0xfe + db 00bh, 005h, 004h, 003h, 002h, 001h, 000h, 020h, 091h, 0feh, 090h, 004h, 091h, 00ah, 091h, 010h + db 091h, 016h, 091h, 01ch, 091h, 020h, 091h +_ahci_init: ; 0xf9051 LB 0xfe push bp ; 55 mov bp, sp ; 89 e5 @@ -13276,8 +13458,8 @@ mov ax, 00601h ; b8 01 06 mov dx, strict word 00001h ; ba 01 00 - call 093ach ; e8 0d 05 + call 0956fh ; e8 0d 05 mov dx, ax ; 89 c2 cmp ax, strict word 0ffffh ; 3d ff ff - je near 08f85h ; 0f 84 dd 00 + je near 09148h ; 0f 84 dd 00 xor al, al ; 30 c0 shr ax, 008h ; c1 e8 08 @@ -13287,8 +13469,8 @@ xor ah, ah ; 30 e4 mov bx, strict word 00034h ; bb 34 00 - call 093d7h ; e8 1a 05 + call 0959ah ; e8 1a 05 mov cl, al ; 88 c1 test cl, cl ; 84 c9 - je short 08ee6h ; 74 23 + je short 090a9h ; 74 23 movzx bx, cl ; 0f b6 d9 movzx di, byte [bp-008h] ; 0f b6 7e f8 @@ -13296,7 +13478,7 @@ mov dx, di ; 89 fa mov ax, si ; 89 f0 - call 093d7h ; e8 02 05 + call 0959ah ; e8 02 05 cmp AL, strict byte 012h ; 3c 12 - je short 08ee6h ; 74 0d + je short 090a9h ; 74 0d mov al, cl ; 88 c8 db 0feh, 0c0h @@ -13305,7 +13487,7 @@ mov dx, di ; 89 fa mov ax, si ; 89 f0 - jmp short 08ebah ; eb d4 + jmp short 0907dh ; eb d4 test cl, cl ; 84 c9 - je near 08f85h ; 0f 84 99 00 + je near 09148h ; 0f 84 99 00 add cl, 002h ; 80 c1 02 movzx bx, cl ; 0f b6 d9 @@ -13314,7 +13496,7 @@ mov dx, di ; 89 fa mov ax, si ; 89 f0 - call 093d7h ; e8 d6 04 + call 0959ah ; e8 d6 04 cmp AL, strict byte 010h ; 3c 10 - jne near 08f85h ; 0f 85 7e 00 + jne near 09148h ; 0f 85 7e 00 mov byte [bp-006h], 000h ; c6 46 fa 00 mov al, cl ; 88 c8 @@ -13323,29 +13505,29 @@ mov dx, di ; 89 fa mov ax, si ; 89 f0 - call 093fbh ; e8 e2 04 + call 095beh ; e8 e2 04 mov dx, ax ; 89 c2 and ax, strict word 0000fh ; 25 0f 00 sub ax, strict word 00004h ; 2d 04 00 cmp ax, strict word 0000bh ; 3d 0b 00 - jnbe short 08f5dh ; 77 37 + jnbe short 09120h ; 77 37 push CS ; 0e pop ES ; 07 mov cx, strict word 00008h ; b9 08 00 - mov di, 08e77h ; bf 77 8e + mov di, 0903ah ; bf 3a 90 repne scasb ; f2 ae sal cx, 1 ; d1 e1 mov di, cx ; 89 cf - mov ax, word [cs:di-07182h] ; 2e 8b 85 7e 8e + mov ax, word [cs:di-06fbfh] ; 2e 8b 85 41 90 jmp ax ; ff e0 mov byte [bp-006h], 010h ; c6 46 fa 10 - jmp short 08f5dh ; eb 1c + jmp short 09120h ; eb 1c mov byte [bp-006h], 014h ; c6 46 fa 14 - jmp short 08f5dh ; eb 16 + jmp short 09120h ; eb 16 mov byte [bp-006h], 018h ; c6 46 fa 18 - jmp short 08f5dh ; eb 10 + jmp short 09120h ; eb 10 mov byte [bp-006h], 01ch ; c6 46 fa 1c - jmp short 08f5dh ; eb 0a + jmp short 09120h ; eb 0a mov byte [bp-006h], 020h ; c6 46 fa 20 - jmp short 08f5dh ; eb 04 + jmp short 09120h ; eb 04 mov byte [bp-006h], 024h ; c6 46 fa 24 mov si, dx ; 89 d6 @@ -13354,14 +13536,14 @@ mov al, byte [bp-006h] ; 8a 46 fa test al, al ; 84 c0 - je short 08f85h ; 74 19 + je short 09148h ; 74 19 movzx bx, al ; 0f b6 d8 movzx dx, byte [bp-008h] ; 0f b6 56 f8 movzx ax, byte [bp-00ah] ; 0f b6 46 f6 - call 0941dh ; e8 a3 04 + call 095e0h ; e8 a3 04 test AL, strict byte 001h ; a8 01 - je short 08f85h ; 74 07 + je short 09148h ; 74 07 and AL, strict byte 0f0h ; 24 f0 add ax, si ; 01 f0 - call 08d69h ; e8 e4 fd + call 08f2ch ; e8 e4 fd lea sp, [bp-004h] ; 8d 66 fc pop di ; 5f @@ -13369,5 +13551,5 @@ pop bp ; 5d retn ; c3 -apm_out_str_: ; 0xf8f8c LB 0x39 +apm_out_str_: ; 0xf914f LB 0x39 push bp ; 55 mov bp, sp ; 89 e5 @@ -13375,5 +13557,5 @@ mov bx, ax ; 89 c3 cmp byte [bx], 000h ; 80 3f 00 - je short 08fa1h ; 74 0a + je short 09164h ; 74 0a mov al, byte [bx] ; 8a 07 out DX, AL ; ee @@ -13382,26 +13564,30 @@ db 00ah, 0c0h ; or al, al ; 0a c0 - jne short 08f99h ; 75 f8 + jne short 0915ch ; 75 f8 lea sp, [bp-002h] ; 8d 66 fe pop bx ; 5b pop bp ; 5d retn ; c3 - call 04439h ; e8 8f b4 - nop ; 90 - cli ; fa - db 08fh, 015h - ; pop word [di] ; 8f 15 - nop ; 90 - mov AH, strict byte 090h ; b4 90 + stosw ; ab + xchg cx, ax ; 91 + jnbe short 09100h ; 77 92 + mov bp, 0d891h ; bd 91 d8 + xchg cx, ax ; 91 + jnbe short 09106h ; 77 92 + add dx, word [bp+si-06d89h] ; 03 92 77 92 + or byte [bp+si-06db4h], dl ; 08 92 4c 92 + dec sp ; 4c + xchg dx, ax ; 92 + dec sp ; 4c + xchg dx, ax ; 92 + inc di ; 47 + xchg dx, ax ; 92 + dec sp ; 4c + xchg dx, ax ; 92 + dec sp ; 4c + xchg dx, ax ; 92 inc ax ; 40 - nop ; 90 - mov AH, strict byte 090h ; b4 90 - inc bp ; 45 - nop ; 90 - mov word [bx+si-06f77h], dx ; 89 90 89 90 - mov word [bx+si-06f7ch], dx ; 89 90 84 90 - mov word [bx+si-06f77h], dx ; 89 90 89 90 - jnl short 08f55h ; 7d 90 -_apm_function: ; 0xf8fc5 LB 0xf5 + xchg dx, ax ; 92 +_apm_function: ; 0xf9188 LB 0xf5 push bp ; 55 mov bp, sp ; 89 e5 @@ -13411,21 +13597,21 @@ xor ah, ah ; 30 e4 cmp ax, strict word 0000eh ; 3d 0e 00 - jnbe near 09089h ; 0f 87 b0 00 + jnbe near 0924ch ; 0f 87 b0 00 mov bx, ax ; 89 c3 add bx, ax ; 01 c3 mov dx, word [bp+018h] ; 8b 56 18 or dl, 001h ; 80 ca 01 - jmp word [cs:bx-07059h] ; 2e ff a7 a7 8f + jmp word [cs:bx-06e96h] ; 2e ff a7 6a 91 mov word [bp+012h], 00102h ; c7 46 12 02 01 mov word [bp+00ch], 0504dh ; c7 46 0c 4d 50 mov word [bp+010h], strict word 00003h ; c7 46 10 03 00 - jmp near 090b4h ; e9 ba 00 + jmp near 09277h ; e9 ba 00 mov word [bp+012h], 0f000h ; c7 46 12 00 f0 - mov word [bp+00ch], 09614h ; c7 46 0c 14 96 + mov word [bp+00ch], 097d4h ; c7 46 0c d4 97 mov word [bp+010h], 0f000h ; c7 46 10 00 f0 mov ax, strict word 0fff0h ; b8 f0 ff mov word [bp+006h], ax ; 89 46 06 mov word [bp+004h], ax ; 89 46 04 - jmp near 090b4h ; e9 9f 00 + jmp near 09277h ; e9 9f 00 mov word [bp+012h], 0f000h ; c7 46 12 00 f0 mov word [bp+00ch], 0da40h ; c7 46 0c 40 da @@ -13440,41 +13626,41 @@ mov si, ax ; 89 c6 sal esi, 010h ; 66 c1 e6 10 - jmp near 090b4h ; e9 74 00 + jmp near 09277h ; e9 74 00 sti ; fb hlt ; f4 - jmp near 090b4h ; e9 6f 00 + jmp near 09277h ; e9 6f 00 cmp word [bp+010h], strict byte 00003h ; 83 7e 10 03 - je short 0906ah ; 74 1f + je short 0922dh ; 74 1f cmp word [bp+010h], strict byte 00002h ; 83 7e 10 02 - je short 09062h ; 74 11 + je short 09225h ; 74 11 cmp word [bp+010h], strict byte 00001h ; 83 7e 10 01 - jne short 09072h ; 75 1b + jne short 09235h ; 75 1b mov dx, 08900h ; ba 00 89 mov ax, 00d12h ; b8 12 0d - call 08f8ch ; e8 2c ff - jmp short 090b4h ; eb 52 + call 0914fh ; e8 2c ff + jmp short 09277h ; eb 52 mov dx, 08900h ; ba 00 89 mov ax, 00d1ah ; b8 1a 0d - jmp short 0905dh ; eb f3 + jmp short 09220h ; eb f3 mov dx, 08900h ; ba 00 89 mov ax, 00d22h ; b8 22 0d - jmp short 0905dh ; eb eb + jmp short 09220h ; eb eb or ah, 00ah ; 80 cc 0a mov word [bp+012h], ax ; 89 46 12 mov word [bp+018h], dx ; 89 56 18 - jmp short 090b4h ; eb 37 + jmp short 09277h ; eb 37 mov word [bp+012h], 00102h ; c7 46 12 02 01 - jmp short 090b4h ; eb 30 + jmp short 09277h ; eb 30 or ah, 080h ; 80 cc 80 - jmp short 09075h ; eb ec - mov bx, 00da2h ; bb a2 0d + jmp short 09238h ; eb ec + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 9d 88 + call 01931h ; e8 da 86 push word [bp+00ch] ; ff 76 0c push word [bp+012h] ; ff 76 12 push 00d2bh ; 68 2b 0d push strict byte 00004h ; 6a 04 - call 01972h ; e8 d0 88 + call 01972h ; e8 0d 87 add sp, strict byte 00008h ; 83 c4 08 mov ax, word [bp+012h] ; 8b 46 12 @@ -13487,5 +13673,5 @@ pop bp ; 5d retn ; c3 -pci16_select_reg_: ; 0xf90ba LB 0x24 +pci16_select_reg_: ; 0xf927d LB 0x24 push bp ; 55 mov bp, sp ; 89 e5 @@ -13504,5 +13690,5 @@ pop bp ; 5d retn ; c3 -pci16_find_device_: ; 0xf90de LB 0xf7 +pci16_find_device_: ; 0xf92a1 LB 0xf7 push bp ; 55 mov bp, sp ; 89 e5 @@ -13518,8 +13704,8 @@ mov byte [bp-008h], 000h ; c6 46 f8 00 test bl, 007h ; f6 c3 07 - jne short 09126h ; 75 2d + jne short 092e9h ; 75 2d mov dx, strict word 0000eh ; ba 0e 00 mov ax, bx ; 89 d8 - call 090bah ; e8 b9 ff + call 0927dh ; e8 b9 ff mov dx, 00cfeh ; ba fe 0c in AL, DX ; ec @@ -13528,23 +13714,23 @@ mov byte [bp-006h], al ; 88 46 fa cmp AL, strict byte 0ffh ; 3c ff - jne short 09114h ; 75 06 + jne short 092d7h ; 75 06 add bx, strict byte 00008h ; 83 c3 08 - jmp near 091a7h ; e9 93 00 + jmp near 0936ah ; e9 93 00 test byte [bp-006h], 080h ; f6 46 fa 80 - je short 09121h ; 74 07 + je short 092e4h ; 74 07 mov word [bp-00ah], strict word 00001h ; c7 46 f6 01 00 - jmp short 09126h ; eb 05 + jmp short 092e9h ; eb 05 mov word [bp-00ah], strict word 00008h ; c7 46 f6 08 00 mov al, byte [bp-006h] ; 8a 46 fa and AL, strict byte 007h ; 24 07 cmp AL, strict byte 001h ; 3c 01 - jne short 0914eh ; 75 1f + jne short 09311h ; 75 1f mov ax, bx ; 89 d8 shr ax, 008h ; c1 e8 08 test ax, ax ; 85 c0 - jne short 0914eh ; 75 16 + jne short 09311h ; 75 16 mov dx, strict word 0001ah ; ba 1a 00 mov ax, bx ; 89 d8 - call 090bah ; e8 7a ff + call 0927dh ; e8 7a ff mov dx, 00cfeh ; ba fe 0c in AL, DX ; ec @@ -13552,13 +13738,13 @@ ; sub ah, ah ; 2a e4 cmp al, byte [bp-008h] ; 3a 46 f8 - jbe short 0914eh ; 76 03 + jbe short 09311h ; 76 03 mov byte [bp-008h], al ; 88 46 f8 test di, di ; 85 ff - je short 09157h ; 74 05 + je short 0931ah ; 74 05 mov dx, strict word 00008h ; ba 08 00 - jmp short 09159h ; eb 02 + jmp short 0931ch ; eb 02 xor dx, dx ; 31 d2 mov ax, bx ; 89 d8 - call 090bah ; e8 5c ff + call 0927dh ; e8 5c ff mov dx, 00cfch ; ba fc 0c in eax, DX ; 66 ed @@ -13571,22 +13757,22 @@ mov word [bp-010h], strict word 00000h ; c7 46 f0 00 00 test di, di ; 85 ff - je short 09188h ; 74 0f + je short 0934bh ; 74 0f mov cx, strict word 00008h ; b9 08 00 shr dx, 1 ; d1 ea rcr ax, 1 ; d1 d8 - loop 0917ch ; e2 fa + loop 0933fh ; e2 fa mov word [bp-00eh], ax ; 89 46 f2 mov word [bp-00ch], dx ; 89 56 f4 mov ax, word [bp-00ch] ; 8b 46 f4 cmp ax, word [bp-014h] ; 3b 46 ec - jne short 09198h ; 75 08 + jne short 0935bh ; 75 08 mov ax, word [bp-00eh] ; 8b 46 f2 cmp ax, word [bp-012h] ; 3b 46 ee - je short 0919eh ; 74 06 + je short 09361h ; 74 06 cmp word [bp-010h], strict byte 00000h ; 83 7e f0 00 - je short 091a4h ; 74 06 + je short 09367h ; 74 06 dec si ; 4e cmp si, strict byte 0ffffh ; 83 fe ff - je short 091b6h ; 74 12 + je short 09379h ; 74 12 add bx, word [bp-00ah] ; 03 5e f6 mov dx, bx ; 89 da @@ -13594,9 +13780,9 @@ movzx ax, byte [bp-008h] ; 0f b6 46 f8 cmp dx, ax ; 39 c2 - jbe near 090f4h ; 0f 86 3e ff + jbe near 092b7h ; 0f 86 3e ff cmp si, strict byte 0ffffh ; 83 fe ff - jne short 091bfh ; 75 04 + jne short 09382h ; 75 04 mov ax, bx ; 89 d8 - jmp short 091c2h ; eb 03 + jmp short 09385h ; eb 03 mov ax, strict word 0ffffh ; b8 ff ff lea sp, [bp-004h] ; 8d 66 fc @@ -13605,12 +13791,13 @@ pop bp ; 5d retn ; c3 - mov BH, strict byte 092h ; b7 92 - rcl word [bp+si-06d1ch], 1 ; d1 92 e4 92 - stc ; f9 - xchg dx, ax ; 92 - or AL, strict byte 093h ; 0c 93 - pop DS ; 1f - xchg bx, ax ; 93 -_pci16_function: ; 0xf91d5 LB 0x1d7 + jp short 09322h ; 7a 94 + xchg sp, ax ; 94 + xchg sp, ax ; 94 + cmpsw ; a7 + xchg sp, ax ; 94 + mov sp, 0cf94h ; bc 94 cf + xchg sp, ax ; 94 + loop 0932ch ; e2 94 +_pci16_function: ; 0xf9398 LB 0x1d7 push bp ; 55 mov bp, sp ; 89 e5 @@ -13626,17 +13813,17 @@ xor ah, ah ; 30 e4 cmp bx, strict byte 00003h ; 83 fb 03 - jc short 0920eh ; 72 1a - jbe short 09266h ; 76 70 + jc short 093d1h ; 72 1a + jbe short 09429h ; 76 70 cmp bx, strict byte 0000eh ; 83 fb 0e - je near 09333h ; 0f 84 36 01 + je near 094f6h ; 0f 84 36 01 cmp bx, strict byte 00008h ; 83 fb 08 - jc near 09378h ; 0f 82 74 01 + jc near 0953bh ; 0f 82 74 01 cmp bx, strict byte 0000dh ; 83 fb 0d - jbe near 0928bh ; 0f 86 80 00 - jmp near 09378h ; e9 6a 01 + jbe near 0944eh ; 0f 86 80 00 + jmp near 0953bh ; e9 6a 01 cmp bx, strict byte 00002h ; 83 fb 02 - je short 09236h ; 74 23 + je short 093f9h ; 74 23 cmp bx, strict byte 00001h ; 83 fb 01 - jne near 09378h ; 0f 85 5e 01 + jne near 0953bh ; 0f 85 5e 01 mov word [bp+020h], strict word 00001h ; c7 46 20 01 00 mov word [bp+014h], 00210h ; c7 46 14 10 02 @@ -13644,49 +13831,49 @@ mov word [bp+018h], 04350h ; c7 46 18 50 43 mov word [bp+01ah], 02049h ; c7 46 1a 49 20 - jmp near 093a5h ; e9 6f 01 + jmp near 09568h ; e9 6f 01 cmp word [bp+018h], strict byte 0ffffh ; 83 7e 18 ff - jne short 09242h ; 75 06 + jne short 09405h ; 75 06 or ah, 083h ; 80 cc 83 - jmp near 0939eh ; e9 5c 01 + jmp near 09561h ; e9 5c 01 mov bx, word [bp+008h] ; 8b 5e 08 mov dx, word [bp+01ch] ; 8b 56 1c mov ax, word [bp+018h] ; 8b 46 18 xor cx, cx ; 31 c9 - call 090deh ; e8 8e fe + call 092a1h ; e8 8e fe cmp ax, strict word 0ffffh ; 3d ff ff - jne short 09260h ; 75 0b + jne short 09423h ; 75 0b mov ax, word [bp+020h] ; 8b 46 20 xor ah, ah ; 30 e4 or ah, 086h ; 80 cc 86 - jmp near 0939eh ; e9 3e 01 + jmp near 09561h ; e9 3e 01 mov word [bp+014h], ax ; 89 46 14 - jmp near 093a5h ; e9 3f 01 + jmp near 09568h ; e9 3f 01 mov bx, word [bp+008h] ; 8b 5e 08 mov ax, word [bp+01ch] ; 8b 46 1c mov dx, word [bp+01eh] ; 8b 56 1e mov cx, strict word 00001h ; b9 01 00 - call 090deh ; e8 69 fe + call 092a1h ; e8 69 fe cmp ax, strict word 0ffffh ; 3d ff ff - jne short 09285h ; 75 0b + jne short 09448h ; 75 0b mov ax, word [bp+020h] ; 8b 46 20 xor ah, ah ; 30 e4 or ah, 086h ; 80 cc 86 - jmp near 0939eh ; e9 19 01 + jmp near 09561h ; e9 19 01 mov word [bp+014h], ax ; 89 46 14 - jmp near 093a5h ; e9 1a 01 + jmp near 09568h ; e9 1a 01 cmp word [bp+004h], 00100h ; 81 7e 04 00 01 - jc short 09298h ; 72 06 + jc short 0945bh ; 72 06 or ah, 087h ; 80 cc 87 - jmp near 0939eh ; e9 06 01 + jmp near 09561h ; e9 06 01 mov dx, word [bp+004h] ; 8b 56 04 mov ax, word [bp+014h] ; 8b 46 14 - call 090bah ; e8 19 fe + call 0927dh ; e8 19 fe mov bx, word [bp+020h] ; 8b 5e 20 xor bh, bh ; 30 ff sub bx, strict byte 00008h ; 83 eb 08 cmp bx, strict byte 00005h ; 83 fb 05 - jnbe near 093a5h ; 0f 87 f5 00 + jnbe near 09568h ; 0f 87 f5 00 add bx, bx ; 01 db - jmp word [cs:bx-06e37h] ; 2e ff a7 c9 91 + jmp word [cs:bx-06c74h] ; 2e ff a7 8c 93 mov bx, word [bp+01ch] ; 8b 5e 1c xor bl, bl ; 30 db @@ -13699,5 +13886,5 @@ or bx, ax ; 09 c3 mov word [bp+01ch], bx ; 89 5e 1c - jmp near 093a5h ; e9 d4 00 + jmp near 09568h ; e9 d4 00 mov dx, word [bp+004h] ; 8b 56 04 xor dh, dh ; 30 f6 @@ -13706,5 +13893,5 @@ in ax, DX ; ed mov word [bp+01ch], ax ; 89 46 1c - jmp near 093a5h ; e9 c1 00 + jmp near 09568h ; e9 c1 00 mov dx, 00cfch ; ba fc 0c in eax, DX ; 66 ed @@ -13715,5 +13902,5 @@ mov word [bp+01ch], ax ; 89 46 1c mov word [bp+01eh], dx ; 89 56 1e - jmp near 093a5h ; e9 ac 00 + jmp near 09568h ; e9 ac 00 mov ax, word [bp+01ch] ; 8b 46 1c mov dx, word [bp+004h] ; 8b 56 04 @@ -13722,5 +13909,5 @@ add dx, 00cfch ; 81 c2 fc 0c out DX, AL ; ee - jmp near 093a5h ; e9 99 00 + jmp near 09568h ; e9 99 00 mov ax, word [bp+01ch] ; 8b 46 1c mov dx, word [bp+004h] ; 8b 56 04 @@ -13729,5 +13916,5 @@ add dx, 00cfch ; 81 c2 fc 0c out DX, ax ; ef - jmp near 093a5h ; e9 86 00 + jmp near 09568h ; e9 86 00 mov ax, word [bp+01ch] ; 8b 46 1c mov cx, word [bp+01eh] ; 8b 4e 1e @@ -13738,5 +13925,5 @@ ; mov ax, cx ; 8b c1 out DX, eax ; 66 ef - jmp short 093a5h ; eb 72 + jmp short 09568h ; eb 72 mov bx, word [bp+004h] ; 8b 5e 04 mov es, [bp+026h] ; 8e 46 26 @@ -13745,5 +13932,5 @@ mov cx, word [0f4a0h] ; 8b 0e a0 f4 cmp cx, word [es:bx] ; 26 3b 0f - jbe short 09359h ; 76 11 + jbe short 0951ch ; 76 11 mov ax, word [bp+020h] ; 8b 46 20 xor ah, ah ; 30 e4 @@ -13751,5 +13938,5 @@ mov word [bp+020h], ax ; 89 46 20 or word [bp+02ch], strict byte 00001h ; 83 4e 2c 01 - jmp short 0936dh ; eb 14 + jmp short 09530h ; eb 14 les di, [es:bx+002h] ; 26 c4 7f 02 mov si, 0f2c0h ; be c0 f2 @@ -13763,9 +13950,9 @@ les bx, [bp-008h] ; c4 5e f8 mov word [es:bx], ax ; 26 89 07 - jmp short 093a5h ; eb 2d - mov bx, 00da2h ; bb a2 0d + jmp short 09568h ; eb 2d + mov bx, 00da8h ; bb a8 0d mov cx, ds ; 8c d9 mov ax, strict word 00004h ; b8 04 00 - call 01931h ; e8 ae 85 + call 01931h ; e8 eb 83 mov ax, word [bp+014h] ; 8b 46 14 push ax ; 50 @@ -13774,5 +13961,5 @@ push 00d5eh ; 68 5e 0d push strict byte 00004h ; 6a 04 - call 01972h ; e8 df 85 + call 01972h ; e8 1c 84 add sp, strict byte 00008h ; 83 c4 08 mov ax, word [bp+020h] ; 8b 46 20 @@ -13786,5 +13973,5 @@ pop bp ; 5d retn ; c3 -pci_find_classcode_: ; 0xf93ac LB 0x2b +pci_find_classcode_: ; 0xf956f LB 0x2b push bp ; 55 mov bp, sp ; 89 e5 @@ -13801,5 +13988,5 @@ int 01ah ; cd 1a cmp ah, 000h ; 80 fc 00 - je near 093cdh ; 0f 84 03 00 + je near 09590h ; 0f 84 03 00 mov bx, strict word 0ffffh ; bb ff ff mov ax, bx ; 89 d8 @@ -13810,5 +13997,5 @@ pop bp ; 5d retn ; c3 -pci_read_config_byte_: ; 0xf93d7 LB 0x24 +pci_read_config_byte_: ; 0xf959a LB 0x24 push bp ; 55 mov bp, sp ; 89 e5 @@ -13829,5 +14016,5 @@ pop bp ; 5d retn ; c3 -pci_read_config_word_: ; 0xf93fb LB 0x22 +pci_read_config_word_: ; 0xf95be LB 0x22 push bp ; 55 mov bp, sp ; 89 e5 @@ -13848,5 +14035,5 @@ pop bp ; 5d retn ; c3 -pci_read_config_dword_: ; 0xf941d LB 0x27 +pci_read_config_dword_: ; 0xf95e0 LB 0x27 push bp ; 55 mov bp, sp ; 89 e5 @@ -13869,5 +14056,5 @@ pop bp ; 5d retn ; c3 -vds_is_present_: ; 0xf9444 LB 0x1d +vds_is_present_: ; 0xf9607 LB 0x1d push bx ; 53 push bp ; 55 @@ -13877,5 +14064,5 @@ mov es, ax ; 8e c0 test byte [es:bx], 020h ; 26 f6 07 20 - je short 0945ch ; 74 06 + je short 0961fh ; 74 06 mov ax, strict word 00001h ; b8 01 00 pop bp ; 5d @@ -13886,5 +14073,5 @@ pop bx ; 5b retn ; c3 -vds_real_to_lin_: ; 0xf9461 LB 0x1e +vds_real_to_lin_: ; 0xf9624 LB 0x1e push bx ; 53 push cx ; 51 @@ -13897,5 +14084,5 @@ sal ax, 1 ; d1 e0 rcl dx, 1 ; d1 d2 - loop 0946fh ; e2 fa + loop 09632h ; e2 fa xor cx, cx ; 31 c9 add ax, bx ; 01 d8 @@ -13905,5 +14092,5 @@ pop bx ; 5b retn ; c3 -vds_build_sg_list_: ; 0xf947f LB 0x79 +vds_build_sg_list_: ; 0xf9642 LB 0x79 push bp ; 55 mov bp, sp ; 89 e5 @@ -13919,21 +14106,21 @@ mov bx, word [bp+006h] ; 8b 5e 06 mov word [es:di+002h], bx ; 26 89 5d 02 - call 09461h ; e8 c3 ff + call 09624h ; e8 c3 ff mov es, si ; 8e c6 mov word [es:di+004h], ax ; 26 89 45 04 mov word [es:di+006h], dx ; 26 89 55 06 mov word [es:di+008h], strict word 00000h ; 26 c7 45 08 00 00 - call 09444h ; e8 93 ff + call 09607h ; e8 93 ff test ax, ax ; 85 c0 - je short 094c8h ; 74 13 + je short 0968bh ; 74 13 mov es, si ; 8e c6 mov ax, 08105h ; b8 05 81 mov dx, strict word 00000h ; ba 00 00 int 04bh ; cd 4b - jc near 094c5h ; 0f 82 02 00 + jc near 09688h ; 0f 82 02 00 db 032h, 0c0h ; xor al, al ; 32 c0 cbw ; 98 - jmp short 094efh ; eb 27 + jmp short 096b2h ; eb 27 mov es, si ; 8e c6 mov word [es:di+00eh], strict word 00001h ; 26 c7 45 0e 01 00 @@ -13952,5 +14139,5 @@ pop bp ; 5d retn 00004h ; c2 04 00 -vds_free_sg_list_: ; 0xf94f8 LB 0x38 +vds_free_sg_list_: ; 0xf96bb LB 0x35 push bp ; 55 mov bp, sp ; 89 e5 @@ -13958,7 +14145,7 @@ push di ; 57 mov bx, ax ; 89 c3 - call 09444h ; e8 42 ff + call 09607h ; e8 42 ff test ax, ax ; 85 c0 - je short 09519h ; 74 13 + je short 096dch ; 74 13 mov di, bx ; 89 df mov es, dx ; 8e c2 @@ -13966,5 +14153,5 @@ mov dx, strict word 00000h ; ba 00 00 int 04bh ; cd 4b - jc near 09518h ; 0f 82 02 00 + jc near 096dbh ; 0f 82 02 00 db 032h, 0c0h ; xor al, al ; 32 c0 @@ -13977,6 +14164,6 @@ pop bp ; 5d retn ; c3 - times 0x8 db 0 -__U4D: ; 0xf9530 LB 0x39 + times 0x5 db 0 +__U4D: ; 0xf96f0 LB 0x39 pushfw ; 9c push eax ; 66 50 @@ -14008,5 +14195,5 @@ popfw ; 9d retn ; c3 -__U4M: ; 0xf9569 LB 0x31 +__U4M: ; 0xf9729 LB 0x31 pushfw ; 9c push eax ; 66 50 @@ -14033,5 +14220,5 @@ popfw ; 9d retn ; c3 -_fmemset_: ; 0xf959a LB 0xd +_fmemset_: ; 0xf975a LB 0xd push di ; 57 mov es, dx ; 8e c2 @@ -14043,5 +14230,5 @@ pop di ; 5f retn ; c3 -_fmemcpy_: ; 0xf95a7 LB 0x33 +_fmemcpy_: ; 0xf9767 LB 0x33 push bp ; 55 db 08bh, 0ech @@ -14063,21 +14250,17 @@ leave ; c9 retn ; c3 - add al, dh ; 00 f0 - xchg bp, ax ; 95 - repne xchg bp, ax ; f2 95 - not byte [di-06a0ah] ; f6 95 f6 95 - not byte [di-06a08h] ; f6 95 f8 95 - clc ; f8 - xchg bp, ax ; 95 - cli ; fa - xchg bp, ax ; 95 - db 0feh - xchg bp, ax ; 95 - db 0feh - xchg bp, ax ; 95 - add byte [bp-069fbh], dl ; 00 96 05 96 - pop ES ; 07 - xchg si, ax ; 96 -apm_worker: ; 0xf95da LB 0x3a + add byte [bx+si-04d69h], dh ; 00 b0 97 b2 + xchg di, ax ; 97 + mov DH, strict byte 097h ; b6 97 + mov DH, strict byte 097h ; b6 97 + mov DH, strict byte 097h ; b6 97 + mov ax, 0b897h ; b8 97 b8 + xchg di, ax ; 97 + mov dx, 0be97h ; ba 97 be + xchg di, ax ; 97 + mov si, 0c097h ; be 97 c0 + xchg di, ax ; 97 + lds dx, [bx-06839h] ; c5 97 c7 97 +apm_worker: ; 0xf979a LB 0x3a sti ; fb push ax ; 50 @@ -14091,21 +14274,21 @@ pop ax ; 58 mov AH, strict byte 053h ; b4 53 - jnc short 09610h ; 73 25 - jmp word [cs:bp-06a40h] ; 2e ff a6 c0 95 - jmp short 0960eh ; eb 1c + jnc short 097d0h ; 73 25 + jmp word [cs:bp-06880h] ; 2e ff a6 80 97 + jmp short 097ceh ; eb 1c sti ; fb hlt ; f4 - jmp short 0960eh ; eb 18 - jmp short 0960eh ; eb 16 - jmp short 09610h ; eb 16 + jmp short 097ceh ; eb 18 + jmp short 097ceh ; eb 16 + jmp short 097d0h ; eb 16 mov AH, strict byte 080h ; b4 80 - jmp short 09612h ; eb 14 - jmp short 09610h ; eb 10 + jmp short 097d2h ; eb 14 + jmp short 097d0h ; eb 10 mov ax, 00102h ; b8 02 01 - jmp short 0960eh ; eb 09 - jmp short 0960eh ; eb 07 + jmp short 097ceh ; eb 09 + jmp short 097ceh ; eb 07 mov BL, strict byte 000h ; b3 00 mov cx, strict word 00000h ; b9 00 00 - jmp short 0960eh ; eb 00 + jmp short 097ceh ; eb 00 clc ; f8 retn ; c3 @@ -14113,5 +14296,5 @@ stc ; f9 retn ; c3 -apm_pm16_entry: ; 0xf9614 LB 0x11 +apm_pm16_entry: ; 0xf97d4 LB 0x11 mov AH, strict byte 002h ; b4 02 push DS ; 1e @@ -14121,11 +14304,11 @@ add bp, strict byte 00008h ; 83 c5 08 mov ds, bp ; 8e dd - call 095dah ; e8 b8 ff + call 0979ah ; e8 b8 ff pop bp ; 5d pop DS ; 1f retf ; cb - ; Padding 0x43db bytes at 0xf9625 - times 17371 db 0 + ; Padding 0x421b bytes at 0xf97e5 + times 16923 db 0 section BIOS32 progbits vstart=0xda00 align=1 ; size=0x3cb class=CODE group=AUTO @@ -14174,5 +14357,5 @@ add bp, strict byte 00008h ; 83 c5 08 push ebp ; 66 55 - mov bp, 09616h ; bd 16 96 + mov bp, 097d6h ; bd d6 97 add byte [bx+si], al ; 00 00 push ebp ; 66 55 @@ -14370,10 +14553,10 @@ xor bx, bx ; 31 db db 00fh, 0b7h, 055h, 00ch - ; movzx dx, word [di+00ch] ; 0f b7 55 0c + ; movzx dx, [di+00ch] ; 0f b7 55 0c db 00fh, 0b7h, 045h, 020h - ; movzx ax, word [di+020h] ; 0f b7 45 20 + ; movzx ax, [di+020h] ; 0f b7 45 20 sal ax, 010h ; c1 e0 10 db 00fh, 0b7h, 04dh, 01ch - ; movzx cx, word [di+01ch] ; 0f b7 4d 1c + ; movzx cx, [di+01ch] ; 0f b7 4d 1c or ax, cx ; 09 c8 call 0da81h ; e8 66 fe @@ -14391,5 +14574,5 @@ add byte [bx+si], al ; 00 00 db 00fh, 0b7h, 055h, 00ch - ; movzx dx, word [di+00ch] ; 0f b7 55 0c + ; movzx dx, [di+00ch] ; 0f b7 55 0c mov ax, word [di+020h] ; 8b 45 20 mov bx, strict word 00001h ; bb 01 00 @@ -14415,7 +14598,7 @@ add byte [bx+si], al ; 00 00 db 00fh, 0b7h, 055h, 008h - ; movzx dx, word [di+008h] ; 0f b7 55 08 + ; movzx dx, [di+008h] ; 0f b7 55 08 db 00fh, 0b7h, 045h, 018h - ; movzx ax, word [di+018h] ; 0f b7 45 18 + ; movzx ax, [di+018h] ; 0f b7 45 18 call 0da5fh ; e8 d9 fd db 0ffh @@ -14484,5 +14667,5 @@ add byte [bx+si], al ; 00 00 db 00fh, 0b7h, 045h, 020h - ; movzx ax, word [di+020h] ; 0f b7 45 20 + ; movzx ax, [di+020h] ; 0f b7 45 20 mov dx, word [di+008h] ; 8b 55 08 xor dh, dh ; 30 f6 @@ -14501,5 +14684,5 @@ jmp short 0ddc3h ; eb 70 db 00fh, 0b7h, 045h, 008h - ; movzx ax, word [di+008h] ; 0f b7 45 08 + ; movzx ax, [di+008h] ; 0f b7 45 08 mov es, [di+028h] ; 8e 45 28 mov [di-010h], es ; 8c 45 f0 @@ -14780,5 +14963,5 @@ mov dx, 0c800h ; ba 00 c8 call 01600h ; e8 e7 33 - call 049b4h ; e8 98 67 + call 04b77h ; e8 5b 69 pop DS ; 1f mov ax, 0ff53h ; b8 53 ff @@ -14896,6 +15079,6 @@ call 01badh ; e8 71 38 call 01fa7h ; e8 68 3c - call 08e8eh ; e8 4c ab - call 07ee5h ; e8 a0 9b + call 09051h ; e8 0f ad + call 080a8h ; e8 63 9d call 0ed2fh ; e8 e7 09 call 0e2d2h ; e8 87 ff @@ -14907,5 +15090,5 @@ mov dx, 0f000h ; ba 00 f0 call 01600h ; e8 a6 32 - call 03698h ; e8 3b 53 + call 0385bh ; e8 fe 54 sti ; fb int 019h ; cd 19 @@ -15005,5 +15188,5 @@ pop DS ; 1f cld ; fc - call 05d9eh ; e8 5c 76 + call 05f61h ; e8 1f 78 popaw ; 61 pop ES ; 07 @@ -15080,5 +15263,5 @@ pop DS ; 1f cld ; fc - call 0510ch ; e8 ca 68 + call 052cfh ; e8 8d 6a popaw ; 61 pop DS ; 1f @@ -15097,5 +15280,5 @@ pop DS ; 1f cld ; fc - call 0510ch ; e8 ac 68 + call 052cfh ; e8 6f 6a popaw ; 61 pop DS ; 1f @@ -15199,5 +15382,5 @@ pop DS ; 1f cld ; fc - call 04cb1h ; e8 e2 62 + call 04e74h ; e8 a5 64 pop ES ; 07 popaw ; 61 @@ -15215,5 +15398,5 @@ pop DS ; 1f cld ; fc - call 067f6h ; e8 11 7e + call 069b9h ; e8 d4 7f pop DS ; 1f pop ES ; 07 @@ -15236,5 +15419,5 @@ cld ; fc push 0ece9h ; 68 e9 ec - jmp near 036dch ; e9 6b 4a + jmp near 0389fh ; e9 2e 4c push ES ; 06 push ax ; 50 @@ -15242,8 +15425,8 @@ push cx ; 51 push dx ; 52 - call 036b0h ; e8 37 4a + call 03873h ; e8 fa 4b cmp AL, strict byte 000h ; 3c 00 je short 0ecabh ; 74 2e - call 036c6h ; e8 46 4a + call 03889h ; e8 09 4c pop dx ; 5a push dx ; 52 @@ -15263,5 +15446,5 @@ cld ; fc push 0ece9h ; 68 e9 ec - jmp near 03cb0h ; e9 19 50 + jmp near 03e73h ; e9 dc 51 and dl, 0e0h ; 80 e2 e0 db 03ah, 0c2h @@ -15309,5 +15492,5 @@ shr ebx, 010h ; 66 c1 eb 10 push bx ; 53 - call 040e4h ; e8 0f 54 + call 042a7h ; e8 d2 55 pop bx ; 5b sal ebx, 010h ; 66 c1 e3 10 @@ -15316,7 +15499,7 @@ cmp ah, 040h ; 80 fc 40 jnbe short 0ece6h ; 77 05 - call 05491h ; e8 ad 67 + call 05654h ; e8 70 69 jmp short 0ece9h ; eb 03 - call 058d2h ; e8 e9 6b + call 05a95h ; e8 ac 6d int13_out: ; 0xfece9 LB 0x4 pop DS ; 1f @@ -15531,5 +15714,5 @@ pop DS ; 1f cld ; fc - call 07150h ; e8 73 81 + call 07313h ; e8 36 83 popaw ; 61 pop ES ; 07 @@ -15579,5 +15762,5 @@ mov ax, strict word 00001h ; b8 01 00 push ax ; 50 - call 0474bh ; e8 7b 56 + call 0490eh ; e8 3e 58 inc sp ; 44 inc sp ; 44 @@ -15586,5 +15769,5 @@ mov ax, strict word 00002h ; b8 02 00 push ax ; 50 - call 0474bh ; e8 6e 56 + call 0490eh ; e8 31 58 inc sp ; 44 inc sp ; 44 @@ -15593,5 +15776,5 @@ mov ax, strict word 00003h ; b8 03 00 push strict byte 00003h ; 6a 03 - call 0474bh ; e8 60 56 + call 0490eh ; e8 23 58 inc sp ; 44 inc sp ; 44 @@ -15600,5 +15783,5 @@ mov ax, strict word 00004h ; b8 04 00 push ax ; 50 - call 0474bh ; e8 53 56 + call 0490eh ; e8 16 58 inc sp ; 44 inc sp ; 44 @@ -15891,5 +16074,5 @@ cmp ah, 0c2h ; 80 fc c2 je short 0f887h ; 74 0e - call 05fabh ; e8 2f 67 + call 0616eh ; e8 f2 68 popaw ; 61 pop ES ; 07 @@ -15897,12 +16080,12 @@ popfw ; 9d jmp short 0f895h ; eb 13 - call 08fc5h ; e8 40 97 + call 09188h ; e8 03 99 jmp short 0f87ch ; eb f5 int15_handler_mouse: ; 0xff887 LB 0x5 - call 06dc5h ; e8 3b 75 + call 06f88h ; e8 fe 76 jmp short 0f87ch ; eb f0 int15_handler32: ; 0xff88c LB 0x9 pushad ; 66 60 - call 06478h ; e8 e7 6b + call 0663bh ; e8 aa 6d popad ; 66 61 jmp short 0f87dh ; eb e8 @@ -15934,5 +16117,5 @@ pop DS ; 1f cld ; fc - call 06cfbh ; e8 3e 74 + call 06ebeh ; e8 01 76 pop cx ; 59 jcxz 0f8cch ; e3 0c @@ -16026,6 +16209,6 @@ db 018h, 018h, 018h, 000h, 018h, 018h, 018h, 000h, 0e0h, 030h, 030h, 01ch, 030h, 030h, 0e0h, 000h db 076h, 0dch, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 010h, 038h, 06ch, 0c6h, 0c6h, 0feh, 000h - db 080h, 0fch, 0b1h, 075h, 00fh, 006h, 01eh, 00eh, 01fh, 0fch, 066h, 060h, 0e8h, 058h, 093h, 066h - db 061h, 01fh, 007h, 0cfh, 006h, 01eh, 060h, 00eh, 01fh, 0fch, 0e8h, 007h, 06ch, 061h, 01fh, 007h + db 080h, 0fch, 0b1h, 075h, 00fh, 006h, 01eh, 00eh, 01fh, 0fch, 066h, 060h, 0e8h, 01bh, 095h, 066h + db 061h, 01fh, 007h, 0cfh, 006h, 01eh, 060h, 00eh, 01fh, 0fch, 0e8h, 0cah, 06dh, 061h, 01fh, 007h db 0cfh int70_handler: ; 0xffe8f LB 0x16 @@ -16036,5 +16219,5 @@ pop DS ; 1f cld ; fc - call 069d4h ; e8 3c 6b + call 06b97h ; e8 ff 6c popaw ; 61 pop DS ; 1f @@ -16087,5 +16270,5 @@ dec di ; 4f jc short 0ff64h ; 72 61 - arpl word [si+065h], bp ; 63 6c 65 + arpl [si+065h], bp ; 63 6c 65 and byte [bp+04dh], dl ; 20 56 4d and byte [bp+069h], dl ; 20 56 69 @@ -16135,3 +16318,3 @@ cpu_reset: ; 0xffff0 LB 0x10 jmp far 0f000h:0e05bh ; ea 5b e0 00 f0 - db 030h, 036h, 02fh, 032h, 033h, 02fh, 039h, 039h, 000h, 0fch, 0ach + db 030h, 036h, 02fh, 032h, 033h, 02fh, 039h, 039h, 000h, 0fch, 05dh Index: /trunk/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.md5sum =================================================================== --- /trunk/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.md5sum (revision 55077) +++ /trunk/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.md5sum (revision 55078) @@ -1,1 +1,1 @@ -81504fb40b77397cbba587ef505d6c22 *VBoxPcBios.rom +52f20c4019f05d0a8b5d96985ecebb03 *VBoxPcBios.rom Index: /trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.cpp =================================================================== --- /trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.cpp (revision 55077) +++ /trunk/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.cpp (revision 55078) @@ -188,19 +188,11 @@ Interval.QuadPart = -(int64_t) 2 /* ms */ * 10000; uint32_t cRefs; - size_t loops = 0; - KTIMER kTimer; - NTSTATUS status = STATUS_SUCCESS; - - KeInitializeTimer(&kTimer); - - while ((cRefs = ASMAtomicReadU32(&pRef->cRefs)) > u32Val && loops < 256) + + while ((cRefs = ASMAtomicReadU32(&pRef->cRefs)) != u32Val) { Assert(cRefs >= u32Val); Assert(cRefs < UINT32_MAX/2); - KeSetTimer(&kTimer, Interval, NULL); - status = KeWaitForSingleObject(&kTimer, Executive, KernelMode, false, NULL); - Assert(NT_SUCCESS(status)); - loops++; + KeDelayExecutionThread(KernelMode, FALSE, &Interval); } } Index: /trunk/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.h =================================================================== --- /trunk/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.h (revision 55077) +++ /trunk/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.h (revision 55078) @@ -190,3 +190,15 @@ } +static DECLHIDDEN(VOID) vboxUsbDdiStateWaitOtherCompleted(PVBOXUSBDEV_EXT pDevExt) +{ + /* Earlier we assumed that 1 request will be pending while we service + Device Power IRP which was leading to host hang when USB is connected + to VM. + With debugging found that at the point when host goes to sleep + state and USB is connected to VM, two Power IRP requests are pending : + One for SYSTEM and other for DEVICE. + */ + VBoxDrvToolRefWaitEqual(&pDevExt->DdiState.Ref, 3); +} + #endif /* #ifndef ___VBoxUsbDev_h___ */ Index: /trunk/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPnP.cpp =================================================================== --- /trunk/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPnP.cpp (revision 55077) +++ /trunk/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPnP.cpp (revision 55078) @@ -70,13 +70,19 @@ ENMVBOXUSB_PNPSTATE enmState = vboxUsbPnPStateGet(pDevExt); NTSTATUS Status = STATUS_SUCCESS; - - IoCopyCurrentIrpStackLocationToNext(pIrp); - Status = VBoxDrvToolIoPostSync(pDevExt->pLowerDO, pIrp); - if (NT_SUCCESS(Status) && enmState == ENMVBOXUSB_PNPSTATE_STOP_PENDING) - { - vboxUsbPnPStateRestore(pDevExt); - } - - Status = STATUS_SUCCESS; + if (enmState == ENMVBOXUSB_PNPSTATE_STOP_PENDING) + { + IoCopyCurrentIrpStackLocationToNext(pIrp); + Status = VBoxDrvToolIoPostSync(pDevExt->pLowerDO, pIrp); + if (NT_SUCCESS(Status)) + { + vboxUsbPnPStateRestore(pDevExt); + } + } + else + { + Assert(0); + Assert(enmState == ENMVBOXUSB_PNPSTATE_STARTED); + } + VBoxDrvToolIoComplete(pIrp, Status, 0); vboxUsbDdiStateRelease(pDevExt); @@ -138,15 +144,19 @@ ENMVBOXUSB_PNPSTATE enmState = vboxUsbPnPStateGet(pDevExt); NTSTATUS Status = STATUS_SUCCESS; - IoCopyCurrentIrpStackLocationToNext(pIrp); - - Status = VBoxDrvToolIoPostSync(pDevExt->pLowerDO, pIrp); - - if (NT_SUCCESS(Status) && - enmState == ENMVBOXUSB_PNPSTATE_REMOVE_PENDING) - { - vboxUsbPnPStateRestore(pDevExt); - } - - Status = STATUS_SUCCESS; + if (enmState == ENMVBOXUSB_PNPSTATE_REMOVE_PENDING) + { + IoCopyCurrentIrpStackLocationToNext(pIrp); + Status = VBoxDrvToolIoPostSync(pDevExt->pLowerDO, pIrp); + if (NT_SUCCESS(Status)) + { + vboxUsbPnPStateRestore(pDevExt); + } + } + else + { + Assert(0); + Assert(enmState == ENMVBOXUSB_PNPSTATE_STARTED); + } + VBoxDrvToolIoComplete(pIrp, Status, 0); vboxUsbDdiStateRelease(pDevExt); Index: /trunk/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPwr.cpp =================================================================== --- /trunk/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPwr.cpp (revision 55077) +++ /trunk/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPwr.cpp (revision 55078) @@ -210,4 +210,6 @@ PIRP pIrp = pCtx->pIrp; + vboxUsbDdiStateWaitOtherCompleted(pDevExt); + vboxUsbPwrIoPostDev(pDevExt, pIrp); Index: /trunk/src/VBox/Installer/linux/debian/control =================================================================== --- /trunk/src/VBox/Installer/linux/debian/control (revision 55077) +++ /trunk/src/VBox/Installer/linux/debian/control (revision 55078) @@ -1,3 +1,3 @@ -Source: virtualbox-4.3 +Source: virtualbox-5.0 Section: contrib/misc Priority: optional @@ -14,5 +14,5 @@ XS-Python-Version: >= 2.4 -Package: virtualbox-4.3 +Package: virtualbox-5.0 Architecture: i386 amd64 Pre-Depends: debconf (>= 1.1) | debconf-2.0 @@ -32,7 +32,7 @@ XB-Python-Version: ${python:Versions} -Package: virtualbox-4.3-dbg +Package: virtualbox-5.0-dbg Architecture: i386 amd64 -Depends: virtualbox-4.3 (= ${Source-Version}) +Depends: virtualbox-5.0 (= ${Source-Version}) Provides: virtualbox-dbg Replaces: virtualbox-dbg Index: /trunk/src/VBox/Installer/linux/debian/rules =================================================================== --- /trunk/src/VBox/Installer/linux/debian/rules (revision 55077) +++ /trunk/src/VBox/Installer/linux/debian/rules (revision 55078) @@ -42,5 +42,5 @@ package := virtualbox -verpkg := virtualbox-4.3 +verpkg := virtualbox-5.0 current := $(shell pwd) vboxroot := $(shell cd ../../../..; pwd) Index: /trunk/src/VBox/Installer/linux/rpm/rules =================================================================== --- /trunk/src/VBox/Installer/linux/rpm/rules (revision 55077) +++ /trunk/src/VBox/Installer/linux/rpm/rules (revision 55078) @@ -53,5 +53,5 @@ endif -verpkg := VirtualBox-4.3 +verpkg := VirtualBox-5.0 current := $(shell pwd) vboxroot := $(shell cd ../../../..; pwd) Index: /trunk/src/VBox/Main/idl/VirtualBox.xidl =================================================================== --- /trunk/src/VBox/Main/idl/VirtualBox.xidl (revision 55077) +++ /trunk/src/VBox/Main/idl/VirtualBox.xidl (revision 55078) @@ -562,5 +562,5 @@ - Settings version "1.15", written by VirtualBox 4.4.x. + Settings version "1.15", written by VirtualBox 5.0.x.