
bootvid.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_VidResetDisplay@0>:


BOOL STDCALL
VidResetDisplay(VOID)
{
   11000:	55                   	push   %ebp
   /* 
    * We are only using standard VGA facilities so we can rely on the
    * HAL 'int10mode3' reset to cleanup the hardware state.
    */

   return FALSE;
}
   11001:	31 c0                	xor    %eax,%eax
   11003:	89 e5                	mov    %esp,%ebp
   11005:	5d                   	pop    %ebp
   11006:	c3                   	ret    
   11007:	89 f6                	mov    %esi,%esi
   11009:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011010 <_VidCleanUp@0>:


VOID STDCALL
VidCleanUp(VOID)
{
   11010:	55                   	push   %ebp
   11011:	89 e5                	mov    %esp,%ebp
   11013:	83 ec 10             	sub    $0x10,%esp
   11016:	8b 0d 40 40 01 00    	mov    0x14040,%ecx
   1101c:	68 00 00 01 00       	push   $0x10000
   11021:	51                   	push   %ecx
   11022:	e8 49 0b 00 00       	call   11b70 <_MmUnmapIoSpace@8>
   11027:	58                   	pop    %eax
   11028:	5a                   	pop    %edx
   11029:	c9                   	leave  
   1102a:	c3                   	ret    
   1102b:	90                   	nop    
   1102c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011030 <@InbvSetColor@16>:
   InbvUnmapVideoMemory();
}


STATIC VOID FASTCALL
InbvSetColor(INT Index, UCHAR Red, UCHAR Green, UCHAR Blue)
{
   11030:	55                   	push   %ebp
   WRITE_PORT_UCHAR(PELINDEX, Index);
   11031:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   11037:	89 e5                	mov    %esp,%ebp
   11039:	57                   	push   %edi
   1103a:	56                   	push   %esi
   1103b:	53                   	push   %ebx
   1103c:	83 ec 14             	sub    $0x14,%esp
   1103f:	88 d3                	mov    %dl,%bl
   11041:	0f b6 75 08          	movzbl 0x8(%ebp),%esi
   11045:	0f b6 7d 0c          	movzbl 0xc(%ebp),%edi
   WRITE_PORT_UCHAR(PELDATA, Red >> 2);
   11049:	c0 eb 02             	shr    $0x2,%bl
   1104c:	51                   	push   %ecx
   1104d:	68 c8 03 00 00       	push   $0x3c8
   11052:	e8 e9 0b 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   11057:	31 c0                	xor    %eax,%eax
   11059:	88 d8                	mov    %bl,%al
   1105b:	50                   	push   %eax
   1105c:	68 c9 03 00 00       	push   $0x3c9
   11061:	e8 da 0b 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   WRITE_PORT_UCHAR(PELDATA, Green >> 2);
   11066:	89 f0                	mov    %esi,%eax
   11068:	c0 e8 02             	shr    $0x2,%al
   1106b:	25 ff 00 00 00       	and    $0xff,%eax
   11070:	50                   	push   %eax
   11071:	68 c9 03 00 00       	push   $0x3c9
   11076:	e8 c5 0b 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   WRITE_PORT_UCHAR(PELDATA, Blue >> 2);
   1107b:	89 f8                	mov    %edi,%eax
   1107d:	c0 e8 02             	shr    $0x2,%al
   11080:	5b                   	pop    %ebx
   11081:	25 ff 00 00 00       	and    $0xff,%eax
   11086:	5e                   	pop    %esi
   11087:	89 45 0c             	mov    %eax,0xc(%ebp)
   1108a:	c7 45 08 c9 03 00 00 	movl   $0x3c9,0x8(%ebp)
   11091:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11094:	5b                   	pop    %ebx
   11095:	5e                   	pop    %esi
   11096:	5f                   	pop    %edi
   11097:	5d                   	pop    %ebp
   11098:	e9 a3 0b 00 00       	jmp    11c40 <_WRITE_PORT_UCHAR@8>
   1109d:	8d 76 00             	lea    0x0(%esi),%esi

000110a0 <_InbvBitmapThreadMain@4>:
}


STATIC VOID FASTCALL
InbvSetBlackPalette()
{
   register ULONG r = 0;

   /* Disable screen and enable palette access. */
   READ_PORT_UCHAR(STATUS);
   WRITE_PORT_UCHAR(ATTRIB, 0x00);

   for (r = 0; r < 16; r++)
   {
      InbvSetColor(r, 0, 0, 0);
   }

   /* Enable screen and enable palette access. */
   READ_PORT_UCHAR(STATUS);
   WRITE_PORT_UCHAR(ATTRIB, 0x20);
}


STATIC VOID FASTCALL
InbvDisplayBitmap(ULONG Width, ULONG Height, PCHAR ImageData)
{
   ULONG j, k, y;
   register ULONG i;
   register ULONG x;
   register ULONG c;

   k = 0;
   for (y = 0; y < Height; y++)
   {
      for (j = 0; j < 8; j++)
      {
         x = j;

         /*
          * Loop through the line and process every 8th pixel.
          * This way we can get a way with using the same bit mask
          * for several pixels and thus not need to do as much I/O
          * communication.
          */
         while (x < 640)
         {
            c = 0;

            if (x < Width)
            {
               c = ImageData[k + x];
               for (i = 1; i < 4; i++)
               {
                  if (x + i * 8 < Width)
                  {
                     c |= (ImageData[k + x + i * 8] << i * 8);
                  }
               }
            }

            InbvPutPixels(x, 479 - y, c);
            x += 8 * 4;
         }
      }
      k += Width;
   }
}


STATIC VOID FASTCALL
InbvDisplayCompressedBitmap()
{
   PBITMAPV5HEADER bminfo;
   ULONG i,j,k;
   ULONG x,y;
   ULONG curx,cury;
   ULONG bfOffBits;
   ULONG clen;
   PCHAR ImageData;
   UCHAR ClrUsed;

   bminfo = (PBITMAPV5HEADER) &BootimageBitmap[0];
   DPRINT("bV5Size = %d\n", bminfo->bV5Size);
   DPRINT("bV5Width = %d\n", bminfo->bV5Width);
   DPRINT("bV5Height = %d\n", bminfo->bV5Height);
   DPRINT("bV5Planes = %d\n", bminfo->bV5Planes);
   DPRINT("bV5BitCount = %d\n", bminfo->bV5BitCount);
   DPRINT("bV5Compression = %d\n", bminfo->bV5Compression);
   DPRINT("bV5SizeImage = %d\n", bminfo->bV5SizeImage);
   DPRINT("bV5XPelsPerMeter = %d\n", bminfo->bV5XPelsPerMeter);
   DPRINT("bV5YPelsPerMeter = %d\n", bminfo->bV5YPelsPerMeter);
   DPRINT("bV5ClrUsed = %d\n", bminfo->bV5ClrUsed);
   DPRINT("bV5ClrImportant = %d\n", bminfo->bV5ClrImportant);

   if (bminfo->bV5ClrUsed)
      ClrUsed = bminfo->bV5ClrUsed;
   else
      ClrUsed = 1 << bminfo->bV5BitCount;

   bfOffBits = bminfo->bV5Size + ClrUsed * sizeof(RGBQUAD);
   DPRINT("bfOffBits = %d\n", bfOffBits);
   DPRINT("size of color indices = %d\n", ClrUsed * sizeof(RGBQUAD));
   DPRINT("first byte of data = %d\n", BootimageBitmap[bfOffBits]);

   InbvSetBlackPalette();

   ImageData = ExAllocatePool(NonPagedPool, bminfo->bV5Width * bminfo->bV5Height);
   RtlZeroMemory(ImageData, bminfo->bV5Width * bminfo->bV5Height);

   /*
    * ImageData has 1 pixel per byte.
    * bootimage has 2 pixels per byte.
    */

   if (bminfo->bV5Compression == 2)
   {
      k = 0;
      j = 0;
      while ((j < bminfo->bV5SizeImage) && (k < (ULONG) (bminfo->bV5Width * bminfo->bV5Height)))
      {
         unsigned char b;
    
         clen = BootimageBitmap[bfOffBits + j];
         j++;
    
         if (clen > 0)
         {
            /* Encoded mode */
    
            b = BootimageBitmap[bfOffBits + j];
            j++;
    
            for (i = 0; i < (clen / 2); i++)
            {
               ImageData[k] = (b & 0xf0) >> 4;
               k++;
               ImageData[k] = b & 0xf;
               k++;
            }
            if ((clen & 1) > 0)
            {
               ImageData[k] = (b & 0xf0) >> 4;
               k++;
            }
         }
         else
         {
            /* Absolute mode */
            b = BootimageBitmap[bfOffBits + j];
            j++;
    
            if (b == 0)
            {
               /* End of line */
               if (k % bminfo->bV5Width)
               {
                  cury = k / bminfo->bV5Width;
                  k = (cury + 1) * bminfo->bV5Width;
               }
            }
            else if (b == 1)
            {
               /* End of image */
               break;
            }
            else if (b == 2)
            {
               x = BootimageBitmap[bfOffBits + j];
               j++;
               y = BootimageBitmap[bfOffBits + j];
               j++;
               curx = k % bminfo->bV5Width;
               cury = k / bminfo->bV5Width;
               k = (cury + y) * bminfo->bV5Width + (curx + x);
            }
            else
            {
               if ((j & 1) > 0)
               {
                  DPRINT("Unaligned copy!\n");
               }
    
               clen = b;
               for (i = 0; i < (clen / 2); i++)
               {
                  b = BootimageBitmap[bfOffBits + j];
                  j++;
       
                  ImageData[k] = (b & 0xf0) >> 4;
                  k++;
                  ImageData[k] = b & 0xf;
                  k++;
               }
               if ((clen & 1) > 0)
               {
                  b = BootimageBitmap[bfOffBits + j];
                  j++;
                  ImageData[k] = (b & 0xf0) >> 4;
                  k++;
               }
               /* Word align */
               j += (j & 1);
            }
         }
      }

      InbvDisplayBitmap(bminfo->bV5Width, bminfo->bV5Height, ImageData);
   }
   else
   {
      DbgPrint("Warning boot image need to be compressed using RLE4\n");
   }

   ExFreePool(ImageData);
}


STATIC VOID FASTCALL
InbvFadeUpPalette()
{
   PBITMAPV5HEADER bminfo;
   PRGBQUAD Palette;
   ULONG i;
   unsigned char r, g, b;
   register ULONG c;
   LARGE_INTEGER Interval;
   FADER_PALETTE_ENTRY FaderPalette[16];
   FADER_PALETTE_ENTRY FaderPaletteDelta[16];
   UCHAR ClrUsed;

   RtlZeroMemory(&FaderPalette, sizeof(FaderPalette));
   RtlZeroMemory(&FaderPaletteDelta, sizeof(FaderPaletteDelta));

   bminfo = (PBITMAPV5HEADER)&BootimageBitmap[0];
   Palette = (PRGBQUAD)&BootimageBitmap[bminfo->bV5Size];

   if (bminfo->bV5ClrUsed)
      ClrUsed = bminfo->bV5ClrUsed;
   else
      ClrUsed = 1 << bminfo->bV5BitCount;

   for (i = 0; i < 16 && i < ClrUsed; i++)
   {
      FaderPaletteDelta[i].r = ((Palette[i].rgbRed << 8) / PALETTE_FADE_STEPS);
      FaderPaletteDelta[i].g = ((Palette[i].rgbGreen << 8) / PALETTE_FADE_STEPS);
      FaderPaletteDelta[i].b = ((Palette[i].rgbBlue << 8) / PALETTE_FADE_STEPS);
   }

   for (i = 0; i < PALETTE_FADE_STEPS; i++)
   {
      /* Disable screen and enable palette access. */
      READ_PORT_UCHAR(STATUS);
      WRITE_PORT_UCHAR(ATTRIB, 0x00);

      for (c = 0; c < ClrUsed; c++)
      {
         /* Add the delta */
         FaderPalette[c].r += FaderPaletteDelta[c].r;
         FaderPalette[c].g += FaderPaletteDelta[c].g;
         FaderPalette[c].b += FaderPaletteDelta[c].b;

         /* Get the integer values */
         r = FaderPalette[c].r >> 8;
         g = FaderPalette[c].g >> 8;
         b = FaderPalette[c].b >> 8;

         /* Don't go too far */
         if (r > Palette[c].rgbRed)
            r = Palette[c].rgbRed;
         if (g > Palette[c].rgbGreen)
            g = Palette[c].rgbGreen;
         if (b > Palette[c].rgbBlue)
            b = Palette[c].rgbBlue;

         /* Update the hardware */
         InbvSetColor(c, r, g, b);
      }

      /* Enable screen and disable palette access. */
      READ_PORT_UCHAR(STATUS);
      WRITE_PORT_UCHAR(ATTRIB, 0x20);

      /* Wait for a bit. */
      Interval.QuadPart = -PALETTE_FADE_TIME;
      KeDelayExecutionThread(KernelMode, FALSE, &Interval);
   }
}


STATIC VOID STDCALL
InbvBitmapThreadMain(PVOID Ignored)
{
   110a0:	55                   	push   %ebp
   110a1:	89 e5                	mov    %esp,%ebp
   110a3:	57                   	push   %edi
   110a4:	56                   	push   %esi
   110a5:	53                   	push   %ebx
   110a6:	81 ec 2c 02 00 00    	sub    $0x22c,%esp
   110ac:	c7 45 d8 02 00 00 00 	movl   $0x2,0xffffffd8(%ebp)
   110b3:	a1 00 40 01 00       	mov    0x14000,%eax
   110b8:	c7 45 dc 64 00 00 00 	movl   $0x64,0xffffffdc(%ebp)
   110bf:	c7 45 e0 09 00 00 00 	movl   $0x9,0xffffffe0(%ebp)
   110c6:	8b 58 0c             	mov    0xc(%eax),%ebx
   110c9:	8d 85 54 fe ff ff    	lea    0xfffffe54(%ebp),%eax
   110cf:	50                   	push   %eax
   110d0:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
   110d3:	6a 03                	push   $0x3
   110d5:	50                   	push   %eax
   110d6:	53                   	push   %ebx
   110d7:	e8 a4 0a 00 00       	call   11b80 <_LdrFindResource_U@16>
   110dc:	31 d2                	xor    %edx,%edx
   110de:	85 c0                	test   %eax,%eax
   110e0:	78 21                	js     11103 <_InbvBitmapThreadMain@4+0x63>
   110e2:	8d 85 50 fe ff ff    	lea    0xfffffe50(%ebp),%eax
   110e8:	50                   	push   %eax
   110e9:	68 20 40 01 00       	push   $0x14020
   110ee:	8b 85 54 fe ff ff    	mov    0xfffffe54(%ebp),%eax
   110f4:	50                   	push   %eax
   110f5:	53                   	push   %ebx
   110f6:	e8 95 0a 00 00       	call   11b90 <_LdrAccessResource@16>
   110fb:	89 c2                	mov    %eax,%edx
   110fd:	83 f2 ff             	xor    $0xffffffff,%edx
   11100:	c1 ea 1f             	shr    $0x1f,%edx
   11103:	85 d2                	test   %edx,%edx
   11105:	0f 84 10 03 00 00    	je     1141b <_InbvBitmapThreadMain@4+0x37b>
   1110b:	8b 3d 20 40 01 00    	mov    0x14020,%edi
   11111:	8b 47 20             	mov    0x20(%edi),%eax
   11114:	88 c2                	mov    %al,%dl
   11116:	85 c0                	test   %eax,%eax
   11118:	0f 84 ee 02 00 00    	je     1140c <_InbvBitmapThreadMain@4+0x36c>
   1111e:	8b 07                	mov    (%edi),%eax
   11120:	81 e2 ff 00 00 00    	and    $0xff,%edx
   11126:	83 ec 0c             	sub    $0xc,%esp
   11129:	31 db                	xor    %ebx,%ebx
   1112b:	8d 14 90             	lea    (%eax,%edx,4),%edx
   1112e:	89 95 40 fe ff ff    	mov    %edx,0xfffffe40(%ebp)
   11134:	68 da 03 00 00       	push   $0x3da
   11139:	e8 12 0b 00 00       	call   11c50 <_READ_PORT_UCHAR@4>
   1113e:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11145:	68 c0 03 00 00       	push   $0x3c0
   1114a:	e8 f1 0a 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   1114f:	5e                   	pop    %esi
   11150:	58                   	pop    %eax
   11151:	31 d2                	xor    %edx,%edx
   11153:	51                   	push   %ecx
   11154:	51                   	push   %ecx
   11155:	89 d9                	mov    %ebx,%ecx
   11157:	6a 00                	push   $0x0
   11159:	6a 00                	push   $0x0
   1115b:	e8 d0 fe ff ff       	call   11030 <@InbvSetColor@16>
   11160:	43                   	inc    %ebx
   11161:	58                   	pop    %eax
   11162:	83 fb 0f             	cmp    $0xf,%ebx
   11165:	5a                   	pop    %edx
   11166:	76 e9                	jbe    11151 <_InbvBitmapThreadMain@4+0xb1>
   11168:	83 ec 0c             	sub    $0xc,%esp
   1116b:	68 da 03 00 00       	push   $0x3da
   11170:	e8 db 0a 00 00       	call   11c50 <_READ_PORT_UCHAR@4>
   11175:	c7 04 24 20 00 00 00 	movl   $0x20,(%esp)
   1117c:	68 c0 03 00 00       	push   $0x3c0
   11181:	e8 ba 0a 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   11186:	8b 47 08             	mov    0x8(%edi),%eax
   11189:	8b 77 04             	mov    0x4(%edi),%esi
   1118c:	0f af c6             	imul   %esi,%eax
   1118f:	50                   	push   %eax
   11190:	6a 00                	push   $0x0
   11192:	e8 09 0a 00 00       	call   11ba0 <_ExAllocatePool@8>
   11197:	8b 5f 04             	mov    0x4(%edi),%ebx
   1119a:	89 85 38 fe ff ff    	mov    %eax,0xfffffe38(%ebp)
   111a0:	8b 47 08             	mov    0x8(%edi),%eax
   111a3:	0f af c3             	imul   %ebx,%eax
   111a6:	50                   	push   %eax
   111a7:	8b 8d 38 fe ff ff    	mov    0xfffffe38(%ebp),%ecx
   111ad:	51                   	push   %ecx
   111ae:	e8 fd 09 00 00       	call   11bb0 <_RtlZeroMemory@8>
   111b3:	83 7f 10 02          	cmpl   $0x2,0x10(%edi)
   111b7:	58                   	pop    %eax
   111b8:	5a                   	pop    %edx
   111b9:	0f 85 b1 02 00 00    	jne    11470 <_InbvBitmapThreadMain@4+0x3d0>
   111bf:	8b 47 14             	mov    0x14(%edi),%eax
   111c2:	31 f6                	xor    %esi,%esi
   111c4:	c7 85 44 fe ff ff 00 	movl   $0x0,0xfffffe44(%ebp)
   111cb:	00 00 00 
   111ce:	89 85 04 fe ff ff    	mov    %eax,0xfffffe04(%ebp)
   111d4:	83 f8 00             	cmp    $0x0,%eax
   111d7:	0f 86 e2 05 00 00    	jbe    117bf <_InbvBitmapThreadMain@4+0x71f>
   111dd:	8b 57 04             	mov    0x4(%edi),%edx
   111e0:	8b 4f 08             	mov    0x8(%edi),%ecx
   111e3:	89 d0                	mov    %edx,%eax
   111e5:	89 95 00 fe ff ff    	mov    %edx,0xfffffe00(%ebp)
   111eb:	0f af c1             	imul   %ecx,%eax
   111ee:	89 8d fc fd ff ff    	mov    %ecx,0xfffffdfc(%ebp)
   111f4:	83 f8 00             	cmp    $0x0,%eax
   111f7:	0f 86 dc 00 00 00    	jbe    112d9 <_InbvBitmapThreadMain@4+0x239>
   111fd:	8b 95 40 fe ff ff    	mov    0xfffffe40(%ebp),%edx
   11203:	8b 1d 20 40 01 00    	mov    0x14020,%ebx
   11209:	31 c9                	xor    %ecx,%ecx
   1120b:	8d 04 13             	lea    (%ebx,%edx,1),%eax
   1120e:	8b 95 44 fe ff ff    	mov    0xfffffe44(%ebp),%edx
   11214:	8a 0c 10             	mov    (%eax,%edx,1),%cl
   11217:	42                   	inc    %edx
   11218:	89 8d 3c fe ff ff    	mov    %ecx,0xfffffe3c(%ebp)
   1121e:	89 95 44 fe ff ff    	mov    %edx,0xfffffe44(%ebp)
   11224:	85 c9                	test   %ecx,%ecx
   11226:	0f 84 09 02 00 00    	je     11435 <_InbvBitmapThreadMain@4+0x395>
   1122c:	8a 0c 10             	mov    (%eax,%edx,1),%cl
   1122f:	42                   	inc    %edx
   11230:	89 95 44 fe ff ff    	mov    %edx,0xfffffe44(%ebp)
   11236:	8b 95 3c fe ff ff    	mov    0xfffffe3c(%ebp),%edx
   1123c:	d1 ea                	shr    %edx
   1123e:	83 fa 00             	cmp    $0x0,%edx
   11241:	76 39                	jbe    1127c <_InbvBitmapThreadMain@4+0x1dc>
   11243:	89 cb                	mov    %ecx,%ebx
   11245:	88 c8                	mov    %cl,%al
   11247:	81 e3 f0 00 00 00    	and    $0xf0,%ebx
   1124d:	83 e0 0f             	and    $0xf,%eax
   11250:	c1 fb 04             	sar    $0x4,%ebx
   11253:	88 85 e7 fd ff ff    	mov    %al,0xfffffde7(%ebp)
   11259:	89 9d d4 fd ff ff    	mov    %ebx,0xfffffdd4(%ebp)
   1125f:	8b 85 38 fe ff ff    	mov    0xfffffe38(%ebp),%eax
   11265:	8a 9d d4 fd ff ff    	mov    0xfffffdd4(%ebp),%bl
   1126b:	88 1c 06             	mov    %bl,(%esi,%eax,1)
   1126e:	46                   	inc    %esi
   1126f:	8a 9d e7 fd ff ff    	mov    0xfffffde7(%ebp),%bl
   11275:	88 1c 06             	mov    %bl,(%esi,%eax,1)
   11278:	46                   	inc    %esi
   11279:	4a                   	dec    %edx
   1127a:	75 e3                	jne    1125f <_InbvBitmapThreadMain@4+0x1bf>
   1127c:	f6 85 3c fe ff ff 01 	testb  $0x1,0xfffffe3c(%ebp)
   11283:	74 14                	je     11299 <_InbvBitmapThreadMain@4+0x1f9>
   11285:	89 c8                	mov    %ecx,%eax
   11287:	8b 95 38 fe ff ff    	mov    0xfffffe38(%ebp),%edx
   1128d:	25 f0 00 00 00       	and    $0xf0,%eax
   11292:	c1 f8 04             	sar    $0x4,%eax
   11295:	88 04 16             	mov    %al,(%esi,%edx,1)
   11298:	46                   	inc    %esi
   11299:	8b 4f 04             	mov    0x4(%edi),%ecx
   1129c:	8b 5f 08             	mov    0x8(%edi),%ebx
   1129f:	8b 47 14             	mov    0x14(%edi),%eax
   112a2:	89 8d 00 fe ff ff    	mov    %ecx,0xfffffe00(%ebp)
   112a8:	89 9d fc fd ff ff    	mov    %ebx,0xfffffdfc(%ebp)
   112ae:	89 85 04 fe ff ff    	mov    %eax,0xfffffe04(%ebp)
   112b4:	8b 95 44 fe ff ff    	mov    0xfffffe44(%ebp),%edx
   112ba:	39 95 04 fe ff ff    	cmp    %edx,0xfffffe04(%ebp)
   112c0:	76 17                	jbe    112d9 <_InbvBitmapThreadMain@4+0x239>
   112c2:	8b 85 00 fe ff ff    	mov    0xfffffe00(%ebp),%eax
   112c8:	8b 95 fc fd ff ff    	mov    0xfffffdfc(%ebp),%edx
   112ce:	0f af c2             	imul   %edx,%eax
   112d1:	39 f0                	cmp    %esi,%eax
   112d3:	0f 87 24 ff ff ff    	ja     111fd <_InbvBitmapThreadMain@4+0x15d>
   112d9:	c7 85 2c fe ff ff 00 	movl   $0x0,0xfffffe2c(%ebp)
   112e0:	00 00 00 
   112e3:	8b 9d fc fd ff ff    	mov    0xfffffdfc(%ebp),%ebx
   112e9:	39 9d 2c fe ff ff    	cmp    %ebx,0xfffffe2c(%ebp)
   112ef:	c7 85 30 fe ff ff 00 	movl   $0x0,0xfffffe30(%ebp)
   112f6:	00 00 00 
   112f9:	0f 83 81 01 00 00    	jae    11480 <_InbvBitmapThreadMain@4+0x3e0>
   112ff:	be df 01 00 00       	mov    $0x1df,%esi
   11304:	8b 9d 2c fe ff ff    	mov    0xfffffe2c(%ebp),%ebx
   1130a:	29 de                	sub    %ebx,%esi
   1130c:	c7 85 34 fe ff ff 00 	movl   $0x0,0xfffffe34(%ebp)
   11313:	00 00 00 
   11316:	89 b5 f4 fd ff ff    	mov    %esi,0xfffffdf4(%ebp)
   1131c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11320:	8b 9d 34 fe ff ff    	mov    0xfffffe34(%ebp),%ebx
   11326:	81 fb 7f 02 00 00    	cmp    $0x27f,%ebx
   1132c:	0f 87 8e 00 00 00    	ja     113c0 <_InbvBitmapThreadMain@4+0x320>
   11332:	8b 85 30 fe ff ff    	mov    0xfffffe30(%ebp),%eax
   11338:	8b 8d 38 fe ff ff    	mov    0xfffffe38(%ebp),%ecx
   1133e:	01 c8                	add    %ecx,%eax
   11340:	01 d8                	add    %ebx,%eax
   11342:	89 85 f8 fd ff ff    	mov    %eax,0xfffffdf8(%ebp)
   11348:	31 ff                	xor    %edi,%edi
   1134a:	3b 9d 00 fe ff ff    	cmp    0xfffffe00(%ebp),%ebx
   11350:	73 42                	jae    11394 <_InbvBitmapThreadMain@4+0x2f4>
   11352:	8b 95 30 fe ff ff    	mov    0xfffffe30(%ebp),%edx
   11358:	8b 85 38 fe ff ff    	mov    0xfffffe38(%ebp),%eax
   1135e:	01 d0                	add    %edx,%eax
   11360:	8b 95 f8 fd ff ff    	mov    0xfffffdf8(%ebp),%edx
   11366:	be 01 00 00 00       	mov    $0x1,%esi
   1136b:	83 c2 08             	add    $0x8,%edx
   1136e:	0f be 3c 18          	movsbl (%eax,%ebx,1),%edi
   11372:	8d 0c f5 00 00 00 00 	lea    0x0(,%esi,8),%ecx
   11379:	8d 04 19             	lea    (%ecx,%ebx,1),%eax
   1137c:	3b 85 00 fe ff ff    	cmp    0xfffffe00(%ebp),%eax
   11382:	73 07                	jae    1138b <_InbvBitmapThreadMain@4+0x2eb>
   11384:	0f be 02             	movsbl (%edx),%eax
   11387:	d3 e0                	shl    %cl,%eax
   11389:	09 c7                	or     %eax,%edi
   1138b:	46                   	inc    %esi
   1138c:	83 c2 08             	add    $0x8,%edx
   1138f:	83 fe 03             	cmp    $0x3,%esi
   11392:	76 de                	jbe    11372 <_InbvBitmapThreadMain@4+0x2d2>
   11394:	50                   	push   %eax
   11395:	57                   	push   %edi
   11396:	8b 85 f4 fd ff ff    	mov    0xfffffdf4(%ebp),%eax
   1139c:	50                   	push   %eax
   1139d:	53                   	push   %ebx
   1139e:	e8 5d 07 00 00       	call   11b00 <_InbvPutPixels>
   113a3:	8b 85 f8 fd ff ff    	mov    0xfffffdf8(%ebp),%eax
   113a9:	83 c0 20             	add    $0x20,%eax
   113ac:	83 c3 20             	add    $0x20,%ebx
   113af:	83 c4 10             	add    $0x10,%esp
   113b2:	89 85 f8 fd ff ff    	mov    %eax,0xfffffdf8(%ebp)
   113b8:	81 fb 7f 02 00 00    	cmp    $0x27f,%ebx
   113be:	76 88                	jbe    11348 <_InbvBitmapThreadMain@4+0x2a8>
   113c0:	8b 85 34 fe ff ff    	mov    0xfffffe34(%ebp),%eax
   113c6:	40                   	inc    %eax
   113c7:	89 85 34 fe ff ff    	mov    %eax,0xfffffe34(%ebp)
   113cd:	83 bd 34 fe ff ff 07 	cmpl   $0x7,0xfffffe34(%ebp)
   113d4:	0f 86 46 ff ff ff    	jbe    11320 <_InbvBitmapThreadMain@4+0x280>
   113da:	8b bd 00 fe ff ff    	mov    0xfffffe00(%ebp),%edi
   113e0:	8b 85 30 fe ff ff    	mov    0xfffffe30(%ebp),%eax
   113e6:	01 f8                	add    %edi,%eax
   113e8:	8b bd 2c fe ff ff    	mov    0xfffffe2c(%ebp),%edi
   113ee:	47                   	inc    %edi
   113ef:	89 85 30 fe ff ff    	mov    %eax,0xfffffe30(%ebp)
   113f5:	89 bd 2c fe ff ff    	mov    %edi,0xfffffe2c(%ebp)
   113fb:	8b 85 fc fd ff ff    	mov    0xfffffdfc(%ebp),%eax
   11401:	39 85 2c fe ff ff    	cmp    %eax,0xfffffe2c(%ebp)
   11407:	e9 ed fe ff ff       	jmp    112f9 <_InbvBitmapThreadMain@4+0x259>
   1140c:	b0 01                	mov    $0x1,%al
   1140e:	66 8b 4f 0e          	mov    0xe(%edi),%cx
   11412:	89 c2                	mov    %eax,%edx
   11414:	d3 e2                	shl    %cl,%edx
   11416:	e9 03 fd ff ff       	jmp    1111e <_InbvBitmapThreadMain@4+0x7e>
   if (InbvFindBootimage())
   {
      InbvDisplayCompressedBitmap();
      InbvFadeUpPalette();
   }
   else
   {
      DbgPrint("Warning: Cannot find boot image\n");
   1141b:	83 ec 0c             	sub    $0xc,%esp
   1141e:	68 00 30 01 00       	push   $0x13000
   11423:	e8 08 08 00 00       	call   11c30 <_DbgPrint>
   11428:	83 c4 10             	add    $0x10,%esp
   }
}
   1142b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1142e:	5b                   	pop    %ebx
   1142f:	5e                   	pop    %esi
   11430:	5f                   	pop    %edi
   11431:	5d                   	pop    %ebp
   11432:	c2 04 00             	ret    $0x4
   11435:	8b 95 44 fe ff ff    	mov    0xfffffe44(%ebp),%edx
   1143b:	8a 0c 10             	mov    (%eax,%edx,1),%cl
   1143e:	42                   	inc    %edx
   1143f:	89 95 44 fe ff ff    	mov    %edx,0xfffffe44(%ebp)
   11445:	84 c9                	test   %cl,%cl
   11447:	0f 85 95 02 00 00    	jne    116e2 <_InbvBitmapThreadMain@4+0x642>
   1144d:	31 d2                	xor    %edx,%edx
   1144f:	89 f0                	mov    %esi,%eax
   11451:	f7 b5 00 fe ff ff    	divl   0xfffffe00(%ebp)
   11457:	85 d2                	test   %edx,%edx
   11459:	0f 84 55 fe ff ff    	je     112b4 <_InbvBitmapThreadMain@4+0x214>
   1145f:	8d 70 01             	lea    0x1(%eax),%esi
   11462:	8b 85 00 fe ff ff    	mov    0xfffffe00(%ebp),%eax
   11468:	0f af f0             	imul   %eax,%esi
   1146b:	e9 44 fe ff ff       	jmp    112b4 <_InbvBitmapThreadMain@4+0x214>
   11470:	83 ec 0c             	sub    $0xc,%esp
   11473:	68 24 30 01 00       	push   $0x13024
   11478:	e8 b3 07 00 00       	call   11c30 <_DbgPrint>
   1147d:	83 c4 10             	add    $0x10,%esp
   11480:	83 ec 0c             	sub    $0xc,%esp
   11483:	8b b5 38 fe ff ff    	mov    0xfffffe38(%ebp),%esi
   11489:	56                   	push   %esi
   1148a:	e8 31 07 00 00       	call   11bc0 <_ExFreePool@4>
   1148f:	8d 85 18 ff ff ff    	lea    0xffffff18(%ebp),%eax
   11495:	c7 04 24 c0 00 00 00 	movl   $0xc0,(%esp)
   1149c:	50                   	push   %eax
   1149d:	e8 0e 07 00 00       	call   11bb0 <_RtlZeroMemory@8>
   114a2:	8d 85 58 fe ff ff    	lea    0xfffffe58(%ebp),%eax
   114a8:	68 c0 00 00 00       	push   $0xc0
   114ad:	50                   	push   %eax
   114ae:	e8 fd 06 00 00       	call   11bb0 <_RtlZeroMemory@8>
   114b3:	8b 15 20 40 01 00    	mov    0x14020,%edx
   114b9:	59                   	pop    %ecx
   114ba:	8b 0a                	mov    (%edx),%ecx
   114bc:	01 d1                	add    %edx,%ecx
   114be:	8b 42 20             	mov    0x20(%edx),%eax
   114c1:	5b                   	pop    %ebx
   114c2:	85 c0                	test   %eax,%eax
   114c4:	89 8d 28 fe ff ff    	mov    %ecx,0xfffffe28(%ebp)
   114ca:	88 85 08 fe ff ff    	mov    %al,0xfffffe08(%ebp)
   114d0:	75 0e                	jne    114e0 <_InbvBitmapThreadMain@4+0x440>
   114d2:	66 8b 4a 0e          	mov    0xe(%edx),%cx
   114d6:	b0 01                	mov    $0x1,%al
   114d8:	d3 e0                	shl    %cl,%eax
   114da:	88 85 08 fe ff ff    	mov    %al,0xfffffe08(%ebp)
   114e0:	31 db                	xor    %ebx,%ebx
   114e2:	c7 85 24 fe ff ff 00 	movl   $0x0,0xfffffe24(%ebp)
   114e9:	00 00 00 
   114ec:	8a 9d 08 fe ff ff    	mov    0xfffffe08(%ebp),%bl
   114f2:	83 fb 00             	cmp    $0x0,%ebx
   114f5:	0f 86 8c 00 00 00    	jbe    11587 <_InbvBitmapThreadMain@4+0x4e7>
   114fb:	8d 75 e8             	lea    0xffffffe8(%ebp),%esi
   114fe:	b9 67 66 66 66       	mov    $0x66666667,%ecx
   11503:	89 b5 e0 fd ff ff    	mov    %esi,0xfffffde0(%ebp)
   11509:	8b bd 24 fe ff ff    	mov    0xfffffe24(%ebp),%edi
   1150f:	8b 85 28 fe ff ff    	mov    0xfffffe28(%ebp),%eax
   11515:	31 d2                	xor    %edx,%edx
   11517:	8b b5 e0 fd ff ff    	mov    0xfffffde0(%ebp),%esi
   1151d:	8a 54 b8 02          	mov    0x2(%eax,%edi,4),%dl
   11521:	c1 e2 08             	shl    $0x8,%edx
   11524:	89 d0                	mov    %edx,%eax
   11526:	f7 e9                	imul   %ecx
   11528:	c1 fa 03             	sar    $0x3,%edx
   1152b:	8b 85 28 fe ff ff    	mov    0xfffffe28(%ebp),%eax
   11531:	89 96 70 fe ff ff    	mov    %edx,0xfffffe70(%esi)
   11537:	31 d2                	xor    %edx,%edx
   11539:	8a 54 b8 01          	mov    0x1(%eax,%edi,4),%dl
   1153d:	c1 e2 08             	shl    $0x8,%edx
   11540:	89 d0                	mov    %edx,%eax
   11542:	f7 e9                	imul   %ecx
   11544:	c1 fa 03             	sar    $0x3,%edx
   11547:	89 96 74 fe ff ff    	mov    %edx,0xfffffe74(%esi)
   1154d:	8b b5 28 fe ff ff    	mov    0xfffffe28(%ebp),%esi
   11553:	31 d2                	xor    %edx,%edx
   11555:	8a 14 be             	mov    (%esi,%edi,4),%dl
   11558:	8b b5 e0 fd ff ff    	mov    0xfffffde0(%ebp),%esi
   1155e:	c1 e2 08             	shl    $0x8,%edx
   11561:	47                   	inc    %edi
   11562:	89 d0                	mov    %edx,%eax
   11564:	89 bd 24 fe ff ff    	mov    %edi,0xfffffe24(%ebp)
   1156a:	f7 e9                	imul   %ecx
   1156c:	c1 fa 03             	sar    $0x3,%edx
   1156f:	89 96 78 fe ff ff    	mov    %edx,0xfffffe78(%esi)
   11575:	83 c6 0c             	add    $0xc,%esi
   11578:	89 b5 e0 fd ff ff    	mov    %esi,0xfffffde0(%ebp)
   1157e:	83 ff 0f             	cmp    $0xf,%edi
   11581:	77 04                	ja     11587 <_InbvBitmapThreadMain@4+0x4e7>
   11583:	39 fb                	cmp    %edi,%ebx
   11585:	77 82                	ja     11509 <_InbvBitmapThreadMain@4+0x469>
   11587:	c7 85 24 fe ff ff 13 	movl   $0x13,0xfffffe24(%ebp)
   1158e:	00 00 00 
   11591:	83 ec 0c             	sub    $0xc,%esp
   11594:	31 ff                	xor    %edi,%edi
   11596:	68 da 03 00 00       	push   $0x3da
   1159b:	e8 b0 06 00 00       	call   11c50 <_READ_PORT_UCHAR@4>
   115a0:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   115a7:	68 c0 03 00 00       	push   $0x3c0
   115ac:	e8 8f 06 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   115b1:	80 bd 08 fe ff ff 00 	cmpb   $0x0,0xfffffe08(%ebp)
   115b8:	58                   	pop    %eax
   115b9:	5a                   	pop    %edx
   115ba:	0f 84 c7 00 00 00    	je     11687 <_InbvBitmapThreadMain@4+0x5e7>
   115c0:	8d 5d e8             	lea    0xffffffe8(%ebp),%ebx
   115c3:	8b 83 30 ff ff ff    	mov    0xffffff30(%ebx),%eax
   115c9:	8b 8b 70 fe ff ff    	mov    0xfffffe70(%ebx),%ecx
   115cf:	01 c1                	add    %eax,%ecx
   115d1:	8b 93 74 fe ff ff    	mov    0xfffffe74(%ebx),%edx
   115d7:	8b 83 34 ff ff ff    	mov    0xffffff34(%ebx),%eax
   115dd:	8b b3 38 ff ff ff    	mov    0xffffff38(%ebx),%esi
   115e3:	01 c2                	add    %eax,%edx
   115e5:	8b 83 78 fe ff ff    	mov    0xfffffe78(%ebx),%eax
   115eb:	01 f0                	add    %esi,%eax
   115ed:	89 93 34 ff ff ff    	mov    %edx,0xffffff34(%ebx)
   115f3:	89 d6                	mov    %edx,%esi
   115f5:	8b 95 28 fe ff ff    	mov    0xfffffe28(%ebp),%edx
   115fb:	89 8b 30 ff ff ff    	mov    %ecx,0xffffff30(%ebx)
   11601:	89 83 38 ff ff ff    	mov    %eax,0xffffff38(%ebx)
   11607:	c1 e9 08             	shr    $0x8,%ecx
   1160a:	8a 54 ba 02          	mov    0x2(%edx,%edi,4),%dl
   1160e:	c1 ee 08             	shr    $0x8,%esi
   11611:	88 95 e6 fd ff ff    	mov    %dl,0xfffffde6(%ebp)
   11617:	c1 e8 08             	shr    $0x8,%eax
   1161a:	38 ca                	cmp    %cl,%dl
   1161c:	73 02                	jae    11620 <_InbvBitmapThreadMain@4+0x580>
   1161e:	88 d1                	mov    %dl,%cl
   11620:	8b 95 28 fe ff ff    	mov    0xfffffe28(%ebp),%edx
   11626:	8a 54 ba 01          	mov    0x1(%edx,%edi,4),%dl
   1162a:	88 95 e6 fd ff ff    	mov    %dl,0xfffffde6(%ebp)
   11630:	89 f2                	mov    %esi,%edx
   11632:	38 95 e6 fd ff ff    	cmp    %dl,0xfffffde6(%ebp)
   11638:	73 07                	jae    11641 <_InbvBitmapThreadMain@4+0x5a1>
   1163a:	0f b6 b5 e6 fd ff ff 	movzbl 0xfffffde6(%ebp),%esi
   11641:	8b 95 28 fe ff ff    	mov    0xfffffe28(%ebp),%edx
   11647:	8a 14 ba             	mov    (%edx,%edi,4),%dl
   1164a:	88 95 e6 fd ff ff    	mov    %dl,0xfffffde6(%ebp)
   11650:	38 c2                	cmp    %al,%dl
   11652:	73 02                	jae    11656 <_InbvBitmapThreadMain@4+0x5b6>
   11654:	88 d0                	mov    %dl,%al
   11656:	25 ff 00 00 00       	and    $0xff,%eax
   1165b:	52                   	push   %edx
   1165c:	52                   	push   %edx
   1165d:	31 d2                	xor    %edx,%edx
   1165f:	50                   	push   %eax
   11660:	89 f0                	mov    %esi,%eax
   11662:	88 ca                	mov    %cl,%dl
   11664:	25 ff 00 00 00       	and    $0xff,%eax
   11669:	89 f9                	mov    %edi,%ecx
   1166b:	50                   	push   %eax
   1166c:	e8 bf f9 ff ff       	call   11030 <@InbvSetColor@16>
   11671:	58                   	pop    %eax
   11672:	31 c0                	xor    %eax,%eax
   11674:	47                   	inc    %edi
   11675:	8a 85 08 fe ff ff    	mov    0xfffffe08(%ebp),%al
   1167b:	83 c3 0c             	add    $0xc,%ebx
   1167e:	5a                   	pop    %edx
   1167f:	39 f8                	cmp    %edi,%eax
   11681:	0f 87 3c ff ff ff    	ja     115c3 <_InbvBitmapThreadMain@4+0x523>
   11687:	83 ec 0c             	sub    $0xc,%esp
   1168a:	68 da 03 00 00       	push   $0x3da
   1168f:	e8 bc 05 00 00       	call   11c50 <_READ_PORT_UCHAR@4>
   11694:	c7 04 24 20 00 00 00 	movl   $0x20,(%esp)
   1169b:	68 c0 03 00 00       	push   $0x3c0
   116a0:	e8 9b 05 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   116a5:	8d 8d 48 fe ff ff    	lea    0xfffffe48(%ebp),%ecx
   116ab:	c7 85 48 fe ff ff c0 	movl   $0xfffcf2c0,0xfffffe48(%ebp)
   116b2:	f2 fc ff 
   116b5:	c7 85 4c fe ff ff ff 	movl   $0xffffffff,0xfffffe4c(%ebp)
   116bc:	ff ff ff 
   116bf:	89 0c 24             	mov    %ecx,(%esp)
   116c2:	6a 00                	push   $0x0
   116c4:	6a 00                	push   $0x0
   116c6:	e8 05 05 00 00       	call   11bd0 <_KeDelayExecutionThread@12>
   116cb:	5f                   	pop    %edi
   116cc:	ff 8d 24 fe ff ff    	decl   0xfffffe24(%ebp)
   116d2:	0f 89 b9 fe ff ff    	jns    11591 <_InbvBitmapThreadMain@4+0x4f1>
   116d8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   116db:	5b                   	pop    %ebx
   116dc:	5e                   	pop    %esi
   116dd:	5f                   	pop    %edi
   116de:	5d                   	pop    %ebp
   116df:	c2 04 00             	ret    $0x4
   116e2:	80 f9 01             	cmp    $0x1,%cl
   116e5:	0f 84 ee fb ff ff    	je     112d9 <_InbvBitmapThreadMain@4+0x239>
   116eb:	80 f9 02             	cmp    $0x2,%cl
   116ee:	0f 84 e2 00 00 00    	je     117d6 <_InbvBitmapThreadMain@4+0x736>
   116f4:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   116fa:	89 c8                	mov    %ecx,%eax
   116fc:	89 8d 3c fe ff ff    	mov    %ecx,0xfffffe3c(%ebp)
   11702:	d1 e8                	shr    %eax
   11704:	89 c2                	mov    %eax,%edx
   11706:	83 f8 00             	cmp    $0x0,%eax
   11709:	77 0b                	ja     11716 <_InbvBitmapThreadMain@4+0x676>
   1170b:	eb 40                	jmp    1174d <_InbvBitmapThreadMain@4+0x6ad>
   1170d:	8d 76 00             	lea    0x0(%esi),%esi
   11710:	8b 1d 20 40 01 00    	mov    0x14020,%ebx
   11716:	8b 8d 40 fe ff ff    	mov    0xfffffe40(%ebp),%ecx
   1171c:	8d 04 0b             	lea    (%ebx,%ecx,1),%eax
   1171f:	8b 9d 44 fe ff ff    	mov    0xfffffe44(%ebp),%ebx
   11725:	8a 0c 18             	mov    (%eax,%ebx,1),%cl
   11728:	43                   	inc    %ebx
   11729:	89 c8                	mov    %ecx,%eax
   1172b:	89 9d 44 fe ff ff    	mov    %ebx,0xfffffe44(%ebp)
   11731:	25 f0 00 00 00       	and    $0xf0,%eax
   11736:	8b 9d 38 fe ff ff    	mov    0xfffffe38(%ebp),%ebx
   1173c:	c1 f8 04             	sar    $0x4,%eax
   1173f:	83 e1 0f             	and    $0xf,%ecx
   11742:	88 04 1e             	mov    %al,(%esi,%ebx,1)
   11745:	46                   	inc    %esi
   11746:	88 0c 1e             	mov    %cl,(%esi,%ebx,1)
   11749:	46                   	inc    %esi
   1174a:	4a                   	dec    %edx
   1174b:	75 c3                	jne    11710 <_InbvBitmapThreadMain@4+0x670>
   1174d:	f6 85 3c fe ff ff 01 	testb  $0x1,0xfffffe3c(%ebp)
   11754:	74 32                	je     11788 <_InbvBitmapThreadMain@4+0x6e8>
   11756:	8b 85 40 fe ff ff    	mov    0xfffffe40(%ebp),%eax
   1175c:	8b 1d 20 40 01 00    	mov    0x14020,%ebx
   11762:	8b 95 44 fe ff ff    	mov    0xfffffe44(%ebp),%edx
   11768:	01 d8                	add    %ebx,%eax
   1176a:	8a 0c 10             	mov    (%eax,%edx,1),%cl
   1176d:	42                   	inc    %edx
   1176e:	89 c8                	mov    %ecx,%eax
   11770:	8b 8d 38 fe ff ff    	mov    0xfffffe38(%ebp),%ecx
   11776:	25 f0 00 00 00       	and    $0xf0,%eax
   1177b:	89 95 44 fe ff ff    	mov    %edx,0xfffffe44(%ebp)
   11781:	c1 f8 04             	sar    $0x4,%eax
   11784:	88 04 0e             	mov    %al,(%esi,%ecx,1)
   11787:	46                   	inc    %esi
   11788:	8b 85 44 fe ff ff    	mov    0xfffffe44(%ebp),%eax
   1178e:	8b 8d 44 fe ff ff    	mov    0xfffffe44(%ebp),%ecx
   11794:	83 e0 01             	and    $0x1,%eax
   11797:	8b 5f 04             	mov    0x4(%edi),%ebx
   1179a:	01 c1                	add    %eax,%ecx
   1179c:	8b 57 14             	mov    0x14(%edi),%edx
   1179f:	8b 47 08             	mov    0x8(%edi),%eax
   117a2:	89 8d 44 fe ff ff    	mov    %ecx,0xfffffe44(%ebp)
   117a8:	89 9d 00 fe ff ff    	mov    %ebx,0xfffffe00(%ebp)
   117ae:	89 85 fc fd ff ff    	mov    %eax,0xfffffdfc(%ebp)
   117b4:	89 95 04 fe ff ff    	mov    %edx,0xfffffe04(%ebp)
   117ba:	e9 f5 fa ff ff       	jmp    112b4 <_InbvBitmapThreadMain@4+0x214>
   117bf:	8b 4f 04             	mov    0x4(%edi),%ecx
   117c2:	8b 7f 08             	mov    0x8(%edi),%edi
   117c5:	89 8d 00 fe ff ff    	mov    %ecx,0xfffffe00(%ebp)
   117cb:	89 bd fc fd ff ff    	mov    %edi,0xfffffdfc(%ebp)
   117d1:	e9 03 fb ff ff       	jmp    112d9 <_InbvBitmapThreadMain@4+0x239>
   117d6:	8b 8d 44 fe ff ff    	mov    0xfffffe44(%ebp),%ecx
   117dc:	31 db                	xor    %ebx,%ebx
   117de:	8a 1c 08             	mov    (%eax,%ecx,1),%bl
   117e1:	41                   	inc    %ecx
   117e2:	89 ca                	mov    %ecx,%edx
   117e4:	89 8d 44 fe ff ff    	mov    %ecx,0xfffffe44(%ebp)
   117ea:	31 c9                	xor    %ecx,%ecx
   117ec:	8a 0c 10             	mov    (%eax,%edx,1),%cl
   117ef:	42                   	inc    %edx
   117f0:	89 f0                	mov    %esi,%eax
   117f2:	89 95 44 fe ff ff    	mov    %edx,0xfffffe44(%ebp)
   117f8:	31 d2                	xor    %edx,%edx
   117fa:	8b b5 00 fe ff ff    	mov    0xfffffe00(%ebp),%esi
   11800:	f7 b5 00 fe ff ff    	divl   0xfffffe00(%ebp)
   11806:	01 c8                	add    %ecx,%eax
   11808:	01 da                	add    %ebx,%edx
   1180a:	0f af c6             	imul   %esi,%eax
   1180d:	8d 34 10             	lea    (%eax,%edx,1),%esi
   11810:	e9 9f fa ff ff       	jmp    112b4 <_InbvBitmapThreadMain@4+0x214>
   11815:	8d 74 26 00          	lea    0x0(%esi),%esi
   11819:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011820 <_VidDispatch@8>:


STATIC BOOLEAN STDCALL
VidInitialize(VOID)
{
   NTSTATUS Status;
   HANDLE BitmapThreadHandle;

   InbvMapVideoMemory();
   InbvInitVGAMode();
  
   Status = PsCreateSystemThread(
      &BitmapThreadHandle,
      THREAD_ALL_ACCESS,
      NULL,
      NULL,
      &BitmapThreadId,
      InbvBitmapThreadMain,
      NULL);
 
   if (!NT_SUCCESS(Status))
   {
      return FALSE;
   }

   ZwClose(BitmapThreadHandle);

   return TRUE;
}


NTSTATUS STDCALL
VidDispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
   11820:	55                   	push   %ebp
   PIO_STACK_LOCATION IrpSp;
   NTSTATUS Status;
   NTBOOTVID_FUNCTION_TABLE* FunctionTable;
 
   IrpSp = IoGetCurrentIrpStackLocation(Irp);
   Status = STATUS_SUCCESS;

   switch(IrpSp->MajorFunction)
   11821:	31 c0                	xor    %eax,%eax
   11823:	89 e5                	mov    %esp,%ebp
   11825:	57                   	push   %edi
   11826:	56                   	push   %esi
   11827:	53                   	push   %ebx
   11828:	83 ec 0c             	sub    $0xc,%esp
   1182b:	31 ff                	xor    %edi,%edi
   1182d:	8b 75 0c             	mov    0xc(%ebp),%esi
   11830:	8b 56 60             	mov    0x60(%esi),%edx
   11833:	8a 02                	mov    (%edx),%al
   11835:	83 f8 02             	cmp    $0x2,%eax
   11838:	74 0b                	je     11845 <_VidDispatch@8+0x25>
   1183a:	7f 24                	jg     11860 <_VidDispatch@8+0x40>
   1183c:	85 c0                	test   %eax,%eax
   1183e:	74 05                	je     11845 <_VidDispatch@8+0x25>
   {
      /* Opening and closing handles to the device */
      case IRP_MJ_CREATE:
      case IRP_MJ_CLOSE:
         break;

      case IRP_MJ_DEVICE_CONTROL:
         switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
         {
            case IOCTL_BOOTVID_INITIALIZE:
               VidInitialize();
               FunctionTable = (NTBOOTVID_FUNCTION_TABLE *)
                  Irp->AssociatedIrp.SystemBuffer;
               FunctionTable->ResetDisplay = VidResetDisplay;
               Irp->IoStatus.Information = sizeof(NTBOOTVID_FUNCTION_TABLE);
               break;

            case IOCTL_BOOTVID_CLEANUP:
               VidCleanUp();	  
               break;

            default:
               Status = STATUS_NOT_IMPLEMENTED;
               break;
         }
         break;

      /* Unsupported operations */
      default:
         Status = STATUS_NOT_IMPLEMENTED;
   11840:	bf 02 00 00 c0       	mov    $0xc0000002,%edi
   }

   Irp->IoStatus.Status = Status;
   11845:	89 7e 18             	mov    %edi,0x18(%esi)
   IoCompleteRequest(Irp, IO_NO_INCREMENT);
   11848:	50                   	push   %eax
   11849:	50                   	push   %eax
   1184a:	6a 00                	push   $0x0
   1184c:	56                   	push   %esi
   1184d:	e8 8e 03 00 00       	call   11be0 <_IoCompleteRequest@8>

   return Status;
}
   11852:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11855:	89 f8                	mov    %edi,%eax
   11857:	5b                   	pop    %ebx
   11858:	5e                   	pop    %esi
   11859:	5f                   	pop    %edi
   1185a:	5d                   	pop    %ebp
   1185b:	c2 08 00             	ret    $0x8
   1185e:	89 f6                	mov    %esi,%esi
   11860:	83 f8 0e             	cmp    $0xe,%eax
   11863:	75 db                	jne    11840 <_VidDispatch@8+0x20>
   11865:	8b 42 0c             	mov    0xc(%edx),%eax
   11868:	3d 04 00 57 d0       	cmp    $0xd0570004,%eax
   1186d:	74 0e                	je     1187d <_VidDispatch@8+0x5d>
   1186f:	3d 08 00 57 d0       	cmp    $0xd0570008,%eax
   11874:	75 ca                	jne    11840 <_VidDispatch@8+0x20>
   11876:	e8 95 f7 ff ff       	call   11010 <_VidCleanUp@0>
   1187b:	eb c8                	jmp    11845 <_VidDispatch@8+0x25>
   1187d:	6a 00                	push   $0x0
   1187f:	68 00 00 01 00       	push   $0x10000
   11884:	6a 00                	push   $0x0
   11886:	68 00 00 0a 00       	push   $0xa0000
   1188b:	e8 60 03 00 00       	call   11bf0 <_MmMapIoSpace@16>
   11890:	a3 40 40 01 00       	mov    %eax,0x14040
   11895:	52                   	push   %edx
   11896:	52                   	push   %edx
   11897:	68 00 00 01 00       	push   $0x10000
   1189c:	50                   	push   %eax
   1189d:	e8 0e 03 00 00       	call   11bb0 <_RtlZeroMemory@8>
   118a2:	31 c0                	xor    %eax,%eax
   118a4:	a0 3b 20 01 00       	mov    0x1203b,%al
   118a9:	50                   	push   %eax
   118aa:	68 c2 03 00 00       	push   $0x3c2
   118af:	e8 8c 03 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   118b4:	6a 00                	push   $0x0
   118b6:	68 c4 03 00 00       	push   $0x3c4
   118bb:	e8 80 03 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   118c0:	6a 01                	push   $0x1
   118c2:	68 c5 03 00 00       	push   $0x3c5
   118c7:	e8 74 03 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   118cc:	5b                   	pop    %ebx
   118cd:	bb 01 00 00 00       	mov    $0x1,%ebx
   118d2:	58                   	pop    %eax
   118d3:	31 c0                	xor    %eax,%eax
   118d5:	88 d8                	mov    %bl,%al
   118d7:	51                   	push   %ecx
   118d8:	51                   	push   %ecx
   118d9:	50                   	push   %eax
   118da:	68 c4 03 00 00       	push   $0x3c4
   118df:	e8 5c 03 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   118e4:	31 c0                	xor    %eax,%eax
   118e6:	8a 83 36 20 01 00    	mov    0x12036(%ebx),%al
   118ec:	43                   	inc    %ebx
   118ed:	50                   	push   %eax
   118ee:	68 c5 03 00 00       	push   $0x3c5
   118f3:	e8 48 03 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   118f8:	83 fb 04             	cmp    $0x4,%ebx
   118fb:	58                   	pop    %eax
   118fc:	5a                   	pop    %edx
   118fd:	76 d4                	jbe    118d3 <_VidDispatch@8+0xb3>
   118ff:	50                   	push   %eax
   11900:	50                   	push   %eax
   11901:	6a 00                	push   $0x0
   11903:	68 c4 03 00 00       	push   $0x3c4
   11908:	e8 33 03 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   1190d:	6a 03                	push   $0x3
   1190f:	68 c5 03 00 00       	push   $0x3c5
   11914:	e8 27 03 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   11919:	6a 11                	push   $0x11
   1191b:	68 d4 03 00 00       	push   $0x3d4
   11920:	e8 1b 03 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   11925:	31 c0                	xor    %eax,%eax
   11927:	a0 11 20 01 00       	mov    0x12011,%al
   1192c:	83 e0 7f             	and    $0x7f,%eax
   1192f:	50                   	push   %eax
   11930:	68 d5 03 00 00       	push   $0x3d5
   11935:	e8 06 03 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   1193a:	5b                   	pop    %ebx
   1193b:	31 db                	xor    %ebx,%ebx
   1193d:	58                   	pop    %eax
   1193e:	89 f6                	mov    %esi,%esi
   11940:	31 c0                	xor    %eax,%eax
   11942:	88 d8                	mov    %bl,%al
   11944:	51                   	push   %ecx
   11945:	51                   	push   %ecx
   11946:	50                   	push   %eax
   11947:	68 d4 03 00 00       	push   $0x3d4
   1194c:	e8 ef 02 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   11951:	31 c0                	xor    %eax,%eax
   11953:	8a 83 00 20 01 00    	mov    0x12000(%ebx),%al
   11959:	43                   	inc    %ebx
   1195a:	50                   	push   %eax
   1195b:	68 d5 03 00 00       	push   $0x3d5
   11960:	e8 db 02 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   11965:	83 fb 17             	cmp    $0x17,%ebx
   11968:	58                   	pop    %eax
   11969:	5a                   	pop    %edx
   1196a:	76 d4                	jbe    11940 <_VidDispatch@8+0x120>
   1196c:	31 db                	xor    %ebx,%ebx
   1196e:	89 f6                	mov    %esi,%esi
   11970:	50                   	push   %eax
   11971:	50                   	push   %eax
   11972:	31 c0                	xor    %eax,%eax
   11974:	88 d8                	mov    %bl,%al
   11976:	50                   	push   %eax
   11977:	68 ce 03 00 00       	push   $0x3ce
   1197c:	e8 bf 02 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   11981:	31 c0                	xor    %eax,%eax
   11983:	8a 83 2d 20 01 00    	mov    0x1202d(%ebx),%al
   11989:	43                   	inc    %ebx
   1198a:	50                   	push   %eax
   1198b:	68 cf 03 00 00       	push   $0x3cf
   11990:	e8 ab 02 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   11995:	83 fb 08             	cmp    $0x8,%ebx
   11998:	59                   	pop    %ecx
   11999:	58                   	pop    %eax
   1199a:	76 d4                	jbe    11970 <_VidDispatch@8+0x150>
   1199c:	31 db                	xor    %ebx,%ebx
   1199e:	89 f6                	mov    %esi,%esi
   119a0:	83 ec 0c             	sub    $0xc,%esp
   119a3:	68 da 03 00 00       	push   $0x3da
   119a8:	e8 a3 02 00 00       	call   11c50 <_READ_PORT_UCHAR@4>
   119ad:	31 c0                	xor    %eax,%eax
   119af:	88 d8                	mov    %bl,%al
   119b1:	89 04 24             	mov    %eax,(%esp)
   119b4:	68 c0 03 00 00       	push   $0x3c0
   119b9:	e8 82 02 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   119be:	31 c0                	xor    %eax,%eax
   119c0:	8a 83 18 20 01 00    	mov    0x12018(%ebx),%al
   119c6:	43                   	inc    %ebx
   119c7:	50                   	push   %eax
   119c8:	68 c0 03 00 00       	push   $0x3c0
   119cd:	e8 6e 02 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   119d2:	83 fb 14             	cmp    $0x14,%ebx
   119d5:	58                   	pop    %eax
   119d6:	5a                   	pop    %edx
   119d7:	76 c7                	jbe    119a0 <_VidDispatch@8+0x180>
   119d9:	50                   	push   %eax
   119da:	50                   	push   %eax
   119db:	68 ff 00 00 00       	push   $0xff
   119e0:	68 c6 03 00 00       	push   $0x3c6
   119e5:	e8 56 02 00 00       	call   11c40 <_WRITE_PORT_UCHAR@8>
   119ea:	31 d2                	xor    %edx,%edx
   119ec:	5b                   	pop    %ebx
   119ed:	58                   	pop    %eax
   119ee:	89 f6                	mov    %esi,%esi
   119f0:	89 d0                	mov    %edx,%eax
   119f2:	42                   	inc    %edx
   119f3:	c1 e0 05             	shl    $0x5,%eax
   119f6:	c7 80 50 40 01 00 80 	movl   $0x80,0x14050(%eax)
   119fd:	00 00 00 
   11a00:	05 50 40 01 00       	add    $0x14050,%eax
   11a05:	83 fa 4f             	cmp    $0x4f,%edx
   11a08:	c7 40 04 40 00 00 00 	movl   $0x40,0x4(%eax)
   11a0f:	c7 40 08 20 00 00 00 	movl   $0x20,0x8(%eax)
   11a16:	c7 40 0c 10 00 00 00 	movl   $0x10,0xc(%eax)
   11a1d:	c7 40 10 08 00 00 00 	movl   $0x8,0x10(%eax)
   11a24:	c7 40 14 04 00 00 00 	movl   $0x4,0x14(%eax)
   11a2b:	c7 40 18 02 00 00 00 	movl   $0x2,0x18(%eax)
   11a32:	c7 40 1c 01 00 00 00 	movl   $0x1,0x1c(%eax)
   11a39:	76 b5                	jbe    119f0 <_VidDispatch@8+0x1d0>
   11a3b:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11a3e:	51                   	push   %ecx
   11a3f:	6a 00                	push   $0x0
   11a41:	68 a0 10 01 00       	push   $0x110a0
   11a46:	68 10 40 01 00       	push   $0x14010
   11a4b:	6a 00                	push   $0x0
   11a4d:	6a 00                	push   $0x0
   11a4f:	68 ff 03 1f 00       	push   $0x1f03ff
   11a54:	50                   	push   %eax
   11a55:	e8 a6 01 00 00       	call   11c00 <_PsCreateSystemThread@28>
   11a5a:	5a                   	pop    %edx
   11a5b:	85 c0                	test   %eax,%eax
   11a5d:	78 0f                	js     11a6e <_VidDispatch@8+0x24e>
   11a5f:	83 ec 0c             	sub    $0xc,%esp
   11a62:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11a65:	50                   	push   %eax
   11a66:	e8 a5 01 00 00       	call   11c10 <_ZwClose@4>
   11a6b:	83 c4 0c             	add    $0xc,%esp
   11a6e:	8b 46 0c             	mov    0xc(%esi),%eax
   11a71:	c7 46 1c 04 00 00 00 	movl   $0x4,0x1c(%esi)
   11a78:	c7 00 00 10 01 00    	movl   $0x11000,(%eax)
   11a7e:	e9 c2 fd ff ff       	jmp    11845 <_VidDispatch@8+0x25>
   11a83:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11a89:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011a90 <_DriverEntry@8>:


NTSTATUS STDCALL
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
   11a90:	55                   	push   %ebp
   11a91:	89 e5                	mov    %esp,%ebp
   11a93:	83 ec 1c             	sub    $0x1c,%esp
   11a96:	8b 55 08             	mov    0x8(%ebp),%edx
   PDEVICE_OBJECT BootVidDevice;
   UNICODE_STRING DeviceName;
   NTSTATUS Status;

   BootVidDriverObject = DriverObject;

   /* Register driver routines */
   DriverObject->MajorFunction[IRP_MJ_CLOSE] = VidDispatch;
   DriverObject->MajorFunction[IRP_MJ_CREATE] = VidDispatch;
   DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VidDispatch;
   DriverObject->DriverUnload = NULL;

   DriverObject->Flags |= DO_BUFFERED_IO;

   /* Create device */
   RtlRosInitUnicodeStringFromLiteral(&DeviceName, L"\\Device\\BootVid");

   Status = IoCreateDevice(
   11a99:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
   11a9c:	66 c7 45 f8 1e 00    	movw   $0x1e,0xfffffff8(%ebp)
   11aa2:	66 c7 45 fa 20 00    	movw   $0x20,0xfffffffa(%ebp)
   11aa8:	8b 4a 08             	mov    0x8(%edx),%ecx
   11aab:	c7 42 40 20 18 01 00 	movl   $0x11820,0x40(%edx)
   11ab2:	83 c9 04             	or     $0x4,%ecx
   11ab5:	c7 42 38 20 18 01 00 	movl   $0x11820,0x38(%edx)
   11abc:	c7 42 70 20 18 01 00 	movl   $0x11820,0x70(%edx)
   11ac3:	c7 42 34 00 00 00 00 	movl   $0x0,0x34(%edx)
   11aca:	89 4a 08             	mov    %ecx,0x8(%edx)
   11acd:	50                   	push   %eax
   11ace:	8d 45 f8             	lea    0xfffffff8(%ebp),%eax
   11ad1:	6a 00                	push   $0x0
   11ad3:	c7 45 fc 5c 30 01 00 	movl   $0x1305c,0xfffffffc(%ebp)
   11ada:	6a 00                	push   $0x0
   11adc:	89 15 00 40 01 00    	mov    %edx,0x14000
   11ae2:	68 57 d0 00 00       	push   $0xd057
   11ae7:	50                   	push   %eax
   11ae8:	6a 00                	push   $0x0
   11aea:	52                   	push   %edx
   11aeb:	e8 30 01 00 00       	call   11c20 <_IoCreateDevice@28>
      DriverObject,
      0,
      &DeviceName,
      FILE_DEVICE_BOOTVID,
      0,
      FALSE,
      &BootVidDevice);

   return Status;
}
   11af0:	c9                   	leave  
   11af1:	c2 08 00             	ret    $0x8
   11af4:	90                   	nop    
   11af5:	90                   	nop    
   11af6:	90                   	nop    
   11af7:	90                   	nop    
   11af8:	90                   	nop    
   11af9:	90                   	nop    
   11afa:	90                   	nop    
   11afb:	90                   	nop    
   11afc:	90                   	nop    
   11afd:	90                   	nop    
   11afe:	90                   	nop    
   11aff:	90                   	nop    

00011b00 <_InbvPutPixels>:
 *   [ESP+10h] - c 4*4-bit color indices
 */
.globl _InbvPutPixels
_InbvPutPixels:
	pushl	%ebp
   11b00:	55                   	push   %ebp
	movl	%esp, %ebp
   11b01:	89 e5                	mov    %esp,%ebp
	pushl	%esi
   11b03:	56                   	push   %esi
	pushl	%ebx
   11b04:	53                   	push   %ebx

  /* Compute mask and put it in EBX
     mask = maskbit[x] */
  movl	0x8(%ebp), %esi
   11b05:	8b 75 08             	mov    0x8(%ebp),%esi
  movl	_maskbit(,%esi, 4), %ebx
   11b08:	8b 1c b5 50 40 01 00 	mov    0x14050(,%esi,4),%ebx

  /* Don't set bit mask if it is already set */
  cmpl  (inbv_last_mask),%ebx
   11b0f:	3b 1d 30 40 01 00    	cmp    0x14030,%ebx
  je  .nomask
   11b15:	74 14                	je     11b2b <.nomask>

  /* Set Mask Bit Register
     WRITE_PORT_UCHAR((PUCHAR)0x3ce,0x08);
     WRITE_PORT_UCHAR((PUCHAR)0x3cf,mask); */
  movl  %ebx,(inbv_last_mask)
   11b17:	89 1d 30 40 01 00    	mov    %ebx,0x14030
  movw  $0x3ce,%dx
   11b1d:	66 ba ce 03          	mov    $0x3ce,%dx
  movb  $0x08,%al
   11b21:	b0 08                	mov    $0x8,%al
  outb  %al,%dx
   11b23:	ee                   	out    %al,(%dx)
  movw  $0x3cf,%dx
   11b24:	66 ba cf 03          	mov    $0x3cf,%dx
  movb  %bl,%al
   11b28:	88 d8                	mov    %bl,%al
  outb  %al,%dx
   11b2a:	ee                   	out    %al,(%dx)

00011b2b <.nomask>:

.nomask:

  /* Compute offset in video memory and put it in EBX
     offset = (x >> 3) + (y << 4) + (y << 6); */
  movl	0xC(%ebp), %esi   /* y */
   11b2b:	8b 75 0c             	mov    0xc(%ebp),%esi
  movl	%esi, %ebx
   11b2e:	89 f3                	mov    %esi,%ebx
  shll  $0x6, %ebx
   11b30:	c1 e3 06             	shl    $0x6,%ebx
  shll  $0x4, %esi
   11b33:	c1 e6 04             	shl    $0x4,%esi
  addl	%esi, %ebx
   11b36:	01 f3                	add    %esi,%ebx
  movl	0x8(%ebp), %eax   /* x */
   11b38:	8b 45 08             	mov    0x8(%ebp),%eax
  shrl  $0x3, %eax
   11b3b:	c1 e8 03             	shr    $0x3,%eax
  addl	%eax, %ebx
   11b3e:	01 c3                	add    %eax,%ebx

  /* Latch first byte
    (UCHAR) READ_REGISTER_UCHAR(VideoMemory + offset+0); */
  movl	(_VideoMemory), %esi
   11b40:	8b 35 40 40 01 00    	mov    0x14040,%esi
  addl	%ebx, %esi
   11b46:	01 de                	add    %ebx,%esi
   movb  0x0(%esi), %bl
   11b48:	8a 5e 00             	mov    0x0(%esi),%bl
  /* Write color index for first pixel
     *((PUCHAR)(VideoMemory + offset+0)) = (c >> 0*8) & 0xff; */
  movl  0x10(%ebp), %eax
   11b4b:	8b 45 10             	mov    0x10(%ebp),%eax
  movb  %al, 0x0(%esi)
   11b4e:	88 46 00             	mov    %al,0x0(%esi)

  /* Latch second byte
    (UCHAR) READ_REGISTER_UCHAR(VideoMemory + offset+1); */
  movb  0x1(%esi), %bl
   11b51:	8a 5e 01             	mov    0x1(%esi),%bl
  /* Write color index for second pixel
     *((PUCHAR)(VideoMemory + offset+1)) = (c >> 1*8) & 0xff; */
  shrl  $0x8, %eax
   11b54:	c1 e8 08             	shr    $0x8,%eax
  movb  %al, 0x1(%esi)
   11b57:	88 46 01             	mov    %al,0x1(%esi)

  /* Latch third byte
    (UCHAR) READ_REGISTER_UCHAR(VideoMemory + offset+2); */
  movb  0x2(%esi), %bl
   11b5a:	8a 5e 02             	mov    0x2(%esi),%bl
  /* Write color index for third pixel
     *((PUCHAR)(VideoMemory + offset+2)) = (c >> 2*8) & 0xff; */
  shrl  $0x8, %eax
   11b5d:	c1 e8 08             	shr    $0x8,%eax
  movb  %al, 0x2(%esi)
   11b60:	88 46 02             	mov    %al,0x2(%esi)

  /* Latch fourth byte
    (UCHAR) READ_REGISTER_UCHAR(VideoMemory + offset+3); */
  movb  0x3(%esi), %bl
   11b63:	8a 5e 03             	mov    0x3(%esi),%bl
  /* Write color index for fourth pixel
     *((PUCHAR)(VideoMemory + offset+3)) = (c >> 3*8) & 0xff; */
  shrl  $0x8, %eax
   11b66:	c1 e8 08             	shr    $0x8,%eax
  movb  %al, 0x3(%esi)
   11b69:	88 46 03             	mov    %al,0x3(%esi)

  popl  %ebx
   11b6c:	5b                   	pop    %ebx
  popl  %esi
   11b6d:	5e                   	pop    %esi
  popl  %ebp
   11b6e:	5d                   	pop    %ebp
	ret
   11b6f:	c3                   	ret    

00011b70 <_MmUnmapIoSpace@8>:
   11b70:	ff 25 c0 50 01 00    	jmp    *0x150c0
   11b76:	90                   	nop    
   11b77:	90                   	nop    
	...

00011b80 <_LdrFindResource_U@16>:
   11b80:	ff 25 b8 50 01 00    	jmp    *0x150b8
   11b86:	90                   	nop    
   11b87:	90                   	nop    
	...

00011b90 <_LdrAccessResource@16>:
   11b90:	ff 25 b4 50 01 00    	jmp    *0x150b4
   11b96:	90                   	nop    
   11b97:	90                   	nop    
	...

00011ba0 <_ExAllocatePool@8>:
   11ba0:	ff 25 a0 50 01 00    	jmp    *0x150a0
   11ba6:	90                   	nop    
   11ba7:	90                   	nop    
	...

00011bb0 <_RtlZeroMemory@8>:
   11bb0:	ff 25 c8 50 01 00    	jmp    *0x150c8
   11bb6:	90                   	nop    
   11bb7:	90                   	nop    
	...

00011bc0 <_ExFreePool@4>:
   11bc0:	ff 25 a4 50 01 00    	jmp    *0x150a4
   11bc6:	90                   	nop    
   11bc7:	90                   	nop    
	...

00011bd0 <_KeDelayExecutionThread@12>:
   11bd0:	ff 25 b0 50 01 00    	jmp    *0x150b0
   11bd6:	90                   	nop    
   11bd7:	90                   	nop    
	...

00011be0 <_IoCompleteRequest@8>:
   11be0:	ff 25 a8 50 01 00    	jmp    *0x150a8
   11be6:	90                   	nop    
   11be7:	90                   	nop    
	...

00011bf0 <_MmMapIoSpace@16>:
   11bf0:	ff 25 bc 50 01 00    	jmp    *0x150bc
   11bf6:	90                   	nop    
   11bf7:	90                   	nop    
	...

00011c00 <_PsCreateSystemThread@28>:
   11c00:	ff 25 c4 50 01 00    	jmp    *0x150c4
   11c06:	90                   	nop    
   11c07:	90                   	nop    
	...

00011c10 <_ZwClose@4>:
   11c10:	ff 25 cc 50 01 00    	jmp    *0x150cc
   11c16:	90                   	nop    
   11c17:	90                   	nop    
	...

00011c20 <_IoCreateDevice@28>:
   11c20:	ff 25 ac 50 01 00    	jmp    *0x150ac
   11c26:	90                   	nop    
   11c27:	90                   	nop    
	...

00011c30 <_DbgPrint>:
   11c30:	ff 25 9c 50 01 00    	jmp    *0x1509c
   11c36:	90                   	nop    
   11c37:	90                   	nop    
	...

00011c40 <_WRITE_PORT_UCHAR@8>:
   11c40:	ff 25 90 50 01 00    	jmp    *0x15090
   11c46:	90                   	nop    
   11c47:	90                   	nop    
	...

00011c50 <_READ_PORT_UCHAR@4>:
   11c50:	ff 25 8c 50 01 00    	jmp    *0x1508c
   11c56:	90                   	nop    
   11c57:	90                   	nop    
	...

00011c60 <__CTOR_LIST__>:
   11c60:	ff                   	(bad)  
   11c61:	ff                   	(bad)  
   11c62:	ff                   	(bad)  
   11c63:	ff 00                	incl   (%eax)
   11c65:	00 00                	add    %al,(%eax)
	...

00011c68 <__DTOR_LIST__>:
   11c68:	ff                   	(bad)  
   11c69:	ff                   	(bad)  
   11c6a:	ff                   	(bad)  
   11c6b:	ff 00                	incl   (%eax)
   11c6d:	00 00                	add    %al,(%eax)
	...
