
blue.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_ScrCreate@8>:

NTSTATUS STDCALL
ScrCreate(PDEVICE_OBJECT DeviceObject,
	  PIRP Irp)
{
   11000:	55                   	push   %ebp
   11001:	89 e5                	mov    %esp,%ebp
   11003:	57                   	push   %edi
   11004:	56                   	push   %esi
   11005:	53                   	push   %ebx
   11006:	83 ec 14             	sub    $0x14,%esp
    PDEVICE_EXTENSION DeviceExtension;
    PHYSICAL_ADDRESS BaseAddress;
    NTSTATUS Status;
    unsigned int offset;
    BYTE data, value;

    DeviceExtension = DeviceObject->DeviceExtension;
   11009:	8b 45 08             	mov    0x8(%ebp),%eax
   1100c:	8b 75 0c             	mov    0xc(%ebp),%esi
   1100f:	8b 58 28             	mov    0x28(%eax),%ebx

    /* disable interrupts */
    __asm__("cli\n\t");
   11012:	fa                   	cli    

    /* get current output position */
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
   11013:	6a 0f                	push   $0xf
   11015:	68 d4 03 00 00       	push   $0x3d4
   1101a:	e8 61 0d 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    offset = READ_PORT_UCHAR (CRTC_DATA);
   1101f:	50                   	push   %eax
   11020:	68 d5 03 00 00       	push   $0x3d5
   11025:	e8 66 0d 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
   1102a:	c7 04 24 0e 00 00 00 	movl   $0xe,(%esp)
   11031:	68 d4 03 00 00       	push   $0x3d4
   11036:	e8 45 0d 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    offset += (READ_PORT_UCHAR (CRTC_DATA) << 8);
   1103b:	50                   	push   %eax
   1103c:	68 d5 03 00 00       	push   $0x3d5
   11041:	e8 4a 0d 00 00       	call   11d90 <_READ_PORT_UCHAR@4>

    /* switch blinking characters off */
    READ_PORT_UCHAR (ATTRC_INPST1);
   11046:	68 da 03 00 00       	push   $0x3da
   1104b:	e8 40 0d 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
    value = READ_PORT_UCHAR (ATTRC_WRITEREG);
   11050:	68 c0 03 00 00       	push   $0x3c0
   11055:	e8 36 0d 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
   1105a:	89 c7                	mov    %eax,%edi
    WRITE_PORT_UCHAR (ATTRC_WRITEREG, 0x10);
   1105c:	c7 04 24 10 00 00 00 	movl   $0x10,(%esp)
   11063:	68 c0 03 00 00       	push   $0x3c0
   11068:	e8 13 0d 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    data  = READ_PORT_UCHAR (ATTRC_READREG);
   1106d:	50                   	push   %eax
   1106e:	68 c1 03 00 00       	push   $0x3c1
   11073:	e8 18 0d 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
    data  = data & ~0x08;
    WRITE_PORT_UCHAR (ATTRC_WRITEREG, data);
   11078:	25 f7 00 00 00       	and    $0xf7,%eax
   1107d:	89 04 24             	mov    %eax,(%esp)
   11080:	68 c0 03 00 00       	push   $0x3c0
   11085:	e8 f6 0c 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    WRITE_PORT_UCHAR (ATTRC_WRITEREG, value);
   1108a:	89 f8                	mov    %edi,%eax
   1108c:	25 ff 00 00 00       	and    $0xff,%eax
   11091:	50                   	push   %eax
   11092:	68 c0 03 00 00       	push   $0x3c0
   11097:	e8 e4 0c 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    READ_PORT_UCHAR (ATTRC_INPST1);
   1109c:	50                   	push   %eax
   1109d:	68 da 03 00 00       	push   $0x3da
   110a2:	e8 e9 0c 00 00       	call   11d90 <_READ_PORT_UCHAR@4>

    /* read screen information from crt controller */
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_COLUMNS);
   110a7:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
   110ae:	68 d4 03 00 00       	push   $0x3d4
   110b3:	e8 c8 0c 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    DeviceExtension->Columns = READ_PORT_UCHAR (CRTC_DATA) + 1;
   110b8:	50                   	push   %eax
   110b9:	68 d5 03 00 00       	push   $0x3d5
   110be:	e8 cd 0c 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
   110c3:	25 ff 00 00 00       	and    $0xff,%eax
   110c8:	40                   	inc    %eax
   110c9:	66 89 43 18          	mov    %ax,0x18(%ebx)
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_ROWS);
   110cd:	c7 04 24 12 00 00 00 	movl   $0x12,(%esp)
   110d4:	68 d4 03 00 00       	push   $0x3d4
   110d9:	e8 a2 0c 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    DeviceExtension->Rows = READ_PORT_UCHAR (CRTC_DATA);
   110de:	50                   	push   %eax
   110df:	68 d5 03 00 00       	push   $0x3d5
   110e4:	e8 a7 0c 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
   110e9:	25 ff 00 00 00       	and    $0xff,%eax
   110ee:	66 89 43 16          	mov    %ax,0x16(%ebx)
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_OVERFLOW);
   110f2:	c7 04 24 07 00 00 00 	movl   $0x7,(%esp)
   110f9:	68 d4 03 00 00       	push   $0x3d4
   110fe:	e8 7d 0c 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    data = READ_PORT_UCHAR (CRTC_DATA);
   11103:	57                   	push   %edi
   11104:	68 d5 03 00 00       	push   $0x3d5
   11109:	e8 82 0c 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
    DeviceExtension->Rows |= (((data & 0x02) << 7) | ((data & 0x40) << 3));
   1110e:	31 d2                	xor    %edx,%edx
   11110:	88 c2                	mov    %al,%dl
   11112:	89 d0                	mov    %edx,%eax
   11114:	83 e2 40             	and    $0x40,%edx
   11117:	c1 e2 03             	shl    $0x3,%edx
   1111a:	83 e0 02             	and    $0x2,%eax
   1111d:	c1 e0 07             	shl    $0x7,%eax
   11120:	09 d0                	or     %edx,%eax
   11122:	66 0b 43 16          	or     0x16(%ebx),%ax
    DeviceExtension->Rows++;
   11126:	40                   	inc    %eax
   11127:	66 89 43 16          	mov    %ax,0x16(%ebx)
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_SCANLINES);
   1112b:	c7 04 24 09 00 00 00 	movl   $0x9,(%esp)
   11132:	68 d4 03 00 00       	push   $0x3d4
   11137:	e8 44 0c 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    DeviceExtension->ScanLines = (READ_PORT_UCHAR (CRTC_DATA) & 0x1F) + 1;
   1113c:	51                   	push   %ecx
   1113d:	68 d5 03 00 00       	push   $0x3d5
   11142:	e8 49 0c 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
   11147:	83 e0 1f             	and    $0x1f,%eax
   1114a:	40                   	inc    %eax
   1114b:	88 43 14             	mov    %al,0x14(%ebx)

    /* enable interrupts */
    __asm__("sti\n\t");
   1114e:	fb                   	sti    

    /* calculate number of text rows */
    DeviceExtension->Rows =
   1114f:	66 8b 53 16          	mov    0x16(%ebx),%dx
   11153:	25 ff 00 00 00       	and    $0xff,%eax
   11158:	81 e2 ff ff 00 00    	and    $0xffff,%edx
        DeviceExtension->Rows / DeviceExtension->ScanLines;
#ifdef BOCHS_30ROWS
    DeviceExtension->Rows = 30;
#endif

    DPRINT ("%d Columns  %d Rows %d Scanlines\n",
            DeviceExtension->Columns,
            DeviceExtension->Rows,
            DeviceExtension->ScanLines);

    /* get pointer to video memory */
    BaseAddress.QuadPart = VIDMEM_BASE;
    DeviceExtension->VideoMemory =
   1115e:	83 c4 0c             	add    $0xc,%esp
   11161:	89 c1                	mov    %eax,%ecx
   11163:	89 d0                	mov    %edx,%eax
   11165:	c1 fa 1f             	sar    $0x1f,%edx
   11168:	f7 f9                	idiv   %ecx
   1116a:	66 89 43 16          	mov    %ax,0x16(%ebx)
   1116e:	6a 00                	push   $0x0
   11170:	66 8b 43 16          	mov    0x16(%ebx),%ax
   11174:	66 8b 53 18          	mov    0x18(%ebx),%dx
   11178:	81 e2 ff ff 00 00    	and    $0xffff,%edx
   1117e:	25 ff ff 00 00       	and    $0xffff,%eax
   11183:	0f af c2             	imul   %edx,%eax
   11186:	01 c0                	add    %eax,%eax
   11188:	50                   	push   %eax
   11189:	6a 00                	push   $0x0
   1118b:	68 00 80 0b 00       	push   $0xb8000
   11190:	e8 8b 0b 00 00       	call   11d20 <_MmMapIoSpace@16>
        (PBYTE)MmMapIoSpace (BaseAddress, DeviceExtension->Rows * DeviceExtension->Columns * 2, MmNonCached);

    DeviceExtension->CursorSize    = 5; /* FIXME: value correct?? */
   11195:	c7 43 04 05 00 00 00 	movl   $0x5,0x4(%ebx)
    DeviceExtension->CursorVisible = TRUE;
   1119c:	c7 43 08 01 00 00 00 	movl   $0x1,0x8(%ebx)
   111a3:	89 03                	mov    %eax,(%ebx)

    /* more initialization */
    DeviceExtension->CharAttribute = 0x17;  /* light grey on blue */
   111a5:	66 c7 43 0c 17 00    	movw   $0x17,0xc(%ebx)
    DeviceExtension->Mode = ENABLE_PROCESSED_OUTPUT |
   111ab:	c7 43 10 03 00 00 00 	movl   $0x3,0x10(%ebx)
                            ENABLE_WRAP_AT_EOL_OUTPUT;

    /* show blinking cursor */
    __asm__("cli\n\t");
   111b2:	fa                   	cli    
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORSTART);
   111b3:	52                   	push   %edx
   111b4:	52                   	push   %edx
   111b5:	6a 0a                	push   $0xa
   111b7:	68 d4 03 00 00       	push   $0x3d4
   111bc:	e8 bf 0b 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    WRITE_PORT_UCHAR (CRTC_DATA, (DeviceExtension->ScanLines - 1) & 0x1F);
   111c1:	8a 43 14             	mov    0x14(%ebx),%al
   111c4:	48                   	dec    %eax
   111c5:	83 e0 1f             	and    $0x1f,%eax
   111c8:	50                   	push   %eax
   111c9:	68 d5 03 00 00       	push   $0x3d5
   111ce:	e8 ad 0b 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSOREND);
   111d3:	6a 0b                	push   $0xb
   111d5:	68 d4 03 00 00       	push   $0x3d4
   111da:	e8 a1 0b 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
    data = READ_PORT_UCHAR (CRTC_DATA) & 0xE0;
   111df:	50                   	push   %eax
   111e0:	68 d5 03 00 00       	push   $0x3d5
   111e5:	e8 a6 0b 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
    WRITE_PORT_UCHAR (CRTC_DATA,
   111ea:	8a 53 14             	mov    0x14(%ebx),%dl
   111ed:	4a                   	dec    %edx
   111ee:	83 e0 e0             	and    $0xffffffe0,%eax
   111f1:	83 e2 1f             	and    $0x1f,%edx
   111f4:	09 c2                	or     %eax,%edx
   111f6:	81 e2 ff 00 00 00    	and    $0xff,%edx
   111fc:	89 14 24             	mov    %edx,(%esp)
   111ff:	68 d5 03 00 00       	push   $0x3d5
   11204:	e8 77 0b 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
                      data | ((DeviceExtension->ScanLines - 1) & 0x1F));
    __asm__("sti\n\t");
   11209:	fb                   	sti    

    Status = STATUS_SUCCESS;

    Irp->IoStatus.Status = Status;
   1120a:	c7 46 18 00 00 00 00 	movl   $0x0,0x18(%esi)
    IoCompleteRequest (Irp, IO_NO_INCREMENT);
   11211:	6a 00                	push   $0x0
   11213:	56                   	push   %esi
   11214:	e8 17 0b 00 00       	call   11d30 <_IoCompleteRequest@8>

    return (Status);
}
   11219:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1121c:	31 c0                	xor    %eax,%eax
   1121e:	5b                   	pop    %ebx
   1121f:	5e                   	pop    %esi
   11220:	5f                   	pop    %edi
   11221:	5d                   	pop    %ebp
   11222:	c2 08 00             	ret    $0x8
   11225:	8d 74 26 00          	lea    0x0(%esi),%esi
   11229:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011230 <_ScrWrite@8>:


NTSTATUS STDCALL
ScrWrite(PDEVICE_OBJECT DeviceObject,
	 PIRP Irp)
{
   11230:	55                   	push   %ebp
   11231:	89 e5                	mov    %esp,%ebp
   11233:	57                   	push   %edi
   11234:	56                   	push   %esi
   11235:	53                   	push   %ebx
   11236:	83 ec 3c             	sub    $0x3c,%esp
    PIO_STACK_LOCATION stk = IoGetCurrentIrpStackLocation (Irp);
   11239:	8b 45 0c             	mov    0xc(%ebp),%eax
    PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    NTSTATUS Status;
    char *pch = Irp->UserBuffer;
   1123c:	8b 55 0c             	mov    0xc(%ebp),%edx
   1123f:	8b 40 60             	mov    0x60(%eax),%eax
   11242:	8b 52 3c             	mov    0x3c(%edx),%edx
   11245:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   11248:	8b 45 08             	mov    0x8(%ebp),%eax
   1124b:	89 55 e8             	mov    %edx,0xffffffe8(%ebp)
   1124e:	8b 40 28             	mov    0x28(%eax),%eax
   11251:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
    PBYTE vidmem;
    int i, j, offset;
    int cursorx, cursory;
    int rows, columns;
    int processed = DeviceExtension->Mode & ENABLE_PROCESSED_OUTPUT;
   11254:	8b 48 10             	mov    0x10(%eax),%ecx
   11257:	83 e1 01             	and    $0x1,%ecx
   1125a:	89 4d d4             	mov    %ecx,0xffffffd4(%ebp)

    if (HalQueryDisplayOwnership())
   1125d:	e8 3e 0b 00 00       	call   11da0 <_HalQueryDisplayOwnership@0>
   11262:	84 c0                	test   %al,%al
   11264:	74 20                	je     11286 <_ScrWrite@8+0x56>
       {
	  /* Display is in graphics mode, we're not allowed to touch it */
	  Status = STATUS_SUCCESS;

	  Irp->IoStatus.Status = Status;
   11266:	8b 75 0c             	mov    0xc(%ebp),%esi
   11269:	c7 46 18 00 00 00 00 	movl   $0x0,0x18(%esi)
	  IoCompleteRequest (Irp, IO_NO_INCREMENT);
   11270:	57                   	push   %edi
   11271:	57                   	push   %edi
   11272:	6a 00                	push   $0x0
   11274:	56                   	push   %esi
   11275:	e8 b6 0a 00 00       	call   11d30 <_IoCompleteRequest@8>

	  return Status;
       }

    vidmem  = DeviceExtension->VideoMemory;
    rows = DeviceExtension->Rows;
    columns = DeviceExtension->Columns;

    __asm__ ("cli\n\t");
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
    offset = READ_PORT_UCHAR (CRTC_DATA)<<8;
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
    offset += READ_PORT_UCHAR (CRTC_DATA);
    __asm__ ("sti\n\t");

    cursory = offset / columns;
    cursorx = offset % columns;
    if( processed == 0 )
       {
	  /* raw output mode */
	  memcpy( &vidmem[(cursorx * 2) + (cursory * columns * 2)], pch, stk->Parameters.Write.Length );
	  offset += (stk->Parameters.Write.Length / 2);
       }
    else {
       for (i = 0; i < stk->Parameters.Write.Length; i++, pch++)
	  {
	     switch (*pch)
		{
		case '\b':
		   if (cursorx > 0)
		      {
			 cursorx--;
		      }
		   else if (cursory > 0)
		      {
			 cursorx = columns - 1;
			 cursory--;
		      }
		   vidmem[(cursorx * 2) + (cursory * columns * 2)] = ' ';
		   vidmem[(cursorx * 2) + (cursory * columns * 2) + 1] = (char) DeviceExtension->CharAttribute;
		   break;
		   
		case '\n':
		   cursory++;
		   cursorx = 0;
		   break;
		   
		case '\r':
		   cursorx = 0;
		   break;
		   
		case '\t':
		   offset = TAB_WIDTH - (cursorx % TAB_WIDTH);
		   for (j = 0; j < offset; j++)
		      {
			 vidmem[(cursorx * 2) + (cursory * columns * 2)] = ' ';
			 cursorx++;
			 
			 if (cursorx >= columns)
			    {
			       cursory++;
			       cursorx = 0;
			    }
		      }
		   break;
		   
		default:
		   vidmem[(cursorx * 2) + (cursory * columns * 2)] = *pch;
		   vidmem[(cursorx * 2) + (cursory * columns * 2) + 1] = (char) DeviceExtension->CharAttribute;
		   cursorx++;
		   if (cursorx >= columns)
		      {
			 cursory++;
			 cursorx = 0;
		      }
		   break;
		}
	     if (cursory >= rows)
		{
		   unsigned short *LinePtr;

		   memcpy (vidmem,
			   &vidmem[columns * 2],
			   columns * (rows - 1) * 2);

		   LinePtr = (unsigned short *) &vidmem[columns * (rows - 1) * 2];

		   for (j = 0; j < columns; j++)
		      {
			 LinePtr[j] = DeviceExtension->CharAttribute << 8;
		      }
		   cursory = rows - 1;
		   for (j = 0; j < columns; j++)
		      {
			 vidmem[(j * 2) + (cursory * columns * 2)] = ' ';
			 vidmem[(j * 2) + (cursory * columns * 2) + 1] = (char)DeviceExtension->CharAttribute;
		      }
		}
	  }
       
       /* Set the cursor position */
       offset = (cursory * columns) + cursorx;
    }
    __asm__ ("cli\n\t");
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
    WRITE_PORT_UCHAR (CRTC_DATA, offset);
    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
    offset >>= 8;
    WRITE_PORT_UCHAR (CRTC_DATA, offset);
    __asm__ ("sti\n\t");

    Status = STATUS_SUCCESS;

    Irp->IoStatus.Status = Status;
    IoCompleteRequest (Irp, IO_NO_INCREMENT);

    return (Status);
}
   1127a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1127d:	31 c0                	xor    %eax,%eax
   1127f:	5b                   	pop    %ebx
   11280:	5e                   	pop    %esi
   11281:	5f                   	pop    %edi
   11282:	5d                   	pop    %ebp
   11283:	c2 08 00             	ret    $0x8
   11286:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11289:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   1128c:	8b 00                	mov    (%eax),%eax
   1128e:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   11291:	66 8b 42 16          	mov    0x16(%edx),%ax
   11295:	25 ff ff 00 00       	and    $0xffff,%eax
   1129a:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   1129d:	66 8b 42 18          	mov    0x18(%edx),%ax
   112a1:	89 c7                	mov    %eax,%edi
   112a3:	81 e7 ff ff 00 00    	and    $0xffff,%edi
   112a9:	fa                   	cli    
   112aa:	56                   	push   %esi
   112ab:	56                   	push   %esi
   112ac:	6a 0e                	push   $0xe
   112ae:	68 d4 03 00 00       	push   $0x3d4
   112b3:	e8 c8 0a 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   112b8:	53                   	push   %ebx
   112b9:	68 d5 03 00 00       	push   $0x3d5
   112be:	e8 cd 0a 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
   112c3:	25 ff 00 00 00       	and    $0xff,%eax
   112c8:	c7 04 24 0f 00 00 00 	movl   $0xf,(%esp)
   112cf:	89 c6                	mov    %eax,%esi
   112d1:	c1 e6 08             	shl    $0x8,%esi
   112d4:	68 d4 03 00 00       	push   $0x3d4
   112d9:	e8 a2 0a 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   112de:	51                   	push   %ecx
   112df:	68 d5 03 00 00       	push   $0x3d5
   112e4:	e8 a7 0a 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
   112e9:	25 ff 00 00 00       	and    $0xff,%eax
   112ee:	01 c6                	add    %eax,%esi
   112f0:	fb                   	sti    
   112f1:	89 f2                	mov    %esi,%edx
   112f3:	89 f0                	mov    %esi,%eax
   112f5:	c1 fa 1f             	sar    $0x1f,%edx
   112f8:	83 c4 0c             	add    $0xc,%esp
   112fb:	f7 ff                	idiv   %edi
   112fd:	89 d3                	mov    %edx,%ebx
   112ff:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
   11302:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   11305:	85 d2                	test   %edx,%edx
   11307:	0f 84 0a 02 00 00    	je     11517 <_ScrWrite@8+0x2e7>
   1130d:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
   11310:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
   11317:	31 c0                	xor    %eax,%eax
   11319:	3b 46 04             	cmp    0x4(%esi),%eax
   1131c:	0f 83 8e 00 00 00    	jae    113b0 <_ScrWrite@8+0x180>
   11322:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   11325:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   11328:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   1132b:	8d 54 12 fe          	lea    0xfffffffe(%edx,%edx,1),%edx
   1132f:	8d 0c 79             	lea    (%ecx,%edi,2),%ecx
   11332:	0f af d7             	imul   %edi,%edx
   11335:	89 55 d0             	mov    %edx,0xffffffd0(%ebp)
   11338:	01 c2                	add    %eax,%edx
   1133a:	89 55 c8             	mov    %edx,0xffffffc8(%ebp)
   1133d:	89 4d cc             	mov    %ecx,0xffffffcc(%ebp)
   11340:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
   11343:	8a 16                	mov    (%esi),%dl
   11345:	0f be c2             	movsbl %dl,%eax
   11348:	83 f8 09             	cmp    $0x9,%eax
   1134b:	0f 84 54 01 00 00    	je     114a5 <_ScrWrite@8+0x275>
   11351:	0f 8f c9 00 00 00    	jg     11420 <_ScrWrite@8+0x1f0>
   11357:	83 f8 08             	cmp    $0x8,%eax
   1135a:	0f 84 92 01 00 00    	je     114f2 <_ScrWrite@8+0x2c2>
   11360:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   11363:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   11366:	0f af c7             	imul   %edi,%eax
   11369:	8d 04 03             	lea    (%ebx,%eax,1),%eax
   1136c:	43                   	inc    %ebx
   1136d:	39 fb                	cmp    %edi,%ebx
   1136f:	88 14 41             	mov    %dl,(%ecx,%eax,2)
   11372:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
   11375:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   11378:	66 8b 4e 0c          	mov    0xc(%esi),%cx
   1137c:	88 4c 42 01          	mov    %cl,0x1(%edx,%eax,2)
   11380:	7c 09                	jl     1138b <_ScrWrite@8+0x15b>
   11382:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   11385:	40                   	inc    %eax
   11386:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   11389:	31 db                	xor    %ebx,%ebx
   1138b:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
   1138e:	39 4d dc             	cmp    %ecx,0xffffffdc(%ebp)
   11391:	0f 8d a0 00 00 00    	jge    11437 <_ScrWrite@8+0x207>
   11397:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   1139a:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
   1139d:	40                   	inc    %eax
   1139e:	46                   	inc    %esi
   1139f:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   113a2:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   113a5:	89 75 e8             	mov    %esi,0xffffffe8(%ebp)
   113a8:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
   113ab:	3b 50 04             	cmp    0x4(%eax),%edx
   113ae:	72 90                	jb     11340 <_ScrWrite@8+0x110>
   113b0:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx
   113b3:	0f af f9             	imul   %ecx,%edi
   113b6:	89 fe                	mov    %edi,%esi
   113b8:	89 7d dc             	mov    %edi,0xffffffdc(%ebp)
   113bb:	01 de                	add    %ebx,%esi
   113bd:	fa                   	cli    
   113be:	52                   	push   %edx
   113bf:	52                   	push   %edx
   113c0:	6a 0f                	push   $0xf
   113c2:	68 d4 03 00 00       	push   $0x3d4
   113c7:	e8 b4 09 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   113cc:	89 f0                	mov    %esi,%eax
   113ce:	25 ff 00 00 00       	and    $0xff,%eax
   113d3:	50                   	push   %eax
   113d4:	68 d5 03 00 00       	push   $0x3d5
   113d9:	e8 a2 09 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   113de:	6a 0e                	push   $0xe
   113e0:	68 d4 03 00 00       	push   $0x3d4
   113e5:	e8 96 09 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   113ea:	89 f1                	mov    %esi,%ecx
   113ec:	0f b6 c5             	movzbl %ch,%eax
   113ef:	50                   	push   %eax
   113f0:	68 d5 03 00 00       	push   $0x3d5
   113f5:	e8 86 09 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   113fa:	fb                   	sti    
   113fb:	8b 75 0c             	mov    0xc(%ebp),%esi
   113fe:	c7 46 18 00 00 00 00 	movl   $0x0,0x18(%esi)
   11405:	6a 00                	push   $0x0
   11407:	56                   	push   %esi
   11408:	e8 23 09 00 00       	call   11d30 <_IoCompleteRequest@8>
   1140d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11410:	31 c0                	xor    %eax,%eax
   11412:	5b                   	pop    %ebx
   11413:	5e                   	pop    %esi
   11414:	5f                   	pop    %edi
   11415:	5d                   	pop    %ebp
   11416:	c2 08 00             	ret    $0x8
   11419:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11420:	83 f8 0a             	cmp    $0xa,%eax
   11423:	0f 84 59 ff ff ff    	je     11382 <_ScrWrite@8+0x152>
   11429:	83 f8 0d             	cmp    $0xd,%eax
   1142c:	0f 85 2e ff ff ff    	jne    11360 <_ScrWrite@8+0x130>
   11432:	e9 52 ff ff ff       	jmp    11389 <_ScrWrite@8+0x159>
   11437:	50                   	push   %eax
   11438:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
   1143b:	50                   	push   %eax
   1143c:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
   1143f:	50                   	push   %eax
   11440:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11443:	50                   	push   %eax
   11444:	e8 27 09 00 00       	call   11d70 <_memcpy>
   11449:	31 d2                	xor    %edx,%edx
   1144b:	83 c4 10             	add    $0x10,%esp
   1144e:	eb 12                	jmp    11462 <_ScrWrite@8+0x232>
   11450:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
   11453:	8b 4d c8             	mov    0xffffffc8(%ebp),%ecx
   11456:	66 8b 46 0c          	mov    0xc(%esi),%ax
   1145a:	c1 e0 08             	shl    $0x8,%eax
   1145d:	66 89 04 51          	mov    %ax,(%ecx,%edx,2)
   11461:	42                   	inc    %edx
   11462:	39 fa                	cmp    %edi,%edx
   11464:	7c ea                	jl     11450 <_ScrWrite@8+0x220>
   11466:	8b 75 d8             	mov    0xffffffd8(%ebp),%esi
   11469:	31 d2                	xor    %edx,%edx
   1146b:	4e                   	dec    %esi
   1146c:	39 fa                	cmp    %edi,%edx
   1146e:	89 75 dc             	mov    %esi,0xffffffdc(%ebp)
   11471:	0f 8d 20 ff ff ff    	jge    11397 <_ScrWrite@8+0x167>
   11477:	0f af f7             	imul   %edi,%esi
   1147a:	89 75 c4             	mov    %esi,0xffffffc4(%ebp)
   1147d:	8d 76 00             	lea    0x0(%esi),%esi
   11480:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
   11483:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
   11486:	8d 0c 02             	lea    (%edx,%eax,1),%ecx
   11489:	42                   	inc    %edx
   1148a:	39 fa                	cmp    %edi,%edx
   1148c:	c6 04 4e 20          	movb   $0x20,(%esi,%ecx,2)
   11490:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
   11493:	66 8b 46 0c          	mov    0xc(%esi),%ax
   11497:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
   1149a:	88 44 4e 01          	mov    %al,0x1(%esi,%ecx,2)
   1149e:	7c e0                	jl     11480 <_ScrWrite@8+0x250>
   114a0:	e9 f2 fe ff ff       	jmp    11397 <_ScrWrite@8+0x167>
   114a5:	89 d8                	mov    %ebx,%eax
   114a7:	85 db                	test   %ebx,%ebx
   114a9:	0f 88 9b 00 00 00    	js     1154a <_ScrWrite@8+0x31a>
   114af:	83 e0 f8             	and    $0xfffffff8,%eax
   114b2:	89 da                	mov    %ebx,%edx
   114b4:	29 c2                	sub    %eax,%edx
   114b6:	be 08 00 00 00       	mov    $0x8,%esi
   114bb:	29 d6                	sub    %edx,%esi
   114bd:	85 f6                	test   %esi,%esi
   114bf:	0f 8e c6 fe ff ff    	jle    1138b <_ScrWrite@8+0x15b>
   114c5:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx
   114c8:	89 f2                	mov    %esi,%edx
   114ca:	0f af cf             	imul   %edi,%ecx
   114cd:	8d 76 00             	lea    0x0(%esi),%esi
   114d0:	8d 04 0b             	lea    (%ebx,%ecx,1),%eax
   114d3:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
   114d6:	43                   	inc    %ebx
   114d7:	c6 04 46 20          	movb   $0x20,(%esi,%eax,2)
   114db:	39 fb                	cmp    %edi,%ebx
   114dd:	7c 0b                	jl     114ea <_ScrWrite@8+0x2ba>
   114df:	8b 5d dc             	mov    0xffffffdc(%ebp),%ebx
   114e2:	01 f9                	add    %edi,%ecx
   114e4:	43                   	inc    %ebx
   114e5:	89 5d dc             	mov    %ebx,0xffffffdc(%ebp)
   114e8:	31 db                	xor    %ebx,%ebx
   114ea:	4a                   	dec    %edx
   114eb:	75 e3                	jne    114d0 <_ScrWrite@8+0x2a0>
   114ed:	e9 99 fe ff ff       	jmp    1138b <_ScrWrite@8+0x15b>
   114f2:	85 db                	test   %ebx,%ebx
   114f4:	7e 5c                	jle    11552 <_ScrWrite@8+0x322>
   114f6:	4b                   	dec    %ebx
   114f7:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   114fa:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   114fd:	0f af c7             	imul   %edi,%eax
   11500:	8d 04 03             	lea    (%ebx,%eax,1),%eax
   11503:	c6 04 42 20          	movb   $0x20,(%edx,%eax,2)
   11507:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
   1150a:	66 8b 4e 0c          	mov    0xc(%esi),%cx
   1150e:	88 4c 42 01          	mov    %cl,0x1(%edx,%eax,2)
   11512:	e9 74 fe ff ff       	jmp    1138b <_ScrWrite@8+0x15b>
   11517:	0f af f8             	imul   %eax,%edi
   1151a:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   1151d:	89 7d dc             	mov    %edi,0xffffffdc(%ebp)
   11520:	8d 04 3b             	lea    (%ebx,%edi,1),%eax
   11523:	53                   	push   %ebx
   11524:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   11527:	8d 04 41             	lea    (%ecx,%eax,2),%eax
   1152a:	8b 4a 04             	mov    0x4(%edx),%ecx
   1152d:	51                   	push   %ecx
   1152e:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   11531:	52                   	push   %edx
   11532:	50                   	push   %eax
   11533:	e8 38 08 00 00       	call   11d70 <_memcpy>
   11538:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   1153b:	8b 41 04             	mov    0x4(%ecx),%eax
   1153e:	83 c4 10             	add    $0x10,%esp
   11541:	d1 e8                	shr    %eax
   11543:	01 c6                	add    %eax,%esi
   11545:	e9 73 fe ff ff       	jmp    113bd <_ScrWrite@8+0x18d>
   1154a:	8d 43 07             	lea    0x7(%ebx),%eax
   1154d:	e9 5d ff ff ff       	jmp    114af <_ScrWrite@8+0x27f>
   11552:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   11555:	85 c0                	test   %eax,%eax
   11557:	7e 9e                	jle    114f7 <_ScrWrite@8+0x2c7>
   11559:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
   1155c:	8d 5f ff             	lea    0xffffffff(%edi),%ebx
   1155f:	4e                   	dec    %esi
   11560:	89 75 dc             	mov    %esi,0xffffffdc(%ebp)
   11563:	eb 92                	jmp    114f7 <_ScrWrite@8+0x2c7>
   11565:	8d 74 26 00          	lea    0x0(%esi),%esi
   11569:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011570 <_ScrIoControl@8>:


NTSTATUS STDCALL
ScrIoControl(PDEVICE_OBJECT DeviceObject,
	     PIRP Irp)
{
   11570:	55                   	push   %ebp
   11571:	89 e5                	mov    %esp,%ebp
   11573:	57                   	push   %edi
   11574:	56                   	push   %esi
   11575:	53                   	push   %ebx
   11576:	83 ec 3c             	sub    $0x3c,%esp
  PIO_STACK_LOCATION stk = IoGetCurrentIrpStackLocation (Irp);
   11579:	8b 45 0c             	mov    0xc(%ebp),%eax
   1157c:	8b 70 60             	mov    0x60(%eax),%esi
  PDEVICE_EXTENSION DeviceExtension;
  NTSTATUS Status;

  DeviceExtension = DeviceObject->DeviceExtension;
   1157f:	8b 45 08             	mov    0x8(%ebp),%eax
   11582:	8b 78 28             	mov    0x28(%eax),%edi
  switch (stk->Parameters.DeviceIoControl.IoControlCode)
   11585:	8b 46 0c             	mov    0xc(%esi),%eax
   11588:	3d 14 60 1c 00       	cmp    $0x1c6014,%eax
   1158d:	0f 84 ed 00 00 00    	je     11680 <_ScrIoControl@8+0x110>
   11593:	77 4e                	ja     115e3 <_ScrIoControl@8+0x73>
   11595:	3d 86 20 1c 00       	cmp    $0x1c2086,%eax
   1159a:	0f 84 c5 02 00 00    	je     11865 <_ScrIoControl@8+0x2f5>
   115a0:	0f 86 0d 01 00 00    	jbe    116b3 <_ScrIoControl@8+0x143>
   115a6:	3d 04 60 1c 00       	cmp    $0x1c6004,%eax
   115ab:	0f 84 91 05 00 00    	je     11b42 <_ScrIoControl@8+0x5d2>
   115b1:	0f 87 1f 03 00 00    	ja     118d6 <_ScrIoControl@8+0x366>
   115b7:	3d 89 20 1c 00       	cmp    $0x1c2089,%eax
   115bc:	0f 84 b3 03 00 00    	je     11975 <_ScrIoControl@8+0x405>
    {
      case IOCTL_CONSOLE_GET_SCREEN_BUFFER_INFO:
        {
          PCONSOLE_SCREEN_BUFFER_INFO pcsbi = (PCONSOLE_SCREEN_BUFFER_INFO)Irp->AssociatedIrp.SystemBuffer;
          int rows = DeviceExtension->Rows;
          int columns = DeviceExtension->Columns;
          unsigned int offset;

          /* read cursor position from crtc */
          __asm__("cli\n\t");
          WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
          offset = READ_PORT_UCHAR (CRTC_DATA);
          WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
          offset += (READ_PORT_UCHAR (CRTC_DATA) << 8);
          __asm__("sti\n\t");

          pcsbi->dwSize.X = columns;
          pcsbi->dwSize.Y = rows;

          pcsbi->dwCursorPosition.X = (SHORT)(offset % columns);
          pcsbi->dwCursorPosition.Y = (SHORT)(offset / columns);

          pcsbi->wAttributes = DeviceExtension->CharAttribute;

          pcsbi->srWindow.Left   = 0;
          pcsbi->srWindow.Right  = columns - 1;
          pcsbi->srWindow.Top    = 0;
          pcsbi->srWindow.Bottom = rows - 1;

          pcsbi->dwMaximumWindowSize.X = columns;
          pcsbi->dwMaximumWindowSize.Y = rows;

          Irp->IoStatus.Information = sizeof (CONSOLE_SCREEN_BUFFER_INFO);
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_SET_SCREEN_BUFFER_INFO:
        {
          PCONSOLE_SCREEN_BUFFER_INFO pcsbi = (PCONSOLE_SCREEN_BUFFER_INFO)Irp->AssociatedIrp.SystemBuffer;
          unsigned int offset;

          DeviceExtension->CharAttribute = pcsbi->wAttributes;
          offset = (pcsbi->dwCursorPosition.Y * DeviceExtension->Columns) +
                    pcsbi->dwCursorPosition.X;

          __asm__("cli\n\t");
          WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
          WRITE_PORT_UCHAR (CRTC_DATA, offset);
          WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
          WRITE_PORT_UCHAR (CRTC_DATA, offset>>8);
          __asm__("sti\n\t");

          Irp->IoStatus.Information = 0;
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_GET_CURSOR_INFO:
        {
          PCONSOLE_CURSOR_INFO pcci = (PCONSOLE_CURSOR_INFO)Irp->AssociatedIrp.SystemBuffer;

          pcci->dwSize = DeviceExtension->CursorSize;
          pcci->bVisible = DeviceExtension->CursorVisible;

          Irp->IoStatus.Information = sizeof (CONSOLE_CURSOR_INFO);
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_SET_CURSOR_INFO:
        {
          PCONSOLE_CURSOR_INFO pcci = (PCONSOLE_CURSOR_INFO)Irp->AssociatedIrp.SystemBuffer;
          BYTE data, value;
          DWORD size, height;

          DeviceExtension->CursorSize = pcci->dwSize;
          DeviceExtension->CursorVisible = pcci->bVisible;
          height = DeviceExtension->ScanLines;
          data = (pcci->bVisible) ? 0x00 : 0x20;

          size = (pcci->dwSize * height) / 100;
          if (size < 1)
            {
              size = 1;
            }

          data |= (BYTE)(height - size);

          __asm__("cli\n\t");
          WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORSTART);
          WRITE_PORT_UCHAR (CRTC_DATA, data);
          WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSOREND);
          value = READ_PORT_UCHAR (CRTC_DATA) & 0xE0;
          WRITE_PORT_UCHAR (CRTC_DATA, value | (height - 1));

          __asm__("sti\n\t");

          Irp->IoStatus.Information = 0;
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_GET_MODE:
        {
          PCONSOLE_MODE pcm = (PCONSOLE_MODE)Irp->AssociatedIrp.SystemBuffer;

          pcm->dwMode = DeviceExtension->Mode;

          Irp->IoStatus.Information = sizeof(CONSOLE_MODE);
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_SET_MODE:
        {
          PCONSOLE_MODE pcm = (PCONSOLE_MODE)Irp->AssociatedIrp.SystemBuffer;

          DeviceExtension->Mode = pcm->dwMode;

          Irp->IoStatus.Information = 0;
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_FILL_OUTPUT_ATTRIBUTE:
        {
          POUTPUT_ATTRIBUTE Buf = (POUTPUT_ATTRIBUTE)Irp->AssociatedIrp.SystemBuffer;
          PBYTE vidmem;
          int offset;
          DWORD dwCount;

          vidmem = DeviceExtension->VideoMemory;
          offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
                    (Buf->dwCoord.X * 2) + 1;

          for (dwCount = 0; dwCount < Buf->nLength; dwCount++)
            {
              vidmem[offset + (dwCount * 2)] = (char) Buf->wAttribute;
            }

          Buf->dwTransfered = Buf->nLength;
                
          Irp->IoStatus.Information = 0;
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_READ_OUTPUT_ATTRIBUTE:
        {
          POUTPUT_ATTRIBUTE Buf = (POUTPUT_ATTRIBUTE)Irp->AssociatedIrp.SystemBuffer;
          PWORD pAttr = (PWORD)MmGetSystemAddressForMdl(Irp->MdlAddress);
          PBYTE vidmem;
          int offset;
          DWORD dwCount;

          vidmem = DeviceExtension->VideoMemory;
          offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
                   (Buf->dwCoord.X * 2) + 1;

          for (dwCount = 0; dwCount < stk->Parameters.DeviceIoControl.OutputBufferLength; dwCount++, pAttr++)
            {
              *((char *) pAttr) = vidmem[offset + (dwCount * 2)];
            }

          Buf->dwTransfered = dwCount;

          Irp->IoStatus.Information = sizeof(OUTPUT_ATTRIBUTE);
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_WRITE_OUTPUT_ATTRIBUTE:
        {
          COORD *pCoord = (COORD *)MmGetSystemAddressForMdl(Irp->MdlAddress);
          CHAR *pAttr = (CHAR *)(pCoord + 1);
          PBYTE vidmem;
          int offset;
          DWORD dwCount;

          vidmem = DeviceExtension->VideoMemory;
          offset = (pCoord->Y * DeviceExtension->Columns * 2) +
                   (pCoord->X * 2) + 1;

          for (dwCount = 0; dwCount < (stk->Parameters.DeviceIoControl.OutputBufferLength - sizeof( COORD )); dwCount++, pAttr++)
            {
              vidmem[offset + (dwCount * 2)] = *pAttr;
            }
          Irp->IoStatus.Information = 0;
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_SET_TEXT_ATTRIBUTE:
        DeviceExtension->CharAttribute = (WORD)*(PWORD)Irp->AssociatedIrp.SystemBuffer;
        Irp->IoStatus.Information = 0;
        Status = STATUS_SUCCESS;
        break;

      case IOCTL_CONSOLE_FILL_OUTPUT_CHARACTER:
        {
          POUTPUT_CHARACTER Buf = (POUTPUT_CHARACTER)Irp->AssociatedIrp.SystemBuffer;
          PBYTE vidmem;
          int offset;
          DWORD dwCount;

          vidmem = DeviceExtension->VideoMemory;
          offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
                   (Buf->dwCoord.X * 2);

          CHECKPOINT

          for (dwCount = 0; dwCount < Buf->nLength; dwCount++)
            {
              vidmem[offset + (dwCount * 2)] = (char) Buf->cCharacter;
            }

          Buf->dwTransfered = Buf->nLength;

          Irp->IoStatus.Information = 0;
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_READ_OUTPUT_CHARACTER:
        {
          POUTPUT_CHARACTER Buf = (POUTPUT_CHARACTER)Irp->AssociatedIrp.SystemBuffer;
          LPSTR pChar = (LPSTR)MmGetSystemAddressForMdl(Irp->MdlAddress);
          PBYTE vidmem;
          int offset;
          DWORD dwCount;

          vidmem = DeviceExtension->VideoMemory;
          offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
                   (Buf->dwCoord.X * 2);

          for (dwCount = 0; dwCount < stk->Parameters.DeviceIoControl.OutputBufferLength; dwCount++, pChar++)
            {
              *pChar = vidmem[offset + (dwCount * 2)];
            }

          Buf->dwTransfered = dwCount;

          Irp->IoStatus.Information = sizeof(OUTPUT_ATTRIBUTE);
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_WRITE_OUTPUT_CHARACTER:
        {
          COORD *pCoord;
          LPSTR pChar;
          PBYTE vidmem;
          int offset;
          DWORD dwCount;

          pCoord = (COORD *)MmGetSystemAddressForMdl(Irp->MdlAddress);
          pChar = (CHAR *)(pCoord + 1);
          vidmem = DeviceExtension->VideoMemory;
          offset = (pCoord->Y * DeviceExtension->Columns * 2) +
                   (pCoord->X * 2);

          for (dwCount = 0; dwCount < (stk->Parameters.DeviceIoControl.OutputBufferLength - sizeof( COORD )); dwCount++, pChar++)
            {
              vidmem[offset + (dwCount * 2)] = *pChar;
            }

          Irp->IoStatus.Information = 0;
          Status = STATUS_SUCCESS;
        }
        break;

      case IOCTL_CONSOLE_DRAW:
        {
          PCONSOLE_DRAW ConsoleDraw;
          PBYTE Src, Dest;
          UINT SrcDelta, DestDelta, i, Offset;

          ConsoleDraw = (PCONSOLE_DRAW) MmGetSystemAddressForMdl(Irp->MdlAddress);
          Src = (PBYTE) (ConsoleDraw + 1);
          SrcDelta = ConsoleDraw->SizeX * 2;
          Dest = DeviceExtension->VideoMemory +
                 (ConsoleDraw->Y * DeviceExtension->Columns + ConsoleDraw->X) * 2;
          DestDelta = DeviceExtension->Columns * 2;

          for (i = 0; i < ConsoleDraw->SizeY; i++)
            {
              RtlCopyMemory(Dest, Src, SrcDelta);
              Src += SrcDelta;
              Dest += DestDelta;
            }

          Offset = (ConsoleDraw->CursorY * DeviceExtension->Columns) +
                   ConsoleDraw->CursorX;

          __asm__("cli\n\t");
          WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
          WRITE_PORT_UCHAR (CRTC_DATA, Offset);
          WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
          WRITE_PORT_UCHAR (CRTC_DATA, Offset >> 8);
          __asm__("sti\n\t");

          Irp->IoStatus.Information = 0;
          Status = STATUS_SUCCESS;
        }
        break;

      default:
        Status = STATUS_NOT_IMPLEMENTED;
    }

  Irp->IoStatus.Status = Status;
   115c2:	8b 55 0c             	mov    0xc(%ebp),%edx
   115c5:	bb 02 00 00 c0       	mov    $0xc0000002,%ebx
   115ca:	89 5a 18             	mov    %ebx,0x18(%edx)
  IoCompleteRequest (Irp, IO_NO_INCREMENT);
   115cd:	50                   	push   %eax
   115ce:	50                   	push   %eax
   115cf:	6a 00                	push   $0x0
   115d1:	52                   	push   %edx
   115d2:	e8 59 07 00 00       	call   11d30 <_IoCompleteRequest@8>

  return Status;
}
   115d7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   115da:	89 d8                	mov    %ebx,%eax
   115dc:	5b                   	pop    %ebx
   115dd:	5e                   	pop    %esi
   115de:	5f                   	pop    %edi
   115df:	5d                   	pop    %ebp
   115e0:	c2 08 00             	ret    $0x8
   115e3:	3d 40 a0 1c 00       	cmp    $0x1ca040,%eax
   115e8:	0f 84 26 02 00 00    	je     11814 <_ScrIoControl@8+0x2a4>
   115ee:	0f 87 3e 01 00 00    	ja     11732 <_ScrIoControl@8+0x1c2>
   115f4:	3d 10 a0 1c 00       	cmp    $0x1ca010,%eax
   115f9:	0f 84 d5 03 00 00    	je     119d4 <_ScrIoControl@8+0x464>
   115ff:	0f 87 f9 02 00 00    	ja     118fe <_ScrIoControl@8+0x38e>
   11605:	3d 08 a0 1c 00       	cmp    $0x1ca008,%eax
   1160a:	75 b6                	jne    115c2 <_ScrIoControl@8+0x52>
   1160c:	8b 45 0c             	mov    0xc(%ebp),%eax
   1160f:	8b 50 0c             	mov    0xc(%eax),%edx
   11612:	66 8b 42 08          	mov    0x8(%edx),%ax
   11616:	66 89 47 0c          	mov    %ax,0xc(%edi)
   1161a:	66 8b 47 18          	mov    0x18(%edi),%ax
   1161e:	0f bf 5a 06          	movswl 0x6(%edx),%ebx
   11622:	25 ff ff 00 00       	and    $0xffff,%eax
   11627:	0f af d8             	imul   %eax,%ebx
   1162a:	0f bf 42 04          	movswl 0x4(%edx),%eax
   1162e:	01 c3                	add    %eax,%ebx
   11630:	fa                   	cli    
   11631:	50                   	push   %eax
   11632:	50                   	push   %eax
   11633:	6a 0f                	push   $0xf
   11635:	68 d4 03 00 00       	push   $0x3d4
   1163a:	e8 41 07 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   1163f:	31 c0                	xor    %eax,%eax
   11641:	88 d8                	mov    %bl,%al
   11643:	50                   	push   %eax
   11644:	68 d5 03 00 00       	push   $0x3d5
   11649:	e8 32 07 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   1164e:	0f b6 df             	movzbl %bh,%ebx
   11651:	6a 0e                	push   $0xe
   11653:	68 d4 03 00 00       	push   $0x3d4
   11658:	e8 23 07 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   1165d:	53                   	push   %ebx
   1165e:	68 d5 03 00 00       	push   $0x3d5
   11663:	e8 18 07 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   11668:	fb                   	sti    
   11669:	8b 55 0c             	mov    0xc(%ebp),%edx
   1166c:	31 db                	xor    %ebx,%ebx
   1166e:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   11675:	58                   	pop    %eax
   11676:	5a                   	pop    %edx
   11677:	eb 1e                	jmp    11697 <_ScrIoControl@8+0x127>
   11679:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11680:	8b 45 0c             	mov    0xc(%ebp),%eax
   11683:	8b 50 0c             	mov    0xc(%eax),%edx
   11686:	8b 47 10             	mov    0x10(%edi),%eax
   11689:	89 02                	mov    %eax,(%edx)
   1168b:	8b 55 0c             	mov    0xc(%ebp),%edx
   1168e:	c7 42 1c 04 00 00 00 	movl   $0x4,0x1c(%edx)
   11695:	31 db                	xor    %ebx,%ebx
   11697:	8b 55 0c             	mov    0xc(%ebp),%edx
   1169a:	89 5a 18             	mov    %ebx,0x18(%edx)
   1169d:	50                   	push   %eax
   1169e:	50                   	push   %eax
   1169f:	6a 00                	push   $0x0
   116a1:	52                   	push   %edx
   116a2:	e8 89 06 00 00       	call   11d30 <_IoCompleteRequest@8>
   116a7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   116aa:	89 d8                	mov    %ebx,%eax
   116ac:	5b                   	pop    %ebx
   116ad:	5e                   	pop    %esi
   116ae:	5f                   	pop    %edi
   116af:	5d                   	pop    %ebp
   116b0:	c2 08 00             	ret    $0x8
   116b3:	3d 46 20 1c 00       	cmp    $0x1c2046,%eax
   116b8:	0f 84 09 04 00 00    	je     11ac7 <_ScrIoControl@8+0x557>
   116be:	3d 49 20 1c 00       	cmp    $0x1c2049,%eax
   116c3:	0f 85 f9 fe ff ff    	jne    115c2 <_ScrIoControl@8+0x52>
   116c9:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   116cc:	8b 53 04             	mov    0x4(%ebx),%edx
   116cf:	66 8b 42 06          	mov    0x6(%edx),%ax
   116d3:	a8 05                	test   $0x5,%al
   116d5:	0f 84 43 05 00 00    	je     11c1e <_ScrIoControl@8+0x6ae>
   116db:	8b 5a 0c             	mov    0xc(%edx),%ebx
   116de:	8b 07                	mov    (%edi),%eax
   116e0:	66 8b 57 18          	mov    0x18(%edi),%dx
   116e4:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   116e7:	81 e2 ff ff 00 00    	and    $0xffff,%edx
   116ed:	0f bf 43 02          	movswl 0x2(%ebx),%eax
   116f1:	0f af c2             	imul   %edx,%eax
   116f4:	0f bf 13             	movswl (%ebx),%edx
   116f7:	01 d0                	add    %edx,%eax
   116f9:	8d 4b 04             	lea    0x4(%ebx),%ecx
   116fc:	31 db                	xor    %ebx,%ebx
   116fe:	8d 44 00 01          	lea    0x1(%eax,%eax,1),%eax
   11702:	83 7e 04 04          	cmpl   $0x4,0x4(%esi)
   11706:	74 1b                	je     11723 <_ScrIoControl@8+0x1b3>
   11708:	8b 7d e0             	mov    0xffffffe0(%ebp),%edi
   1170b:	8d 14 38             	lea    (%eax,%edi,1),%edx
   1170e:	89 f6                	mov    %esi,%esi
   11710:	8a 01                	mov    (%ecx),%al
   11712:	43                   	inc    %ebx
   11713:	88 02                	mov    %al,(%edx)
   11715:	41                   	inc    %ecx
   11716:	8b 46 04             	mov    0x4(%esi),%eax
   11719:	83 c2 02             	add    $0x2,%edx
   1171c:	83 e8 04             	sub    $0x4,%eax
   1171f:	39 d8                	cmp    %ebx,%eax
   11721:	77 ed                	ja     11710 <_ScrIoControl@8+0x1a0>
   11723:	8b 45 0c             	mov    0xc(%ebp),%eax
   11726:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   1172d:	e9 63 ff ff ff       	jmp    11695 <_ScrIoControl@8+0x125>
   11732:	3d 80 a0 1c 00       	cmp    $0x1ca080,%eax
   11737:	0f 84 42 03 00 00    	je     11a7f <_ScrIoControl@8+0x50f>
   1173d:	0f 86 15 02 00 00    	jbe    11958 <_ScrIoControl@8+0x3e8>
   11743:	3d c1 a0 1c 00       	cmp    $0x1ca0c1,%eax
   11748:	0f 85 74 fe ff ff    	jne    115c2 <_ScrIoControl@8+0x52>
   1174e:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11751:	8b 53 04             	mov    0x4(%ebx),%edx
   11754:	66 8b 42 06          	mov    0x6(%edx),%ax
   11758:	a8 05                	test   $0x5,%al
   1175a:	0f 84 e4 04 00 00    	je     11c44 <_ScrIoControl@8+0x6d4>
   11760:	8b 52 0c             	mov    0xc(%edx),%edx
   11763:	89 55 d0             	mov    %edx,0xffffffd0(%ebp)
   11766:	8b 55 d0             	mov    0xffffffd0(%ebp),%edx
   11769:	8b 5d d0             	mov    0xffffffd0(%ebp),%ebx
   1176c:	83 c3 18             	add    $0x18,%ebx
   1176f:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
   11776:	8b 42 08             	mov    0x8(%edx),%eax
   11779:	8b 32                	mov    (%edx),%esi
   1177b:	01 c0                	add    %eax,%eax
   1177d:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
   11780:	66 8b 47 18          	mov    0x18(%edi),%ax
   11784:	89 c1                	mov    %eax,%ecx
   11786:	66 89 45 c2          	mov    %ax,0xffffffc2(%ebp)
   1178a:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
   11790:	8b 42 04             	mov    0x4(%edx),%eax
   11793:	0f af c1             	imul   %ecx,%eax
   11796:	8b 17                	mov    (%edi),%edx
   11798:	01 f0                	add    %esi,%eax
   1179a:	01 c9                	add    %ecx,%ecx
   1179c:	8d 34 42             	lea    (%edx,%eax,2),%esi
   1179f:	8b 55 d0             	mov    0xffffffd0(%ebp),%edx
   117a2:	89 4d c4             	mov    %ecx,0xffffffc4(%ebp)
   117a5:	8b 52 0c             	mov    0xc(%edx),%edx
   117a8:	85 d2                	test   %edx,%edx
   117aa:	0f 85 70 01 00 00    	jne    11920 <_ScrIoControl@8+0x3b0>
   117b0:	8b 7d d0             	mov    0xffffffd0(%ebp),%edi
   117b3:	66 8b 5d c2          	mov    0xffffffc2(%ebp),%bx
   117b7:	81 e3 ff ff 00 00    	and    $0xffff,%ebx
   117bd:	8b 47 14             	mov    0x14(%edi),%eax
   117c0:	8b 77 10             	mov    0x10(%edi),%esi
   117c3:	0f af d8             	imul   %eax,%ebx
   117c6:	01 f3                	add    %esi,%ebx
   117c8:	fa                   	cli    
   117c9:	51                   	push   %ecx
   117ca:	51                   	push   %ecx
   117cb:	6a 0f                	push   $0xf
   117cd:	68 d4 03 00 00       	push   $0x3d4
   117d2:	e8 a9 05 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   117d7:	31 c0                	xor    %eax,%eax
   117d9:	88 d8                	mov    %bl,%al
   117db:	50                   	push   %eax
   117dc:	68 d5 03 00 00       	push   $0x3d5
   117e1:	e8 9a 05 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   117e6:	0f b6 df             	movzbl %bh,%ebx
   117e9:	6a 0e                	push   $0xe
   117eb:	68 d4 03 00 00       	push   $0x3d4
   117f0:	e8 8b 05 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   117f5:	53                   	push   %ebx
   117f6:	68 d5 03 00 00       	push   $0x3d5
   117fb:	e8 80 05 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   11800:	fb                   	sti    
   11801:	8b 45 0c             	mov    0xc(%ebp),%eax
   11804:	31 db                	xor    %ebx,%ebx
   11806:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   1180d:	58                   	pop    %eax
   1180e:	5a                   	pop    %edx
   1180f:	e9 83 fe ff ff       	jmp    11697 <_ScrIoControl@8+0x127>
   11814:	8b 45 0c             	mov    0xc(%ebp),%eax
   11817:	66 8b 57 18          	mov    0x18(%edi),%dx
   1181b:	81 e2 ff ff 00 00    	and    $0xffff,%edx
   11821:	31 db                	xor    %ebx,%ebx
   11823:	8b 48 0c             	mov    0xc(%eax),%ecx
   11826:	8b 37                	mov    (%edi),%esi
   11828:	0f bf 41 0a          	movswl 0xa(%ecx),%eax
   1182c:	0f af c2             	imul   %edx,%eax
   1182f:	0f bf 51 08          	movswl 0x8(%ecx),%edx
   11833:	01 d0                	add    %edx,%eax
   11835:	8d 54 00 01          	lea    0x1(%eax,%eax,1),%edx
   11839:	8b 41 04             	mov    0x4(%ecx),%eax
   1183c:	83 f8 00             	cmp    $0x0,%eax
   1183f:	76 12                	jbe    11853 <_ScrIoControl@8+0x2e3>
   11841:	01 f2                	add    %esi,%edx
   11843:	66 8b 01             	mov    (%ecx),%ax
   11846:	43                   	inc    %ebx
   11847:	88 02                	mov    %al,(%edx)
   11849:	83 c2 02             	add    $0x2,%edx
   1184c:	8b 41 04             	mov    0x4(%ecx),%eax
   1184f:	39 d8                	cmp    %ebx,%eax
   11851:	77 f0                	ja     11843 <_ScrIoControl@8+0x2d3>
   11853:	89 41 0c             	mov    %eax,0xc(%ecx)
   11856:	8b 55 0c             	mov    0xc(%ebp),%edx
   11859:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   11860:	e9 30 fe ff ff       	jmp    11695 <_ScrIoControl@8+0x125>
   11865:	8b 45 0c             	mov    0xc(%ebp),%eax
   11868:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   1186b:	8b 50 04             	mov    0x4(%eax),%edx
   1186e:	8b 5b 0c             	mov    0xc(%ebx),%ebx
   11871:	89 5d dc             	mov    %ebx,0xffffffdc(%ebp)
   11874:	66 8b 42 06          	mov    0x6(%edx),%ax
   11878:	a8 05                	test   $0x5,%al
   1187a:	0f 84 af 02 00 00    	je     11b2f <_ScrIoControl@8+0x5bf>
   11880:	8b 4a 0c             	mov    0xc(%edx),%ecx
   11883:	8b 5d dc             	mov    0xffffffdc(%ebp),%ebx
   11886:	8b 17                	mov    (%edi),%edx
   11888:	89 55 d8             	mov    %edx,0xffffffd8(%ebp)
   1188b:	66 8b 57 18          	mov    0x18(%edi),%dx
   1188f:	0f bf 43 0a          	movswl 0xa(%ebx),%eax
   11893:	81 e2 ff ff 00 00    	and    $0xffff,%edx
   11899:	8b 7e 04             	mov    0x4(%esi),%edi
   1189c:	0f af c2             	imul   %edx,%eax
   1189f:	0f bf 53 08          	movswl 0x8(%ebx),%edx
   118a3:	01 d0                	add    %edx,%eax
   118a5:	31 db                	xor    %ebx,%ebx
   118a7:	01 c0                	add    %eax,%eax
   118a9:	85 ff                	test   %edi,%edi
   118ab:	74 14                	je     118c1 <_ScrIoControl@8+0x351>
   118ad:	8b 7d d8             	mov    0xffffffd8(%ebp),%edi
   118b0:	8d 14 38             	lea    (%eax,%edi,1),%edx
   118b3:	8a 02                	mov    (%edx),%al
   118b5:	43                   	inc    %ebx
   118b6:	88 01                	mov    %al,(%ecx)
   118b8:	83 c2 02             	add    $0x2,%edx
   118bb:	41                   	inc    %ecx
   118bc:	39 5e 04             	cmp    %ebx,0x4(%esi)
   118bf:	77 f2                	ja     118b3 <_ScrIoControl@8+0x343>
   118c1:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   118c4:	8b 55 0c             	mov    0xc(%ebp),%edx
   118c7:	89 58 0c             	mov    %ebx,0xc(%eax)
   118ca:	c7 42 1c 10 00 00 00 	movl   $0x10,0x1c(%edx)
   118d1:	e9 bf fd ff ff       	jmp    11695 <_ScrIoControl@8+0x125>
   118d6:	3d 0c 60 1c 00       	cmp    $0x1c600c,%eax
   118db:	0f 85 e1 fc ff ff    	jne    115c2 <_ScrIoControl@8+0x52>
   118e1:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   118e4:	8b 57 04             	mov    0x4(%edi),%edx
   118e7:	8b 43 0c             	mov    0xc(%ebx),%eax
   118ea:	89 10                	mov    %edx,(%eax)
   118ec:	8b 57 08             	mov    0x8(%edi),%edx
   118ef:	89 50 04             	mov    %edx,0x4(%eax)
   118f2:	c7 43 1c 08 00 00 00 	movl   $0x8,0x1c(%ebx)
   118f9:	e9 97 fd ff ff       	jmp    11695 <_ScrIoControl@8+0x125>
   118fe:	3d 18 a0 1c 00       	cmp    $0x1ca018,%eax
   11903:	0f 85 b9 fc ff ff    	jne    115c2 <_ScrIoControl@8+0x52>
   11909:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   1190c:	8b 43 0c             	mov    0xc(%ebx),%eax
   1190f:	8b 00                	mov    (%eax),%eax
   11911:	89 47 10             	mov    %eax,0x10(%edi)
   11914:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   1191b:	e9 75 fd ff ff       	jmp    11695 <_ScrIoControl@8+0x125>
   11920:	50                   	push   %eax
   11921:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
   11924:	50                   	push   %eax
   11925:	53                   	push   %ebx
   11926:	56                   	push   %esi
   11927:	e8 44 04 00 00       	call   11d70 <_memcpy>
   1192c:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
   1192f:	83 c4 10             	add    $0x10,%esp
   11932:	01 c3                	add    %eax,%ebx
   11934:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
   11937:	01 c6                	add    %eax,%esi
   11939:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
   1193c:	40                   	inc    %eax
   1193d:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   11940:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
   11943:	8b 55 cc             	mov    0xffffffcc(%ebp),%edx
   11946:	39 50 0c             	cmp    %edx,0xc(%eax)
   11949:	77 d5                	ja     11920 <_ScrIoControl@8+0x3b0>
   1194b:	66 8b 7f 18          	mov    0x18(%edi),%di
   1194f:	66 89 7d c2          	mov    %di,0xffffffc2(%ebp)
   11953:	e9 58 fe ff ff       	jmp    117b0 <_ScrIoControl@8+0x240>
   11958:	3d 4c a0 1c 00       	cmp    $0x1ca04c,%eax
   1195d:	0f 85 5f fc ff ff    	jne    115c2 <_ScrIoControl@8+0x52>
   11963:	8b 55 0c             	mov    0xc(%ebp),%edx
   11966:	8b 42 0c             	mov    0xc(%edx),%eax
   11969:	66 8b 00             	mov    (%eax),%ax
   1196c:	66 89 47 0c          	mov    %ax,0xc(%edi)
   11970:	e9 e4 fe ff ff       	jmp    11859 <_ScrIoControl@8+0x2e9>
   11975:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11978:	8b 53 04             	mov    0x4(%ebx),%edx
   1197b:	66 8b 42 06          	mov    0x6(%edx),%ax
   1197f:	a8 05                	test   $0x5,%al
   11981:	0f 84 aa 02 00 00    	je     11c31 <_ScrIoControl@8+0x6c1>
   11987:	8b 5a 0c             	mov    0xc(%edx),%ebx
   1198a:	8b 07                	mov    (%edi),%eax
   1198c:	66 8b 57 18          	mov    0x18(%edi),%dx
   11990:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   11993:	81 e2 ff ff 00 00    	and    $0xffff,%edx
   11999:	0f bf 43 02          	movswl 0x2(%ebx),%eax
   1199d:	0f af c2             	imul   %edx,%eax
   119a0:	0f bf 13             	movswl (%ebx),%edx
   119a3:	01 d0                	add    %edx,%eax
   119a5:	8d 4b 04             	lea    0x4(%ebx),%ecx
   119a8:	01 c0                	add    %eax,%eax
   119aa:	31 db                	xor    %ebx,%ebx
   119ac:	83 7e 04 04          	cmpl   $0x4,0x4(%esi)
   119b0:	0f 84 6d fd ff ff    	je     11723 <_ScrIoControl@8+0x1b3>
   119b6:	8b 7d d4             	mov    0xffffffd4(%ebp),%edi
   119b9:	8d 14 38             	lea    (%eax,%edi,1),%edx
   119bc:	8a 01                	mov    (%ecx),%al
   119be:	43                   	inc    %ebx
   119bf:	88 02                	mov    %al,(%edx)
   119c1:	41                   	inc    %ecx
   119c2:	8b 46 04             	mov    0x4(%esi),%eax
   119c5:	83 c2 02             	add    $0x2,%edx
   119c8:	83 e8 04             	sub    $0x4,%eax
   119cb:	39 d8                	cmp    %ebx,%eax
   119cd:	77 ed                	ja     119bc <_ScrIoControl@8+0x44c>
   119cf:	e9 4f fd ff ff       	jmp    11723 <_ScrIoControl@8+0x1b3>
   119d4:	8b 45 0c             	mov    0xc(%ebp),%eax
   119d7:	8a 5f 14             	mov    0x14(%edi),%bl
   119da:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   119e0:	8b 50 0c             	mov    0xc(%eax),%edx
   119e3:	89 de                	mov    %ebx,%esi
   119e5:	8b 02                	mov    (%edx),%eax
   119e7:	89 47 04             	mov    %eax,0x4(%edi)
   119ea:	8b 42 04             	mov    0x4(%edx),%eax
   119ed:	89 47 08             	mov    %eax,0x8(%edi)
   119f0:	8b 42 04             	mov    0x4(%edx),%eax
   119f3:	8b 12                	mov    (%edx),%edx
   119f5:	83 f8 01             	cmp    $0x1,%eax
   119f8:	b8 1f 85 eb 51       	mov    $0x51eb851f,%eax
   119fd:	19 db                	sbb    %ebx,%ebx
   119ff:	0f af d6             	imul   %esi,%edx
   11a02:	f7 e2                	mul    %edx
   11a04:	89 d0                	mov    %edx,%eax
   11a06:	83 e3 20             	and    $0x20,%ebx
   11a09:	c1 e8 05             	shr    $0x5,%eax
   11a0c:	75 05                	jne    11a13 <_ScrIoControl@8+0x4a3>
   11a0e:	b8 01 00 00 00       	mov    $0x1,%eax
   11a13:	89 f2                	mov    %esi,%edx
   11a15:	28 c2                	sub    %al,%dl
   11a17:	88 d0                	mov    %dl,%al
   11a19:	09 c3                	or     %eax,%ebx
   11a1b:	fa                   	cli    
   11a1c:	50                   	push   %eax
   11a1d:	50                   	push   %eax
   11a1e:	6a 0a                	push   $0xa
   11a20:	68 d4 03 00 00       	push   $0x3d4
   11a25:	e8 56 03 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   11a2a:	31 c0                	xor    %eax,%eax
   11a2c:	88 d8                	mov    %bl,%al
   11a2e:	50                   	push   %eax
   11a2f:	68 d5 03 00 00       	push   $0x3d5
   11a34:	e8 47 03 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   11a39:	6a 0b                	push   $0xb
   11a3b:	68 d4 03 00 00       	push   $0x3d4
   11a40:	e8 3b 03 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   11a45:	57                   	push   %edi
   11a46:	68 d5 03 00 00       	push   $0x3d5
   11a4b:	e8 40 03 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
   11a50:	8d 56 ff             	lea    0xffffffff(%esi),%edx
   11a53:	83 e0 e0             	and    $0xffffffe0,%eax
   11a56:	09 c2                	or     %eax,%edx
   11a58:	81 e2 ff 00 00 00    	and    $0xff,%edx
   11a5e:	89 14 24             	mov    %edx,(%esp)
   11a61:	68 d5 03 00 00       	push   $0x3d5
   11a66:	e8 15 03 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   11a6b:	fb                   	sti    
   11a6c:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11a6f:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   11a76:	31 db                	xor    %ebx,%ebx
   11a78:	58                   	pop    %eax
   11a79:	5a                   	pop    %edx
   11a7a:	e9 18 fc ff ff       	jmp    11697 <_ScrIoControl@8+0x127>
   11a7f:	8b 45 0c             	mov    0xc(%ebp),%eax
   11a82:	66 8b 57 18          	mov    0x18(%edi),%dx
   11a86:	81 e2 ff ff 00 00    	and    $0xffff,%edx
   11a8c:	31 f6                	xor    %esi,%esi
   11a8e:	8b 58 0c             	mov    0xc(%eax),%ebx
   11a91:	8b 0f                	mov    (%edi),%ecx
   11a93:	0f bf 43 0a          	movswl 0xa(%ebx),%eax
   11a97:	0f af c2             	imul   %edx,%eax
   11a9a:	0f bf 53 08          	movswl 0x8(%ebx),%edx
   11a9e:	01 d0                	add    %edx,%eax
   11aa0:	8b 53 04             	mov    0x4(%ebx),%edx
   11aa3:	01 c0                	add    %eax,%eax
   11aa5:	83 fa 00             	cmp    $0x0,%edx
   11aa8:	76 15                	jbe    11abf <_ScrIoControl@8+0x54f>
   11aaa:	8d 0c 08             	lea    (%eax,%ecx,1),%ecx
   11aad:	8d 76 00             	lea    0x0(%esi),%esi
   11ab0:	8a 03                	mov    (%ebx),%al
   11ab2:	46                   	inc    %esi
   11ab3:	88 01                	mov    %al,(%ecx)
   11ab5:	83 c1 02             	add    $0x2,%ecx
   11ab8:	8b 53 04             	mov    0x4(%ebx),%edx
   11abb:	39 f2                	cmp    %esi,%edx
   11abd:	77 f1                	ja     11ab0 <_ScrIoControl@8+0x540>
   11abf:	89 53 0c             	mov    %edx,0xc(%ebx)
   11ac2:	e9 8f fd ff ff       	jmp    11856 <_ScrIoControl@8+0x2e6>
   11ac7:	8b 45 0c             	mov    0xc(%ebp),%eax
   11aca:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11acd:	8b 50 04             	mov    0x4(%eax),%edx
   11ad0:	8b 5b 0c             	mov    0xc(%ebx),%ebx
   11ad3:	89 5d e8             	mov    %ebx,0xffffffe8(%ebp)
   11ad6:	66 8b 42 06          	mov    0x6(%edx),%ax
   11ada:	a8 05                	test   $0x5,%al
   11adc:	0f 84 29 01 00 00    	je     11c0b <_ScrIoControl@8+0x69b>
   11ae2:	8b 4a 0c             	mov    0xc(%edx),%ecx
   11ae5:	8b 5d e8             	mov    0xffffffe8(%ebp),%ebx
   11ae8:	8b 17                	mov    (%edi),%edx
   11aea:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   11aed:	66 8b 57 18          	mov    0x18(%edi),%dx
   11af1:	0f bf 43 0a          	movswl 0xa(%ebx),%eax
   11af5:	81 e2 ff ff 00 00    	and    $0xffff,%edx
   11afb:	8b 7e 04             	mov    0x4(%esi),%edi
   11afe:	0f af c2             	imul   %edx,%eax
   11b01:	0f bf 53 08          	movswl 0x8(%ebx),%edx
   11b05:	01 d0                	add    %edx,%eax
   11b07:	31 db                	xor    %ebx,%ebx
   11b09:	85 ff                	test   %edi,%edi
   11b0b:	8d 44 00 01          	lea    0x1(%eax,%eax,1),%eax
   11b0f:	74 16                	je     11b27 <_ScrIoControl@8+0x5b7>
   11b11:	8b 7d e4             	mov    0xffffffe4(%ebp),%edi
   11b14:	8d 14 38             	lea    (%eax,%edi,1),%edx
   11b17:	8a 02                	mov    (%edx),%al
   11b19:	43                   	inc    %ebx
   11b1a:	88 01                	mov    %al,(%ecx)
   11b1c:	83 c2 02             	add    $0x2,%edx
   11b1f:	83 c1 02             	add    $0x2,%ecx
   11b22:	39 5e 04             	cmp    %ebx,0x4(%esi)
   11b25:	77 f0                	ja     11b17 <_ScrIoControl@8+0x5a7>
   11b27:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11b2a:	e9 95 fd ff ff       	jmp    118c4 <_ScrIoControl@8+0x354>
   11b2f:	53                   	push   %ebx
   11b30:	53                   	push   %ebx
   11b31:	6a 00                	push   $0x0
   11b33:	52                   	push   %edx
   11b34:	e8 07 02 00 00       	call   11d40 <_MmMapLockedPages@8>
   11b39:	5a                   	pop    %edx
   11b3a:	59                   	pop    %ecx
   11b3b:	89 c1                	mov    %eax,%ecx
   11b3d:	e9 41 fd ff ff       	jmp    11883 <_ScrIoControl@8+0x313>
   11b42:	8b 55 0c             	mov    0xc(%ebp),%edx
   11b45:	66 8b 47 16          	mov    0x16(%edi),%ax
   11b49:	25 ff ff 00 00       	and    $0xffff,%eax
   11b4e:	8b 72 0c             	mov    0xc(%edx),%esi
   11b51:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   11b54:	66 8b 47 18          	mov    0x18(%edi),%ax
   11b58:	25 ff ff 00 00       	and    $0xffff,%eax
   11b5d:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   11b60:	fa                   	cli    
   11b61:	50                   	push   %eax
   11b62:	50                   	push   %eax
   11b63:	6a 0f                	push   $0xf
   11b65:	68 d4 03 00 00       	push   $0x3d4
   11b6a:	e8 11 02 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   11b6f:	50                   	push   %eax
   11b70:	68 d5 03 00 00       	push   $0x3d5
   11b75:	e8 16 02 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
   11b7a:	88 c3                	mov    %al,%bl
   11b7c:	c7 04 24 0e 00 00 00 	movl   $0xe,(%esp)
   11b83:	68 d4 03 00 00       	push   $0x3d4
   11b88:	e8 f3 01 00 00       	call   11d80 <_WRITE_PORT_UCHAR@8>
   11b8d:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   11b93:	50                   	push   %eax
   11b94:	68 d5 03 00 00       	push   $0x3d5
   11b99:	e8 f2 01 00 00       	call   11d90 <_READ_PORT_UCHAR@4>
   11b9e:	25 ff 00 00 00       	and    $0xff,%eax
   11ba3:	c1 e0 08             	shl    $0x8,%eax
   11ba6:	01 c3                	add    %eax,%ebx
   11ba8:	fb                   	sti    
   11ba9:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11bac:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   11baf:	66 89 06             	mov    %ax,(%esi)
   11bb2:	66 89 56 02          	mov    %dx,0x2(%esi)
   11bb6:	89 d8                	mov    %ebx,%eax
   11bb8:	31 d2                	xor    %edx,%edx
   11bba:	f7 75 ec             	divl   0xffffffec(%ebp)
   11bbd:	66 89 56 04          	mov    %dx,0x4(%esi)
   11bc1:	66 89 46 06          	mov    %ax,0x6(%esi)
   11bc5:	66 8b 47 0c          	mov    0xc(%edi),%ax
   11bc9:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
   11bcc:	66 89 46 08          	mov    %ax,0x8(%esi)
   11bd0:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11bd3:	48                   	dec    %eax
   11bd4:	8b 7d 0c             	mov    0xc(%ebp),%edi
   11bd7:	66 89 46 0e          	mov    %ax,0xe(%esi)
   11bdb:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11bde:	48                   	dec    %eax
   11bdf:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11be2:	66 89 5e 14          	mov    %bx,0x14(%esi)
   11be6:	83 c4 0c             	add    $0xc,%esp
   11be9:	31 db                	xor    %ebx,%ebx
   11beb:	66 c7 46 0a 00 00    	movw   $0x0,0xa(%esi)
   11bf1:	66 c7 46 0c 00 00    	movw   $0x0,0xc(%esi)
   11bf7:	66 89 46 10          	mov    %ax,0x10(%esi)
   11bfb:	66 89 56 12          	mov    %dx,0x12(%esi)
   11bff:	c7 47 1c 16 00 00 00 	movl   $0x16,0x1c(%edi)
   11c06:	e9 8c fa ff ff       	jmp    11697 <_ScrIoControl@8+0x127>
   11c0b:	53                   	push   %ebx
   11c0c:	53                   	push   %ebx
   11c0d:	6a 00                	push   $0x0
   11c0f:	52                   	push   %edx
   11c10:	e8 2b 01 00 00       	call   11d40 <_MmMapLockedPages@8>
   11c15:	5a                   	pop    %edx
   11c16:	59                   	pop    %ecx
   11c17:	89 c1                	mov    %eax,%ecx
   11c19:	e9 c7 fe ff ff       	jmp    11ae5 <_ScrIoControl@8+0x575>
   11c1e:	53                   	push   %ebx
   11c1f:	53                   	push   %ebx
   11c20:	6a 00                	push   $0x0
   11c22:	52                   	push   %edx
   11c23:	e8 18 01 00 00       	call   11d40 <_MmMapLockedPages@8>
   11c28:	5a                   	pop    %edx
   11c29:	89 c3                	mov    %eax,%ebx
   11c2b:	59                   	pop    %ecx
   11c2c:	e9 ad fa ff ff       	jmp    116de <_ScrIoControl@8+0x16e>
   11c31:	53                   	push   %ebx
   11c32:	53                   	push   %ebx
   11c33:	6a 00                	push   $0x0
   11c35:	52                   	push   %edx
   11c36:	e8 05 01 00 00       	call   11d40 <_MmMapLockedPages@8>
   11c3b:	5a                   	pop    %edx
   11c3c:	89 c3                	mov    %eax,%ebx
   11c3e:	59                   	pop    %ecx
   11c3f:	e9 46 fd ff ff       	jmp    1198a <_ScrIoControl@8+0x41a>
   11c44:	53                   	push   %ebx
   11c45:	53                   	push   %ebx
   11c46:	6a 00                	push   $0x0
   11c48:	52                   	push   %edx
   11c49:	e8 f2 00 00 00       	call   11d40 <_MmMapLockedPages@8>
   11c4e:	5a                   	pop    %edx
   11c4f:	59                   	pop    %ecx
   11c50:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   11c53:	e9 0e fb ff ff       	jmp    11766 <_ScrIoControl@8+0x1f6>
   11c58:	90                   	nop    
   11c59:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011c60 <_ScrDispatch@8>:


NTSTATUS STDCALL
ScrDispatch(PDEVICE_OBJECT DeviceObject,
	    PIRP Irp)
{
   11c60:	55                   	push   %ebp
   11c61:	89 e5                	mov    %esp,%ebp
   11c63:	53                   	push   %ebx
   11c64:	83 ec 0c             	sub    $0xc,%esp
   11c67:	8b 55 0c             	mov    0xc(%ebp),%edx
    PIO_STACK_LOCATION stk = IoGetCurrentIrpStackLocation(Irp);
   11c6a:	8b 42 60             	mov    0x60(%edx),%eax
    NTSTATUS Status;

    switch (stk->MajorFunction)
    {
        case IRP_MJ_CLOSE:
            Status = STATUS_SUCCESS;
   11c6d:	80 38 02             	cmpb   $0x2,(%eax)
   11c70:	0f 94 c3             	sete   %bl
   11c73:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   11c79:	4b                   	dec    %ebx
   11c7a:	81 e3 02 00 00 c0    	and    $0xc0000002,%ebx
            break;

        default:
            Status = STATUS_NOT_IMPLEMENTED;
            break;
    }


    Irp->IoStatus.Status = Status;
   11c80:	89 5a 18             	mov    %ebx,0x18(%edx)
    IoCompleteRequest (Irp, IO_NO_INCREMENT);
   11c83:	6a 00                	push   $0x0
   11c85:	52                   	push   %edx
   11c86:	e8 a5 00 00 00       	call   11d30 <_IoCompleteRequest@8>

    return (Status);
}
   11c8b:	89 d8                	mov    %ebx,%eax
   11c8d:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11c90:	c9                   	leave  
   11c91:	c2 08 00             	ret    $0x8
   11c94:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11c9a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011ca0 <_DriverEntry@8>:


/*
 * Module entry point
 */
NTSTATUS STDCALL
DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
   11ca0:	55                   	push   %ebp
   11ca1:	89 e5                	mov    %esp,%ebp
   11ca3:	53                   	push   %ebx
   11ca4:	83 ec 28             	sub    $0x28,%esp
   11ca7:	8b 55 08             	mov    0x8(%ebp),%edx
    PDEVICE_OBJECT DeviceObject;
    UNICODE_STRING DeviceName = ROS_STRING_INITIALIZER(L"\\Device\\BlueScreen");
   11caa:	8d 5d f0             	lea    0xfffffff0(%ebp),%ebx
    UNICODE_STRING SymlinkName = ROS_STRING_INITIALIZER(L"\\??\\BlueScreen");

    DPRINT ("Screen Driver 0.0.6\n");

    DriverObject->MajorFunction[IRP_MJ_CREATE] = ScrCreate;
    DriverObject->MajorFunction[IRP_MJ_CLOSE]  = ScrDispatch;
    DriverObject->MajorFunction[IRP_MJ_READ]   = ScrDispatch;
    DriverObject->MajorFunction[IRP_MJ_WRITE]  = ScrWrite;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL ] = ScrIoControl;

    IoCreateDevice (DriverObject,
   11cad:	8d 45 e4             	lea    0xffffffe4(%ebp),%eax
   11cb0:	66 c7 45 f0 24 00    	movw   $0x24,0xfffffff0(%ebp)
   11cb6:	c7 42 38 00 10 01 00 	movl   $0x11000,0x38(%edx)
   11cbd:	c7 42 40 60 1c 01 00 	movl   $0x11c60,0x40(%edx)
   11cc4:	c7 42 44 60 1c 01 00 	movl   $0x11c60,0x44(%edx)
   11ccb:	c7 42 48 30 12 01 00 	movl   $0x11230,0x48(%edx)
   11cd2:	c7 42 70 70 15 01 00 	movl   $0x11570,0x70(%edx)
   11cd9:	66 c7 45 f2 26 00    	movw   $0x26,0xfffffff2(%ebp)
   11cdf:	50                   	push   %eax
   11ce0:	c7 45 f4 00 20 01 00 	movl   $0x12000,0xfffffff4(%ebp)
   11ce7:	6a 01                	push   $0x1
   11ce9:	66 c7 45 e8 1c 00    	movw   $0x1c,0xffffffe8(%ebp)
   11cef:	6a 00                	push   $0x0
   11cf1:	66 c7 45 ea 1e 00    	movw   $0x1e,0xffffffea(%ebp)
   11cf7:	6a 1c                	push   $0x1c
   11cf9:	c7 45 ec 26 20 01 00 	movl   $0x12026,0xffffffec(%ebp)
   11d00:	53                   	push   %ebx
   11d01:	6a 1c                	push   $0x1c
   11d03:	52                   	push   %edx
   11d04:	e8 47 00 00 00       	call   11d50 <_IoCreateDevice@28>
                    sizeof(DEVICE_EXTENSION),
                    &DeviceName,
                    FILE_DEVICE_SCREEN,
                    0,
                    TRUE,
                    &DeviceObject);

    IoCreateSymbolicLink (&SymlinkName, &DeviceName);
   11d09:	50                   	push   %eax
   11d0a:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   11d0d:	53                   	push   %ebx
   11d0e:	50                   	push   %eax
   11d0f:	e8 4c 00 00 00       	call   11d60 <_IoCreateSymbolicLink@8>

    return (STATUS_SUCCESS);
}
   11d14:	31 c0                	xor    %eax,%eax
   11d16:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11d19:	c9                   	leave  
   11d1a:	c2 08 00             	ret    $0x8
   11d1d:	90                   	nop    
   11d1e:	90                   	nop    
   11d1f:	90                   	nop    

00011d20 <_MmMapIoSpace@16>:
   11d20:	ff 25 94 30 01 00    	jmp    *0x13094
   11d26:	90                   	nop    
   11d27:	90                   	nop    
	...

00011d30 <_IoCompleteRequest@8>:
   11d30:	ff 25 88 30 01 00    	jmp    *0x13088
   11d36:	90                   	nop    
   11d37:	90                   	nop    
	...

00011d40 <_MmMapLockedPages@8>:
   11d40:	ff 25 98 30 01 00    	jmp    *0x13098
   11d46:	90                   	nop    
   11d47:	90                   	nop    
	...

00011d50 <_IoCreateDevice@28>:
   11d50:	ff 25 8c 30 01 00    	jmp    *0x1308c
   11d56:	90                   	nop    
   11d57:	90                   	nop    
	...

00011d60 <_IoCreateSymbolicLink@8>:
   11d60:	ff 25 90 30 01 00    	jmp    *0x13090
   11d66:	90                   	nop    
   11d67:	90                   	nop    
	...

00011d70 <_memcpy>:
   11d70:	ff 25 9c 30 01 00    	jmp    *0x1309c
   11d76:	90                   	nop    
   11d77:	90                   	nop    
	...

00011d80 <_WRITE_PORT_UCHAR@8>:
   11d80:	ff 25 7c 30 01 00    	jmp    *0x1307c
   11d86:	90                   	nop    
   11d87:	90                   	nop    
	...

00011d90 <_READ_PORT_UCHAR@4>:
   11d90:	ff 25 78 30 01 00    	jmp    *0x13078
   11d96:	90                   	nop    
   11d97:	90                   	nop    
	...

00011da0 <_HalQueryDisplayOwnership@0>:
   11da0:	ff 25 74 30 01 00    	jmp    *0x13074
   11da6:	90                   	nop    
   11da7:	90                   	nop    
	...

00011db0 <__CTOR_LIST__>:
   11db0:	ff                   	(bad)  
   11db1:	ff                   	(bad)  
   11db2:	ff                   	(bad)  
   11db3:	ff 00                	incl   (%eax)
   11db5:	00 00                	add    %al,(%eax)
	...

00011db8 <__DTOR_LIST__>:
   11db8:	ff                   	(bad)  
   11db9:	ff                   	(bad)  
   11dba:	ff                   	(bad)  
   11dbb:	ff 00                	incl   (%eax)
   11dbd:	00 00                	add    %al,(%eax)
	...
