Torch Graduate

for bbc micro/electron hardware, peripherals & programming issues (NOT emulators!)
Post Reply
IBM portable PC
Posts: 149
Joined: Mon Apr 01, 2013 9:48 pm
Location: Melbourne, Australia
Contact:

Torch Graduate

Post by IBM portable PC » Tue Nov 18, 2014 10:01 pm

I just paid a Kings ransom for one of these last week and should receive it next week.

Does anyone have any tips to share?

I'm looking at adding an AST Sixpakplus to add; Serial, Parallel, 384K RAM, RTC and game port. I'm also going to test it with my IBM 5161 System Expander:

http://www.computinghistory.org.uk/det/21352/IBM-5161/

I've found the manuals and believe it will boot a standard DOS floppy.
WISH LIST: Acornsoft C Compiler PDF manual, Anything 68008/68000 related, LVL Upgrade manual/ROMS, Watford Floppy Drive Selector, Commodore (CBM) PET ROM/S for CST Procyon IEEE-488 Interface", Beeb on a Eurocard systems

User avatar
Arcadian
Site Admin
Posts: 2936
Joined: Fri Nov 24, 2000 12:16 pm
Contact:

Re: Torch Graduate

Post by Arcadian » Tue Nov 18, 2014 10:58 pm

Just checking you're aware that the support discs are available here:
http://www.stairwaytohell.com/essentials
For a "Complete BBC Games Archive" visit www.bbcmicro.co.uk

Image
ABug SOUTH (Hampshire) (1-3 June 2018)

IBM portable PC
Posts: 149
Joined: Mon Apr 01, 2013 9:48 pm
Location: Melbourne, Australia
Contact:

Re: Torch Graduate

Post by IBM portable PC » Wed Nov 19, 2014 8:38 am

Arcadian wrote:Just checking you're aware that the support discs are available here:
http://www.stairwaytohell.com/essentials
No, I didn't know that! Thank you very much.
WISH LIST: Acornsoft C Compiler PDF manual, Anything 68008/68000 related, LVL Upgrade manual/ROMS, Watford Floppy Drive Selector, Commodore (CBM) PET ROM/S for CST Procyon IEEE-488 Interface", Beeb on a Eurocard systems

IBM portable PC
Posts: 149
Joined: Mon Apr 01, 2013 9:48 pm
Location: Melbourne, Australia
Contact:

Re: Torch Graduate

Post by IBM portable PC » Wed Nov 19, 2014 8:41 am

I also have various 286-486 upgrade cards for XT's which I'll try along with an IDE controller and a SCSI HDC controller.
WISH LIST: Acornsoft C Compiler PDF manual, Anything 68008/68000 related, LVL Upgrade manual/ROMS, Watford Floppy Drive Selector, Commodore (CBM) PET ROM/S for CST Procyon IEEE-488 Interface", Beeb on a Eurocard systems

User avatar
george.h
Posts: 1027
Joined: Wed Apr 13, 2011 5:32 pm
Location: Chelmsford Essex
Contact:

Re: Torch Graduate

Post by george.h » Wed Nov 19, 2014 1:55 pm

I used to have one and used it to connect to PC based bulletin boards (BITD) using an early US Robotics internal modem card and Telix SE. I'm pretty sure it only takes 8-bit ISA cards (can't remember if it's PC or PC-XT, or even if there is a difference!) so anything needing 16-bit is a no-goer.
Pic Caption: "One day son, this will all be yours..."

Prime
Posts: 2499
Joined: Sun May 31, 2009 11:52 pm
Contact:

Re: Torch Graduate

Post by Prime » Wed Nov 19, 2014 3:33 pm

george.h wrote:I used to have one and used it to connect to PC based bulletin boards (BITD) using an early US Robotics internal modem card and Telix SE. I'm pretty sure it only takes 8-bit ISA cards (can't remember if it's PC or PC-XT, or even if there is a difference!) so anything needing 16-bit is a no-goer.
IIRC PC (5150) and XT (5160) cards are the same. The main difference between the two machines was that the XT has 8 expansion slots whereas the PC only has 5. So you sometimes come across a card with a wide plate on the back for the PC which obviously had more space between each slot.

On a standard PC or XT, you can (clearance permitting) use a 16 bit IDE combo card for everything EXCEPT the IDE, so with the correct drivers you can have HD 1.44M/1.2M floppies, parallel, serial & games all on one card.

The same is true for a fair number of 16 bit VGA cards, they either auto-detected or had a jumper to set them to be 8 bit.

There is also a hardware design & BIOS to allow the use of IDE && || compact flash drives on an 8 bit PC.

Cheers.

Phill.

User avatar
george.h
Posts: 1027
Joined: Wed Apr 13, 2011 5:32 pm
Location: Chelmsford Essex
Contact:

Re: Torch Graduate

Post by george.h » Wed Nov 19, 2014 4:07 pm

Hi Pill (is it double "L"?),

Your memory is probably working *much* better than mine (who am I again? :lol: ) but what you said all sounds very familiar. I'd guess that the Graduate has the slot arrangement for XT 8-bit cards then as I don't recall a US Robotics Sportster internal PC card being for ye olde original PC, only XT/AT.

It also rings bells regarding the use of 16-bit cards in 8-bit slots (connector placement and board clearance allowing). I remember vague things about that sort of stuff when I was doing support in NEC Peripherals UK with regards to the VGA/SVGA cards we sold then. The 8/16 bit selection caused havoc with the BIOS on the SCSI card we sold to drive our CD-ROM (1x speed!!!!) :wink:

George
Pic Caption: "One day son, this will all be yours..."

User avatar
Pernod
Posts: 1216
Joined: Fri Jun 08, 2012 10:01 pm
Location: Croydon, UK
Contact:

Re: Torch Graduate

Post by Pernod » Sun Aug 06, 2017 8:39 pm

I know it's an old post but any chance of getting the ROMs dumped from this? Looks like three to dump.

Without a circuit diagram this could be quite a challenge to emulate, but having the ROMs would be a good start.
- Nigel

BBC Model B, ATPL Sidewise, Acorn Speech, 2xWatford Floppy Drives, AMX Mouse, Viglen case, BeebZIF, etc.

User avatar
Pernod
Posts: 1216
Joined: Fri Jun 08, 2012 10:01 pm
Location: Croydon, UK
Contact:

Re: Torch Graduate

Post by Pernod » Wed Aug 09, 2017 2:10 am

I'm struggling to understand how the Graduate boots as there's no ROM in the Beeb to communicate with it.

So the Graduate contains a 6502 ROM which is somehow transferred to the Beeb, via JIM? Pressing BREAK causes the Graduate to reset (boot) which must then cause an IRQ from the 1MHz bus. What does the Beeb do in this situation that could cause the 6502 code from the Graduate to be transferred via the 1MHz bus and begin execution?
- Nigel

BBC Model B, ATPL Sidewise, Acorn Speech, 2xWatford Floppy Drives, AMX Mouse, Viglen case, BeebZIF, etc.

User avatar
1024MAK
Posts: 7542
Joined: Mon Apr 18, 2011 4:46 pm
Location: Looking forward to summer in Somerset, UK...
Contact:

Re: Torch Graduate

Post by 1024MAK » Wed Aug 09, 2017 3:07 am

The Acorn OS includes a test quite early on in the start up code to test for an external device. I forget the details, but I think it maybe so control can pass to an Acorn test device. It may be making use of this in some way.

Mark
For a "Complete BBC Games Archive" visit www.bbcmicro.co.uk NOW!
BeebWiki‬ - for answers to many questions...

User avatar
hoglet
Posts: 7216
Joined: Sat Oct 13, 2012 6:21 pm
Location: Bristol
Contact:

Re: Torch Graduate

Post by hoglet » Wed Aug 09, 2017 6:44 am

1024MAK wrote:The Acorn OS includes a test quite early on in the start up code to test for an external device. I forget the details, but I think it maybe so control can pass to an Acorn test device. It may be making use of this in some way.
This is it:

Code: Select all

...
DA77  58                 X       CLI				   ; Briefly allow interrupts to clear anything pending
DA78  78                 x       SEI				   ; Disable interrupts (All VIA IRQs are disabled)
DA79  24 FC              $.      BIT &FC			  ; Check bit 6 (An IRQ occurred)
DA7B  50 03              P.      BVC &DA80			; If not, skip
DA7D  20 55 F0            U.     JSR &F055			; JMP (&FDFE) : Execute code in FRED
...
F055  6C FE FD          .l..     JMP (&FDFE)
It requires the device to generate an interrupt on reset.

Dave

User avatar
1024MAK
Posts: 7542
Joined: Mon Apr 18, 2011 4:46 pm
Location: Looking forward to summer in Somerset, UK...
Contact:

Re: Torch Graduate

Post by 1024MAK » Wed Aug 09, 2017 11:26 am

Yeah, that's what I was thinking of :D

Mark
For a "Complete BBC Games Archive" visit www.bbcmicro.co.uk NOW!
BeebWiki‬ - for answers to many questions...

User avatar
Pernod
Posts: 1216
Joined: Fri Jun 08, 2012 10:01 pm
Location: Croydon, UK
Contact:

Re: Torch Graduate

Post by Pernod » Wed Aug 09, 2017 12:53 pm

hoglet wrote:

Code: Select all

...
DA77  58                 X       CLI				   ; Briefly allow interrupts to clear anything pending
DA78  78                 x       SEI				   ; Disable interrupts (All VIA IRQs are disabled)
DA79  24 FC              $.      BIT &FC			  ; Check bit 6 (An IRQ occurred)
DA7B  50 03              P.      BVC &DA80			; If not, skip
DA7D  20 55 F0            U.     JSR &F055			; JMP (&FDFE) : Execute code in FRED
...
F055  6C FE FD          .l..     JMP (&FDFE)
It requires the device to generate an interrupt on reset.

Dave
Thanks, that explains it well. Shouldn't it read 'JMP (&FDFE) : Execute code in JIM''? So at startup the Graduate will expose a page of it's 6502 ROM in JIM to begin execution, and transfer itself to RAM. I'd not encountered any other devices that make use of this. All I need now are the ROMs.
- Nigel

BBC Model B, ATPL Sidewise, Acorn Speech, 2xWatford Floppy Drives, AMX Mouse, Viglen case, BeebZIF, etc.

User avatar
hoglet
Posts: 7216
Joined: Sat Oct 13, 2012 6:21 pm
Location: Bristol
Contact:

Re: Torch Graduate

Post by hoglet » Wed Aug 09, 2017 1:29 pm

Yes, it should.

Comments I think are Eelco's:
https://acorn.huininga.nl/pub/docs/sour ... 201629.asm

Dave

User avatar
Pernod
Posts: 1216
Joined: Fri Jun 08, 2012 10:01 pm
Location: Croydon, UK
Contact:

Re: Torch Graduate

Post by Pernod » Sat Nov 11, 2017 11:39 am

I now have the ROMs, thanks Jules Richardson, and am trying to get the thing running in MAME. This won't be easy without schematics but worth a challenge.
The I8088 side is standard IBM-PC and so fairly straightforward, and is running, albeit minus the 1770 being hooked up. The 6502 ROM does contain download code in it's first page, and when mapped at &FD00 has an execution vector at (&FDFE) to execute at &FD00. So it seems I just need to generate an interrupt on RST, but when?

I'm currently generating the interrupt from the 1MHz bus when RST is cleared, ie. when BREAK is released, but isn't being picked up to trigger the code. Since the test hardware PET/FIT apparently do something similar I looked at their schematics, which are elsewhere here, but they don't seem to have the IRQ line from the 1MHz bus connected so not much help. Any suggestions on how the RST and IRQ lines are supposed to be connected?
- Nigel

BBC Model B, ATPL Sidewise, Acorn Speech, 2xWatford Floppy Drives, AMX Mouse, Viglen case, BeebZIF, etc.

User avatar
jonb
Posts: 2139
Joined: Sat May 21, 2011 12:42 pm
Location: South Coast of England
Contact:

Re: Torch Graduate

Post by jonb » Sat Nov 11, 2017 11:47 am

Sorry, thickie question here - I didn't know what the Torch Graduate is so headed over to Chris's Acorns. Do I take it it is a co-processor that implements a sort of "PC in a box" that uses the Beeb as a keyboard / display?

User avatar
Pernod
Posts: 1216
Joined: Fri Jun 08, 2012 10:01 pm
Location: Croydon, UK
Contact:

Re: Torch Graduate

Post by Pernod » Sat Nov 11, 2017 11:51 am

jonb wrote:Sorry, thickie question here - I didn't know what the Torch Graduate is so headed over to Chris's Acorns. Do I take it it is a co-processor that implements a sort of "PC in a box" that uses the Beeb as a keyboard / display?
Yep, just connects to the 1MHz bus to use the Beeb for keyboard, video, serial, parallel ports. Doesn't even require a DFS or any specific ROM in the Beeb.
- Nigel

BBC Model B, ATPL Sidewise, Acorn Speech, 2xWatford Floppy Drives, AMX Mouse, Viglen case, BeebZIF, etc.

User avatar
jonb
Posts: 2139
Joined: Sat May 21, 2011 12:42 pm
Location: South Coast of England
Contact:

Re: Torch Graduate

Post by jonb » Sun Nov 12, 2017 9:29 am

Sweet!

So you're playing Commander Keen on it?

crj
Posts: 834
Joined: Thu May 02, 2013 4:58 pm
Contact:

Re: Torch Graduate

Post by crj » Thu Nov 16, 2017 6:51 pm

Intriguing!

Does anyone know which range of OSes support that?

User avatar
Pernod
Posts: 1216
Joined: Fri Jun 08, 2012 10:01 pm
Location: Croydon, UK
Contact:

Re: Torch Graduate

Post by Pernod » Sat Dec 30, 2017 4:10 pm

A little progress with this... decided to assert the IRQ line on BREAK/RESET and only clear it on read of &FDFE and the code is now triggered :)
The first page of the boot rom is present in JIM initially:

Code: Select all

FD00: php
FD01: pha
FD02: txa
FD03: pha
FD04: tya
FD05: pha
FD06: sei
FD07: lda #$40
FD09: sta $0d00		; ??
FD0C: lda $fc9e		; read from graduate ??
FD0F: lda $fc97		; read from graduate ??
FD12: lda $020e		; preserve WRCHV vector
FD15: sta $8e		; preserve WRCHV vector
FD17: lda $020f		; preserve WRCHV vector
FD1A: sta $8f		; preserve WRCHV vector
FD1C: lda #$00		; set WRCHV vector to &FD00
FD1E: sta $020e		; set WRCHV vector to &FD00
FD21: lda #$fd		; set WRCHV vector to &FD00
FD23: sta $020f		; set WRCHV vector to &FD00
FD26: ldx #$00		; copy from &FD37 to &70
FD28: lda $fd37, x	; copy from &FD37 to &70
FD2B: sta $70, x	; copy from &FD37 to &70
FD2D: inx			; copy from &FD37 to &70
FD2E: cpx #$0a		; copy from &FD37 to &70
FD30: bne $fd28		; copy from &FD37 to &70
FD32: lda #$01		; boot rom page
FD34: jmp $0070
FD37: sta $fc96		; set boot rom page
FD3A: pla
FD3B: tay
FD3C: pla
FD3D: tax
FD3E: pla
FD3F: plp
FD40: rts
Nothing much of interest in there apart from it telling us that writing to &FC96 changes the exposed page of the boot rom. Also a couple of unknown reads from the Graduate at &FC9E and &FC97.

It then continues to execute the next page:

Code: Select all

FD00: php
FD01: pha
FD02: txa
FD03: pha
FD04: tya
FD05: pha
FD06: lda $8e		; set WRCHV vector to default
FD08: sei
FD09: sta $020e		; set WRCHV vector to default
FD0C: lda $8f		; set WRCHV vector to default
FD0E: sta $020f		; set WRCHV vector to default
FD11: cli
FD12: lda $fc94		; read from graduate ??
FD15: and #$01
FD17: bne $fd12		; wait for bit 0 of &FC94 != 1
FD19: lda #$a5
FD1B: sta $fc97		; write to graduate ??
FD1E: lda $fc94		; read from graduate ??
FD21: and #$01
FD23: bne $fd1e		; wait for bit 0 of &FC94 != 1
FD25: lda #$5a
FD27: sta $fc97		; write to graduate ??
FD2A: sei
FD2B: lda $fc94		; read from graduate ??
FD2E: and #$02
FD30: beq $fd2b		; wait for bit 1 of &FC94 != 1
FD32: lda $fc97		; read from graduate ??
FD35: cmp #$00
FD37: beq $fd81		; branch when &FC97 = 0
FD39: cmp #$01
FD3B: beq $fd50		; branch when &FC97 = 1
FD3D: cli
FD3E: lda #$04
FD40: ldx #$00
FD42: ldy #$00
FD44: jsr $fff4
FD47: pla
FD48: tay
FD49: pla
FD4A: tax
FD4B: pla
FD4C: plp
FD4D: jmp ($020e)
FD50: cli
FD51: ldx #$00		; copy from &FD62 to &70
FD53: lda $fd62, x	; copy from &FD62 to &70
FD56: sta $70, x	; copy from &FD62 to &70
FD58: inx			; copy from &FD62 to &70
FD59: cpx #$06		; copy from &FD62 to &70
FD5B: bne $fd53		; copy from &FD62 to &70
FD5D: lda #$15		; boot rom page
FD5F: jmp $0070
FD62: sta $fc96		; set boot rom page
FD65: jmp $fd00
FD68: sta $fc96		; set boot rom page
FD6B: pha
FD6C: tya
FD6D: pha
FD6E: lda #$00
FD70: tay
FD71: sta $80
FD73: stx $81
FD75: lda $fd00, y
FD78: sta ($80), y
FD7A: iny
FD7B: bne $fd75
FD7D: pla
FD7E: tay
FD7F: pla
FD80: rts
FD81: cli
FD82: lda #$ca
FD84: ldy #$ef
FD86: ldx #$10
FD88: jsr $fff4
FD8B: lda #$76
FD8D: jsr $fff4
FD90: ldx #$00		; copy from &FDxx to &Exx
FD92: lda $fd00, x	; copy from &FDxx to &Exx
FD95: sta $0e00, x	; copy from &FDxx to &Exx
FD98: inx			; copy from &FDxx to &Exx
FD99: bne $fd92		; copy from &FDxx to &Exx
FD9B: jmp $0e9e
FD9E: lda #$02
FDA0: ldx #$0f
FDA2: jsr $0e68
FDA5: inx
FDA6: clc
FDA7: adc #$01
FDA9: cmp #$14
FDAB: bcc $fda2
FDAD: sei
FDAE: lda $0206
FDB1: sta $8e
FDB3: lda $0207
FDB6: sta $8f
FDB8: lda #$f8
FDBA: sta $0206
FDBD: lda #$0f
FDBF: sta $0207
FDC2: cli
FDC3: lda #$04
FDC5: ldx #$01
FDC7: jsr $fff4
FDCA: lda #$e1
FDCC: ldx #$90
FDCE: ldy #$00
FDD0: jsr $fff4
FDD3: lda #$e2
FDD5: ldx #$9a
FDD7: ldy #$00
FDD9: jsr $fff4
FDDC: lda #$e3
FDDE: ldx #$a4
FDE0: ldy #$00
FDE2: jsr $fff4
FDE5: lda #$e4
FDE7: ldx #$ae
FDE9: ldy #$00
FDEB: jsr $fff4
FDEE: lda #$c8
FDF0: ldy #$00
FDF2: ldx #$01
FDF4: jsr $fff4
FDF7: lda #$e5
FDF9: ldy #$00
FDFB: ldx #$ff
FDFD: jsr $fff4
This is where is wants to download the boot rom from the Graduate into RAM starting at &E00. It's waiting for responses from the Graduate at &FC94 and &FC97, to be determined.
- Nigel

BBC Model B, ATPL Sidewise, Acorn Speech, 2xWatford Floppy Drives, AMX Mouse, Viglen case, BeebZIF, etc.

User avatar
Pernod
Posts: 1216
Joined: Fri Jun 08, 2012 10:01 pm
Location: Croydon, UK
Contact:

Re: Torch Graduate

Post by Pernod » Sat Dec 30, 2017 4:22 pm

On the Graduate side the 8088 is running the following: (trimmed to fit post)

Code: Select all

FE020: cli     			; start
FE021: in      al,0A0h
FE023: mov     al,1h
FE025: out     0F0h,al
FE027: mov     al,99h
FE029: out     63h,al
FE02B: mov     al,0FCh
FE02D: out     61h,al
FE02F: mov     al,2h
FE031: out     0F0h,al
FE033: mov     al,4h
FE035: out     8h,al
FE037: mov     al,54h
FE039: out     43h,al
FE03B: mov     al,0h
FE03D: out     41h,al
FE03F: xor     cx,cx
FE041: mov     al,40h
FE043: out     43h,al
FE045: in      al,41h
FE047: cmp     al,0FFh
FE049: je      0FE052h
FE04B: loop    0FE041h
FE04D: mov     al,0FFh
FE04F: jmp     0FE449h
FE052: mov     al,0FFh
FE054: out     41h,al
FE056: xor     cx,cx
FE058: mov     al,40h
FE05A: out     43h,al
FE05C: in      al,41h
FE05E: cmp     al,0h
FE060: je      0FE069h
FE062: loop    0FE058h
FE064: mov     al,0FEh
FE066: jmp     0FE449h
FE069: mov     al,54h
FE06B: out     43h,al
FE06D: mov     al,18h
FE06F: out     41h,al
FE071: out     0Dh,al
FE073: mov     al,3h
FE075: out     0F0h,al
FE077: mov     al,0FFh
FE079: mov     bl,al
FE07B: mov     bh,al
FE07D: mov     cx,8h
FE080: mov     dx,0h
FE083: out     dx,al
FE084: out     dx,al
FE085: in      al,dx
FE086: mov     ah,al
FE088: in      al,dx
FE089: cmp     bx,ax
FE08B: je      0FE092h
FE08D: mov     al,0FDh
FE08F: jmp     0FE449h
FE092: inc     dx
FE093: loop    0FE083h
FE095: not     al
FE097: je      0FE079h
FE099: mov     al,4h
FE09B: out     0F0h,al
FE09D: mov     al,0h
FE09F: out     80h,al
FE0A1: out     81h,al
FE0A3: out     82h,al
FE0A5: out     83h,al
FE0A7: mov     al,0FFh
FE0A9: out     1h,al
FE0AB: out     1h,al
FE0AD: mov     al,58h
FE0AF: out     0Bh,al
FE0B1: mov     al,20h
FE0B3: out     8h,al
FE0B5: out     0Ah,al
FE0B7: mov     al,41h
FE0B9: out     0Bh,al
FE0BB: mov     al,42h
FE0BD: out     0Bh,al
FE0BF: mov     al,43h
FE0C1: out     0Bh,al
FE0C3: mov     al,5h
FE0C5: out     0F0h,al
FE0C7: cld     
FE0C8: xor     ax,ax
FE0CA: mov     ds,ax
FE0CC: xor     bx,bx
FE0CE: mov     cx,[bx]
FE0D0: mov     [bx],cx
FE0D2: add     bx,2h
FE0D5: jne     0FE0CEh
FE0D7: add     ah,10h
FE0DA: cmp     ah,40h
FE0DD: jne     0FE0CAh
FE0DF: mov     al,6h
FE0E1: out     0F0h,al
FE0E3: mov     al,13h
FE0E5: out     20h,al
FE0E7: mov     al,8h
FE0E9: out     21h,al
FE0EB: mov     al,9h
FE0ED: out     21h,al
FE0EF: mov     al,7h
FE0F1: out     0F0h,al
FE0F3: cli     
FE0F4: mov     al,0h
FE0F6: out     21h,al
FE0F8: in      al,21h
FE0FA: cmp     al,0h
FE0FC: je      0FE103h
FE0FE: mov     al,0FAh
FE100: jmp     0FE449h
FE103: mov     al,0FFh
FE105: out     21h,al
FE107: in      al,21h
FE109: inc     al
FE10B: jne     0FE0FEh
FE10D: mov     al,8h
FE10F: out     0F0h,al
FE111: mov     ax,1FE0h
FE114: mov     ss,ax
FE116: mov     ax,200h
FE119: mov     sp,ax
FE11B: push    cs 
FE11C: pop     ds 
FE11D: cld     
FE11E: mov     cx,8h
FE121: mov     di,20h
FE124: mov     ax,13Bh
FE127: stosw   
FE128: mov     ax,cs
FE12A: stosw   
FE12B: loop    0FE124h
FE12D: sti     
FE12E: xor     ax,ax
FE130: nop     
FE131: cmp     ah,1h
FE134: jne     0FE142h
FE136: mov     al,0F9h
FE138: jmp     0FE449h
FE13B: mov     ah,1h
FE13D: mov     al,20h
FE13F: out     20h,al
FE141: iret    
FE142: cli     
FE143: mov     al,9h
FE145: out     0F0h,al
FE147: xor     ax,ax
FE149: mov     es,ax
FE14B: mov     di,ax
FE14D: mov     cx,1000h
FE150: rep     stosw   
FE152: mov     ax,40h
FE155: mov     ds,ax
FE157: xor     bx,bx
FE159: mov     ax,5AA5h
FE15C: mov     es,bx
FE15E: mov     cx,es:[0h]
FE163: mov     es:[0h],ax
FE167: mov     ax,es:[0h]
FE16B: mov     es:[0h],cx
FE170: cmp     ax,5AA5h
FE173: jne     0FE17Bh
FE175: add     bx,1000h
FE179: jmp     0FE159h
FE17B: mov     bl,bh
FE17D: xor     bh,bh
FE17F: mov     cl,2h
FE181: shl     bx,cl
FE183: mov     [13h],bx
FE187: mov     al,0Ah
FE189: out     0F0h,al
FE18B: xor     ax,ax
FE18D: mov     ds,ax
FE18F: xor     di,di
FE191: mov     word ptr [di],45Dh
FE195: inc     di
FE196: inc     di
FE197: mov     [di],cs
FE199: inc     di
FE19A: inc     di
FE19B: cmp     di,400h
FE19F: jl      0FE191h
FE1A1: mov     al,0Bh
FE1A3: out     0F0h,al
FE1A5: xor     ax,ax
FE1A7: mov     es,ax
FE1A9: push    cs 
FE1AA: pop     ds 
FE1AB: mov     si,41Bh
FE1AE: lodsb   
FE1AF: cmp     al,21h
FE1B1: je      0FE1C2h
FE1B3: xor     ah,ah
FE1B5: shl     ax,1
FE1B7: shl     ax,1
FE1B9: mov     di,ax
FE1BB: lodsw   
FE1BC: stosw   
FE1BD: mov     es:[di],cs
FE1C0: jmp     0FE1AEh
FE1C2: mov     al,0ECh
FE1C4: out     61h,al
FE1C6: mov     dx,3B8h
FE1C9: mov     al,1h
FE1CB: out     dx,al
FE1CC: mov     dx,3B4h
FE1CF: mov     ax,0E35h
FE1D2: call    0FEB82h
FE1D5: mov     al,0Eh
FE1D7: out     dx,al
FE1D8: inc     dx
FE1D9: in      al,dx
FE1DA: and     al,3Fh
FE1DC: cmp     al,35h
FE1DE: mov     ax,40h
FE1E1: mov     ds,ax
FE1E3: jne     0FE1F3h
FE1E5: mov     word ptr [63h],3B4h
FE1EB: or      word ptr [10h],30h
FE1F1: jmp     0FE1F9h
FE1F3: mov     word ptr [63h],3D4h
FE1F9: xor     si,si
FE1FB: mov     bx,1h
FE1FE: mov     dx,3FAh
FE201: in      al,dx
FE202: test    al,0F8h
FE204: jne     0FE20Fh
FE206: mov     word ptr [si],3F8h
FE20C: inc     si
FE20D: inc     si
FE20E: inc     bx
FE20F: mov     dx,2FAh
FE212: in      al,dx
FE213: test    al,0F8h
FE215: jne     0FE220h
FE217: mov     word ptr [si],2F8h
FE21D: inc     si
FE21E: inc     si
FE21F: inc     bx
FE220: mov     word ptr [si],0BEEBh
FE226: mov     bh,bl
FE228: shl     bh,1
FE22A: xor     bl,bl
FE22C: or      [10h],bx
FE230: xor     si,si
FE232: mov     bh,1h
FE234: mov     bp,415h
FE237: mov     dx,cs:[bp]
FE23B: mov     al,0AAh
FE23D: out     dx,al
FE23E: sub     al,al
FE240: in      al,dx
FE241: cmp     al,0AAh
FE243: jne     0FE24Dh
FE245: mov     [si+8h],dx
FE249: inc     bh
FE24B: inc     si
FE24C: inc     si
FE24D: inc     bp
FE24E: inc     bp
FE24F: cmp     bp,41Bh
FE253: jne     0FE237h
FE255: mov     word ptr [si+8h],0BEEBh
FE25B: cmp     bh,4h
FE25E: jb      0FE262h
FE260: mov     bh,3h
FE262: mov     cl,6h
FE264: shl     bh,cl
FE266: xor     bl,bl
FE268: or      [10h],bx
FE26C: mov     word ptr [1Ah],1Eh
FE272: mov     word ptr [1Ch],1Eh
FE278: mov     al,0FFh
FE27A: out     21h,al
FE27C: in      al,0E3h
FE27E: mov     al,1h
FE280: call    0FE47Bh
FE283: jae     0FE28Ah
FE285: mov     al,0F8h
FE287: jmp     0FE449h
FE28A: mov     al,2h
FE28C: call    0FE47Bh
FE28F: jae     0FE296h
FE291: mov     bx,1h
FE294: jmp     0FE2B1h
FE296: mov     al,4h
FE298: call    0FE47Bh
FE29B: jae     0FE2A2h
FE29D: mov     bx,41h
FE2A0: jmp     0FE2B1h
FE2A2: mov     al,8h
FE2A4: call    0FE47Bh
FE2A7: jae     0FE2AEh
FE2A9: mov     bx,81h
FE2AC: jmp     0FE2B1h
FE2AE: mov     bx,0C1h
FE2B1: or      [10h],bx
FE2B5: or      word ptr [10h],2Ch
FE2BB: mov     byte ptr [49h],2h
FE2C0: mov     word ptr [4Ah],50h
FE2C6: mov     word ptr [60h],607h
FE2CC: mov     byte ptr [66h],20h
FE2D1: mov     word ptr [72h],1234h
FE2D7: mov     byte ptr [8Dh],5h
FE2DC: mov     byte ptr [8Eh],55h
FE2E1: mov     al,0Ch
FE2E3: out     0F0h,al
FE2E5: mov     al,36h
FE2E7: out     43h,al
FE2E9: mov     al,14h
FE2EB: out     40h,al
FE2ED: mov     al,86h
FE2EF: out     40h,al
FE2F1: mov     al,0Dh
FE2F3: out     0F0h,al
FE2F5: call    0FE4F0h
FE2F8: cmp     al,0A5h
FE2FA: jne     0FE2F5h
FE2FC: mov     al,0Eh
FE2FE: out     0F0h,al
FE300: call    0FE4F0h
FE303: cmp     al,5Ah
FE305: jne     0FE300h
FE307: mov     al,0Fh
FE309: out     0F0h,al
FE30B: mov     al,0BCh
FE30D: out     21h,al
FE30F: sti     
FE310: mov     al,10h
FE312: out     0F0h,al
FE314: xor     ah,ah
FE316: int     13h
FE318: jae     0FE31Fh
FE31A: mov     al,0F7h
FE31C: jmp     0FE449h
FE31F: mov     al,11h
FE321: out     0F0h,al
FE323: mov     si,5h
FE326: mov     ax,201h
FE329: xor     dx,dx
FE32B: mov     cx,1h
FE32E: mov     es,dx
FE330: mov     bx,7C00h
FE333: int     13h
FE335: jae     0FE34Eh
FE337: mov     dx,ax
FE339: xor     ah,ah
FE33B: int     13h
FE33D: dec     si
FE33E: jne     0FE326h
FE340: call    0FE495h
FE343: mov     al,2h
FE345: call    0FE4F9h
FE348: cli     
FE349: mov     al,dh
FE34B: jmp     0FE449h
FE34E: mov     al,12h
FE350: out     0F0h,al
FE352: xor     bx,bx
FE354: mov     ds,bx
FE356: mov     si,7C03h
FE359: lodsw   
FE35A: cmp     ax,4644h
FE35D: jne     0FE367h
FE35F: lodsb   
FE360: cmp     al,53h
FE362: jne     0FE367h
FE364: jmp     0FE3CBh
FE366: nop     
FE367: mov     al,13h
FE369: out     0F0h,al
FE36B: mov     al,0h
FE36D: call    0FE4F9h
FE370: mov     bl,3h
FE372: xor     cx,cx
FE374: loop    0FE374h
FE376: dec     bl
FE378: jne     0FE374h
FE37A: mov     al,14h
FE37C: out     0F0h,al
FE37E: mov     ax,40h
FE381: mov     ds,ax
FE383: mov     al,0AFh
FE385: mov     [100h],al
FE388: mov     ax,2h
FE38B: cmp     word ptr [63h],3B4h
FE391: jne     0FE396h
FE393: mov     ax,7h
FE396: int     10h
FE398: mov     al,15h
FE39A: out     0F0h,al
FE39C: mov     dx,3D9h
FE39F: call    0FE504h
FE3A2: mov     al,16h
FE3A4: out     0F0h,al
FE3A6: mov     dx,0C800h
FE3A9: mov     ds,dx
FE3AB: xor     bx,bx
FE3AD: mov     ax,[bx]
FE3AF: push    bx
FE3B0: pop     bx
FE3B1: cmp     ax,0AA55h
FE3B4: jne     0FE3BBh
FE3B6: call    0FE4A4h
FE3B9: jmp     0FE3BFh
FE3BB: add     dx,80h
FE3BF: cmp     dx,0F600h
FE3C3: jb      0FE3A9h
FE3C5: mov     al,17h
FE3C7: out     0F0h,al
FE3C9: int     19h
FE3CB: mov     al,18h
FE3CD: out     0F0h,al
FE3CF: mov     al,1h
FE3D1: call    0FE4F9h
FE3D4: jmp     0000h:7C00h
FE3D9: push    sp
FE3DA: outsw   
FE3DB: jb      0FE440h
FE3DD: push    4720h
FE3E0: jb      0FE443h
FE3E2: jne     0FE446h
FE3E5: je      0FE44Ch
FE3E7: and     [bp+33h],dh
FE3EA: xor     cs:[bp+si],si
FE3ED: or      ax,240Ah
FE3F0: or      ax,500Ah
FE3F3: popa    
FE3F4: jb      0FE45Fh
FE3F6: je      0FE471h
FE3F8: and     [bp+di+68h],ah
FE3FB: arpl    gs:[bp+di+20h],bp
FE3FF: and     al,52h
FE401: dec     di
FE402: dec     bp
FE403: and     [bp+di+68h],al
FE406: arpl    gs:[bp+di+73h],bp
FE40A: jne     0FE479h
FE40C: and     [di+72h],ah
FE40F: jb      0FE480h
FE411: jb      0FE420h
FE413: or      ah,[si]
FE415: mov     sp,7803h
FE418: add     di,[bx+si+2h]
FE41B: add     bl,[bp+4h]
FE41E: add     ax,1EE7h
FE421: or      [bp+1Eh],ch
FE424: or      ax,dx
FE426: pop     es 
FE427: push    cs 
FE428: enter   1009h,0FCh
FE42C: or      [bx+di],dx
FE42E: aad     1Fh
FE430: adc     dl,[si]
FE432: adc     dx,[bp+di]
FE434: pop     ds 
FE435: adc     dx,[si]
FE437: jne     0FE450h
FE439: push    ss 
FE43A: xchg    ax,dx
FE43B: pop     ds 
FE43C: pop     ss 
FE43D: or      [bx+di],bx
FE43F: sbb     ax,bx
FE441: sbb     [bp+si],bx
FE443: pop     ds 
FE445: push    ds 
FE446: pop     dx
FE447: pop     ss 
FE448: and     [bp+si-1920h],cx
FE44C: lock    
FE44D: xor     bx,bx
FE44F: dec     bx
FE450: jne     0FE44Fh
FE452: mov     al,bl
FE454: out     0F0h,al
FE456: dec     bx
FE457: jne     0FE456h
FE459: mov     al,ah
FE45B: jmp     0FE44Bh
FE45D: iret    
FE45E: push    ax
FE45F: push    ds 
FE460: push    dx
FE461: push    cs 
FE462: pop     ds 
FE463: mov     dx,3F0h
FE466: call    0FE504h
FE469: in      al,62h
FE46B: and     al,0C0h
FE46D: rol     al,1
FE46F: rol     al,1
FE471: or      al,30h
FE473: mov     ah,0Eh
FE475: int     10h
FE477: pop     dx
FE478: pop     ds 
FE479: pop     ax
FE47A: iret    
FE47B: out     0C0h,al
FE47D: xor     cx,cx
FE47F: mov     bh,2h
FE481: mov     al,8h
FE483: out     0E3h,al
FE485: in      al,0E3h
FE487: test    al,4h
FE489: jne     0FE493h
FE48B: loop    0FE485h
FE48D: dec     bh
FE48F: jne     0FE485h
FE491: stc     
FE492: ret     
FE493: clc     
FE494: ret     
FE495: mov     al,40h
FE497: out     0C0h,al
FE499: mov     al,0h
FE49B: out     0C0h,al
FE49D: in      al,0E3h
FE49F: test    al,80h
FE4A1: jne     0FE495h
FE4A3: ret     
FE4A4: mov     ax,40h
FE4A7: mov     es,ax
FE4A9: sub     ah,ah
FE4AB: mov     al,[bx+2h]
FE4AE: mov     cl,9h
FE4B0: shl     ax,cl
FE4B2: mov     cx,ax
FE4B4: push    cx
FE4B5: mov     cx,4h
FE4B8: shr     ax,cl
FE4BA: add     dx,ax
FE4BC: pop     cx
FE4BD: call    0FE4E6h
FE4C0: je      0FE4CFh
FE4C2: push    ax
FE4C3: push    dx
FE4C4: push    bx
FE4C5: mov     dx,400h
FE4C8: call    0FE504h
FE4CB: pop     bx
FE4CC: pop     dx
FE4CD: pop     ax
FE4CE: ret     
FE4CF: push    dx
FE4D0: mov     word ptr es:[67h],3h
FE4D7: mov     es:[69h],ds
FE4DC: call    far ptr  es:[67h]
FE4E1: pop     dx
FE4E2: ret     
FE4E3: mov     cx,2000h
FE4E6: xor     al,al
FE4E8: add     al,[bx]
FE4EA: inc     bx
FE4EB: loop    0FE4E8h
FE4ED: or      al,al
FE4EF: ret     
FE4F0: in      al,0F0h
FE4F2: and     al,2h
FE4F4: je      0FE4F0h
FE4F6: in      al,0A0h
FE4F8: ret     
FE4F9: push    ax
FE4FA: in      al,0F0h
FE4FC: and     al,4h
FE4FE: jne     0FE4FAh
FE500: pop     ax
FE501: out     0A0h,al
FE503: ret     
FE504: push    ax
FE505: push    bx
FE506: push    si
FE507: mov     si,dx
FE509: lodsb   cs:
FE50B: cmp     al,24h
FE50D: je      0FE517h
FE50F: mov     ah,0Eh
FE511: mov     bh,0h
FE513: int     10h
FE515: jmp     0FE509h
FE517: pop     si
FE518: pop     bx
FE519: pop     ax
FE51A: ret     
FE51B: push    ax
FE51C: push    bx
FE51D: push    cx
FE51E: mov     al,0B6h
FE520: out     43h,al
FE522: mov     ax,0A66h
FE525: out     42h,al
FE527: mov     al,ah
FE529: out     42h,al
FE52B: in      al,61h
FE52D: mov     ah,al
FE52F: or      al,3h
FE531: out     61h,al
FE533: mov     cx,1000h
FE536: loop    0FE536h
FE538: dec     bl
FE53A: jne     0FE536h
FE53C: mov     al,ah
FE53E: out     61h,al
FE540: pop     cx
FE541: pop     bx
FE542: pop     ax
FE543: ret     
FE544: push    ax
FE545: mov     al,0Eh
FE547: call    0FE4F9h
FE54A: mov     al,dh
FE54C: call    0FE4F9h
FE54F: mov     al,dl
FE551: call    0FE4F9h
FE554: pop     ax
FE555: call    0FE4F9h
FE558: ret     
FE559: cli     
FE55A: in      al,21h
FE55C: or      al,2h
FE55E: out     21h,al
FE560: sti     
FE561: mov     al,0Fh
FE563: call    0FE4F9h
FE566: mov     al,dh
FE568: call    0FE4F9h
FE56B: mov     al,dl
FE56D: call    0FE4F9h
FE570: call    0FE4F0h
FE573: push    ax
FE574: cli     
FE575: in      al,21h
FE577: and     al,0FDh
FE579: out     21h,al
FE57B: sti     
FE57C: pop     ax
FE57D: ret     
FE57E: cli     
FE57F: in      al,21h
FE581: or      al,2h
FE583: out     21h,al
FE585: sti     
FE586: mov     al,10h
FE588: jmp     0FE563h
FE58A: push    ax
FE58B: cli     
FE58C: in      al,21h
FE58E: or      al,2h
FE590: out     21h,al
FE592: sti     
FE593: mov     al,5h
FE595: call    0FE4F9h
FE598: mov     al,dl
FE59A: call    0FE4F9h
FE59D: mov     al,dh
FE59F: call    0FE4F9h
FE5A2: pop     ax
FE5A3: call    0FE4F9h
FE5A6: call    0FE4F0h
FE5A9: push    ax
FE5AA: call    0FE4F0h
FE5AD: mov     dh,al
FE5AF: call    0FE4F0h
FE5B2: mov     dl,al
FE5B4: cli     
FE5B5: in      al,21h
FE5B7: and     al,0FDh
FE5B9: out     21h,al
FE5BB: sti     
FE5BC: pop     ax
FE5BD: ret     
FE5BE: push    ax
FE5BF: cli     
FE5C0: in      al,21h
FE5C2: or      al,2h
FE5C4: out     21h,al
FE5C6: sti     
FE5C7: mov     al,6h
FE5C9: jmp     0FE595h
FE5CB: add     [bx+di],ax
FE5CD: push    ds 
FE5CE: add     al,[bp+si]
FE5D0: xor     [bp+di],al
FE5D2: add     bp,[404h]
FE5D6: and     [di],al
FE5D8: add     ax,612h
FE5DB: push    es 
FE5DC: and     [bx],ax
FE5DE: pop     es 
FE5DF: and     cl,[bx+si]
FE5E1: or      [bp+di],ah
FE5E3: or      [bx+di],cx
FE5E5: pop     ss 
FE5E6: or      cl,[bp+si]
FE5E8: and     al,0Bh
FE5EA: or      sp,[di]
FE5EC: or      al,0Ch
FE5EE: or      ax,1C0Dh
FE5F2: push    cs 
FE5F3: push    cs 
FE5F4: xor     [bx],cx
FE5F6: prefetch1 [bx+si]
FE5F9: adc     [bx+di],bl
FE5FB: adc     [bx+di],dx
FE5FD: adc     [bp+si],dl
FE5FF: adc     dl,[bp+di]
FE601: adc     dx,[bp+di]
FE603: pop     ds 
FE604: adc     al,14h
FE606: adc     al,15h
FE608: adc     ax,1616h
FE60B: push    ss 
FE60C: das     
FE60D: pop     ss 
FE60E: pop     ss 
FE60F: adc     [bx+si],bx
FE611: sbb     [di],ch
FE613: sbb     [bx+di],bx
FE615: adc     ax,1A1Ah
FE618: sub     al,1Bh
FE61A: sbb     ax,[bx+di]
FE61C: sbb     al,1Ch
FE61E: sub     bx,[di]
FE620: sbb     ax,1E1Bh
FE623: push    ds 
FE624: pop     es 
FE625: pop     ds 
FE626: add     [bp+di+20h],dl
FE629: and     [bx+di],bh
FE62B: and     [bx+di],sp
FE62D: add     ah,[bp+si]
FE62F: and     al,[bp+di]
FE631: and     sp,[bp+di]
FE633: sub     [si],sp
FE635: and     al,5h
FE637: and     ax,625h
FE63A: or      es:[bx],ah
FE63E: daa     
FE63F: sub     [bx+si],ch
FE641: sub     [bp+si],cl
FE643: sub     [bx+di],bp
FE645: or      bp,[bp+si]
FE647: sub     cl,[bx+di]
FE649: sub     bp,[bp+di]
FE64B: or      ax,2C2Ch
FE64E: xor     bp,[di]
FE650: sub     ax,2E0Ch
FE653: xor     al,2Fh
FE656: das     
FE657: xor     ax,3030h
FE65A: or      si,[bx+di]
FE65C: xor     [bp+si],ax
FE65E: xor     dh,[bp+si]
FE660: add     si,[bp+di]
FE662: xor     ax,[si]
FE664: xor     al,34h
FE666: add     ax,3535h
FE669: push    es 
FE66A: pop     es 
FE66D: aaa     
FE66E: aaa     
FE66F: or      [bx+si],bh
FE671: cmp     [bx+di],cl
FE673: cmp     [bx+di],di
FE675: or      bh,[bp+si]
FE677: cmp     ah,[bx]
FE679: cmp     di,[bp+di]
FE67B: daa     
FE67C: cmp     al,3Ch
FE67E: xor     di,[di]
FE680: cmp     ax,3E0Dh
FE683: xor     al,3Fh
FE686: aas     
FE687: xor     ax,4040h
FE68A: sub     [bx+di+41h],al
FE68D: push    ds 
FE68E: inc     dx
FE68F: inc     dx
FE690: xor     [bp+di+43h],al
FE693: inc     sp
FE695: inc     sp
FE696: and     [di+45h],al
FE699: adc     al,[bp+46h]
FE69C: and     [bx+47h],ax
FE69F: and     cl,[bx+si+48h]
FE6A2: and     cx,[bx+di+49h]
FE6A5: pop     ss 
FE6A6: dec     dx
FE6A7: dec     dx
FE6A8: and     al,4Bh
FE6AA: dec     bx
FE6AB: and     ax,4C4Ch
FE6AE: dec     bp
FE6B0: dec     bp
FE6B1: xor     cl,[bp+4Eh]
FE6B4: xor     [bx+4Fh],cx
FE6B7: sbb     [bx+si+50h],dl
FE6BA: sbb     [bx+di+51h],dx
FE6BD: adc     [bp+si+52h],dl
FE6C0: adc     dx,[bp+di+53h]
FE6C3: pop     ds 
FE6C4: push    sp
FE6C5: push    sp
FE6C6: adc     al,55h
FE6C8: push    bp
FE6C9: push    ss 
FE6CA: push    si
FE6CB: push    si
FE6CC: das     
FE6CD: push    di
FE6CE: push    di
FE6CF: adc     [bx+si+58h],bx
FE6D2: sub     ax,5959h
FE6D5: adc     ax,5A5Ah
FE6D8: sub     al,5Bh
FE6DA: pop     bx
FE6DB: sbb     bl,[si+5Ch]
FE6DE: sub     bx,[di+5Dh]
FE6E1: sbb     bx,[bp+5Eh]
FE6E4: pop     es 
FE6E5: pop     di
FE6E6: pop     di
FE6E7: or      al,60h
FE6E9: pusha   
FE6EA: add     al,61h
FE6EC: popa    
FE6ED: push    ds 
FE6EE: bound   sp,[bp+si+30h]
FE6F1: arpl    [bp+di+2Eh],sp
FE6F4: and     fs:[di+65h],ah
FE6F9: adc     ah,[bp+66h]
FE6FC: and     [bx+67h],sp
FE6FF: and     ch,[bx+si+68h]
FE702: and     bp,[bx+di+69h]
FE705: pop     ss 
FE706: push    6Ah
FE708: and     al,6Bh
FE70A: imul    sp,[di],6Ch
FE70D: insb    
FE70E: insw    
FE710: insw    
FE711: xor     ch,[bp+6Eh]
FE714: xor     [bx+6Fh],bp
FE717: sbb     [bx+si+70h],dh
FE71A: sbb     [bx+di+71h],si
FE71D: adc     [bp+si+72h],dh
FE720: adc     si,[bp+di+73h]
FE723: pop     ds 
FE724: je      0FE79Ah
FE726: adc     al,75h
FE728: jne     0FE740h
FE72A: jbe     0FE7A2h
FE72C: das     
FE72D: ja      0FE7A6h
FE72F: adc     [bx+si+78h],di
FE732: sub     ax,7979h
FE735: adc     ax,7A7Ah
FE738: sub     al,7Bh
FE73A: jnp     0FE756h
FE73C: jl      0FE7BAh
FE73E: sub     di,[di+7Dh]
FE741: sbb     di,[bp+7Eh]
FE744: sub     [bx],di
FE747: push    bx
FE748: xchg    ax,[bx+si]
FE74A: push    dx
FE74B: mov     [bx+si],al
FE74D: dec     bx
FE74E: mov     [bx+si],ax
FE750: dec     bp
FE751: mov     al,[bx+si]
FE753: push    ax
FE754: mov     ax,[bx+si]
FE756: dec     ax
FE757: nop     
FE758: add     [si-6Fh],al
FE75B: add     [bp+di],bh
FE75D: xchg    ax,dx
FE75E: add     [si],bh
FE760: xchg    ax,bx
FE761: add     [di],bh
FE763: xchg    ax,sp
FE764: add     [95h],bh
FE768: aas     
FE769: xchg    ax,si
FE76A: add     [bx+si-69h],al
FE76D: add     [bx+di-68h],al
FE770: add     [bp+si-67h],al
FE773: add     [bp+di-66h],al
FE776: add     [di-65h],bl
FE779: add     [si-64h],dl
FE77C: add     [di-63h],dl
FE77F: add     [bp-62h],dl
FE782: add     [bx-61h],dl
FE785: add     [bx+si-60h],bl
FE788: add     [bx+di-5Fh],bl
FE78B: add     [bp+si-5Eh],bl
FE78E: add     [bp+di-5Dh],bl
FE791: add     [si-5Ch],bl
FE794: add     [bx-5Bh],ah
FE797: add     [bp-5Ah],bl
FE79A: add     [bx-59h],bl
FE79D: add     [bx+si-58h],ah
FE7A0: add     [bx+di-57h],ah
FE7A3: add     [bp+si-56h],ah
FE7A6: add     [bp+di-55h],ah
FE7A9: add     [si-54h],ah
FE7AC: add     [di-53h],ah
FE7AF: add     [bp-52h],ah
FE7B2: add     [bx+di-51h],dh
FE7B5: add     [bx+si-50h],ch
FE7B8: add     [bx+di-4Fh],ch
FE7BB: add     [bp+si-4Eh],ch
FE7BE: add     [bp+di-4Dh],ch
FE7C1: add     [si-4Ch],ch
FE7C4: add     [di-4Bh],ch
FE7C7: add     [bp-4Ah],ch
FE7CA: add     [bx-49h],ch
FE7CD: add     [bx+si],dh
FE7D0: sti     
FE7D1: push    ds 
FE7D2: push    ax
FE7D3: push    dx
FE7D4: push    bx
FE7D5: push    si
FE7D6: mov     ax,40h
FE7D9: mov     ds,ax
FE7DB: in      al,0A0h
FE7DD: cmp     al,0FFh
FE7DF: je      0FE7E4h
FE7E1: jmp     0FE9A1h
FE7E4: call    0FE4F0h
FE7E7: mov     dl,al
FE7E9: call    0FE4F0h
FE7EC: xchg    dl,al
FE7EE: mov     bx,5CBh
FE7F1: mov     ah,cs:[bx]
FE7F4: cmp     ah,0h
FE7F7: je      0FE802h
FE7F9: cmp     ah,al
FE7FB: je      0FE805h
FE7FD: add     bx,3h
FE800: jmp     0FE7F1h
FE802: jmp     0FE9B4h
FE805: inc     bx
FE806: mov     al,cs:[bx]
FE809: inc     bx
FE80A: mov     ah,cs:[bx]
FE80D: mov     dh,[17h]
FE811: and     dh,10h
FE814: cmp     ah,52h
FE817: jne     0FE821h
FE819: test    dl,40h
FE81C: je      0FE821h
FE81E: xor     dh,10h
FE821: test    dl,10h
FE824: jne     0FE829h
FE826: or      dh,40h
FE829: test    dl,20h
FE82C: jne     0FE831h
FE82E: or      dh,20h
FE831: test    dl,40h
FE834: je      0FE839h
FE836: or      dh,4h
FE839: test    dl,8h
FE83C: je      0FE841h
FE83E: or      dh,3h
FE841: mov     [17h],dh
FE845: and     dh,7h
FE848: cmp     dh,7h
FE84B: jne     0FE857h
FE84D: and     byte ptr [17h],0F0h
FE852: or      byte ptr [17h],8h
FE857: test    byte ptr [18h],8h
FE85C: je      0FE86Ch
FE85E: cmp     ah,4Dh
FE861: je      0FE868h
FE863: and     byte ptr [18h],0F7h
FE868: cli     
FE869: jmp     0FE980h
FE86C: cmp     al,1Bh
FE86E: jne     0FE87Bh
FE870: test    dl,40h
FE873: je      0FE87Bh
FE875: jmp     0FE98Ah
FE878: jmp     0FE95Ah
FE87B: cmp     ah,52h
FE87E: jne     0FE899h
FE880: test    dl,40h
FE883: je      0FE888h
FE885: jmp     0FE980h
FE888: test    dl,8h
FE88B: je      0FE896h
FE88D: mov     al,61h
FE88F: out     20h,al
FE891: int     5h
FE893: jmp     0FE984h
FE896: jmp     0FE95Ah
FE899: cmp     ah,48h
FE89C: jne     0FE8B3h
FE89E: test    dl,8h
FE8A1: je      0FE8A8h
FE8A3: mov     ah,49h
FE8A5: jmp     0FE95Ah
FE8A8: test    dl,40h
FE8AB: je      0FE8B0h
FE8AD: mov     ax,4A2Dh
FE8B0: jmp     0FE95Ah
FE8B3: cmp     ah,50h
FE8B6: jne     0FE8CDh
FE8B8: test    dl,8h
FE8BB: je      0FE8C2h
FE8BD: mov     ah,51h
FE8BF: jmp     0FE95Ah
FE8C2: test    dl,40h
FE8C5: je      0FE8CAh
FE8C7: mov     ax,4E2Bh
FE8CA: jmp     0FE95Ah
FE8CD: cmp     ah,4Bh
FE8D0: jne     0FE8DCh
FE8D2: test    dl,8h
FE8D5: je      0FE8D9h
FE8D7: mov     ah,47h
FE8D9: jmp     0FE95Ah
FE8DB: nop     
FE8DC: cmp     ah,4Dh
FE8DF: jne     0FE903h
FE8E1: test    dl,8h
FE8E4: je      0FE8EBh
FE8E6: mov     ah,4Fh
FE8E8: jmp     0FE95Ah
FE8EA: nop     
FE8EB: test    dl,40h
FE8EE: je      0FE8E8h
FE8F0: or      byte ptr [18h],8h
FE8F5: mov     al,61h
FE8F7: out     20h,al
FE8F9: test    byte ptr [18h],8h
FE8FE: jne     0FE8F9h
FE900: jmp     0FE984h
FE903: cmp     ah,53h
FE906: jne     0FE913h
FE908: test    dl,8h
FE90B: jne     0FE910h
FE90D: mov     ax,0E08h
FE910: jmp     0FE95Ah
FE912: nop     
FE913: cmp     al,9h
FE915: jne     0FE922h
FE917: test    dl,8h
FE91A: je      0FE91Fh
FE91C: mov     ax,0F00h
FE91F: jmp     0FE95Ah
FE921: nop     
FE922: test    dl,40h
FE925: je      0FE95Ah
FE927: test    dl,8h
FE92A: je      0FE95Ah
FE92C: cmp     al,30h
FE92E: je      0FE938h
FE930: cmp     al,21h
FE932: jb      0FE94Dh
FE934: cmp     al,29h
FE936: ja      0FE94Dh
FE938: and     al,0Fh
FE93A: push    ax
FE93B: mov     al,[19h]
FE93E: mov     ah,0Ah
FE940: mul     ah
FE942: mov     [19h],al
FE945: pop     ax
FE946: add     [19h],al
FE94A: jmp     0FE980h
FE94C: nop     
FE94D: xor     al,al
FE94F: cmp     ah,0Fh
FE952: ja      0FE95Ah
FE954: add     ah,76h
FE957: jmp     0FE96Bh
FE959: nop     
FE95A: cmp     byte ptr [19h],0h
FE95F: je      0FE96Bh
FE961: mov     al,[19h]
FE964: xor     ah,ah
FE966: mov     byte ptr [19h],0h
FE96B: mov     bx,[1Ch]
FE96F: mov     si,bx
FE971: call    0FE9BBh
FE974: cmp     bx,[1Ah]
FE978: je      0FE9B4h
FE97A: mov     [si],ax
FE97C: mov     [1Ch],bx
FE980: mov     al,61h
FE982: out     20h,al
FE984: pop     si
FE985: pop     bx
FE986: pop     dx
FE987: pop     ax
FE988: pop     ds 
FE989: iret    
FE98A: mov     bx,1Eh
FE98D: mov     [1Ah],bx
FE991: mov     [1Ch],bx
FE995: mov     byte ptr [71h],80h
FE99A: int     1Bh
FE99C: mov     ax,0h
FE99F: jmp     0FE966h
FE9A1: mov     ah,al
FE9A3: cmp     ah,0FEh
FE9A6: jne     0FE9AEh
FE9A8: call    0FE4F0h
FE9AB: mov     [8Ch],al
FE9AE: mov     [8Bh],ah
FE9B2: jmp     0FE980h
FE9B4: mov     bl,1h
FE9B6: call    0FE51Bh
FE9B9: jmp     0FE980h
FE9BB: add     bx,2h
FE9BE: cmp     bx,3Eh
FE9C2: jne     0FE9C7h
FE9C4: mov     bx,1Eh
FE9C7: ret     
FE9C8: sti     
FE9C9: push    ax
FE9CA: push    ds 
FE9CB: mov     ax,40h
FE9CE: mov     ds,ax
FE9D0: or      byte ptr [3Eh],80h
FE9D5: pop     ds 
FE9D6: mov     al,66h
FE9D8: out     20h,al
FE9DA: pop     ax
FE9DB: iret    
FE9DC: inc     sp
FE9DD: or      dl,[bp+di+0Bh]
FE9E0: lea     cx,[bp+di]
FE9E2: rep     or      dx,[bx]
FE9E5: or      al,1Ch
FE9E7: or      al,5Dh
FE9E9: or      al,7h
FE9EB: or      ax,0F4Fh
FE9EE: outsb   
FE9EF: sets    byte ptr [bx]
FE9F2: out     11h,ax
FE9F4: jmp     7D12h:2211h
FE9F9: adc     al,[di]
FE9FB: adc     di,bx
FE9FD: cld     
FE9FE: cmp     ah,0Fh
FEA01: ja      0FEA35h
FEA03: push    bp
FEA04: push    es 
FEA05: push    ds 
FEA06: push    si
FEA07: push    di
FEA08: push    dx
FEA09: push    cx
FEA0A: push    bx
FEA0B: push    ax
FEA0C: xor     al,al
FEA0E: xchg    ah,al
FEA10: shl     ax,1
FEA12: mov     si,9DCh
FEA15: add     si,ax
FEA17: mov     ax,40h
FEA1A: mov     ds,ax
FEA1C: mov     ax,0B800h
FEA1F: mov     es,ax
FEA21: pop     ax
FEA22: mov     ah,[49h]
FEA26: cmp     ah,7h
FEA29: jb      0FEA32h
FEA2B: push    ax
FEA2C: mov     ax,0B000h
FEA2F: mov     es,ax
FEA31: pop     ax
FEA32: jmp     word ptr cs:[si]
FEA35: iret    
FEA36: add     [bx+di],ax
FEA38: add     [bx+si],al
FEA3A: add     [bx+di],ax
FEA3C: add     [bx+si],ch
FEA3E: sub     [bx+si+50h],dl
FEA41: sub     [bx+si],ch
FEA43: push    ax
FEA44: cmp     al,7h
FEA46: jb      0FEA4Bh
FEA48: jmp     0FEAF1h
FEA4B: push    ax
FEA4C: xor     bx,bx
FEA4E: mov     bl,al
FEA50: mov     ah,cs:[bx+0A36h]
FEA55: mov     byte ptr [8Bh],0h
FEA5A: mov     al,0Ch
FEA5C: call    0FE4F9h
FEA5F: mov     al,ah
FEA61: call    0FE4F9h
FEA64: pop     ax
FEA65: mov     [49h],al
FEA68: call    0FE4F9h
FEA6B: cmp     byte ptr [8Bh],0h
FEA70: je      0FEA6Bh
FEA72: mov     cx,4000h
FEA75: loop    0FEA75h
FEA77: mov     word ptr [4Eh],0h
FEA7D: mov     byte ptr [62h],0h
FEA82: mov     word ptr [63h],3D4h
FEA88: mov     al,[49h]
FEA8B: xor     ah,ah
FEA8D: mov     si,ax
FEA8F: mov     al,cs:[si+0A3Dh]
FEA94: mov     [4Ah],ax
FEA97: mov     dl,al
FEA99: dec     dl
FEA9B: mov     cx,0h
FEA9E: mov     dh,18h
FEAA0: mov     ax,600h
FEAA3: mov     bh,7h
FEAA5: cmp     byte ptr [49h],4h
FEAAA: jb      0FEAAEh
FEAAC: xor     bh,bh
FEAAE: int     10h
FEAB0: call    0FEB46h
FEAB3: xor     dx,dx
FEAB5: mov     bh,0h
FEAB7: mov     ah,2h
FEAB9: int     10h
FEABB: mov     cx,607h
FEABE: mov     ah,1h
FEAC0: int     10h
FEAC2: mov     word ptr [4Ch],3E80h
FEAC8: pop     bx
FEAC9: pop     cx
FEACA: pop     dx
FEACB: pop     di
FEACC: pop     si
FEACD: pop     ds 
FEACE: pop     es 
FEACF: pop     bp
FEAD0: iret    
FEAD1: popa    
FEAD2: add     [bx+si+1h],dl
FEAD5: push    dx
FEAD6: add     cl,[bx]
FEAD8: add     bx,[bx+di]
FEADA: add     al,6h
FEADC: add     ax,619h
FEADF: sbb     [bx],ax
FEAE1: add     cl,[bx+si]
FEAE3: or      ax,0B09h
FEAE6: or      cl,[si]
FEAE8: or      ax,[bx+si]
FEAEA: or      al,0h
FEAEC: or      ax,0E00h
FEAEF: add     [bx],cl
FEAF1: mov     dx,3B8h
FEAF4: mov     al,1h
FEAF6: out     dx,al
FEAF7: mov     cx,10h
FEAFA: mov     si,0AD1h
FEAFD: mov     dx,3B4h
FEB00: lodsw   cs:
FEB02: call    0FEB82h
FEB05: loop    0FEB00h
FEB07: mov     ax,0B000h
FEB0A: mov     es,ax
FEB0C: xor     di,di
FEB0E: mov     cx,1F40h
FEB11: mov     ax,720h
FEB14: rep     stosw   
FEB16: mov     dx,3B8h
FEB19: mov     al,29h
FEB1B: out     dx,al
FEB1C: mov     [65h],al
FEB1F: mov     byte ptr [49h],7h
FEB24: mov     word ptr [4Eh],0h
FEB2A: mov     byte ptr [62h],0h
FEB2F: mov     word ptr [4Ah],50h
FEB35: mov     word ptr [60h],0B0Ch
FEB3B: mov     word ptr [63h],3B4h
FEB41: call    0FEB46h
FEB44: jmp     0FEAC8h
FEB46: mov     cx,8h
FEB49: mov     di,50h
FEB4C: xor     ax,ax
FEB4E: push    ds 
FEB4F: pop     es 
FEB50: rep     stosw   
FEB52: ret     
FEB53: cmp     ah,7h
FEB56: je      0FEB6Eh
FEB58: mov     [60h],cx
FEB5C: mov     al,4h
FEB5E: call    0FE4F9h
FEB61: mov     al,ch
FEB63: call    0FE4F9h
FEB66: mov     al,cl
FEB68: call    0FE4F9h
FEB6B: jmp     0FEAC8h
FEB6E: mov     dx,3B4h
FEB71: mov     ah,0Ah
FEB73: mov     al,ch
FEB75: call    0FEB82h
FEB78: mov     ah,0Bh
FEB7A: mov     al,cl
FEB7C: call    0FEB82h
FEB7F: jmp     0FEAC8h
FEB82: push    dx
FEB83: push    ax
FEB84: mov     al,ah
FEB86: out     dx,al
FEB87: inc     dx
FEB88: pop     ax
FEB89: out     dx,al
FEB8A: pop     dx
FEB8B: ret     
FEB8C: push    ax
FEB8D: cmp     ah,7h
FEB90: je      0FEBC2h
FEB92: cmp     bh,0h
FEB95: jne     0FEB7Fh
FEB97: mov     [50h],dx
FEB9B: mov     al,0Bh
FEB9D: call    0FE4F9h
FEBA0: mov     al,dh
FEBA2: mul     byte ptr cs:[0B8Ch]
FEBA7: mov     dh,0h
FEBA9: cmp     byte ptr [4Ah],28h
FEBAE: jne     0FEBB2h
FEBB0: shl     dx,1
FEBB2: add     ax,dx
FEBB4: add     ax,830h
FEBB7: call    0FE4F9h
FEBBA: mov     al,ah
FEBBC: call    0FE4F9h
FEBBF: jmp     0FEC19h
FEBC1: nop     
FEBC2: push    bx
FEBC3: mov     bl,bh
FEBC5: xor     bh,bh
FEBC7: shl     bx,1
FEBC9: mov     [bx+50h],dx
FEBCD: pop     bx
FEBCE: cmp     [62h],bh
FEBD2: jne     0FEBBFh
FEBD4: mov     ax,dx
FEBD6: call    0FED81h
FEBD9: add     ax,[4Eh]
FEBDD: shr     ax,1
FEBDF: push    ax
FEBE0: mov     dx,3B4h
FEBE3: mov     al,ah
FEBE5: mov     ah,0Eh
FEBE7: call    0FEB82h
FEBEA: pop     ax
FEBEB: mov     ah,0Fh
FEBED: call    0FEB82h
FEBF0: jmp     0FEAC8h
FEBF3: cmp     ah,7h
FEBF6: je      0FEC0Bh
FEBF8: cmp     bh,0h
FEBFB: jne     0FEC19h
FEBFD: mov     dx,[50h]
FEC01: mov     cx,[60h]
FEC05: pop     bx
FEC06: pop     ds 
FEC07: pop     ds 
FEC08: jmp     0FEACBh
FEC0B: xor     bl,bl
FEC0D: mov     cl,7h
FEC0F: shr     bx,cl
FEC11: mov     dx,[bx+50h]
FEC15: jmp     0FEC01h
FEC17: mov     ah,0h
FEC19: jmp     0FEAC8h
FEC1C: cmp     ah,7h
FEC1F: je      0FEC29h
FEC21: mov     byte ptr [62h],0h
FEC26: jmp     0FEAC8h
FEC29: mov     [62h],al
FEC2C: xor     cx,cx
FEC2E: mov     cl,al
FEC30: mov     ax,0h
FEC33: jcxz    0FEC3Ah
FEC35: add     ax,1000h
FEC38: loop    0FEC35h
FEC3A: mov     [4Eh],ax
FEC3D: push    ax
FEC3E: mov     dx,3B4h
FEC41: mov     al,ah
FEC43: mov     ah,0Ch
FEC45: call    0FEB82h
FEC48: pop     ax
FEC49: mov     ah,0Dh
FEC4B: call    0FEB82h
FEC4E: xor     bx,bx
FEC50: mov     bl,[62h]
FEC54: shl     bx,1
FEC56: mov     ax,[bx+50h]
FEC5A: jmp     0FEBD6h
FEC5D: cmp     ah,7h
FEC60: je      0FEC85h
FEC62: cmp     ah,4h
FEC65: jb      0FEC72h
FEC67: cmp     ah,6h
FEC6A: jb      0FEC6Fh
FEC6C: jmp     0FED9Ch
FEC6F: jmp     0FED92h
FEC72: push    ax
FEC73: mov     byte ptr [8Bh],0h
FEC78: mov     al,0Ah
FEC7A: call    0FE4F9h
FEC7D: pop     ax
FEC7E: cmp     byte ptr [8Bh],0h
FEC83: je      0FEC7Eh
FEC85: xor     ah,ah
FEC87: xchg    ax,cx
FEC88: jcxz    0FECDAh
FEC8A: push    cx
FEC8B: push    ax
FEC8C: push    dx
FEC8D: push    ax
FEC8E: call    0FED81h
FEC91: add     ax,[4Eh]
FEC95: mov     di,ax
FEC97: mov     si,ax
FEC99: xor     ax,ax
FEC9B: mov     al,[4Ah]
FEC9E: shl     ax,1
FECA0: mov     bp,ax
FECA2: add     si,bp
FECA4: pop     ax
FECA5: sub     dx,ax
FECA7: push    ds 
FECA8: push    es 
FECA9: pop     ds 
FECAA: inc     dl
FECAC: inc     dh
FECAE: dec     dh
FECB0: je      0FECC2h
FECB2: xor     cx,cx
FECB4: mov     cl,dl
FECB6: push    si
FECB7: push    di
FECB8: rep     movsw   
FECBA: pop     di
FECBB: pop     si
FECBC: add     si,bp
FECBE: add     di,bp
FECC0: jmp     0FECAEh
FECC2: xor     cx,cx
FECC4: mov     cl,dl
FECC6: mov     ah,bh
FECC8: mov     al,20h
FECCA: rep     stosw   
FECCC: pop     ds 
FECCD: pop     dx
FECCE: pop     ax
FECCF: pop     cx
FECD0: loop    0FEC8Ah
FECD2: mov     al,0Dh
FECD4: call    0FE4F9h
FECD7: jmp     0FEAC8h
FECDA: push    ax
FECDB: call    0FED81h
FECDE: add     ax,[4Eh]
FECE2: mov     di,ax
FECE4: xor     ax,ax
FECE6: mov     al,[4Ah]
FECE9: shl     ax,1
FECEB: mov     bp,ax
FECED: pop     ax
FECEE: sub     dx,ax
FECF0: mov     cl,dl
FECF2: inc     cx
FECF3: inc     dh
FECF5: push    di
FECF6: push    cx
FECF7: mov     ah,bh
FECF9: mov     al,20h
FECFB: rep     stosw   
FECFD: pop     cx
FECFE: pop     di
FECFF: add     di,bp
FED01: dec     dh
FED03: jne     0FECF5h
FED05: jmp     0FECD2h
FED07: cmp     ah,7h
FED0A: je      0FED2Fh
FED0C: cmp     ah,4h
FED0F: jb      0FED1Ch
FED11: cmp     ah,6h
FED14: jb      0FED19h
FED16: jmp     0FEE93h
FED19: jmp     0FEE8Ah
FED1C: push    ax
FED1D: mov     byte ptr [8Bh],0h
FED22: mov     al,0Ah
FED24: call    0FE4F9h
FED27: pop     ax
FED28: cmp     byte ptr [8Bh],0h
FED2D: je      0FED28h
FED2F: xor     ah,ah
FED31: xchg    ax,cx
FED32: jcxz    0FECDAh
FED34: push    cx
FED35: push    ax
FED36: push    dx
FED37: push    ax
FED38: mov     ah,dh
FED3A: call    0FED81h
FED3D: add     ax,[4Eh]
FED41: mov     si,ax
FED43: mov     di,ax
FED45: xor     ax,ax
FED47: mov     al,[4Ah]
FED4A: shl     ax,1
FED4C: mov     bp,ax
FED4E: sub     si,bp
FED50: pop     ax
FED51: sub     dx,ax
FED53: inc     dl
FED55: inc     dh
FED57: push    ds 
FED58: push    es 
FED59: pop     ds 
FED5A: dec     dh
FED5C: je      0FED6Eh
FED5E: xor     cx,cx
FED60: mov     cl,dl
FED62: push    si
FED63: push    di
FED64: rep     movsw   
FED66: pop     di
FED67: pop     si
FED68: sub     si,bp
FED6A: sub     di,bp
FED6C: jmp     0FED5Ah
FED6E: xor     cx,cx
FED70: mov     cl,dl
FED72: mov     ah,bh
FED74: mov     al,20h
FED76: rep     stosw   
FED78: pop     ds 
FED79: pop     dx
FED7A: pop     ax
FED7B: pop     cx
FED7C: loop    0FED34h
FED7E: jmp     0FECD2h
FED81: push    bx
FED82: xor     bx,bx
FED84: mov     bl,al
FED86: mov     al,ah
FED88: mul     byte ptr [4Ah]
FED8C: add     ax,bx
FED8E: shl     ax,1
FED90: pop     bx
FED91: ret     
FED92: shl     cl,1
FED94: stc     
FED95: rcl     dl,1
FED97: jmp     0FED9Ch
FED99: jmp     0FEE41h
FED9C: xor     ah,ah
FED9E: xchg    ax,cx
FED9F: jcxz    0FED99h
FEDA1: push    cx
FEDA2: push    ax
FEDA3: push    dx
FEDA4: push    ax
FEDA5: call    0FF1D3h
FEDA8: mov     di,ax
FEDAA: mov     si,ax
FEDAC: add     si,140h
FEDB0: pop     ax
FEDB1: sub     dh,ah
FEDB3: sub     dl,al
FEDB5: push    ds 
FEDB6: push    es 
FEDB7: pop     ds 
FEDB8: inc     dl
FEDBA: inc     dh
FEDBC: dec     dh
FEDBE: je      0FEE00h
FEDC0: xor     cx,cx
FEDC2: mov     cl,dl
FEDC4: call    0FEF38h
FEDC7: call    0FEF48h
FEDCA: call    0FEF38h
FEDCD: call    0FEF48h
FEDD0: call    0FEF38h
FEDD3: call    0FEF48h
FEDD6: call    0FEF38h
FEDD9: add     si,1F10h
FEDDD: add     di,1F10h
FEDE1: call    0FEF38h
FEDE4: call    0FEF48h
FEDE7: call    0FEF38h
FEDEA: call    0FEF48h
FEDED: call    0FEF38h
FEDF0: call    0FEF48h
FEDF3: call    0FEF38h
FEDF6: sub     si,1FB0h
FEDFA: sub     di,1FB0h
FEDFE: jmp     0FEDBCh
FEE00: xor     cx,cx
FEE02: mov     cl,dl
FEE04: mov     al,bh
FEE06: call    0FEF41h
FEE09: add     di,50h
FEE0C: call    0FEF41h
FEE0F: add     di,50h
FEE12: call    0FEF41h
FEE15: add     di,50h
FEE18: call    0FEF41h
FEE1B: add     di,1F10h
FEE1F: call    0FEF41h
FEE22: add     di,50h
FEE25: call    0FEF41h
FEE28: add     di,50h
FEE2B: call    0FEF41h
FEE2E: add     di,50h
FEE31: call    0FEF41h
FEE34: pop     ds 
FEE35: pop     dx
FEE36: pop     ax
FEE37: pop     cx
FEE38: dec     cx
FEE39: je      0FEE3Eh
FEE3B: jmp     0FEDA1h
FEE3E: jmp     0FEAC8h
FEE41: push    ax
FEE42: call    0FF1D3h
FEE45: mov     di,ax
FEE47: pop     ax
FEE48: sub     dx,ax
FEE4A: mov     cl,dl
FEE4C: inc     dh
FEE4E: inc     cx
FEE4F: mov     al,bh
FEE51: call    0FEF41h
FEE54: add     di,50h
FEE57: call    0FEF41h
FEE5A: add     di,50h
FEE5D: call    0FEF41h
FEE60: add     di,50h
FEE63: call    0FEF41h
FEE66: add     di,1F10h
FEE6A: call    0FEF41h
FEE6D: add     di,50h
FEE70: call    0FEF41h
FEE73: add     di,50h
FEE76: call    0FEF41h
FEE79: add     di,50h
FEE7C: call    0FEF41h
FEE7F: sub     di,1FB0h
FEE83: dec     dh
FEE85: jne     0FEE4Fh
FEE87: jmp     0FEAC8h
FEE8A: shl     cl,1
FEE8C: stc     
FEE8D: rcl     dl,1
FEE8F: jmp     0FEE93h
FEE91: jmp     0FEE41h
FEE93: xor     ah,ah
FEE95: xchg    ax,cx
FEE96: jcxz    0FEE91h
FEE98: push    cx
FEE99: push    ax
FEE9A: push    dx
FEE9B: push    ax
FEE9C: mov     ah,dh
FEE9E: call    0FF1D3h
FEEA1: mov     di,ax
FEEA3: mov     si,ax
FEEA5: sub     si,140h
FEEA9: pop     ax
FEEAA: sub     dx,ax
FEEAC: push    ds 
FEEAD: push    es 
FEEAE: pop     ds 
FEEAF: inc     dl
FEEB1: inc     dh
FEEB3: dec     dh
FEEB5: je      0FEEF7h
FEEB7: xor     cx,cx
FEEB9: mov     cl,dl
FEEBB: call    0FEF38h
FEEBE: call    0FEF48h
FEEC1: call    0FEF38h
FEEC4: call    0FEF48h
FEEC7: call    0FEF38h
FEECA: call    0FEF48h
FEECD: call    0FEF38h
FEED0: add     si,1F10h
FEED4: add     di,1F10h
FEED8: call    0FEF38h
FEEDB: call    0FEF48h
FEEDE: call    0FEF38h
FEEE1: call    0FEF48h
FEEE4: call    0FEF38h
FEEE7: call    0FEF48h
FEEEA: call    0FEF38h
FEEED: sub     si,2230h
FEEF1: sub     di,2230h
FEEF5: jmp     0FEEB3h
FEEF7: xor     cx,cx
FEEF9: mov     cl,dl
FEEFB: mov     al,bh
FEEFD: call    0FEF41h
FEF00: add     di,50h
FEF03: call    0FEF41h
FEF06: add     di,50h
FEF09: call    0FEF41h
FEF0C: add     di,50h
FEF0F: call    0FEF41h
FEF12: add     di,1F10h
FEF16: call    0FEF41h
FEF19: add     di,50h
FEF1C: call    0FEF41h
FEF1F: add     di,50h
FEF22: call    0FEF41h
FEF25: add     di,50h
FEF28: call    0FEF41h
FEF2B: pop     ds 
FEF2C: pop     dx
FEF2D: pop     ax
FEF2E: pop     cx
FEF2F: dec     cx
FEF30: je      0FEF35h
FEF32: jmp     0FEE98h
FEF35: jmp     0FEAC8h
FEF38: push    si
FEF39: push    di
FEF3A: push    cx
FEF3B: rep     movsb   
FEF3D: pop     cx
FEF3E: pop     di
FEF3F: pop     si
FEF40: ret     
FEF41: push    di
FEF42: push    cx
FEF43: rep     stosb   
FEF45: pop     cx
FEF46: pop     di
FEF47: ret     
FEF48: add     si,50h
FEF4B: add     di,50h
FEF4E: ret     
FEF4F: cmp     ah,7h
FEF52: je      0FEF5Ch
FEF54: cmp     ah,4h
FEF57: jb      0FEF5Ch
FEF59: jmp     0FF06Bh
FEF5C: mov     ax,[50h]
FEF5F: call    0FED81h
FEF62: add     ax,[4Eh]
FEF66: mov     bx,ax
FEF68: mov     ax,es:[bx]
FEF6B: jmp     0FEAC8h
FEF6E: cmp     ah,7h
FEF71: je      0FEF83h
FEF73: cmp     ah,4h
FEF76: jb      0FEF83h
FEF78: cmp     ah,6h
FEF7B: je      0FEF80h
FEF7D: jmp     0FF01Ch
FEF80: jmp     0FEFC4h
FEF82: nop     
FEF83: mov     ah,bl
FEF85: push    ax
FEF86: mov     ax,[50h]
FEF89: call    0FED81h
FEF8C: add     ax,[4Eh]
FEF90: mov     di,ax
FEF92: pop     ax
FEF93: rep     stosw   
FEF95: jmp     0FEAC8h
FEF98: cmp     ah,7h
FEF9B: je      0FEFAFh
FEF9D: cmp     ah,4h
FEFA0: jb      0FEFAFh
FEFA2: mov     bl,3h
FEFA4: cmp     ah,6h
FEFA7: je      0FEFACh
FEFA9: jmp     0FF01Ch
FEFAB: nop     
FEFAC: jmp     0FEFC4h
FEFAE: nop     
FEFAF: push    ax
FEFB0: mov     ax,[50h]
FEFB3: call    0FED81h
FEFB6: add     ax,[4Eh]
FEFBA: mov     di,ax
FEFBC: pop     ax
FEFBD: stosb   
FEFBE: inc     di
FEFBF: loop    0FEFBDh
FEFC1: jmp     0FEAC8h
FEFC4: push    ax
FEFC5: call    0FF1C7h
FEFC8: mov     di,ax
FEFCA: pop     ax
FEFCB: test    al,80h
FEFCD: jne     0FEFD6h
FEFCF: mov     si,1A6Eh
FEFD2: push    cs 
FEFD3: pop     ds 
FEFD4: jmp     0FEFDEh
FEFD6: xor     bx,bx
FEFD8: mov     ds,bx
FEFDA: lds     si,[7Ch]
FEFDE: and     ax,7Fh
FEFE1: shl     ax,1
FEFE3: shl     ax,1
FEFE5: shl     ax,1
FEFE7: add     si,ax
FEFE9: push    si
FEFEA: push    di
FEFEB: lodsb   
FEFEC: stosb   
FEFED: lodsb   
FEFEE: mov     es:[di+1FFFh],al
FEFF3: add     di,4Fh
FEFF6: lodsb   
FEFF7: stosb   
FEFF8: lodsb   
FEFF9: mov     es:[di+1FFFh],al
FEFFE: add     di,4Fh
FF001: lodsb   
FF002: stosb   
FF003: lodsb   
FF004: mov     es:[di+1FFFh],al
FF009: add     di,4Fh
FF00C: lodsb   
FF00D: stosb   
FF00E: lodsb   
FF00F: mov     es:[di+1FFFh],al
FF014: pop     di
FF015: inc     di
FF016: pop     si
FF017: loop    0FEFE9h
FF019: jmp     0FEAC8h
FF01C: push    ax
FF01D: call    0FF1C7h
FF020: mov     di,ax
FF022: pop     ax
FF023: test    al,80h
FF025: jne     0FF02Eh
FF027: mov     si,1A6Eh
FF02A: push    cs 
FF02B: pop     ds 
FF02C: jmp     0FF036h
FF02E: xor     si,si
FF030: mov     ds,si
FF032: lds     si,[7Ch]
FF036: and     ax,7Fh
FF039: shl     ax,1
FF03B: shl     ax,1
FF03D: shl     ax,1
FF03F: add     si,ax
FF041: call    0FF15Eh
FF044: push    si
FF045: push    di
FF046: push    cx
FF047: mov     cx,4h
FF04A: lodsb   
FF04B: call    0FF178h
FF04E: and     ax,bx
FF050: stosw   
FF051: lodsb   
FF052: call    0FF178h
FF055: and     ax,bx
FF057: mov     es:[di+1FFEh],ax
FF05C: add     di,4Eh
FF05F: loop    0FF04Ah
FF061: pop     cx
FF062: pop     di
FF063: inc     di
FF064: inc     di
FF065: pop     si
FF066: loop    0FF044h
FF068: jmp     0FEAC8h
FF06B: sub     sp,8h
FF06E: mov     bp,sp
FF070: cmp     ah,6h
FF073: pushf   
FF074: call    0FF1C7h
FF077: mov     bx,ax
FF079: popf    
FF07A: jne     0FF0BBh
FF07C: mov     al,es:[bx]
FF07F: call    0FF159h
FF082: mov     al,es:[bx+2000h]
FF087: call    0FF159h
FF08A: mov     al,es:[bx+50h]
FF08E: call    0FF159h
FF091: mov     al,es:[bx+2050h]
FF096: call    0FF159h
FF099: mov     al,es:[bx+0A0h]
FF09E: call    0FF159h
FF0A1: mov     al,es:[bx+20A0h]
FF0A6: call    0FF159h
FF0A9: mov     al,es:[bx+0F0h]
FF0AE: call    0FF159h
FF0B1: mov     al,es:[bx+20F0h]
FF0B6: call    0FF159h
FF0B9: jmp     0FF0F8h
FF0BB: mov     ax,es:[bx]
FF0BE: call    0FF140h
FF0C1: mov     ax,es:[bx+2000h]
FF0C6: call    0FF140h
FF0C9: mov     ax,es:[bx+50h]
FF0CD: call    0FF140h
FF0D0: mov     ax,es:[bx+2050h]
FF0D5: call    0FF140h
FF0D8: mov     ax,es:[bx+0A0h]
FF0DD: call    0FF140h
FF0E0: mov     ax,es:[bx+20A0h]
FF0E5: call    0FF140h
FF0E8: mov     ax,es:[bx+0F0h]
FF0ED: call    0FF140h
FF0F0: mov     ax,es:[bx+20F0h]
FF0F5: call    0FF140h
FF0F8: sub     bp,8h
FF0FB: mov     si,bp
FF0FD: push    ss 
FF0FE: pop     ds 
FF0FF: mov     di,1A6Eh
FF102: push    cs 
FF103: pop     es 
FF104: mov     al,0h
FF106: mov     cx,8h
FF109: push    si
FF10A: push    di
FF10B: rep     cmpsb   
FF10D: pop     di
FF10E: pop     si
FF10F: je      0FF13Ah
FF111: add     di,8h
FF114: inc     al
FF116: cmp     al,80h
FF118: jb      0FF106h
FF11A: push    ds 
FF11B: xor     ax,ax
FF11D: mov     ds,ax
FF11F: les     di,[7Ch]
FF123: pop     ds 
FF124: mov     al,80h
FF126: mov     cx,8h
FF129: push    si
FF12A: push    di
FF12B: rep     cmpsb   
FF12D: pop     di
FF12E: pop     si
FF12F: je      0FF13Ah
FF131: add     di,8h
FF134: inc     al
FF136: cmp     al,0h
FF138: jne     0FF126h
FF13A: add     sp,8h
FF13D: jmp     0FEAC8h
FF140: xchg    al,ah
FF142: mov     cx,3h
FF145: xor     dl,dl
FF147: test    cx,ax
FF149: je      0FF14Eh
FF14B: stc     
FF14C: jmp     0FF14Fh
FF14E: clc     
FF14F: rcr     dl,1
FF151: shl     cx,1
FF153: shl     cx,1
FF155: jae     0FF147h
FF157: mov     al,dl
FF159: mov     [bp],al
FF15C: inc     bp
FF15D: ret     
FF15E: and     bl,3h
FF161: mov     al,bl
FF163: shl     bl,1
FF165: shl     bl,1
FF167: or      bl,al
FF169: mov     al,bl
FF16B: shl     bl,1
FF16D: shl     bl,1
FF16F: shl     bl,1
FF171: shl     bl,1
FF173: or      bl,al
FF175: mov     bh,bl
FF177: ret     
FF178: push    dx
FF179: xor     dx,dx
FF17B: mov     ah,80h
FF17D: test    ah,al
FF17F: je      0FF184h
FF181: or      dl,0C0h
FF184: shr     ah,1
FF186: test    ah,al
FF188: je      0FF18Dh
FF18A: or      dl,30h
FF18D: shr     ah,1
FF18F: test    ah,al
FF191: je      0FF196h
FF193: or      dl,0Ch
FF196: shr     ah,1
FF198: test    ah,al
FF19A: je      0FF19Fh
FF19C: or      dl,3h
FF19F: shr     ah,1
FF1A1: test    ah,al
FF1A3: je      0FF1A8h
FF1A5: or      dh,0C0h
FF1A8: shr     ah,1
FF1AA: test    ah,al
FF1AC: je      0FF1B1h
FF1AE: or      dh,30h
FF1B1: shr     ah,1
FF1B3: test    ah,al
FF1B5: je      0FF1BAh
FF1B7: or      dh,0Ch
FF1BA: shr     ah,1
FF1BC: test    ah,al
FF1BE: je      0FF1C3h
FF1C0: or      dh,3h
FF1C3: mov     ax,dx
FF1C5: pop     dx
FF1C6: ret     
FF1C7: mov     ax,[50h]
FF1CA: cmp     byte ptr [49h],6h
FF1CF: jae     0FF1D3h
FF1D1: shl     al,1
FF1D3: push    bx
FF1D4: push    dx
FF1D5: xor     bx,bx
FF1D7: mov     bl,al
FF1D9: mov     al,ah
FF1DB: xor     ah,ah
FF1DD: mov     dx,140h
FF1E0: mul     dx
FF1E2: add     ax,bx
FF1E4: pop     dx
FF1E5: pop     bx
FF1E6: ret     
FF1E7: jmp     0FEAC8h
FF1EA: call    0FF23Ch
FF1ED: cmp     ah,6h
FF1F0: jb      0FF213h
FF1F2: mov     ah,es:[si]
FF1F5: test    al,80h
FF1F7: jne     0FF20Bh
FF1F9: and     al,1h
FF1FB: shl     al,cl
FF1FD: mov     ch,al
FF1FF: not     al
FF201: and     ah,al
FF203: or      ah,ch
FF205: mov     es:[si],ah
FF208: jmp     0FEAC8h
FF20B: and     al,1h
FF20D: shl     al,cl
FF20F: xor     ah,al
FF211: jmp     0FF205h
FF213: mov     ah,es:[si]
FF216: test    al,80h
FF218: jne     0FF21Eh
FF21A: and     al,3h
FF21C: jmp     0FF1FBh
FF21E: and     al,3h
FF220: jmp     0FF20Dh
FF222: call    0FF23Ch
FF225: mov     al,es:[si]
FF228: cmp     ah,6h
FF22B: jb      0FF238h
FF22D: mov     ah,1h
FF22F: shl     ah,cl
FF231: and     al,ah
FF233: shr     al,cl
FF235: jmp     0FEAC8h
FF238: mov     ah,3h
FF23A: jmp     0FF22Fh
FF23C: push    ax
FF23D: push    ax
FF23E: xor     si,si
FF240: clc     
FF241: rcr     dx,1
FF243: jae     0FF249h
FF245: add     si,2000h
FF249: mov     al,50h
FF24B: mul     dl
FF24D: add     si,ax
FF24F: pop     ax
FF250: cmp     ah,6h
FF253: jb      0FF268h
FF255: mov     ax,cx
FF257: push    ax
FF258: mov     cl,3h
FF25A: shr     ax,cl
FF25C: add     si,ax
FF25E: pop     ax
FF25F: and     ax,7h
FF262: xor     al,7h
FF264: mov     cl,al
FF266: pop     ax
FF267: ret     
FF268: mov     ax,cx
FF26A: push    ax
FF26B: shr     ax,1
FF26D: shr     ax,1
FF26F: add     si,ax
FF271: pop     ax
FF272: and     ax,3h
FF275: xor     al,3h
FF277: shl     al,1
FF279: mov     cl,al
FF27B: pop     ax
FF27C: ret     
FF27D: push    ax
FF27E: mov     dx,[50h]
FF282: cmp     al,7h
FF284: je      0FF2BEh
FF286: cmp     al,8h
FF288: je      0FF2C7h
FF28A: cmp     al,0Ah
FF28C: je      0FF2D0h
FF28E: cmp     al,0Dh
FF290: je      0FF2DEh
FF292: mov     bh,0h
FF294: mov     ah,0Ah
FF296: mov     cx,1h
FF299: int     10h
FF29B: inc     dl
FF29D: cmp     dl,[4Ah]
FF2A1: je      0FF2ADh
FF2A3: mov     ah,2h
FF2A5: mov     bh,0h
FF2A7: int     10h
FF2A9: pop     ax
FF2AA: jmp     0FEAC8h
FF2AD: mov     dl,0h
FF2AF: inc     dh
FF2B1: cmp     dh,19h
FF2B4: jne     0FF2A3h
FF2B6: call    0FF2E2h
FF2B9: mov     dx,1800h
FF2BC: jmp     0FF2A3h
FF2BE: mov     bl,2h
FF2C0: call    0FE51Bh
FF2C3: pop     ax
FF2C4: jmp     0FEAC8h
FF2C7: cmp     dl,0h
FF2CA: je      0FF2C3h
FF2CC: dec     dl
FF2CE: jmp     0FF2A3h
FF2D0: cmp     dh,18h
FF2D3: je      0FF2D9h
FF2D5: inc     dh
FF2D7: jmp     0FF2A3h
FF2D9: call    0FF2E2h
FF2DC: jmp     0FF2C3h
FF2DE: mov     dl,0h
FF2E0: jmp     0FF2A3h
FF2E2: mov     bh,0h
FF2E4: mov     al,[49h]
FF2E7: cmp     al,7h
FF2E9: je      0FF2EFh
FF2EB: cmp     al,4h
FF2ED: jae     0FF2F5h
FF2EF: mov     ah,8h
FF2F1: int     10h
FF2F3: mov     bh,ah
FF2F5: mov     ax,601h
FF2F8: xor     cx,cx
FF2FA: mov     dh,18h
FF2FC: mov     dl,[4Ah]
FF300: dec     dl
FF302: int     10h
FF304: ret     
FF305: mov     ah,[4Ah]
FF309: mov     al,[49h]
FF30C: mov     bh,[62h]
FF310: pop     cx
FF311: jmp     0FEAC9h
FF314: push    ds 
FF315: mov     ax,40h
FF318: mov     ds,ax
FF31A: mov     ax,[13h]
FF31D: pop     ds 
FF31E: iret    
FF31F: sti     
FF320: push    es 
FF321: push    bx
FF322: push    ds 
FF323: push    si
FF324: push    di
FF325: push    bp
FF326: push    ax
FF327: push    cx
FF328: push    dx
FF329: mov     bp,sp
FF32B: mov     si,40h
FF32E: mov     ds,si
FF330: call    0FF357h
FF333: mov     bx,2h
FF336: call    0FF5B4h
FF339: mov     [40h],ah
FF33D: mov     ah,[41h]
FF341: cmp     ah,0h
FF344: je      0FF349h
FF346: stc     
FF347: jmp     0FF34Ah
FF349: clc     
FF34A: pop     dx
FF34B: pop     cx
FF34C: pop     bp
FF34D: pop     bp
FF34E: pop     di
FF34F: pop     si
FF350: pop     ds 
FF351: pop     bx
FF352: pop     es 
FF353: sti     
FF354: retf    2h
FF357: mov     byte ptr [88h],0h
FF35C: mov     byte ptr [40h],0FFh
FF361: mov     byte ptr [8Ah],0h
FF366: and     byte ptr [3Fh],7Fh
FF36B: mov     dh,al
FF36D: cmp     ah,0FEh
FF370: jne     0FF375h
FF372: jmp     0FF400h
FF375: cmp     ah,0FDh
FF378: jne     0FF37Dh
FF37A: jmp     0FF40Fh
FF37D: or      ah,ah
FF37F: je      0FF3AFh
FF381: dec     ah
FF383: jne     0FF388h
FF385: jmp     0FF3D5h
FF387: nop     
FF388: cmp     dl,4h
FF38B: jae     0FF3A9h
FF38D: dec     ah
FF38F: jne     0FF394h
FF391: jmp     0FF3D9h
FF393: nop     
FF394: dec     ah
FF396: jne     0FF39Bh
FF398: jmp     0FF3E3h
FF39A: nop     
FF39B: dec     ah
FF39D: jne     0FF3A2h
FF39F: jmp     0FF3F2h
FF3A1: nop     
FF3A2: dec     ah
FF3A4: jne     0FF3A9h
FF3A6: jmp     0FF3F6h
FF3A8: nop     
FF3A9: mov     byte ptr [41h],1h
FF3AE: ret     
FF3AF: push    cx
FF3B0: push    dx
FF3B1: push    ax
FF3B2: mov     byte ptr [41h],0h
FF3B7: and     byte ptr [3Eh],0F0h
FF3BC: mov     al,0D0h
FF3BE: out     0E3h,al
FF3C0: mov     cx,100h
FF3C3: loop    0FF3C3h
FF3C5: in      al,0E3h
FF3C7: test    al,1h
FF3C9: je      0FF3D1h
FF3CB: mov     byte ptr [41h],20h
FF3D0: stc     
FF3D1: pop     ax
FF3D2: pop     dx
FF3D3: pop     cx
FF3D4: ret     
FF3D5: mov     al,[41h]
FF3D8: ret     
FF3D9: mov     al,46h
FF3DB: call    0FF56Eh
FF3DE: mov     ah,84h
FF3E0: jmp     0FF423h
FF3E2: nop     
FF3E3: or      byte ptr [3Fh],80h
FF3E8: mov     al,4Ah
FF3EA: call    0FF56Eh
FF3ED: mov     ah,0A6h
FF3EF: jmp     0FF423h
FF3F1: nop     
FF3F2: mov     al,42h
FF3F4: jmp     0FF3DBh
FF3F6: or      byte ptr [3Fh],80h
FF3FB: mov     ah,0F6h
FF3FD: jmp     0FF42Dh
FF3FF: nop     
FF400: mov     al,46h
FF402: call    0FF56Eh
FF405: mov     ah,84h
FF407: or      byte ptr [8Ah],1h
FF40C: jmp     0FF423h
FF40E: nop     
FF40F: or      byte ptr [3Fh],80h
FF414: mov     al,4Ah
FF416: call    0FF56Eh
FF419: mov     ah,0A6h
FF41B: or      byte ptr [8Ah],1h
FF420: jmp     0FF423h
FF422: nop     
FF423: jae     0FF42Dh
FF425: mov     byte ptr [41h],9h
FF42A: mov     al,0h
FF42C: ret     
FF42D: mov     byte ptr [41h],0h
FF432: mov     al,dh
FF434: push    ax
FF435: push    cx
FF436: mov     cl,dl
FF438: mov     al,1h
FF43A: shl     al,cl
FF43C: or      [3Fh],al
FF440: cmp     byte ptr [bp+1h],0h
FF444: je      0FF448h
FF446: or      al,20h
FF448: test    byte ptr [8Ah],1h
FF44D: je      0FF451h
FF44F: or      al,10h
FF451: out     0C0h,al
FF453: pop     cx
FF454: and     byte ptr [3Eh],7Fh
FF459: push    bx
FF45A: push    ax
FF45B: push    cx
FF45C: mov     al,1h
FF45E: mov     cl,[bp]
FF461: shl     al,cl
FF463: test    [3Eh],al
FF467: jne     0FF48Fh
FF469: call    0FF6D1h
FF46C: jae     0FF474h
FF46E: pop     cx
FF46F: pop     ax
FF470: pop     bx
FF471: pop     ax
FF472: stc     
FF473: ret     
FF474: mov     al,1h
FF476: mov     cl,[bp]
FF479: shl     al,cl
FF47B: or      [3Eh],al
FF47F: and     byte ptr [3Eh],7Fh
FF484: xor     bx,bx
FF486: mov     bl,cl
FF488: mov     al,0h
FF48A: mov     byte ptr [bx+84h],0h
FF48F: pop     cx
FF490: pop     ax
FF491: xor     bx,bx
FF493: mov     bl,[bp]
FF496: mov     al,[bx+84h]
FF49A: out     0E2h,al
FF49C: cmp     al,ch
FF49E: je      0FF4CCh
FF4A0: call    0FF6F5h
FF4A3: jae     0FF4A9h
FF4A5: pop     bx
FF4A6: pop     ax
FF4A7: stc     
FF4A8: ret     
FF4A9: cmp     byte ptr [bp+5h],5h
FF4AD: je      0FF4C7h
FF4AF: in      al,0E3h
FF4B1: test    al,10h
FF4B3: je      0FF4BCh
FF4B5: mov     byte ptr [41h],40h
FF4BA: jmp     0FF4A5h
FF4BC: test    al,8h
FF4BE: je      0FF4C7h
FF4C0: mov     byte ptr [41h],10h
FF4C5: jmp     0FF4A5h
FF4C7: and     byte ptr [3Eh],7Fh
FF4CC: pop     bx
FF4CD: pop     ax
FF4CE: and     byte ptr [3Eh],7Fh
FF4D3: cmp     ah,0F6h
FF4D6: jne     0FF4DBh
FF4D8: jmp     0FF649h
FF4DB: mov     [88h],al
FF4DE: xor     bx,bx
FF4E0: mov     bl,[bp]
FF4E3: mov     al,[bx+84h]
FF4E7: out     0E2h,al
FF4E9: mov     al,cl
FF4EB: out     0E1h,al
FF4ED: cmp     byte ptr [88h],1h
FF4F2: ja      0FF50Fh
FF4F4: and     byte ptr [3Eh],7Fh
FF4F9: mov     al,ah
FF4FB: out     0E3h,al
FF4FD: call    0FF728h
FF500: jb      0FF50Eh
FF502: call    0FF5C1h
FF505: jb      0FF50Eh
FF507: mov     byte ptr [41h],0h
FF50C: mov     al,1h
FF50E: ret     
FF50F: and     byte ptr [3Eh],7Fh
FF514: in      al,8h
FF516: or      ah,10h
FF519: mov     al,ah
FF51B: out     0E3h,al
FF51D: mov     bl,3h
FF51F: xor     cx,cx
FF521: test    byte ptr [3Eh],80h
FF526: je      0FF536h
FF528: call    0FF5C1h
FF52B: jb      0FF533h
FF52D: mov     byte ptr [41h],20h
FF532: stc     
FF533: jmp     0FF56Ah
FF535: nop     
FF536: in      al,8h
FF538: test    al,4h
FF53A: jne     0FF54Ah
FF53C: loop    0FF521h
FF53E: dec     bl
FF540: jne     0FF521h
FF542: mov     byte ptr [41h],80h
FF547: jmp     0FF56Ah
Anyone familiar with the 8088 that can help annotate this?
- Nigel

BBC Model B, ATPL Sidewise, Acorn Speech, 2xWatford Floppy Drives, AMX Mouse, Viglen case, BeebZIF, etc.

User avatar
Pernod
Posts: 1216
Joined: Fri Jun 08, 2012 10:01 pm
Location: Croydon, UK
Contact:

Re: Torch Graduate

Post by Pernod » Sat Dec 30, 2017 4:23 pm

The log produces:

Code: Select all

[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE022): unmapped io memory read from 00A0 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE026): unmapped io memory write to 00F0 = 01 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE02A): unmapped io memory write to 0063 = 99 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE02E): unmapped io memory write to 0061 = FC & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE032): unmapped io memory write to 00F0 = 02 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE076): unmapped io memory write to 00F0 = 03 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE09C): unmapped io memory write to 00F0 = 04 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE0C6): unmapped io memory write to 00F0 = 05 & FF
[:maincpu] ':maincpu' (FD0C): unmapped program memory read from FC9E & FF
[:maincpu] ':maincpu' (FD0F): unmapped program memory read from FC97 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE0E2): unmapped io memory write to 00F0 = 06 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE0F2): unmapped io memory write to 00F0 = 07 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE110): unmapped io memory write to 00F0 = 08 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE146): unmapped io memory write to 00F0 = 09 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE162): unmapped program memory read from 40000 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE162): unmapped program memory read from 40001 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE166): unmapped program memory write to 40000 = A5 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE166): unmapped program memory write to 40001 = 5A & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE16A): unmapped program memory read from 40000 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE16A): unmapped program memory read from 40001 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE16F): unmapped program memory write to 40000 = FF & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE16F): unmapped program memory write to 40001 = FF & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE18A): unmapped io memory write to 00F0 = 0A & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE1A4): unmapped io memory write to 00F0 = 0B & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE1C5): unmapped io memory write to 0061 = EC & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE1CB): unmapped io memory write to 03B8 = 01 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FEB86): unmapped io memory write to 03B4 = 0E & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FEB89): unmapped io memory write to 03B5 = 35 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE1D7): unmapped io memory write to 03B4 = 0E & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE1D9): unmapped io memory read from 03B5 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE201): unmapped io memory read from 03FA & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE212): unmapped io memory read from 02FA & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE23D): unmapped io memory write to 03BC = AA & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE240): unmapped io memory read from 03BC & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE23D): unmapped io memory write to 0378 = AA & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE240): unmapped io memory read from 0378 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE23D): unmapped io memory write to 0278 = AA & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE240): unmapped io memory read from 0278 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE27D): unmapped io memory read from 00E3 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE47C): unmapped io memory write to 00C0 = 01 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE484): unmapped io memory write to 00E3 = 08 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE486): unmapped io memory read from 00E3 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE47C): unmapped io memory write to 00C0 = 02 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE484): unmapped io memory write to 00E3 = 08 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE486): unmapped io memory read from 00E3 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE47C): unmapped io memory write to 00C0 = 04 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE484): unmapped io memory write to 00E3 = 08 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE486): unmapped io memory read from 00E3 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE47C): unmapped io memory write to 00C0 = 08 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE484): unmapped io memory write to 00E3 = 08 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE486): unmapped io memory read from 00E3 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE2E4): unmapped io memory write to 00F0 = 0C & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE2F4): unmapped io memory write to 00F0 = 0D & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE4F1): unmapped io memory read from 00F0 & FF
[:1mhzbus:graduate:i8088] ':1mhzbus:graduate:i8088' (FE4F7): unmapped io memory read from 00A0 & FF
Then gets stuck in a loop waiting for a response in IO &F0 and &A0.

I guess I need to tie some of these IO ports to the 1MHz bus &FCxx.

OUT &0F0 looks like a counter indicating startup progress.
- Nigel

BBC Model B, ATPL Sidewise, Acorn Speech, 2xWatford Floppy Drives, AMX Mouse, Viglen case, BeebZIF, etc.

Post Reply