
class2.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_DriverEntry@8>:

NTSTATUS STDCALL
DriverEntry(IN PDRIVER_OBJECT DriverObject,
	    IN PUNICODE_STRING RegistryPath)
{
   11000:	55                   	push   %ebp
  DPRINT("Class Driver %s\n", VERSION);
  return(STATUS_SUCCESS);
}
   11001:	31 c0                	xor    %eax,%eax
   11003:	89 e5                	mov    %esp,%ebp
   11005:	5d                   	pop    %ebp
   11006:	c2 08 00             	ret    $0x8
   11009:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011010 <_ScsiClassDebugPrint>:


VOID
ScsiClassDebugPrint(IN ULONG DebugPrintLevel,
		    IN PCHAR DebugMessage,
		    ...)
{
   11010:	55                   	push   %ebp
   11011:	89 e5                	mov    %esp,%ebp
   11013:	53                   	push   %ebx
   11014:	81 ec 08 01 00 00    	sub    $0x108,%esp
  char Buffer[256];
  va_list ap;

#if 0
  if (DebugPrintLevel > InternalDebugLevel)
    return;
#endif

  va_start(ap, DebugMessage);
   1101a:	8d 45 10             	lea    0x10(%ebp),%eax
  vsprintf(Buffer, DebugMessage, ap);
   1101d:	8d 9d f8 fe ff ff    	lea    0xfffffef8(%ebp),%ebx
   11023:	50                   	push   %eax
   11024:	8b 45 0c             	mov    0xc(%ebp),%eax
   11027:	50                   	push   %eax
   11028:	53                   	push   %ebx
   11029:	e8 72 22 00 00       	call   132a0 <_vsprintf>
  va_end(ap);

  DbgPrint(Buffer);
   1102e:	89 1c 24             	mov    %ebx,(%esp)
   11031:	e8 5a 22 00 00       	call   13290 <_DbgPrint>
   11036:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11039:	c9                   	leave  
   1103a:	c3                   	ret    
   1103b:	90                   	nop    
   1103c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011040 <_ScsiClassBuildRequest@8>:
}


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassAsynchronousCompletion(IN PDEVICE_OBJECT DeviceObject,
				IN PIRP Irp,
				IN PVOID Context)
{
  PCOMPLETION_CONTEXT CompletionContext;
  PSCSI_REQUEST_BLOCK Srb;

  CompletionContext = (PCOMPLETION_CONTEXT) Context;
  Srb = &CompletionContext->Srb;

  /* Release the queue if it is frozen */
  if (Srb->Function == SRB_FUNCTION_EXECUTE_SCSI &&
      Srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN)
    {
      ScsiClassReleaseQueue (CompletionContext->DeviceObject);
    }

  /* Release the completion context and the IRP */
  if (Irp->MdlAddress != NULL)
    {
      MmUnlockPages (Irp->MdlAddress);
      IoFreeMdl (Irp->MdlAddress);
      Irp->MdlAddress = NULL;
    }
  ExFreePool (CompletionContext);
  IoFreeIrp (Irp);

  return STATUS_MORE_PROCESSING_REQUIRED;
}


/*
 * @implemented
 */
VOID STDCALL
ScsiClassBuildRequest(IN PDEVICE_OBJECT DeviceObject,
		      IN PIRP Irp)
{
   11040:	55                   	push   %ebp
   11041:	89 e5                	mov    %esp,%ebp
   11043:	57                   	push   %edi
   11044:	56                   	push   %esi
   11045:	53                   	push   %ebx
   11046:	83 ec 1c             	sub    $0x1c,%esp
  PDEVICE_EXTENSION DeviceExtension;
  PIO_STACK_LOCATION CurrentIrpStack;
  PIO_STACK_LOCATION NextIrpStack;
  LARGE_INTEGER StartingOffset;
  LARGE_INTEGER StartingBlock;
  PSCSI_REQUEST_BLOCK Srb;
  PCDB Cdb;
  ULONG LogicalBlockAddress;
  USHORT TransferBlocks;

  DeviceExtension = DeviceObject->DeviceExtension;
   11049:	8b 45 08             	mov    0x8(%ebp),%eax
   1104c:	8b 78 28             	mov    0x28(%eax),%edi
  CurrentIrpStack = IoGetCurrentIrpStackLocation(Irp);
   1104f:	8b 45 0c             	mov    0xc(%ebp),%eax
   11052:	8b 40 60             	mov    0x60(%eax),%eax
   11055:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
  NextIrpStack = IoGetNextIrpStackLocation(Irp);
   11058:	83 e8 24             	sub    $0x24,%eax
  StartingOffset = CurrentIrpStack->Parameters.Read.ByteOffset;
   1105b:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   1105e:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   11061:	8b 51 10             	mov    0x10(%ecx),%edx
   11064:	8b 41 0c             	mov    0xc(%ecx),%eax

  /* Calculate logical block address */
  StartingBlock.QuadPart = StartingOffset.QuadPart >> DeviceExtension->SectorShift;
   11067:	31 c9                	xor    %ecx,%ecx
   11069:	8a 8f c0 00 00 00    	mov    0xc0(%edi),%cl
   1106f:	0f ad d0             	shrd   %cl,%edx,%eax
   11072:	d3 fa                	sar    %cl,%edx
   11074:	83 e1 20             	and    $0x20,%ecx
   11077:	74 02                	je     1107b <_ScsiClassBuildRequest@8+0x3b>
   11079:	89 d0                	mov    %edx,%eax
PVOID
ExAllocateFromNPagedLookasideList (
	IN	PNPAGED_LOOKASIDE_LIST	Lookaside
	)
{
   1107b:	8d 5f 68             	lea    0x68(%edi),%ebx
  StartingOffset = CurrentIrpStack->Parameters.Read.ByteOffset;

  /* Calculate logical block address */
  StartingBlock.QuadPart = StartingOffset.QuadPart >> DeviceExtension->SectorShift;
  LogicalBlockAddress = (ULONG)StartingBlock.u.LowPart;
   1107e:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
{
	PVOID Entry;

	Lookaside->TotalAllocates++;
	Entry = ExInterlockedPopEntrySList (&Lookaside->ListHead,
   11081:	8d 97 b0 00 00 00    	lea    0xb0(%edi),%edx
   11087:	89 d9                	mov    %ebx,%ecx
   11089:	8b 43 0c             	mov    0xc(%ebx),%eax
   1108c:	40                   	inc    %eax
   1108d:	89 43 0c             	mov    %eax,0xc(%ebx)
   11090:	e8 ab 1f 00 00       	call   13040 <@ExInterlockedPopEntrySList@8>
   11095:	89 c6                	mov    %eax,%esi
	                                    &Lookaside->Obsoleted);
	if (Entry == NULL)
   11097:	85 c0                	test   %eax,%eax
   11099:	75 1a                	jne    110b5 <_ScsiClassBuildRequest@8+0x75>
	{
		Lookaside->AllocateMisses++;
   1109b:	8b 43 10             	mov    0x10(%ebx),%eax
   1109e:	40                   	inc    %eax
   1109f:	89 43 10             	mov    %eax,0x10(%ebx)
		Entry = (Lookaside->Allocate)(Lookaside->Type,
   110a2:	50                   	push   %eax
   110a3:	8b 43 20             	mov    0x20(%ebx),%eax
   110a6:	50                   	push   %eax
   110a7:	8b 43 24             	mov    0x24(%ebx),%eax
   110aa:	50                   	push   %eax
   110ab:	8b 43 1c             	mov    0x1c(%ebx),%eax
   110ae:	50                   	push   %eax
   110af:	ff 53 28             	call   *0x28(%ebx)
   110b2:	5e                   	pop    %esi
   110b3:	89 c6                	mov    %eax,%esi

  DPRINT("Logical block address: %lu\n", LogicalBlockAddress);

  /* Allocate and initialize an SRB */
  Srb = ExAllocateFromNPagedLookasideList(&DeviceExtension->SrbLookasideListHead);

  Srb->SrbFlags = 0;
  Srb->Length = sizeof(SCSI_REQUEST_BLOCK); //SCSI_REQUEST_BLOCK_SIZE;
  Srb->OriginalRequest = Irp;
   110b5:	8b 45 0c             	mov    0xc(%ebp),%eax
   110b8:	66 c7 06 40 00       	movw   $0x40,(%esi)
   110bd:	c7 46 0c 00 00 00 00 	movl   $0x0,0xc(%esi)
   110c4:	89 46 24             	mov    %eax,0x24(%esi)
  Srb->PathId = DeviceExtension->PathId;
   110c7:	8a 87 bd 00 00 00    	mov    0xbd(%edi),%al
   110cd:	88 46 05             	mov    %al,0x5(%esi)
  Srb->TargetId = DeviceExtension->TargetId;
   110d0:	8a 87 be 00 00 00    	mov    0xbe(%edi),%al
   110d6:	88 46 06             	mov    %al,0x6(%esi)
  Srb->Lun = DeviceExtension->Lun;
   110d9:	8a 87 bf 00 00 00    	mov    0xbf(%edi),%al
  Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
   110df:	c6 46 02 00          	movb   $0x0,0x2(%esi)
   110e3:	88 46 07             	mov    %al,0x7(%esi)
  //FIXME: NT4 DDK sample uses MmGetMdlVirtualAddress! Why shouldn't we?
  Srb->DataBuffer = MmGetSystemAddressForMdl(Irp->MdlAddress);
   110e6:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   110e9:	8b 51 04             	mov    0x4(%ecx),%edx
   110ec:	66 8b 42 06          	mov    0x6(%edx),%ax
   110f0:	a8 05                	test   $0x5,%al
   110f2:	0f 84 f8 00 00 00    	je     111f0 <_ScsiClassBuildRequest@8+0x1b0>
   110f8:	8b 42 0c             	mov    0xc(%edx),%eax
   110fb:	89 46 18             	mov    %eax,0x18(%esi)
  Srb->DataTransferLength = CurrentIrpStack->Parameters.Read.Length;
   110fe:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
  Srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
  Srb->QueueSortKey = LogicalBlockAddress;

  Srb->SenseInfoBuffer = (SENSE_DATA*)ROUND_UP((ULONG_PTR)(Srb + 1), SENSEINFO_ALIGNMENT);
  Srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;

  Srb->TimeOutValue =
    ((Srb->DataTransferLength + 0xFFFF) >> 16) * DeviceExtension->TimeOutValue;

  Srb->SrbStatus = SRB_STATUS_SUCCESS;
  Srb->ScsiStatus = 0;
  Srb->NextSrb = 0;

  Srb->CdbLength = 10;
  Cdb = (PCDB)Srb->Cdb;
   11101:	8d 5e 30             	lea    0x30(%esi),%ebx
   11104:	8b 50 04             	mov    0x4(%eax),%edx
   11107:	c6 46 09 20          	movb   $0x20,0x9(%esi)
   1110b:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   1110e:	89 56 10             	mov    %edx,0x10(%esi)
   11111:	89 46 2c             	mov    %eax,0x2c(%esi)
   11114:	8d 46 5f             	lea    0x5f(%esi),%eax
   11117:	c6 46 0b 12          	movb   $0x12,0xb(%esi)
   1111b:	83 e0 e0             	and    $0xffffffe0,%eax
   1111e:	81 c2 ff ff 00 00    	add    $0xffff,%edx
   11124:	89 46 1c             	mov    %eax,0x1c(%esi)
   11127:	c1 ea 10             	shr    $0x10,%edx
   1112a:	8b 47 50             	mov    0x50(%edi),%eax
   1112d:	0f af d0             	imul   %eax,%edx
   11130:	89 56 14             	mov    %edx,0x14(%esi)
   11133:	c6 46 03 01          	movb   $0x1,0x3(%esi)
   11137:	c6 46 04 00          	movb   $0x0,0x4(%esi)
   1113b:	c7 46 20 00 00 00 00 	movl   $0x0,0x20(%esi)
   11142:	c6 46 0a 0a          	movb   $0xa,0xa(%esi)

  /* Initialize ATAPI packet (12 bytes) */
  RtlZeroMemory(Cdb,
   11146:	50                   	push   %eax
   11147:	50                   	push   %eax
   11148:	6a 0c                	push   $0xc
   1114a:	53                   	push   %ebx
   1114b:	e8 00 1f 00 00       	call   13050 <_RtlZeroMemory@8>
		MAXIMUM_CDB_SIZE);

  Cdb->CDB10.LogicalUnitNumber = DeviceExtension->Lun;
   11150:	8a 97 bf 00 00 00    	mov    0xbf(%edi),%dl
   11156:	8a 43 01             	mov    0x1(%ebx),%al
   11159:	c1 e2 05             	shl    $0x5,%edx
   1115c:	83 e0 1f             	and    $0x1f,%eax
   1115f:	09 d0                	or     %edx,%eax
  TransferBlocks = (USHORT)(CurrentIrpStack->Parameters.Read.Length >> DeviceExtension->SectorShift);
   11161:	31 c9                	xor    %ecx,%ecx
   11163:	88 43 01             	mov    %al,0x1(%ebx)
   11166:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   11169:	8a 8f c0 00 00 00    	mov    0xc0(%edi),%cl
   1116f:	8b 42 04             	mov    0x4(%edx),%eax
   11172:	d3 e8                	shr    %cl,%eax
   11174:	66 89 45 ee          	mov    %ax,0xffffffee(%ebp)

  /* Copy little endian values into CDB in big endian format */
  Cdb->CDB10.LogicalBlockByte0 = ((PFOUR_BYTE)&LogicalBlockAddress)->Byte3;
   11178:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   1117b:	88 43 02             	mov    %al,0x2(%ebx)
  Cdb->CDB10.LogicalBlockByte1 = ((PFOUR_BYTE)&LogicalBlockAddress)->Byte2;
   1117e:	8a 45 f2             	mov    0xfffffff2(%ebp),%al
   11181:	88 43 03             	mov    %al,0x3(%ebx)
  Cdb->CDB10.LogicalBlockByte2 = ((PFOUR_BYTE)&LogicalBlockAddress)->Byte1;
   11184:	8a 45 f1             	mov    0xfffffff1(%ebp),%al
   11187:	88 43 04             	mov    %al,0x4(%ebx)
  Cdb->CDB10.LogicalBlockByte3 = ((PFOUR_BYTE)&LogicalBlockAddress)->Byte0;
   1118a:	8a 45 f0             	mov    0xfffffff0(%ebp),%al
   1118d:	88 43 05             	mov    %al,0x5(%ebx)

  Cdb->CDB10.TransferBlocksMsb = ((PFOUR_BYTE)&TransferBlocks)->Byte1;
   11190:	8a 45 ef             	mov    0xffffffef(%ebp),%al
   11193:	88 43 07             	mov    %al,0x7(%ebx)
  Cdb->CDB10.TransferBlocksLsb = ((PFOUR_BYTE)&TransferBlocks)->Byte0;
   11196:	8a 45 ee             	mov    0xffffffee(%ebp),%al
   11199:	88 43 08             	mov    %al,0x8(%ebx)


  if (CurrentIrpStack->MajorFunction == IRP_MJ_READ)
   1119c:	58                   	pop    %eax
   1119d:	80 3a 03             	cmpb   $0x3,(%edx)
   111a0:	59                   	pop    %ecx
   111a1:	74 5e                	je     11201 <_ScsiClassBuildRequest@8+0x1c1>
    {
      DPRINT("ScsiClassBuildRequest: Read Command\n");

      Srb->SrbFlags |= SRB_FLAGS_DATA_IN;
      Cdb->CDB10.OperationCode = SCSIOP_READ;
    }
  else
    {
      DPRINT("ScsiClassBuildRequest: Write Command\n");

      Srb->SrbFlags |= SRB_FLAGS_DATA_OUT;
   111a3:	8b 4e 0c             	mov    0xc(%esi),%ecx
      Cdb->CDB10.OperationCode = SCSIOP_WRITE;
   111a6:	c6 46 30 2a          	movb   $0x2a,0x30(%esi)
   111aa:	80 c9 80             	or     $0x80,%cl
   111ad:	89 4e 0c             	mov    %ecx,0xc(%esi)
    }

#if 0
  /* if this is not a write-through request, then allow caching */
  if (!(CurrentIrpStack->Flags & SL_WRITE_THROUGH))
    {
      Srb->SrbFlags |= SRB_FLAGS_ADAPTER_CACHE_ENABLE;
    }
  else if (DeviceExtension->DeviceFlags & DEV_WRITE_CACHE)
    {
      /* if write caching is enable then force media access in the cdb */
      Cdb->CDB10.ForceUnitAccess = TRUE;
    }
#endif

  /* Update srb flags */
  Srb->SrbFlags |= DeviceExtension->SrbFlags;
   111b0:	8b 47 58             	mov    0x58(%edi),%eax
   111b3:	8b 56 0c             	mov    0xc(%esi),%edx

  /* Initialize next stack location */
  NextIrpStack->MajorFunction = IRP_MJ_SCSI;
   111b6:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   111b9:	09 c2                	or     %eax,%edx
   111bb:	89 56 0c             	mov    %edx,0xc(%esi)
   111be:	c6 01 0f             	movb   $0xf,(%ecx)
  NextIrpStack->Parameters.Scsi.Srb = Srb;
   111c1:	89 71 04             	mov    %esi,0x4(%ecx)

  /* Set retry count */
  CurrentIrpStack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES;
   111c4:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax

  DPRINT("IoSetCompletionRoutine (Irp %p  Srb %p)\n", Irp, Srb);
  IoSetCompletionRoutine(Irp,
   111c7:	8b 55 0c             	mov    0xc(%ebp),%edx
   111ca:	c7 40 10 0f 00 00 00 	movl   $0xf,0x10(%eax)
   111d1:	8b 42 60             	mov    0x60(%edx),%eax
   111d4:	83 e8 24             	sub    $0x24,%eax
   111d7:	c7 40 1c 50 1f 01 00 	movl   $0x11f50,0x1c(%eax)
   111de:	89 70 20             	mov    %esi,0x20(%eax)
   111e1:	c6 40 03 e0          	movb   $0xe0,0x3(%eax)
   111e5:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   111e8:	5b                   	pop    %ebx
   111e9:	5e                   	pop    %esi
   111ea:	5f                   	pop    %edi
   111eb:	5d                   	pop    %ebp
   111ec:	c2 08 00             	ret    $0x8
   111ef:	90                   	nop    
   111f0:	53                   	push   %ebx
   111f1:	53                   	push   %ebx
   111f2:	6a 00                	push   $0x0
   111f4:	52                   	push   %edx
   111f5:	e8 66 1e 00 00       	call   13060 <_MmMapLockedPages@8>
   111fa:	5a                   	pop    %edx
   111fb:	59                   	pop    %ecx
   111fc:	e9 fa fe ff ff       	jmp    110fb <_ScsiClassBuildRequest@8+0xbb>
   11201:	8b 5e 0c             	mov    0xc(%esi),%ebx
   11204:	c6 46 30 28          	movb   $0x28,0x30(%esi)
   11208:	83 cb 40             	or     $0x40,%ebx
   1120b:	89 5e 0c             	mov    %ebx,0xc(%esi)
   1120e:	eb a0                	jmp    111b0 <_ScsiClassBuildRequest@8+0x170>

00011210 <_ScsiClassClaimDevice@16>:
			 ScsiClassIoComplete,
			 Srb,
			 TRUE,
			 TRUE,
			 TRUE);
}


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassClaimDevice(PDEVICE_OBJECT PortDeviceObject,
		     PSCSI_INQUIRY_DATA LunInfo,
		     BOOLEAN Release,
		     PDEVICE_OBJECT *NewPortDeviceObject OPTIONAL)
{
   11210:	55                   	push   %ebp
   11211:	89 e5                	mov    %esp,%ebp
   11213:	57                   	push   %edi
   11214:	56                   	push   %esi
   11215:	53                   	push   %ebx
   11216:	83 ec 6c             	sub    $0x6c,%esp
   11219:	8b 7d 14             	mov    0x14(%ebp),%edi
   1121c:	8a 45 10             	mov    0x10(%ebp),%al
   1121f:	8b 75 08             	mov    0x8(%ebp),%esi
   11222:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11225:	88 45 8f             	mov    %al,0xffffff8f(%ebp)
  PIO_STACK_LOCATION IoStack;
  IO_STATUS_BLOCK IoStatusBlock;
  SCSI_REQUEST_BLOCK Srb;
  KEVENT Event;
  PIRP Irp;
  NTSTATUS Status;

  DPRINT("ScsiClassClaimDevice() called\n");

  if (NewPortDeviceObject != NULL)
   11228:	85 ff                	test   %edi,%edi
   1122a:	74 06                	je     11232 <_ScsiClassClaimDevice@16+0x22>
    *NewPortDeviceObject = NULL;
   1122c:	c7 07 00 00 00 00    	movl   $0x0,(%edi)

  /* initialize an SRB */
  RtlZeroMemory(&Srb,
   11232:	8d 4d a8             	lea    0xffffffa8(%ebp),%ecx
   11235:	50                   	push   %eax
   11236:	50                   	push   %eax
   11237:	6a 40                	push   $0x40
   11239:	51                   	push   %ecx
   1123a:	e8 11 1e 00 00       	call   13050 <_RtlZeroMemory@8>
		sizeof(SCSI_REQUEST_BLOCK));
  Srb.Length = SCSI_REQUEST_BLOCK_SIZE;
   1123f:	66 c7 45 a8 40 00    	movw   $0x40,0xffffffa8(%ebp)
  Srb.PathId = LunInfo->PathId;
   11245:	8a 03                	mov    (%ebx),%al
   11247:	88 45 ad             	mov    %al,0xffffffad(%ebp)
  Srb.TargetId = LunInfo->TargetId;
   1124a:	8a 43 01             	mov    0x1(%ebx),%al
   1124d:	88 45 ae             	mov    %al,0xffffffae(%ebp)
  Srb.Lun = LunInfo->Lun;
   11250:	8a 43 02             	mov    0x2(%ebx),%al
  Srb.Function =
    (Release == TRUE) ? SRB_FUNCTION_RELEASE_DEVICE : SRB_FUNCTION_CLAIM_DEVICE;

  KeInitializeEvent(&Event,
   11253:	8d 5d 98             	lea    0xffffff98(%ebp),%ebx
   11256:	80 7d 8f 01          	cmpb   $0x1,0xffffff8f(%ebp)
   1125a:	88 45 af             	mov    %al,0xffffffaf(%ebp)
   1125d:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11264:	0f 94 c0             	sete   %al
   11267:	6a 00                	push   $0x0
   11269:	53                   	push   %ebx
   1126a:	8d 44 80 01          	lea    0x1(%eax,%eax,4),%eax
   1126e:	88 45 aa             	mov    %al,0xffffffaa(%ebp)
   11271:	e8 fa 1d 00 00       	call   13070 <_KeInitializeEvent@12>
		    NotificationEvent,
		    FALSE);

  Irp = IoBuildDeviceIoControlRequest(IOCTL_SCSI_EXECUTE_NONE,
   11276:	50                   	push   %eax
   11277:	50                   	push   %eax
   11278:	8d 45 90             	lea    0xffffff90(%ebp),%eax
   1127b:	50                   	push   %eax
   1127c:	53                   	push   %ebx
   1127d:	6a 01                	push   $0x1
   1127f:	6a 00                	push   $0x0
   11281:	6a 00                	push   $0x0
   11283:	6a 00                	push   $0x0
   11285:	6a 00                	push   $0x0
   11287:	56                   	push   %esi
   11288:	68 13 00 1b 00       	push   $0x1b0013
   1128d:	e8 ee 1d 00 00       	call   13080 <_IoBuildDeviceIoControlRequest@36>
   11292:	89 c2                	mov    %eax,%edx
				      PortDeviceObject,
				      NULL,
				      0,
				      NULL,
				      0,
				      TRUE,
				      &Event,
				      &IoStatusBlock);
  if (Irp == NULL)
   11294:	83 c4 0c             	add    $0xc,%esp
    {
      DPRINT("Failed to allocate Irp!\n");
      return(STATUS_INSUFFICIENT_RESOURCES);
   11297:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   1129c:	85 d2                	test   %edx,%edx
   1129e:	74 3b                	je     112db <_ScsiClassClaimDevice@16+0xcb>
    }

  /* Link Srb and Irp */
  IoStack = IoGetNextIrpStackLocation(Irp);
   112a0:	8b 42 60             	mov    0x60(%edx),%eax
  IoStack->Parameters.Scsi.Srb = &Srb;
   112a3:	8d 4d a8             	lea    0xffffffa8(%ebp),%ecx
   112a6:	83 e8 24             	sub    $0x24,%eax
   112a9:	89 48 04             	mov    %ecx,0x4(%eax)
  Srb.OriginalRequest = Irp;
   112ac:	89 55 cc             	mov    %edx,0xffffffcc(%ebp)

  /* Call SCSI port driver */
  Status = IoCallDriver(PortDeviceObject,
   112af:	50                   	push   %eax
   112b0:	50                   	push   %eax
   112b1:	52                   	push   %edx
   112b2:	56                   	push   %esi
   112b3:	e8 d8 1d 00 00       	call   13090 <_IoCallDriver@8>
			Irp);
  if (Status == STATUS_PENDING)
   112b8:	5a                   	pop    %edx
   112b9:	3d 03 01 00 00       	cmp    $0x103,%eax
   112be:	59                   	pop    %ecx
   112bf:	74 2f                	je     112f0 <_ScsiClassClaimDevice@16+0xe0>
    {
      KeWaitForSingleObject(&Event,
			    Suspended,
			    KernelMode,
			    FALSE,
			    NULL);
      Status = IoStatusBlock.Status;
    }

  if (Release == TRUE)
   112c1:	80 7d 8f 01          	cmpb   $0x1,0xffffff8f(%ebp)
   112c5:	74 1e                	je     112e5 <_ScsiClassClaimDevice@16+0xd5>
    {
      ObDereferenceObject(PortDeviceObject);
      return(STATUS_SUCCESS);
    }

//  Status = ObReferenceObjectByPointer(Srb.DataBuffer,
  Status = ObReferenceObjectByPointer(PortDeviceObject,
   112c7:	6a 00                	push   $0x0
   112c9:	6a 00                	push   $0x0
   112cb:	6a 00                	push   $0x0
   112cd:	56                   	push   %esi
   112ce:	e8 cd 1d 00 00       	call   130a0 <_ObReferenceObjectByPointer@16>
				      0,
				      NULL,
				      KernelMode);

  if (NewPortDeviceObject != NULL)
   112d3:	85 ff                	test   %edi,%edi
   112d5:	74 02                	je     112d9 <_ScsiClassClaimDevice@16+0xc9>
    {
//      *NewPortDeviceObject = Srb.DataBuffer;
      *NewPortDeviceObject = PortDeviceObject;
   112d7:	89 37                	mov    %esi,(%edi)
    }

  return(STATUS_SUCCESS);
   112d9:	31 c0                	xor    %eax,%eax
}
   112db:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   112de:	5b                   	pop    %ebx
   112df:	5e                   	pop    %esi
   112e0:	5f                   	pop    %edi
   112e1:	5d                   	pop    %ebp
   112e2:	c2 10 00             	ret    $0x10
   112e5:	89 f1                	mov    %esi,%ecx
   112e7:	e8 c4 1d 00 00       	call   130b0 <@ObfDereferenceObject@4>
   112ec:	eb eb                	jmp    112d9 <_ScsiClassClaimDevice@16+0xc9>
   112ee:	89 f6                	mov    %esi,%esi
   112f0:	83 ec 0c             	sub    $0xc,%esp
   112f3:	6a 00                	push   $0x0
   112f5:	6a 00                	push   $0x0
   112f7:	6a 00                	push   $0x0
   112f9:	6a 05                	push   $0x5
   112fb:	53                   	push   %ebx
   112fc:	e8 bf 1d 00 00       	call   130c0 <_KeWaitForSingleObject@20>
   11301:	83 c4 0c             	add    $0xc,%esp
   11304:	eb bb                	jmp    112c1 <_ScsiClassClaimDevice@16+0xb1>
   11306:	8d 76 00             	lea    0x0(%esi),%esi
   11309:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011310 <_ScsiClassCreateDeviceObject@20>:


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassCreateDeviceObject(IN PDRIVER_OBJECT DriverObject,
			    IN PCCHAR ObjectNameBuffer,
			    IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
			    IN OUT PDEVICE_OBJECT *DeviceObject,
			    IN PCLASS_INIT_DATA InitializationData)
{
   11310:	55                   	push   %ebp
   11311:	89 e5                	mov    %esp,%ebp
   11313:	57                   	push   %edi
   11314:	56                   	push   %esi
   11315:	53                   	push   %ebx
   11316:	83 ec 24             	sub    $0x24,%esp
  PDEVICE_OBJECT InternalDeviceObject;
  PDEVICE_EXTENSION DeviceExtension;
  ANSI_STRING AnsiName;
  UNICODE_STRING DeviceName;
  NTSTATUS Status;

  DPRINT("ScsiClassCreateDeviceObject() called\n");

  *DeviceObject = NULL;

  RtlInitAnsiString(&AnsiName,
   11319:	8d 5d e8             	lea    0xffffffe8(%ebp),%ebx
   1131c:	8b 45 14             	mov    0x14(%ebp),%eax
   1131f:	8b 75 18             	mov    0x18(%ebp),%esi
		    ObjectNameBuffer);

  Status = RtlAnsiStringToUnicodeString(&DeviceName,
   11322:	8d 7d e0             	lea    0xffffffe0(%ebp),%edi
   11325:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   1132b:	8b 45 0c             	mov    0xc(%ebp),%eax
   1132e:	50                   	push   %eax
   1132f:	53                   	push   %ebx
   11330:	e8 9b 1d 00 00       	call   130d0 <_RtlInitAnsiString@8>
   11335:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
   1133c:	53                   	push   %ebx
   1133d:	57                   	push   %edi
   1133e:	e8 9d 1d 00 00       	call   130e0 <_RtlAnsiStringToUnicodeString@12>
   11343:	89 c3                	mov    %eax,%ebx
					&AnsiName,
					TRUE);
  if (!NT_SUCCESS(Status))
   11345:	58                   	pop    %eax
   11346:	85 db                	test   %ebx,%ebx
   11348:	78 7c                	js     113c6 <_ScsiClassCreateDeviceObject@20+0xb6>
    {
      return(Status);
    }

  DPRINT("Device name: '%wZ'\n", &DeviceName);

  Status = IoCreateDevice(DriverObject,
   1134a:	50                   	push   %eax
   1134b:	8d 45 dc             	lea    0xffffffdc(%ebp),%eax
   1134e:	50                   	push   %eax
   1134f:	6a 00                	push   $0x0
   11351:	8b 5e 0c             	mov    0xc(%esi),%ebx
   11354:	8b 45 08             	mov    0x8(%ebp),%eax
   11357:	53                   	push   %ebx
   11358:	8b 4e 08             	mov    0x8(%esi),%ecx
   1135b:	51                   	push   %ecx
   1135c:	57                   	push   %edi
   1135d:	8b 56 04             	mov    0x4(%esi),%edx
   11360:	52                   	push   %edx
   11361:	50                   	push   %eax
   11362:	e8 89 1d 00 00       	call   130f0 <_IoCreateDevice@28>
   11367:	89 c3                	mov    %eax,%ebx
			  InitializationData->DeviceExtensionSize,
			  &DeviceName,
			  InitializationData->DeviceType,
			  InitializationData->DeviceCharacteristics,
			  FALSE,
			  &InternalDeviceObject);
  if (NT_SUCCESS(Status))
   11369:	58                   	pop    %eax
   1136a:	85 db                	test   %ebx,%ebx
   1136c:	78 4f                	js     113bd <_ScsiClassCreateDeviceObject@20+0xad>
    {
      DeviceExtension = InternalDeviceObject->DeviceExtension;
   1136e:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx

      DeviceExtension->ClassError = InitializationData->ClassError;
   11371:	8b 46 10             	mov    0x10(%esi),%eax
   11374:	8b 51 28             	mov    0x28(%ecx),%edx
   11377:	89 42 24             	mov    %eax,0x24(%edx)
      DeviceExtension->ClassReadWriteVerification = InitializationData->ClassReadWriteVerification;
   1137a:	8b 46 14             	mov    0x14(%esi),%eax
   1137d:	89 42 28             	mov    %eax,0x28(%edx)
      DeviceExtension->ClassFindDevices = InitializationData->ClassFindDevices;
   11380:	8b 46 1c             	mov    0x1c(%esi),%eax
   11383:	89 42 2c             	mov    %eax,0x2c(%edx)
      DeviceExtension->ClassDeviceControl = InitializationData->ClassDeviceControl;
   11386:	8b 46 20             	mov    0x20(%esi),%eax
   11389:	89 42 30             	mov    %eax,0x30(%edx)
      DeviceExtension->ClassShutdownFlush = InitializationData->ClassShutdownFlush;
      DeviceExtension->ClassCreateClose = InitializationData->ClassCreateClose;
      DeviceExtension->ClassStartIo = InitializationData->ClassStartIo;

      DeviceExtension->MediaChangeCount = 0;
   1138c:	c7 82 d0 00 00 00 00 	movl   $0x0,0xd0(%edx)
   11393:	00 00 00 
   11396:	8b 46 24             	mov    0x24(%esi),%eax
   11399:	89 42 34             	mov    %eax,0x34(%edx)
   1139c:	8b 46 28             	mov    0x28(%esi),%eax
   1139f:	89 42 38             	mov    %eax,0x38(%edx)
   113a2:	8b 46 2c             	mov    0x2c(%esi),%eax
   113a5:	89 42 3c             	mov    %eax,0x3c(%edx)

      if (PhysicalDeviceObject != NULL)
   113a8:	8b 45 10             	mov    0x10(%ebp),%eax
   113ab:	85 c0                	test   %eax,%eax
   113ad:	74 23                	je     113d2 <_ScsiClassCreateDeviceObject@20+0xc2>
	{
	  DeviceExtension->PhysicalDevice = PhysicalDeviceObject;
   113af:	8b 45 10             	mov    0x10(%ebp),%eax
   113b2:	89 42 48             	mov    %eax,0x48(%edx)
	}
      else
	{
	  DeviceExtension->PhysicalDevice = InternalDeviceObject;
        }

      *DeviceObject = InternalDeviceObject;
   113b5:	8b 55 14             	mov    0x14(%ebp),%edx
   113b8:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   113bb:	89 02                	mov    %eax,(%edx)
    }

  RtlFreeUnicodeString(&DeviceName);
   113bd:	83 ec 0c             	sub    $0xc,%esp
   113c0:	57                   	push   %edi
   113c1:	e8 3a 1d 00 00       	call   13100 <_RtlFreeUnicodeString@4>

  return(Status);
}
   113c6:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   113c9:	89 d8                	mov    %ebx,%eax
   113cb:	5b                   	pop    %ebx
   113cc:	5e                   	pop    %esi
   113cd:	5f                   	pop    %edi
   113ce:	5d                   	pop    %ebp
   113cf:	c2 14 00             	ret    $0x14
   113d2:	89 4a 48             	mov    %ecx,0x48(%edx)
   113d5:	eb de                	jmp    113b5 <_ScsiClassCreateDeviceObject@20+0xa5>
   113d7:	89 f6                	mov    %esi,%esi
   113d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000113e0 <_ScsiClassFindModePage@16>:


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassDeviceControl(IN PDEVICE_OBJECT DeviceObject,
		       IN PIRP Irp)
{
  PDEVICE_EXTENSION DeviceExtension;
  PIO_STACK_LOCATION NextStack;
  PIO_STACK_LOCATION Stack;
  ULONG IoControlCode;
  ULONG InputBufferLength;
  ULONG OutputBufferLength;
  ULONG ModifiedControlCode;
  PSCSI_REQUEST_BLOCK Srb;
  PCDB Cdb;
  PIRP SubIrp;

  DPRINT("ScsiClassDeviceControl() called\n");

  DeviceExtension = DeviceObject->DeviceExtension;
  Stack = IoGetCurrentIrpStackLocation(Irp);

  IoControlCode = Stack->Parameters.DeviceIoControl.IoControlCode;
  InputBufferLength = Stack->Parameters.DeviceIoControl.InputBufferLength;
  OutputBufferLength = Stack->Parameters.DeviceIoControl.OutputBufferLength;

  if (IoControlCode == IOCTL_SCSI_GET_DUMP_POINTERS)
    {
      PDUMP_POINTERS DumpPointers;

      if (OutputBufferLength < sizeof(DUMP_POINTERS))
	{
	  Irp->IoStatus.Information = 0;
	  Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
	  IoCompleteRequest(Irp, IO_NO_INCREMENT);

	  return(STATUS_BUFFER_TOO_SMALL);
	}
      DumpPointers = (PDUMP_POINTERS)Irp->AssociatedIrp.SystemBuffer;

      /* Initialize next stack location for call to the port driver */
      NextStack = IoGetNextIrpStackLocation(Irp);

      NextStack->Parameters = Stack->Parameters;
      NextStack->MajorFunction = Stack->MajorFunction;
      NextStack->MinorFunction = Stack->MinorFunction;

      /* Call port driver */
      return(IoCallDriver(DeviceExtension->PortDeviceObject,
			  Irp));
    }
  if (IoControlCode == IOCTL_SCSI_GET_ADDRESS)
    {
      PSCSI_ADDRESS ScsiAddress;

      if (OutputBufferLength < sizeof(SCSI_ADDRESS))
	{
	  Irp->IoStatus.Information = 0;
	  Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
	  IoCompleteRequest(Irp, IO_NO_INCREMENT);

	  return(STATUS_BUFFER_TOO_SMALL);
	}

      ScsiAddress = Irp->AssociatedIrp.SystemBuffer;
      ScsiAddress->Length = sizeof(SCSI_ADDRESS);
      ScsiAddress->PortNumber = DeviceExtension->PortNumber;
      ScsiAddress->PathId = DeviceExtension->PathId;
      ScsiAddress->TargetId = DeviceExtension->TargetId;
      ScsiAddress->Lun = DeviceExtension->Lun;

      Irp->IoStatus.Information = sizeof(SCSI_ADDRESS);
      Irp->IoStatus.Status = STATUS_SUCCESS;
      IoCompleteRequest(Irp, IO_NO_INCREMENT);

      return(STATUS_SUCCESS);
    }

  if (IoControlCode == IOCTL_SCSI_PASS_THROUGH ||
      IoControlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT)
    {
      PSCSI_PASS_THROUGH ScsiPassThrough;

      DPRINT("IOCTL_SCSI_PASS_THROUGH/IOCTL_SCSI_PASS_THROUGH_DIRECT\n");

      /* Check input size */
      if (InputBufferLength < sizeof(SCSI_PASS_THROUGH))
	{
	  Irp->IoStatus.Information = 0;
	  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
	  IoCompleteRequest(Irp, IO_NO_INCREMENT);
	  return(STATUS_INVALID_PARAMETER);
	}

      /* Initialize next stack location for call to the port driver */
      NextStack = IoGetNextIrpStackLocation(Irp);

      ScsiPassThrough = Irp->AssociatedIrp.SystemBuffer;
      ScsiPassThrough->PathId = DeviceExtension->PathId;
      ScsiPassThrough->TargetId = DeviceExtension->TargetId;
      ScsiPassThrough->Lun = DeviceExtension->Lun;
      ScsiPassThrough->Cdb[1] |= DeviceExtension->Lun << 5;

      NextStack->Parameters = Stack->Parameters;
      NextStack->MajorFunction = Stack->MajorFunction;
      NextStack->MinorFunction = Stack->MinorFunction;

      /* Call port driver */
      return(IoCallDriver(DeviceExtension->PortDeviceObject,
			  Irp));
    }

  /* Allocate and initialize an SRB */
  Srb = ExAllocateFromNPagedLookasideList(&DeviceExtension->SrbLookasideListHead);

  if (Srb == NULL)
    {
      Irp->IoStatus.Information = 0;
      Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
      IoCompleteRequest(Irp,
			IO_NO_INCREMENT);
      return(STATUS_INSUFFICIENT_RESOURCES);
    }

  /* Initialize the SRB */
  RtlZeroMemory(Srb,
		sizeof(SCSI_REQUEST_BLOCK));
  Cdb = (PCDB)Srb->Cdb;

  ModifiedControlCode = (IoControlCode & 0x0000FFFF) | (IOCTL_DISK_BASE << 16);
  switch (ModifiedControlCode)
    {
      case IOCTL_DISK_CHECK_VERIFY:
	DPRINT ("ScsiClassDeviceControl: IOCTL_DISK_CHECK_VERIFY\n");

	if (OutputBufferLength != 0)
	  {
	    if (OutputBufferLength < sizeof(ULONG))
	      {
		DPRINT ("ScsiClassDeviceControl: IOCTL_DISK_CHECK_VERIFY SMALL\n");
		Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
		Irp->IoStatus.Information = 0;
                /* Free the SRB */
                ExFreeToNPagedLookasideList(&DeviceExtension->SrbLookasideListHead,
			                    Srb);
		IoCompleteRequest (Irp,
				   IO_NO_INCREMENT);
		return STATUS_BUFFER_TOO_SMALL;
	      }

	    /* Allocate new IRP for TEST UNIT READY scsi command */
	    SubIrp = IoAllocateIrp ((CCHAR)DeviceObject->StackSize + 3,
				    FALSE);
	    if (SubIrp == NULL)
	      {
	        DPRINT ("ScsiClassDeviceControl: IOCTL_DISK_CHECK_VERIFY NotEnuf\n");
		Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
		Irp->IoStatus.Information = 0;
                /* Free the SRB */
                ExFreeToNPagedLookasideList(&DeviceExtension->SrbLookasideListHead,
			                    Srb);
		IoCompleteRequest (Irp,
				   IO_NO_INCREMENT);
		return STATUS_INSUFFICIENT_RESOURCES;
	      }

	    SubIrp->Tail.Overlay.Thread = Irp->Tail.Overlay.Thread;
	    IoSetNextIrpStackLocation (SubIrp);

	    NextStack = IoGetCurrentIrpStackLocation (SubIrp);
	    NextStack->Parameters.Others.Argument1 = Irp;
	    NextStack->DeviceObject = DeviceObject;

	    IoSetCompletionRoutine (SubIrp,
				    ScsiClassCheckVerifyCompletion,
				    NULL,
				    TRUE,
				    TRUE,
				    TRUE);

	DPRINT ("ScsiClassDeviceControl: IOCTL_DISK_CHECK_VERIFY IoSet\n");

	    IoSetNextIrpStackLocation (SubIrp);
	    NextStack = IoGetCurrentIrpStackLocation (SubIrp);
	    NextStack->DeviceObject = DeviceObject;

	    IoMarkIrpPending (Irp);

	    Irp = SubIrp;
	  }

	/* Initialize SRB operation */
	Srb->CdbLength = 6;
	Srb->TimeOutValue = DeviceExtension->TimeOutValue;
	Cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;

DPRINT ("ScsiClassDeviceControl: IOCTL_DISK_CHECK_VERIFY SrbAsync\n");

	return(ScsiClassSendSrbAsynchronous(DeviceObject,
					    Srb,
					    Irp,
					    NULL,
					    0,
					    FALSE));

      default:
	DPRINT("Unknown device io control code %lx\n",
		ModifiedControlCode);
        /* Free the SRB */
        ExFreeToNPagedLookasideList(&DeviceExtension->SrbLookasideListHead,
			            Srb);
	/* Pass the IOCTL down to the port driver */
	NextStack = IoGetNextIrpStackLocation(Irp);
	NextStack->Parameters = Stack->Parameters;
	NextStack->MajorFunction = Stack->MajorFunction;
	NextStack->MinorFunction = Stack->MinorFunction;

	/* Call port driver */
	return(IoCallDriver(DeviceExtension->PortDeviceObject,
			    Irp));
    }

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

  return(STATUS_UNSUCCESSFUL);
}


/*
 * @implemented
 */
PVOID STDCALL
ScsiClassFindModePage(IN PCHAR ModeSenseBuffer,
		      IN ULONG Length,
		      IN UCHAR PageMode,
		      IN BOOLEAN Use6Byte)
{
   113e0:	55                   	push   %ebp
   113e1:	89 e5                	mov    %esp,%ebp
   113e3:	57                   	push   %edi
   113e4:	56                   	push   %esi
   113e5:	53                   	push   %ebx
   113e6:	8a 4d 14             	mov    0x14(%ebp),%cl
   113e9:	8b 7d 0c             	mov    0xc(%ebp),%edi
  ULONG DescriptorLength;
  ULONG HeaderLength;
  PCHAR End;
  PCHAR Ptr;

  DPRINT("ScsiClassFindModePage() called\n");

  /* Get header length */
  HeaderLength = (Use6Byte) ? sizeof(MODE_PARAMETER_HEADER) : sizeof(MODE_PARAMETER_HEADER10);
   113ec:	80 f9 01             	cmp    $0x1,%cl
   113ef:	8b 75 08             	mov    0x8(%ebp),%esi
   113f2:	19 d2                	sbb    %edx,%edx
   113f4:	8a 5d 10             	mov    0x10(%ebp),%bl
   113f7:	83 e2 04             	and    $0x4,%edx

  /* Check header length */
  if (Length < HeaderLength)
    return NULL;
   113fa:	31 c0                	xor    %eax,%eax
   113fc:	83 c2 04             	add    $0x4,%edx
   113ff:	39 d7                	cmp    %edx,%edi
   11401:	72 2a                	jb     1142d <_ScsiClassFindModePage@16+0x4d>

  /* Get descriptor length */
  if (Use6Byte == TRUE)
   11403:	fe c9                	dec    %cl
   11405:	74 36                	je     1143d <_ScsiClassFindModePage@16+0x5d>
    {
      DescriptorLength = ((PMODE_PARAMETER_HEADER)ModeSenseBuffer)->BlockDescriptorLength;
    }
  else
    {
      DescriptorLength = ((PMODE_PARAMETER_HEADER10)ModeSenseBuffer)->BlockDescriptorLength[1];
   11407:	31 c9                	xor    %ecx,%ecx
   11409:	8a 4e 07             	mov    0x7(%esi),%cl
    }

  /* Set page pointers */
  Ptr = ModeSenseBuffer + HeaderLength + DescriptorLength;
   1140c:	8d 04 16             	lea    (%esi,%edx,1),%eax
   1140f:	8d 14 08             	lea    (%eax,%ecx,1),%edx
  End = ModeSenseBuffer + Length;
   11412:	8d 0c 3e             	lea    (%esi,%edi,1),%ecx
   11415:	eb 10                	jmp    11427 <_ScsiClassFindModePage@16+0x47>

  /* Search for page */
  while (Ptr < End)
    {
      /* Check page code */
      if (((PMODE_DISCONNECT_PAGE)Ptr)->PageCode == PageMode)
   11417:	8a 02                	mov    (%edx),%al
   11419:	83 e0 3f             	and    $0x3f,%eax
   1141c:	38 d8                	cmp    %bl,%al
   1141e:	74 14                	je     11434 <_ScsiClassFindModePage@16+0x54>
	return Ptr;

      /* Skip to next page */
      Ptr += ((PMODE_DISCONNECT_PAGE)Ptr)->PageLength;
   11420:	31 c0                	xor    %eax,%eax
   11422:	8a 42 01             	mov    0x1(%edx),%al
   11425:	01 c2                	add    %eax,%edx
   11427:	39 ca                	cmp    %ecx,%edx
   11429:	72 ec                	jb     11417 <_ScsiClassFindModePage@16+0x37>
    }

  return NULL;
   1142b:	31 c0                	xor    %eax,%eax
}
   1142d:	5b                   	pop    %ebx
   1142e:	5e                   	pop    %esi
   1142f:	5f                   	pop    %edi
   11430:	5d                   	pop    %ebp
   11431:	c2 10 00             	ret    $0x10
   11434:	89 d0                	mov    %edx,%eax
   11436:	5b                   	pop    %ebx
   11437:	5e                   	pop    %esi
   11438:	5f                   	pop    %edi
   11439:	5d                   	pop    %ebp
   1143a:	c2 10 00             	ret    $0x10
   1143d:	31 c9                	xor    %ecx,%ecx
   1143f:	8a 4e 03             	mov    0x3(%esi),%cl
   11442:	eb c8                	jmp    1140c <_ScsiClassFindModePage@16+0x2c>
   11444:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1144a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011450 <_ScsiClassFindUnclaimedDevices@8>:


/*
 * @implemented
 */
ULONG STDCALL
ScsiClassFindUnclaimedDevices(IN PCLASS_INIT_DATA InitializationData,
			      IN PSCSI_ADAPTER_BUS_INFO AdapterInformation)
{
   11450:	55                   	push   %ebp
   11451:	89 e5                	mov    %esp,%ebp
   11453:	57                   	push   %edi
   11454:	56                   	push   %esi
   11455:	53                   	push   %ebx
   11456:	83 ec 0c             	sub    $0xc,%esp
  PSCSI_INQUIRY_DATA UnitInfo;
  PINQUIRYDATA InquiryData;
  PUCHAR Buffer;
  ULONG Bus;
  ULONG UnclaimedDevices = 0;
   11459:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   11460:	8b 75 0c             	mov    0xc(%ebp),%esi

  DPRINT("ScsiClassFindUnclaimedDevices() called\n");

  DPRINT("NumberOfBuses: %lu\n",AdapterInformation->NumberOfBuses);
  Buffer = (PUCHAR)AdapterInformation;
  for (Bus = 0; Bus < (ULONG)AdapterInformation->NumberOfBuses; Bus++)
   11463:	31 ff                	xor    %edi,%edi
   11465:	80 3e 00             	cmpb   $0x0,(%esi)
   11468:	74 45                	je     114af <_ScsiClassFindUnclaimedDevices@8+0x5f>
   1146a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
    {
      DPRINT("Searching bus %lu\n", Bus);

      UnitInfo = (PSCSI_INQUIRY_DATA)(Buffer + AdapterInformation->BusData[Bus].InquiryDataOffset);
   11470:	8b 44 fe 08          	mov    0x8(%esi,%edi,8),%eax

      while (AdapterInformation->BusData[Bus].InquiryDataOffset)
	{
	  InquiryData = (PINQUIRYDATA)UnitInfo->InquiryData;

	  DPRINT("Device: '%.8s'\n", InquiryData->VendorId);

	  if ((InitializationData->ClassFindDeviceCallBack(InquiryData) == TRUE) &&
	      (UnitInfo->DeviceClaimed == FALSE))
	    {
	      UnclaimedDevices++;
	    }

	  if (UnitInfo->NextInquiryDataOffset == 0)
	    break;

	  UnitInfo = (PSCSI_INQUIRY_DATA) (Buffer + UnitInfo->NextInquiryDataOffset);
   11474:	85 c0                	test   %eax,%eax
   11476:	8d 1c 30             	lea    (%eax,%esi,1),%ebx
   11479:	74 2b                	je     114a6 <_ScsiClassFindUnclaimedDevices@8+0x56>
   1147b:	90                   	nop    
   1147c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11480:	83 ec 0c             	sub    $0xc,%esp
   11483:	8b 55 08             	mov    0x8(%ebp),%edx
   11486:	8d 43 0c             	lea    0xc(%ebx),%eax
   11489:	50                   	push   %eax
   1148a:	ff 52 18             	call   *0x18(%edx)
   1148d:	83 c4 0c             	add    $0xc,%esp
   11490:	fe c8                	dec    %al
   11492:	74 2c                	je     114c0 <_ScsiClassFindUnclaimedDevices@8+0x70>
   11494:	8b 43 08             	mov    0x8(%ebx),%eax
   11497:	85 c0                	test   %eax,%eax
   11499:	74 0b                	je     114a6 <_ScsiClassFindUnclaimedDevices@8+0x56>
   1149b:	8d 1c 30             	lea    (%eax,%esi,1),%ebx
   1149e:	8b 44 fe 08          	mov    0x8(%esi,%edi,8),%eax
   114a2:	85 c0                	test   %eax,%eax
   114a4:	75 da                	jne    11480 <_ScsiClassFindUnclaimedDevices@8+0x30>
   114a6:	31 c0                	xor    %eax,%eax
   114a8:	47                   	inc    %edi
   114a9:	8a 06                	mov    (%esi),%al
   114ab:	39 f8                	cmp    %edi,%eax
   114ad:	77 c1                	ja     11470 <_ScsiClassFindUnclaimedDevices@8+0x20>
	}
    }

  return(UnclaimedDevices);
}
   114af:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   114b2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   114b5:	5b                   	pop    %ebx
   114b6:	5e                   	pop    %esi
   114b7:	5f                   	pop    %edi
   114b8:	5d                   	pop    %ebp
   114b9:	c2 08 00             	ret    $0x8
   114bc:	8d 74 26 00          	lea    0x0(%esi),%esi
   114c0:	8a 43 03             	mov    0x3(%ebx),%al
   114c3:	3c 01                	cmp    $0x1,%al
   114c5:	83 55 f0 00          	adcl   $0x0,0xfffffff0(%ebp)
   114c9:	eb c9                	jmp    11494 <_ScsiClassFindUnclaimedDevices@8+0x44>
   114cb:	90                   	nop    
   114cc:	8d 74 26 00          	lea    0x0(%esi),%esi

000114d0 <_ScsiClassGetCapabilities@8>:


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassGetCapabilities(IN PDEVICE_OBJECT PortDeviceObject,
			 OUT PIO_SCSI_CAPABILITIES *PortCapabilities)
{
   114d0:	55                   	push   %ebp
   114d1:	89 e5                	mov    %esp,%ebp
   114d3:	56                   	push   %esi
   114d4:	53                   	push   %ebx
   114d5:	83 ec 24             	sub    $0x24,%esp
  IO_STATUS_BLOCK IoStatusBlock;
  NTSTATUS Status;
  KEVENT Event;
  PIRP Irp;

  KeInitializeEvent(&Event,
   114d8:	8d 5d e8             	lea    0xffffffe8(%ebp),%ebx
   114db:	8b 75 08             	mov    0x8(%ebp),%esi
   114de:	6a 00                	push   $0x0
   114e0:	6a 00                	push   $0x0
   114e2:	53                   	push   %ebx
   114e3:	e8 88 1b 00 00       	call   13070 <_KeInitializeEvent@12>
		    NotificationEvent,
		    FALSE);

  Irp = IoBuildDeviceIoControlRequest(IOCTL_SCSI_GET_CAPABILITIES,
   114e8:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   114eb:	50                   	push   %eax
   114ec:	50                   	push   %eax
   114ed:	8d 45 e0             	lea    0xffffffe0(%ebp),%eax
   114f0:	50                   	push   %eax
   114f1:	53                   	push   %ebx
   114f2:	6a 00                	push   $0x0
   114f4:	6a 04                	push   $0x4
   114f6:	51                   	push   %ecx
   114f7:	6a 00                	push   $0x0
   114f9:	6a 00                	push   $0x0
   114fb:	56                   	push   %esi
   114fc:	68 10 10 04 00       	push   $0x41010
   11501:	e8 7a 1b 00 00       	call   13080 <_IoBuildDeviceIoControlRequest@36>
				      PortDeviceObject,
				      NULL,
				      0,
				      PortCapabilities,
				      sizeof(PVOID),
				      FALSE,
				      &Event,
				      &IoStatusBlock);
  if (Irp == NULL)
    {
      return(STATUS_INSUFFICIENT_RESOURCES);
   11506:	ba 9a 00 00 c0       	mov    $0xc000009a,%edx
   1150b:	83 c4 0c             	add    $0xc,%esp
   1150e:	85 c0                	test   %eax,%eax
   11510:	74 14                	je     11526 <_ScsiClassGetCapabilities@8+0x56>
    }

  Status = IoCallDriver(PortDeviceObject,
   11512:	52                   	push   %edx
   11513:	52                   	push   %edx
   11514:	50                   	push   %eax
   11515:	56                   	push   %esi
   11516:	e8 75 1b 00 00       	call   13090 <_IoCallDriver@8>
			Irp);
  if (Status == STATUS_PENDING)
   1151b:	5a                   	pop    %edx
   1151c:	3d 03 01 00 00       	cmp    $0x103,%eax
   11521:	59                   	pop    %ecx
   11522:	74 0d                	je     11531 <_ScsiClassGetCapabilities@8+0x61>
    {
      KeWaitForSingleObject(&Event,
			    Suspended,
			    KernelMode,
			    FALSE,
			    NULL);
      Status = IoStatusBlock.Status;
    }

  DPRINT("PortCapabilities at %p\n", *PortCapabilities);

  return(Status);
   11524:	89 c2                	mov    %eax,%edx
}
   11526:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11529:	89 d0                	mov    %edx,%eax
   1152b:	5b                   	pop    %ebx
   1152c:	5e                   	pop    %esi
   1152d:	5d                   	pop    %ebp
   1152e:	c2 08 00             	ret    $0x8
   11531:	83 ec 0c             	sub    $0xc,%esp
   11534:	6a 00                	push   $0x0
   11536:	6a 00                	push   $0x0
   11538:	6a 00                	push   $0x0
   1153a:	6a 05                	push   $0x5
   1153c:	53                   	push   %ebx
   1153d:	e8 7e 1b 00 00       	call   130c0 <_KeWaitForSingleObject@20>
   11542:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   11545:	83 c4 0c             	add    $0xc,%esp
   11548:	eb da                	jmp    11524 <_ScsiClassGetCapabilities@8+0x54>
   1154a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011550 <_ScsiClassGetInquiryData@8>:


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassGetInquiryData(IN PDEVICE_OBJECT PortDeviceObject,
			IN PSCSI_ADAPTER_BUS_INFO *ConfigInfo)
{
   11550:	55                   	push   %ebp
   11551:	89 e5                	mov    %esp,%ebp
   11553:	57                   	push   %edi
   11554:	56                   	push   %esi
   11555:	53                   	push   %ebx
   11556:	83 ec 34             	sub    $0x34,%esp
  PSCSI_ADAPTER_BUS_INFO Buffer;
  IO_STATUS_BLOCK IoStatusBlock;
  NTSTATUS Status;
  KEVENT Event;
  PIRP Irp;

  DPRINT("ScsiClassGetInquiryData() called\n");

  *ConfigInfo = NULL;
   11559:	8b 45 0c             	mov    0xc(%ebp),%eax
   1155c:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1155f:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
  Buffer = ExAllocatePool(NonPagedPool,
   11565:	68 00 08 00 00       	push   $0x800
   1156a:	6a 00                	push   $0x0
   1156c:	e8 9f 1b 00 00       	call   13110 <_ExAllocatePool@8>
   11571:	89 c6                	mov    %eax,%esi
			  INQUIRY_DATA_SIZE);
  if (Buffer == NULL)
   11573:	58                   	pop    %eax
   11574:	85 f6                	test   %esi,%esi
   11576:	5a                   	pop    %edx
    {
      return(STATUS_INSUFFICIENT_RESOURCES);
   11577:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   1157c:	74 53                	je     115d1 <_ScsiClassGetInquiryData@8+0x81>
    }

  KeInitializeEvent(&Event,
   1157e:	8d 7d d8             	lea    0xffffffd8(%ebp),%edi
   11581:	50                   	push   %eax
   11582:	6a 00                	push   $0x0
   11584:	6a 00                	push   $0x0
   11586:	57                   	push   %edi
   11587:	e8 e4 1a 00 00       	call   13070 <_KeInitializeEvent@12>
		    NotificationEvent,
		    FALSE);

  Irp = IoBuildDeviceIoControlRequest(IOCTL_SCSI_GET_INQUIRY_DATA,
   1158c:	50                   	push   %eax
   1158d:	50                   	push   %eax
   1158e:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
   11591:	50                   	push   %eax
   11592:	57                   	push   %edi
   11593:	6a 00                	push   $0x0
   11595:	68 00 08 00 00       	push   $0x800
   1159a:	56                   	push   %esi
   1159b:	6a 00                	push   $0x0
   1159d:	6a 00                	push   $0x0
   1159f:	53                   	push   %ebx
   115a0:	68 0c 10 04 00       	push   $0x4100c
   115a5:	e8 d6 1a 00 00       	call   13080 <_IoBuildDeviceIoControlRequest@36>
				      PortDeviceObject,
				      NULL,
				      0,
				      Buffer,
				      INQUIRY_DATA_SIZE,
				      FALSE,
				      &Event,
				      &IoStatusBlock);
  if (Irp == NULL)
   115aa:	83 c4 0c             	add    $0xc,%esp
   115ad:	85 c0                	test   %eax,%eax
   115af:	74 56                	je     11607 <_ScsiClassGetInquiryData@8+0xb7>
    {
      ExFreePool(Buffer);
      return(STATUS_INSUFFICIENT_RESOURCES);
    }

  Status = IoCallDriver(PortDeviceObject,
   115b1:	51                   	push   %ecx
   115b2:	51                   	push   %ecx
   115b3:	50                   	push   %eax
   115b4:	53                   	push   %ebx
   115b5:	e8 d6 1a 00 00       	call   13090 <_IoCallDriver@8>
   115ba:	89 c3                	mov    %eax,%ebx
			Irp);
  if (Status == STATUS_PENDING)
   115bc:	58                   	pop    %eax
   115bd:	81 fb 03 01 00 00    	cmp    $0x103,%ebx
   115c3:	5a                   	pop    %edx
   115c4:	74 1a                	je     115e0 <_ScsiClassGetInquiryData@8+0x90>
    {
      KeWaitForSingleObject(&Event,
			    Suspended,
			    KernelMode,
			    FALSE,
			    NULL);
      Status = IoStatusBlock.Status;
    }

  if (!NT_SUCCESS(Status))
   115c6:	85 db                	test   %ebx,%ebx
   115c8:	78 2f                	js     115f9 <_ScsiClassGetInquiryData@8+0xa9>
    {
      ExFreePool(Buffer);
    }
  else
    {
      *ConfigInfo = Buffer;
   115ca:	8b 45 0c             	mov    0xc(%ebp),%eax
   115cd:	89 30                	mov    %esi,(%eax)
    }

  DPRINT("ScsiClassGetInquiryData() done\n");

  return(Status);
   115cf:	89 d8                	mov    %ebx,%eax
}
   115d1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   115d4:	5b                   	pop    %ebx
   115d5:	5e                   	pop    %esi
   115d6:	5f                   	pop    %edi
   115d7:	5d                   	pop    %ebp
   115d8:	c2 08 00             	ret    $0x8
   115db:	90                   	nop    
   115dc:	8d 74 26 00          	lea    0x0(%esi),%esi
   115e0:	83 ec 0c             	sub    $0xc,%esp
   115e3:	6a 00                	push   $0x0
   115e5:	6a 00                	push   $0x0
   115e7:	6a 00                	push   $0x0
   115e9:	6a 05                	push   $0x5
   115eb:	57                   	push   %edi
   115ec:	e8 cf 1a 00 00       	call   130c0 <_KeWaitForSingleObject@20>
   115f1:	8b 5d d0             	mov    0xffffffd0(%ebp),%ebx
   115f4:	83 c4 0c             	add    $0xc,%esp
   115f7:	eb cd                	jmp    115c6 <_ScsiClassGetInquiryData@8+0x76>
   115f9:	83 ec 0c             	sub    $0xc,%esp
   115fc:	56                   	push   %esi
   115fd:	e8 1e 1b 00 00       	call   13120 <_ExFreePool@4>
   11602:	83 c4 0c             	add    $0xc,%esp
   11605:	eb c8                	jmp    115cf <_ScsiClassGetInquiryData@8+0x7f>
   11607:	83 ec 0c             	sub    $0xc,%esp
   1160a:	56                   	push   %esi
   1160b:	e8 10 1b 00 00       	call   13120 <_ExFreePool@4>
   11610:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   11615:	eb ba                	jmp    115d1 <_ScsiClassGetInquiryData@8+0x81>
   11617:	89 f6                	mov    %esi,%esi
   11619:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011620 <_ScsiClassInitialize@12>:


/*
 * @implemented
 */
ULONG STDCALL
ScsiClassInitialize(IN PVOID Argument1,
		    IN PVOID Argument2,
		    IN PCLASS_INIT_DATA InitializationData)
{
   11620:	55                   	push   %ebp
   11621:	89 e5                	mov    %esp,%ebp
   11623:	57                   	push   %edi
   11624:	56                   	push   %esi
   11625:	53                   	push   %ebx
   11626:	81 ec cc 00 00 00    	sub    $0xcc,%esp
  PCONFIGURATION_INFORMATION ConfigInfo;
  PDRIVER_OBJECT DriverObject = Argument1;
  WCHAR NameBuffer[80];
  UNICODE_STRING PortName;
  ULONG PortNumber;
  PDEVICE_OBJECT PortDeviceObject;
  PFILE_OBJECT FileObject;
  BOOLEAN DiskFound = FALSE;
   1162c:	c6 85 33 ff ff ff 00 	movb   $0x0,0xffffff33(%ebp)
  NTSTATUS Status;

  DPRINT("ScsiClassInitialize() called!\n");

  DriverObject->MajorFunction[IRP_MJ_CREATE] = ScsiClassCreateClose;
  DriverObject->MajorFunction[IRP_MJ_CLOSE] = ScsiClassCreateClose;
  DriverObject->MajorFunction[IRP_MJ_READ] = ScsiClassReadWrite;
  DriverObject->MajorFunction[IRP_MJ_WRITE] = ScsiClassReadWrite;
  DriverObject->MajorFunction[IRP_MJ_SCSI] = ScsiClassInternalIoControl;
  DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ScsiClassDeviceDispatch;
  DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = ScsiClassShutdownFlush;
  DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = ScsiClassShutdownFlush;
  if (InitializationData->ClassStartIo)
   11633:	8b 55 10             	mov    0x10(%ebp),%edx
   11636:	8b 7d 08             	mov    0x8(%ebp),%edi
   11639:	8b 42 2c             	mov    0x2c(%edx),%eax
   1163c:	c7 47 38 30 2d 01 00 	movl   $0x12d30,0x38(%edi)
   11643:	c7 47 40 30 2d 01 00 	movl   $0x12d30,0x40(%edi)
   1164a:	c7 47 44 70 2d 01 00 	movl   $0x12d70,0x44(%edi)
   11651:	c7 47 48 70 2d 01 00 	movl   $0x12d70,0x48(%edi)
   11658:	c7 47 74 90 17 01 00 	movl   $0x11790,0x74(%edi)
   1165f:	c7 47 70 60 2f 01 00 	movl   $0x12f60,0x70(%edi)
   11666:	c7 47 78 a0 2f 01 00 	movl   $0x12fa0,0x78(%edi)
   1166d:	c7 47 5c a0 2f 01 00 	movl   $0x12fa0,0x5c(%edi)
   11674:	85 c0                	test   %eax,%eax
   11676:	74 03                	je     1167b <_ScsiClassInitialize@12+0x5b>
    {
      DriverObject->DriverStartIo = InitializationData->ClassStartIo;
   11678:	89 47 30             	mov    %eax,0x30(%edi)
    }

  ConfigInfo = IoGetConfigurationInformation();
   1167b:	e8 b0 1a 00 00       	call   13130 <_IoGetConfigurationInformation@0>

  DPRINT("ScsiPorts: %lu\n", ConfigInfo->ScsiPortCount);

  /* look for ScsiPortX scsi port devices */
  for (PortNumber = 0; PortNumber < ConfigInfo->ScsiPortCount; PortNumber++)
   11680:	31 db                	xor    %ebx,%ebx
   11682:	89 85 34 ff ff ff    	mov    %eax,0xffffff34(%ebp)
   11688:	8b 40 10             	mov    0x10(%eax),%eax
   1168b:	85 c0                	test   %eax,%eax
   1168d:	0f 84 af 00 00 00    	je     11742 <_ScsiClassInitialize@12+0x122>
   11693:	8d b5 40 ff ff ff    	lea    0xffffff40(%ebp),%esi
   11699:	eb 39                	jmp    116d4 <_ScsiClassInitialize@12+0xb4>
   1169b:	90                   	nop    
   1169c:	8d 74 26 00          	lea    0x0(%esi),%esi
    {
      swprintf(NameBuffer,
	       L"\\Device\\ScsiPort%lu",
	        PortNumber);
      RtlInitUnicodeString(&PortName,
			   NameBuffer);
      DPRINT("Checking scsi port %ld\n", PortNumber);
      Status = IoGetDeviceObjectPointer(&PortName,
					FILE_READ_ATTRIBUTES,
					&FileObject,
					&PortDeviceObject);
      DPRINT("Status 0x%08lX\n", Status);
      if (NT_SUCCESS(Status))
	{
	  DPRINT("ScsiPort%lu found.\n", PortNumber);

	  /* check scsi port for attached disk drives */
	  if (InitializationData->ClassFindDevices(DriverObject,
   116a0:	83 ec 0c             	sub    $0xc,%esp
   116a3:	8b 85 3c ff ff ff    	mov    0xffffff3c(%ebp),%eax
   116a9:	8b 55 10             	mov    0x10(%ebp),%edx
   116ac:	53                   	push   %ebx
   116ad:	50                   	push   %eax
   116ae:	8b 45 10             	mov    0x10(%ebp),%eax
   116b1:	50                   	push   %eax
   116b2:	8b 45 0c             	mov    0xc(%ebp),%eax
   116b5:	50                   	push   %eax
   116b6:	57                   	push   %edi
   116b7:	ff 52 1c             	call   *0x1c(%edx)
   116ba:	83 c4 0c             	add    $0xc,%esp
   116bd:	84 c0                	test   %al,%al
   116bf:	74 07                	je     116c8 <_ScsiClassInitialize@12+0xa8>
						   Argument2,
						   InitializationData,
						   PortDeviceObject,
						   PortNumber))
	    {
	      DiskFound = TRUE;
   116c1:	c6 85 33 ff ff ff 01 	movb   $0x1,0xffffff33(%ebp)
   116c8:	8b 85 34 ff ff ff    	mov    0xffffff34(%ebp),%eax
   116ce:	43                   	inc    %ebx
   116cf:	39 58 10             	cmp    %ebx,0x10(%eax)
   116d2:	76 63                	jbe    11737 <_ScsiClassInitialize@12+0x117>
   116d4:	50                   	push   %eax
   116d5:	8d 85 48 ff ff ff    	lea    0xffffff48(%ebp),%eax
   116db:	53                   	push   %ebx
   116dc:	68 00 40 01 00       	push   $0x14000
   116e1:	50                   	push   %eax
   116e2:	e8 99 1b 00 00       	call   13280 <_swprintf>
   116e7:	59                   	pop    %ecx
   116e8:	8d 95 48 ff ff ff    	lea    0xffffff48(%ebp),%edx
   116ee:	58                   	pop    %eax
   116ef:	52                   	push   %edx
   116f0:	56                   	push   %esi
   116f1:	e8 4a 1a 00 00       	call   13140 <_RtlInitUnicodeString@8>
   116f6:	8d b5 40 ff ff ff    	lea    0xffffff40(%ebp),%esi
   116fc:	58                   	pop    %eax
   116fd:	8d 85 3c ff ff ff    	lea    0xffffff3c(%ebp),%eax
   11703:	5a                   	pop    %edx
   11704:	8d 95 38 ff ff ff    	lea    0xffffff38(%ebp),%edx
   1170a:	50                   	push   %eax
   1170b:	52                   	push   %edx
   1170c:	68 80 00 00 00       	push   $0x80
   11711:	56                   	push   %esi
   11712:	e8 39 1a 00 00       	call   13150 <_IoGetDeviceObjectPointer@16>
   11717:	85 c0                	test   %eax,%eax
   11719:	79 85                	jns    116a0 <_ScsiClassInitialize@12+0x80>
	    }
	}
      else
	{
	  DbgPrint("Couldn't find ScsiPort%lu (Status %lx)\n", PortNumber, Status);
   1171b:	51                   	push   %ecx
   1171c:	50                   	push   %eax
   1171d:	53                   	push   %ebx
   1171e:	68 28 40 01 00       	push   $0x14028
   11723:	e8 68 1b 00 00       	call   13290 <_DbgPrint>
   11728:	8b 85 34 ff ff ff    	mov    0xffffff34(%ebp),%eax
   1172e:	43                   	inc    %ebx
   1172f:	83 c4 10             	add    $0x10,%esp
   11732:	39 58 10             	cmp    %ebx,0x10(%eax)
   11735:	77 9d                	ja     116d4 <_ScsiClassInitialize@12+0xb4>
	}
    }

  DPRINT("ScsiClassInitialize() done!\n");

  return((DiskFound == TRUE) ? STATUS_SUCCESS : STATUS_NO_SUCH_DEVICE);
   11737:	31 c0                	xor    %eax,%eax
   11739:	80 bd 33 ff ff ff 01 	cmpb   $0x1,0xffffff33(%ebp)
   11740:	74 05                	je     11747 <_ScsiClassInitialize@12+0x127>
   11742:	b8 0e 00 00 c0       	mov    $0xc000000e,%eax
}
   11747:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1174a:	5b                   	pop    %ebx
   1174b:	5e                   	pop    %esi
   1174c:	5f                   	pop    %edi
   1174d:	5d                   	pop    %ebp
   1174e:	c2 0c 00             	ret    $0xc
   11751:	eb 0d                	jmp    11760 <_ScsiClassInitializeSrbLookasideList@8>
   11753:	90                   	nop    
   11754:	90                   	nop    
   11755:	90                   	nop    
   11756:	90                   	nop    
   11757:	90                   	nop    
   11758:	90                   	nop    
   11759:	90                   	nop    
   1175a:	90                   	nop    
   1175b:	90                   	nop    
   1175c:	90                   	nop    
   1175d:	90                   	nop    
   1175e:	90                   	nop    
   1175f:	90                   	nop    

00011760 <_ScsiClassInitializeSrbLookasideList@8>:


/**********************************************************************
 * NAME							EXPORTED
 *	ScsiClassInitializeSrbLookasideList
 *
 * DESCRIPTION
 *	Initializes a lookaside list for SRBs.
 *
 * RUN LEVEL
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS
 *	DeviceExtension
 *		Class specific device extension.
 *
 *	NumberElements
 *		Maximum number of elements of the lookaside list.
 *
 * RETURN VALUE
 *	None.
 *
 * @implemented
 */
VOID STDCALL
ScsiClassInitializeSrbLookasideList(IN PDEVICE_EXTENSION DeviceExtension,
				    IN ULONG NumberElements)
{
   11760:	55                   	push   %ebp
   11761:	89 e5                	mov    %esp,%ebp
   11763:	83 ec 0c             	sub    $0xc,%esp
  ExInitializeNPagedLookasideList(&DeviceExtension->SrbLookasideListHead,
   11766:	8b 45 0c             	mov    0xc(%ebp),%eax
   11769:	25 ff ff 00 00       	and    $0xffff,%eax
   1176e:	50                   	push   %eax
   1176f:	8b 45 08             	mov    0x8(%ebp),%eax
   11772:	83 c0 68             	add    $0x68,%eax
   11775:	68 53 72 62 54       	push   $0x54627253
   1177a:	6a 71                	push   $0x71
   1177c:	6a 00                	push   $0x0
   1177e:	6a 00                	push   $0x0
   11780:	6a 00                	push   $0x0
   11782:	50                   	push   %eax
   11783:	e8 d8 19 00 00       	call   13160 <_ExInitializeNPagedLookasideList@28>
   11788:	c9                   	leave  
   11789:	c2 08 00             	ret    $0x8
   1178c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011790 <_ScsiClassInternalIoControl@8>:
				  NULL,
				  NULL,
				  NonPagedPool,
				  sizeof(SCSI_REQUEST_BLOCK) + sizeof(SENSE_DATA) + SENSEINFO_ALIGNMENT - 1,
				  TAG_SRBT,
				  (USHORT)NumberElements);
}


/*
 * @unimplemented
 */
NTSTATUS STDCALL
ScsiClassInternalIoControl(IN PDEVICE_OBJECT DeviceObject,
			   IN PIRP Irp)
{
   11790:	55                   	push   %ebp
   11791:	89 e5                	mov    %esp,%ebp
   11793:	83 ec 10             	sub    $0x10,%esp
   11796:	8b 45 0c             	mov    0xc(%ebp),%eax
  DPRINT("ScsiClassInternalIoContol() called\n");

  Irp->IoStatus.Status = STATUS_SUCCESS;
   11799:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
  Irp->IoStatus.Information = 0;
   117a0:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
  IoCompleteRequest(Irp, IO_NO_INCREMENT);
   117a7:	6a 00                	push   $0x0
   117a9:	50                   	push   %eax
   117aa:	e8 c1 19 00 00       	call   13170 <_IoCompleteRequest@8>

  return(STATUS_SUCCESS);
}
   117af:	31 c0                	xor    %eax,%eax
   117b1:	c9                   	leave  
   117b2:	c2 08 00             	ret    $0x8
   117b5:	8d 74 26 00          	lea    0x0(%esi),%esi
   117b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000117c0 <_ScsiClassInvalidateMedia>:


/*
 * Implements part of the directives on:
 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/kmarch/hh/kmarch/other_c694d732-fa95-4841-8d61-2a55ee787905.xml.asp
 */
static VOID
ScsiClassInvalidateMedia(IN PDEVICE_OBJECT DeviceObject,
			 OUT NTSTATUS *Status)
{
   117c0:	55                   	push   %ebp
   117c1:	89 c1                	mov    %eax,%ecx
   117c3:	89 e5                	mov    %esp,%ebp
   117c5:	53                   	push   %ebx
  PDEVICE_EXTENSION DeviceExtension;
  PDEVICE_EXTENSION PhysicalExtension;

  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
   117c6:	8b 40 28             	mov    0x28(%eax),%eax
   117c9:	89 d3                	mov    %edx,%ebx
  PhysicalExtension = (PDEVICE_EXTENSION)DeviceExtension->PhysicalDevice->DeviceExtension;

  if (DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA)
    {
      DPRINT("Invalidate: test char yields TRUE\n");
    }
  else
    {
      DPRINT("Invalidate: test char yields FALSE\n");
    }

  if ((DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) &&
   117cb:	f6 41 20 01          	testb  $0x1,0x20(%ecx)
   117cf:	8b 40 48             	mov    0x48(%eax),%eax
   117d2:	8b 50 28             	mov    0x28(%eax),%edx
   117d5:	74 09                	je     117e0 <_ScsiClassInvalidateMedia+0x20>
   117d7:	8b 41 24             	mov    0x24(%ecx),%eax
   117da:	f6 40 04 01          	testb  $0x1,0x4(%eax)
   117de:	75 16                	jne    117f6 <_ScsiClassInvalidateMedia+0x36>
      (DeviceObject->Vpb->Flags & VPB_MOUNTED))
    {
      DPRINT("Set DO_VERIFY_VOLUME\n");
      DeviceObject->Flags |= DO_VERIFY_VOLUME;
      *Status = STATUS_VERIFY_REQUIRED;
    }
  else
    {
      *Status = STATUS_IO_DEVICE_ERROR;
   117e0:	c7 03 85 01 00 c0    	movl   $0xc0000185,(%ebx)
    }

  /* Increment the media change count */
  PhysicalExtension->MediaChangeCount++;
   117e6:	8b 82 d0 00 00 00    	mov    0xd0(%edx),%eax
   117ec:	40                   	inc    %eax
   117ed:	89 82 d0 00 00 00    	mov    %eax,0xd0(%edx)
   117f3:	5b                   	pop    %ebx
   117f4:	5d                   	pop    %ebp
   117f5:	c3                   	ret    
   117f6:	8b 41 1c             	mov    0x1c(%ecx),%eax
   117f9:	83 c8 02             	or     $0x2,%eax
   117fc:	89 41 1c             	mov    %eax,0x1c(%ecx)
   117ff:	c7 03 16 00 00 80    	movl   $0x80000016,(%ebx)
   11805:	8b 82 d0 00 00 00    	mov    0xd0(%edx),%eax
   1180b:	40                   	inc    %eax
   1180c:	89 82 d0 00 00 00    	mov    %eax,0xd0(%edx)
   11812:	5b                   	pop    %ebx
   11813:	5d                   	pop    %ebp
   11814:	c3                   	ret    
   11815:	8d 74 26 00          	lea    0x0(%esi),%esi
   11819:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011820 <_ScsiClassInterpretSenseInfo@24>:
}


/*
 * @implemented
 */
BOOLEAN STDCALL
ScsiClassInterpretSenseInfo(IN PDEVICE_OBJECT DeviceObject,
			    IN PSCSI_REQUEST_BLOCK Srb,
			    IN UCHAR MajorFunctionCode,
			    IN ULONG IoDeviceCode,
			    IN ULONG RetryCount,
			    OUT NTSTATUS *Status)
{
   11820:	55                   	push   %ebp
   11821:	89 e5                	mov    %esp,%ebp
   11823:	57                   	push   %edi
   11824:	56                   	push   %esi
   11825:	53                   	push   %ebx
   11826:	83 ec 0c             	sub    $0xc,%esp
   11829:	8b 75 0c             	mov    0xc(%ebp),%esi
   1182c:	8b 5d 1c             	mov    0x1c(%ebp),%ebx
  PDEVICE_EXTENSION DeviceExtension;
  PDEVICE_EXTENSION PhysicalExtension;
#if 0
  PIO_ERROR_LOG_PACKET LogPacket;
#endif
  PSENSE_DATA SenseData;
  BOOLEAN LogError;
  BOOLEAN Retry;

  DPRINT("ScsiClassInterpretSenseInfo() called\n");

  DPRINT("Srb->SrbStatus %lx\n", Srb->SrbStatus);

  if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_PENDING)
   1182f:	8a 46 03             	mov    0x3(%esi),%al
   11832:	a8 3f                	test   $0x3f,%al
   11834:	75 12                	jne    11848 <_ScsiClassInterpretSenseInfo@24+0x28>
    {
      *Status = STATUS_SUCCESS;
   11836:	c7 03 00 00 00 00    	movl   $0x0,(%ebx)
      return(FALSE);
   1183c:	31 c0                	xor    %eax,%eax
    }

  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
  PhysicalExtension = (PDEVICE_EXTENSION)DeviceExtension->PhysicalDevice->DeviceExtension;
  SenseData = Srb->SenseInfoBuffer;
  LogError = FALSE;
  Retry = TRUE;

  if ((Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID) &&
      (Srb->SenseInfoBufferLength > 0))
    {
      /* Got valid sense data, interpret them */

      DPRINT("ErrorCode: %x\n", SenseData->ErrorCode);
      DPRINT("SenseKey: %x\n", SenseData->SenseKey);
      DPRINT("SenseCode: %x\n", SenseData->AdditionalSenseCode);

      switch (SenseData->SenseKey & 0xf)
	{
	  case SCSI_SENSE_NO_SENSE:
	    DPRINT("SCSI_SENSE_NO_SENSE\n");
	    if (SenseData->IncorrectLength)
	      {
		DPRINT("Incorrect block length\n");
		*Status = STATUS_INVALID_BLOCK_LENGTH;
		Retry = FALSE;
	      }
	    else
	      {
		DPRINT("Unspecified error\n");
		*Status = STATUS_IO_DEVICE_ERROR;
		Retry = FALSE;
	      }
	    break;

	  case SCSI_SENSE_RECOVERED_ERROR:
	    DPRINT("SCSI_SENSE_RECOVERED_ERROR\n");
	    *Status = STATUS_SUCCESS;
	    Retry = FALSE;
	    break;

	  case SCSI_SENSE_NOT_READY:
	    DPRINT("SCSI_SENSE_NOT_READY\n");
	    *Status = STATUS_DEVICE_NOT_READY;
	    switch (SenseData->AdditionalSenseCode)
	      {
		case SCSI_ADSENSE_LUN_NOT_READY:
		  DPRINT("SCSI_ADSENSE_LUN_NOT_READY\n");
		  break;

		case SCSI_ADSENSE_NO_MEDIA_IN_DEVICE:
		  DPRINT("SCSI_ADSENSE_NO_MEDIA_IN_DEVICE\n");
		  ScsiClassInvalidateMedia(DeviceObject,
					   Status);

		  *Status = STATUS_NO_MEDIA_IN_DEVICE;
		  Retry = FALSE;

		  if((DeviceExtension->MediaChangeEvent != NULL) &&
		    (!DeviceExtension->MediaChangeEvent))
		    {
		    KeSetEvent(DeviceExtension->MediaChangeEvent,
		    	       0,
		    	       FALSE);
		    DeviceExtension->MediaChangeNoMedia = TRUE;
		    }
		  break;
	      }
	    break;

	  case SCSI_SENSE_MEDIUM_ERROR:
	    DPRINT("SCSI_SENSE_MEDIUM_ERROR\n");
	    *Status = STATUS_DEVICE_DATA_ERROR;
	    Retry = FALSE;
	    break;

	  case SCSI_SENSE_HARDWARE_ERROR:
	    DPRINT("SCSI_SENSE_HARDWARE_ERROR\n");
	    *Status = STATUS_IO_DEVICE_ERROR;
	    break;

	  case SCSI_SENSE_ILLEGAL_REQUEST:
	    DPRINT("SCSI_SENSE_ILLEGAL_REQUEST\n");
	    *Status = STATUS_INVALID_DEVICE_REQUEST;
	    switch (SenseData->AdditionalSenseCode)
	      {
		case SCSI_ADSENSE_ILLEGAL_COMMAND:
		  DPRINT("SCSI_ADSENSE_ILLEGAL_COMMAND\n");
		  Retry = FALSE;
		  break;

		case SCSI_ADSENSE_ILLEGAL_BLOCK:
		  DPRINT("SCSI_ADSENSE_ILLEGAL_BLOCK\n");
		  *Status = STATUS_NONEXISTENT_SECTOR;
		  Retry = FALSE;
		  break;

		case SCSI_ADSENSE_INVALID_LUN:
		  DPRINT("SCSI_ADSENSE_INVALID_LUN\n");
		  *Status = STATUS_NO_SUCH_DEVICE;
		  Retry = FALSE;
		  break;

		case SCSI_ADSENSE_MUSIC_AREA:
		  DPRINT("SCSI_ADSENSE_MUSIC_AREA\n");
		  Retry = FALSE;
		  break;

		case SCSI_ADSENSE_DATA_AREA:
		  DPRINT("SCSI_ADSENSE_DATA_AREA\n");
		  Retry = FALSE;
		  break;

		case SCSI_ADSENSE_VOLUME_OVERFLOW:
		  DPRINT("SCSI_ADSENSE_VOLUME_OVERFLOW\n");
		  Retry = FALSE;
		  break;

		case SCSI_ADSENSE_INVALID_CDB:
		  DPRINT("SCSI_ADSENSE_INVALID_CDB\n");
		  Retry = FALSE;
		  break;
	      }
	    break;

	  case SCSI_SENSE_UNIT_ATTENTION:
	    DPRINT("SCSI_SENSE_UNIT_ATTENTION\n");
	    switch (SenseData->AdditionalSenseCode)
	      {
		case SCSI_ADSENSE_MEDIUM_CHANGED:
		  DPRINT("SCSI_ADSENSE_MEDIUM_CHANGED\n");
                  if(DeviceExtension->MediaChangeEvent != NULL)
                    {
                    KeSetEvent(DeviceExtension->MediaChangeEvent,
                               0,
                               FALSE);
                    DeviceExtension->MediaChangeNoMedia = FALSE;
                    }
		  break;

		case SCSI_ADSENSE_BUS_RESET:
		  DPRINT("SCSI_ADSENSE_BUS_RESET\n");
		  break;

		default:
		  DPRINT("Unit attention\n");
		  break;
	      }

	    ScsiClassInvalidateMedia(DeviceObject,
				     Status);
	    Retry = FALSE;
	    break;

	  case SCSI_SENSE_DATA_PROTECT:
	    DPRINT("SCSI_SENSE_DATA_PROTECT\n");
	    *Status = STATUS_MEDIA_WRITE_PROTECTED;
	    Retry = FALSE;
	    break;

	  case SCSI_SENSE_ABORTED_COMMAND:
	    DPRINT("SCSI_SENSE_ABORTED_COMMAND\n");
	    *Status = STATUS_IO_DEVICE_ERROR;
	    break;

	  default:
	    DPRINT("SCSI error (sense key: %x)\n",
		    SenseData->SenseKey & 0xf);
	    *Status = STATUS_IO_DEVICE_ERROR;
	    break;
	}
    }
  else
    {
      /* Got no or invalid sense data, return generic error codes */
      switch (SRB_STATUS(Srb->SrbStatus))
	{
	  /* FIXME: add more srb status codes */

	  case SRB_STATUS_INVALID_PATH_ID:
	  case SRB_STATUS_INVALID_TARGET_ID:
	  case SRB_STATUS_INVALID_LUN:
	  case SRB_STATUS_NO_DEVICE:
	  case SRB_STATUS_NO_HBA:
	    *Status = STATUS_NO_SUCH_DEVICE;
	    Retry = FALSE;
	    break;

	  case SRB_STATUS_BUSY:
	    *Status = STATUS_DEVICE_BUSY;
	    Retry = TRUE;
	    break;

	  case SRB_STATUS_DATA_OVERRUN:
	    *Status = STATUS_DATA_OVERRUN;
	    Retry = FALSE;
	    break;

	  case SRB_STATUS_INVALID_REQUEST:
	    *Status = STATUS_INVALID_DEVICE_REQUEST;
	    Retry = FALSE;
	    break;

	  default:
	    DPRINT("SCSI error (SRB status: %x)\n",
		    SRB_STATUS(Srb->SrbStatus));
	    LogError = TRUE;
	    *Status = STATUS_IO_DEVICE_ERROR;
	    break;
	}
    }

  /* Call the class driver specific error function */
  if (DeviceExtension->ClassError != NULL)
    {
      DeviceExtension->ClassError(DeviceObject,
				  Srb,
				  Status,
				  &Retry);
    }

  if (LogError == TRUE)
    {
#if 0
      /* Allocate error packet */
      LogPacket = IoAllocateErrorLogEntry (DeviceObject,
					   sizeof(IO_ERROR_LOG_PACKET) +
					     5 * sizeof(ULONG));
      if (LogPacket == NULL)
	{
	  DPRINT ("Failed to allocate a log packet!\n");
	  return Retry;
	}

      /* Initialize error packet */
      LogPacket->MajorFunctionCode = MajorFunctionCode;
      LogPacket->RetryCount = (UCHAR)RetryCount;
      LogPacket->DumpDataSize = 6 * sizeof(ULONG);
      LogPacket->ErrorCode = 0; /* FIXME */
      LogPacket->FinalStatus = *Status;
      LogPacket->IoControlCode = IoDeviceCode;
      LogPacket->DeviceOffset.QuadPart = 0; /* FIXME */
      LogPacket->DumpData[0] = Srb->PathId;
      LogPacket->DumpData[1] = Srb->TargetId;
      LogPacket->DumpData[2] = Srb->Lun;
      LogPacket->DumpData[3] = 0;
      LogPacket->DumpData[4] = (Srb->SrbStatus << 8) | Srb->ScsiStatus;
      if (SenseData != NULL)
	{
	  LogPacket->DumpData[5] = (SenseData->SenseKey << 16) |
				   (SenseData->AdditionalSenseCode << 8) |
				   SenseData->AdditionalSenseCodeQualifier;
	}

      /* Write error packet */
      IoWriteErrorLogEntry (LogPacket);
#endif
    }

  DPRINT("ScsiClassInterpretSenseInfo() done\n");

  return Retry;
}
   1183e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11841:	5b                   	pop    %ebx
   11842:	5e                   	pop    %esi
   11843:	5f                   	pop    %edi
   11844:	5d                   	pop    %ebp
   11845:	c2 18 00             	ret    $0x18
   11848:	8b 55 08             	mov    0x8(%ebp),%edx
   1184b:	84 c0                	test   %al,%al
   1184d:	8b 7a 28             	mov    0x28(%edx),%edi
   11850:	8b 56 1c             	mov    0x1c(%esi),%edx
   11853:	78 4b                	js     118a0 <_ScsiClassInterpretSenseInfo@24+0x80>
   11855:	83 e0 3f             	and    $0x3f,%eax
   11858:	83 e8 05             	sub    $0x5,%eax
   1185b:	83 f8 1c             	cmp    $0x1c,%eax
   1185e:	77 07                	ja     11867 <_ScsiClassInterpretSenseInfo@24+0x47>
   11860:	ff 24 85 50 40 01 00 	jmp    *0x14050(,%eax,4)
   11867:	c6 45 f3 01          	movb   $0x1,0xfffffff3(%ebp)
   1186b:	c7 03 85 01 00 c0    	movl   $0xc0000185,(%ebx)
   11871:	8b 57 24             	mov    0x24(%edi),%edx
   11874:	85 d2                	test   %edx,%edx
   11876:	75 0f                	jne    11887 <_ScsiClassInterpretSenseInfo@24+0x67>
   11878:	31 c0                	xor    %eax,%eax
   1187a:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   1187d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11880:	5b                   	pop    %ebx
   11881:	5e                   	pop    %esi
   11882:	5f                   	pop    %edi
   11883:	5d                   	pop    %ebp
   11884:	c2 18 00             	ret    $0x18
   11887:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   1188a:	50                   	push   %eax
   1188b:	53                   	push   %ebx
   1188c:	56                   	push   %esi
   1188d:	8b 45 08             	mov    0x8(%ebp),%eax
   11890:	50                   	push   %eax
   11891:	ff d2                	call   *%edx
   11893:	31 c0                	xor    %eax,%eax
   11895:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11898:	eb e3                	jmp    1187d <_ScsiClassInterpretSenseInfo@24+0x5d>
   1189a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   118a0:	80 7e 0b 00          	cmpb   $0x0,0xb(%esi)
   118a4:	74 af                	je     11855 <_ScsiClassInterpretSenseInfo@24+0x35>
   118a6:	c6 45 f3 01          	movb   $0x1,0xfffffff3(%ebp)
   118aa:	8a 42 02             	mov    0x2(%edx),%al
   118ad:	83 e0 0f             	and    $0xf,%eax
   118b0:	83 e0 0f             	and    $0xf,%eax
   118b3:	83 f8 0b             	cmp    $0xb,%eax
   118b6:	77 b3                	ja     1186b <_ScsiClassInterpretSenseInfo@24+0x4b>
   118b8:	ff 24 85 c4 40 01 00 	jmp    *0x140c4(,%eax,4)
   118bf:	c7 03 0e 00 00 c0    	movl   $0xc000000e,(%ebx)
   118c5:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   118c9:	eb a6                	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   118cb:	c7 03 11 00 00 80    	movl   $0x80000011,(%ebx)
   118d1:	c6 45 f3 01          	movb   $0x1,0xfffffff3(%ebp)
   118d5:	eb 9a                	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   118d7:	c7 03 10 00 00 c0    	movl   $0xc0000010,(%ebx)
   118dd:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   118e1:	eb 8e                	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   118e3:	c7 03 3c 00 00 c0    	movl   $0xc000003c,(%ebx)
   118e9:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   118ed:	eb 82                	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   118ef:	c7 03 a2 00 00 c0    	movl   $0xc00000a2,(%ebx)
   118f5:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   118f9:	e9 73 ff ff ff       	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   118fe:	80 7a 0c 28          	cmpb   $0x28,0xc(%edx)
   11902:	0f 84 cc 00 00 00    	je     119d4 <_ScsiClassInterpretSenseInfo@24+0x1b4>
   11908:	89 da                	mov    %ebx,%edx
   1190a:	8b 45 08             	mov    0x8(%ebp),%eax
   1190d:	e8 ae fe ff ff       	call   117c0 <_ScsiClassInvalidateMedia>
   11912:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   11916:	e9 56 ff ff ff       	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   1191b:	31 c0                	xor    %eax,%eax
   1191d:	c7 03 10 00 00 c0    	movl   $0xc0000010,(%ebx)
   11923:	8a 42 0c             	mov    0xc(%edx),%al
   11926:	83 f8 25             	cmp    $0x25,%eax
   11929:	74 94                	je     118bf <_ScsiClassInterpretSenseInfo@24+0x9f>
   1192b:	0f 8f 8c 00 00 00    	jg     119bd <_ScsiClassInterpretSenseInfo@24+0x19d>
   11931:	83 f8 21             	cmp    $0x21,%eax
   11934:	0f 84 c6 00 00 00    	je     11a00 <_ScsiClassInterpretSenseInfo@24+0x1e0>
   1193a:	0f 8f cf 00 00 00    	jg     11a0f <_ScsiClassInterpretSenseInfo@24+0x1ef>
   11940:	83 f8 20             	cmp    $0x20,%eax
   11943:	0f 85 28 ff ff ff    	jne    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   11949:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   1194d:	e9 1f ff ff ff       	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   11952:	c7 03 9c 00 00 c0    	movl   $0xc000009c,(%ebx)
   11958:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   1195c:	e9 10 ff ff ff       	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   11961:	c7 03 00 00 00 00    	movl   $0x0,(%ebx)
   11967:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   1196b:	e9 01 ff ff ff       	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   11970:	f6 42 02 20          	testb  $0x20,0x2(%edx)
   11974:	74 38                	je     119ae <_ScsiClassInterpretSenseInfo@24+0x18e>
   11976:	c7 03 73 01 00 c0    	movl   $0xc0000173,(%ebx)
   1197c:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   11980:	e9 ec fe ff ff       	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   11985:	c7 03 a3 00 00 c0    	movl   $0xc00000a3,(%ebx)
   1198b:	80 7a 0c 3a          	cmpb   $0x3a,0xc(%edx)
   1198f:	0f 85 dc fe ff ff    	jne    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   11995:	89 da                	mov    %ebx,%edx
   11997:	8b 45 08             	mov    0x8(%ebp),%eax
   1199a:	e8 21 fe ff ff       	call   117c0 <_ScsiClassInvalidateMedia>
   1199f:	c7 03 13 00 00 c0    	movl   $0xc0000013,(%ebx)
   119a5:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   119a9:	e9 c3 fe ff ff       	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   119ae:	c7 03 85 01 00 c0    	movl   $0xc0000185,(%ebx)
   119b4:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   119b8:	e9 b4 fe ff ff       	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   119bd:	3d a1 00 00 00       	cmp    $0xa1,%eax
   119c2:	0f 84 fd fe ff ff    	je     118c5 <_ScsiClassInterpretSenseInfo@24+0xa5>
   119c8:	7f 4d                	jg     11a17 <_ScsiClassInterpretSenseInfo@24+0x1f7>
   119ca:	3d a0 00 00 00       	cmp    $0xa0,%eax
   119cf:	e9 6f ff ff ff       	jmp    11943 <_ScsiClassInterpretSenseInfo@24+0x123>
   119d4:	8b 87 c4 00 00 00    	mov    0xc4(%edi),%eax
   119da:	85 c0                	test   %eax,%eax
   119dc:	0f 84 26 ff ff ff    	je     11908 <_ScsiClassInterpretSenseInfo@24+0xe8>
   119e2:	50                   	push   %eax
   119e3:	6a 00                	push   $0x0
   119e5:	6a 00                	push   $0x0
   119e7:	8b 8f c4 00 00 00    	mov    0xc4(%edi),%ecx
   119ed:	51                   	push   %ecx
   119ee:	e8 8d 17 00 00       	call   13180 <_KeSetEvent@12>
   119f3:	c6 87 cc 00 00 00 00 	movb   $0x0,0xcc(%edi)
   119fa:	5a                   	pop    %edx
   119fb:	e9 08 ff ff ff       	jmp    11908 <_ScsiClassInterpretSenseInfo@24+0xe8>
   11a00:	c7 03 15 00 00 c0    	movl   $0xc0000015,(%ebx)
   11a06:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   11a0a:	e9 62 fe ff ff       	jmp    11871 <_ScsiClassInterpretSenseInfo@24+0x51>
   11a0f:	83 f8 24             	cmp    $0x24,%eax
   11a12:	e9 2c ff ff ff       	jmp    11943 <_ScsiClassInterpretSenseInfo@24+0x123>
   11a17:	3d a7 00 00 00       	cmp    $0xa7,%eax
   11a1c:	e9 22 ff ff ff       	jmp    11943 <_ScsiClassInterpretSenseInfo@24+0x123>
   11a21:	eb 0d                	jmp    11a30 <_ScsiClassRetryRequest>
   11a23:	90                   	nop    
   11a24:	90                   	nop    
   11a25:	90                   	nop    
   11a26:	90                   	nop    
   11a27:	90                   	nop    
   11a28:	90                   	nop    
   11a29:	90                   	nop    
   11a2a:	90                   	nop    
   11a2b:	90                   	nop    
   11a2c:	90                   	nop    
   11a2d:	90                   	nop    
   11a2e:	90                   	nop    
   11a2f:	90                   	nop    

00011a30 <_ScsiClassRetryRequest>:


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassIoComplete(IN PDEVICE_OBJECT DeviceObject,
		    IN PIRP Irp,
		    IN PVOID Context)
{
  PDEVICE_EXTENSION DeviceExtension;
  PIO_STACK_LOCATION IrpStack;
  PSCSI_REQUEST_BLOCK Srb;
  BOOLEAN Retry;
  NTSTATUS Status;

  DPRINT("ScsiClassIoComplete(DeviceObject %p  Irp %p  Context %p) called\n",
	  DeviceObject, Irp, Context);

  DeviceExtension = DeviceObject->DeviceExtension;

  IrpStack = IoGetCurrentIrpStackLocation(Irp);

  /*
   * BUGBUG -> Srb = IrpStack->Parameters.Scsi.Srb;
   * Must pass Srb as Context arg!! See comment about Completion routines in 
   * IofCallDriver for more info.
   */

  Srb = (PSCSI_REQUEST_BLOCK)Context;

  DPRINT("Srb %p\n", Srb);

  if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_SUCCESS)
    {
      Status = STATUS_SUCCESS;
    }
  else
    {
      /* Release the queue if it is frozen */
      if (Srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN)
	{
	  ScsiClassReleaseQueue (DeviceObject);
	}

      /* Get more detailed status information */
      Retry = ScsiClassInterpretSenseInfo(DeviceObject,
					  Srb,
					  IrpStack->MajorFunction,
					  0,
					  MAXIMUM_RETRIES - ((ULONG)IrpStack->Parameters.Others.Argument4),
					  &Status);

      /* Retry the request if verify should be overridden */
      if ((IrpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME) &&
	  Status == STATUS_VERIFY_REQUIRED)
	{
	  Status = STATUS_IO_DEVICE_ERROR;
	  Retry = TRUE;
	}

      /* Retry the request */
      if ((Retry) &&
	  ((ULONG_PTR)IrpStack->Parameters.Others.Argument4 > 0))
	{
	  IrpStack->Parameters.Others.Argument4 = (PVOID) ((ULONG_PTR)IrpStack->Parameters.Others.Argument4 - 1);

	  ScsiClassRetryRequest(DeviceObject,
				Irp,
				Srb,
				FALSE);

	  return(STATUS_MORE_PROCESSING_REQUIRED);
	}
    }

  /* Free the SRB */
  ExFreeToNPagedLookasideList(&DeviceExtension->SrbLookasideListHead,
			      Srb);

  Irp->IoStatus.Status = Status;
  if (!NT_SUCCESS(Status))
    {
      Irp->IoStatus.Information = 0;
      if (IoIsErrorUserInduced(Status))
	{
	  IoSetHardErrorOrVerifyDevice(Irp,
				       DeviceObject);
	}
    }

  if (Irp->PendingReturned)
    {
      IoMarkIrpPending (Irp);
    }

  if (DeviceExtension->ClassStartIo != NULL)
    {
      if (IrpStack->MajorFunction != IRP_MJ_DEVICE_CONTROL)
	{
	  KIRQL oldIrql;
	  oldIrql = KeGetCurrentIrql();
          if (oldIrql < DISPATCH_LEVEL)
            {
              KeRaiseIrql (DISPATCH_LEVEL, &oldIrql);
              IoStartNextPacket (DeviceObject, FALSE);
              KeLowerIrql(oldIrql);
	    }
          else
            {
              IoStartNextPacket (DeviceObject, FALSE);
	    }
	}
    }

  DPRINT("ScsiClassIoComplete() done (Status %lx)\n", Status);

  return(Status);
}


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassIoCompleteAssociated(IN PDEVICE_OBJECT DeviceObject,
			      IN PIRP Irp,
			      IN PVOID Context)
{
  PDEVICE_EXTENSION DeviceExtension;
  PIO_STACK_LOCATION IrpStack;
  PSCSI_REQUEST_BLOCK Srb;
  PIRP MasterIrp;
  BOOLEAN Retry;
  LONG RequestCount;
  NTSTATUS Status;

  DPRINT("ScsiClassIoCompleteAssociated(DeviceObject %p  Irp %p  Context %p) called\n",
	 DeviceObject, Irp, Context);

  MasterIrp = Irp->AssociatedIrp.MasterIrp;
  DeviceExtension = DeviceObject->DeviceExtension;

  IrpStack = IoGetCurrentIrpStackLocation(Irp);

  /*
   * BUGBUG -> Srb = Srb = IrpStack->Parameters.Scsi.Srb;
   * Must pass Srb as Context arg!! See comment about Completion routines in 
   * IofCallDriver for more info.
   */

  Srb = (PSCSI_REQUEST_BLOCK)Context;

  DPRINT("Srb %p\n", Srb);

  if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_SUCCESS)
    {
      Status = STATUS_SUCCESS;
    }
  else
    {
      /* Release the queue if it is frozen */
      if (Srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN)
	{
	  ScsiClassReleaseQueue (DeviceObject);
	}

      /* Get more detailed status information */
      Retry = ScsiClassInterpretSenseInfo(DeviceObject,
					  Srb,
					  IrpStack->MajorFunction,
					  0,
					  MAXIMUM_RETRIES - ((ULONG)IrpStack->Parameters.Others.Argument4),
					  &Status);

      /* Retry the request if verify should be overridden */
      if ((IrpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME) &&
	  Status == STATUS_VERIFY_REQUIRED)
	{
	  Status = STATUS_IO_DEVICE_ERROR;
	  Retry = TRUE;
	}

      /* Retry the request */
      if ((Retry) &&
	  ((ULONG_PTR)IrpStack->Parameters.Others.Argument4 > 0))
	{
	  IrpStack->Parameters.Others.Argument4 = (PVOID) ((ULONG_PTR)IrpStack->Parameters.Others.Argument4 - 1);

	  ScsiClassRetryRequest(DeviceObject,
				Irp,
				Srb,
				TRUE);

	  return(STATUS_MORE_PROCESSING_REQUIRED);
	}
    }

  /* Free the SRB */
  ExFreeToNPagedLookasideList(&DeviceExtension->SrbLookasideListHead,
			      Srb);

  Irp->IoStatus.Status = Status;

  IrpStack = IoGetNextIrpStackLocation(MasterIrp);
  if (!NT_SUCCESS(Status))
    {
      MasterIrp->IoStatus.Status = Status;
      MasterIrp->IoStatus.Information = 0;

      if (IoIsErrorUserInduced(Status))
	{
	  IoSetHardErrorOrVerifyDevice(MasterIrp,
				       DeviceObject);
	}
    }

  /* Decrement the request counter in the Master IRP */
  RequestCount = InterlockedDecrement((PLONG)&IrpStack->Parameters.Others.Argument1);

  if (RequestCount == 0)
    {
      /* Complete the Master IRP */
      IoCompleteRequest(MasterIrp,
			IO_DISK_INCREMENT);

      if (DeviceExtension->ClassStartIo)
	{
	  KIRQL oldIrql;
	  oldIrql = KeGetCurrentIrql();
          if (oldIrql < DISPATCH_LEVEL)
            {
              KeRaiseIrql (DISPATCH_LEVEL, &oldIrql);
              IoStartNextPacket (DeviceObject, FALSE);
              KeLowerIrql(oldIrql);
	    }
          else
            {
              IoStartNextPacket (DeviceObject, FALSE);
	    }
	}
    }

  /* Free the current IRP */
  IoFreeIrp(Irp);

  return(STATUS_MORE_PROCESSING_REQUIRED);
}


/*
 * @implemented
 */
ULONG STDCALL
ScsiClassModeSense(IN PDEVICE_OBJECT DeviceObject,
		   IN PCHAR ModeSenseBuffer,
		   IN ULONG Length,
		   IN UCHAR PageMode)
{
  PDEVICE_EXTENSION DeviceExtension;
  SCSI_REQUEST_BLOCK Srb;
  ULONG RetryCount;
  PCDB Cdb;
  NTSTATUS Status;

  DPRINT("ScsiClassModeSense() called\n");

  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
  RetryCount = 1;

  /* Initialize the SRB */
  RtlZeroMemory (&Srb,
		 sizeof(SCSI_REQUEST_BLOCK));
  Srb.CdbLength = 6;
  Srb.TimeOutValue = DeviceExtension->TimeOutValue;

  /* Initialize the CDB */
  Cdb = (PCDB)&Srb.Cdb;
  Cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
  Cdb->MODE_SENSE.PageCode = PageMode;
  Cdb->MODE_SENSE.AllocationLength = (UCHAR)Length;

TryAgain:
  Status = ScsiClassSendSrbSynchronous (DeviceObject,
					&Srb,
					ModeSenseBuffer,
					Length,
					FALSE);
  if (Status == STATUS_VERIFY_REQUIRED)
    {
      if (RetryCount != 0)
	{
	  RetryCount--;
	  goto TryAgain;
	}
    }
  else if (SRB_STATUS(Srb.SrbStatus) == SRB_STATUS_DATA_OVERRUN)
    {
      Status = STATUS_SUCCESS;
    }

  if (!NT_SUCCESS(Status))
    {
      return 0;
    }

  return Srb.DataTransferLength;
}


/*
 * @implemented
 */
ULONG STDCALL
ScsiClassQueryTimeOutRegistryValue(IN PUNICODE_STRING RegistryPath)
{
  PRTL_QUERY_REGISTRY_TABLE Table;
  ULONG TimeOutValue;
  ULONG ZeroTimeOut;
  ULONG Size;
  PWSTR Path;
  NTSTATUS Status;

  if (RegistryPath == NULL)
    {
      return 0;
    }

  TimeOutValue = 0;
  ZeroTimeOut = 0;

  /* Allocate zero-terminated path string */
  Size = RegistryPath->Length + sizeof(WCHAR);
  Path = (PWSTR)ExAllocatePool (NonPagedPool,
				Size);
  if (Path == NULL)
    {
      return 0;
    }
  RtlZeroMemory (Path,
		 Size);
  RtlCopyMemory (Path,
		 RegistryPath->Buffer,
		 Size - sizeof(WCHAR));

  /* Allocate query table */
  Size = sizeof(RTL_QUERY_REGISTRY_TABLE) * 2;
  Table = (PRTL_QUERY_REGISTRY_TABLE)ExAllocatePool (NonPagedPool,
						     Size);
  if (Table == NULL)
    {
      ExFreePool (Path);
      return 0;
    }
  RtlZeroMemory (Table,
		 Size);

  Table[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
  Table[0].Name = L"TimeOutValue";
  Table[0].EntryContext = &TimeOutValue;
  Table[0].DefaultType = REG_DWORD;
  Table[0].DefaultData = &ZeroTimeOut;
  Table[0].DefaultLength = sizeof(ULONG);

  Status = RtlQueryRegistryValues (RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
				   Path,
				   Table,
				   NULL,
				   NULL);
  if (!NT_SUCCESS(Status))
    {
      DPRINT("RtlQueryRegistryValue() failed (Status %lx)\n", Status);
      TimeOutValue = 0;
    }

  ExFreePool (Table);
  ExFreePool (Path);

  DPRINT("TimeOut: %lu\n", TimeOutValue);

  return TimeOutValue;
}


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassReadDriveCapacity(IN PDEVICE_OBJECT DeviceObject)
{
  PDEVICE_EXTENSION DeviceExtension;
  PREAD_CAPACITY_DATA CapacityBuffer;
  SCSI_REQUEST_BLOCK Srb;
  PCDB Cdb;
  NTSTATUS Status;
  ULONG LastSector;
  ULONG SectorSize;
  ULONG RetryCount = 1;

  DPRINT("ScsiClassReadDriveCapacity() called\n");

  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;

  CapacityBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
				  sizeof(READ_CAPACITY_DATA));
  if (CapacityBuffer == NULL)
    {
      return(STATUS_INSUFFICIENT_RESOURCES);
    }

  RtlZeroMemory(&Srb, sizeof(SCSI_REQUEST_BLOCK));

  Srb.CdbLength = 10;
  Srb.TimeOutValue = DeviceExtension->TimeOutValue;

  Cdb = (PCDB)Srb.Cdb;
  Cdb->CDB10.OperationCode = SCSIOP_READ_CAPACITY;

TryAgain:
  Status = ScsiClassSendSrbSynchronous(DeviceObject,
				       &Srb,
				       CapacityBuffer,
				       sizeof(READ_CAPACITY_DATA),
				       FALSE);
  DPRINT("Status: %lx\n", Status);
  DPRINT("Srb: %p\n", &Srb);
  if (NT_SUCCESS(Status))
    {
      SectorSize = (((PUCHAR)&CapacityBuffer->BytesPerBlock)[0] << 24) |
		   (((PUCHAR)&CapacityBuffer->BytesPerBlock)[1] << 16) |
		   (((PUCHAR)&CapacityBuffer->BytesPerBlock)[2] << 8) |
		    ((PUCHAR)&CapacityBuffer->BytesPerBlock)[3];


      LastSector = (((PUCHAR)&CapacityBuffer->LogicalBlockAddress)[0] << 24) |
		   (((PUCHAR)&CapacityBuffer->LogicalBlockAddress)[1] << 16) |
		   (((PUCHAR)&CapacityBuffer->LogicalBlockAddress)[2] << 8) |
		    ((PUCHAR)&CapacityBuffer->LogicalBlockAddress)[3];

      DeviceExtension->DiskGeometry->BytesPerSector = SectorSize;

      DeviceExtension->PartitionLength.QuadPart = (LONGLONG)(LastSector + 1);
      WHICH_BIT(DeviceExtension->DiskGeometry->BytesPerSector,
		DeviceExtension->SectorShift);
      DeviceExtension->PartitionLength.QuadPart =
	(DeviceExtension->PartitionLength.QuadPart << DeviceExtension->SectorShift);

      DeviceExtension->PartitionLength.QuadPart =
      (DeviceExtension->PartitionLength.QuadPart -
                                   DeviceExtension->StartingOffset.QuadPart);

      if (DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA)
	{
	  DeviceExtension->DiskGeometry->MediaType = RemovableMedia;
	}
      else
	{
	  DeviceExtension->DiskGeometry->MediaType = FixedMedia;
	}
      DeviceExtension->DiskGeometry->Cylinders.QuadPart = (LONGLONG)((LastSector + 1)/(32 * 64));
      DeviceExtension->DiskGeometry->SectorsPerTrack = 32;
      DeviceExtension->DiskGeometry->TracksPerCylinder = 64;

      DPRINT("SectorSize: %lu  SectorCount: %lu PartitionLenght %I64d\n", SectorSize, LastSector + 1,
      DeviceExtension->PartitionLength.QuadPart / 512 );
    }

  /* Try again if device needs to be verified */
  if (Status == STATUS_VERIFY_REQUIRED)
    {
      if (RetryCount > 0)
	{
	  RetryCount--;
	  goto TryAgain;
	}
    }

  if (!NT_SUCCESS(Status))
    {
      /* Use default values if disk geometry cannot be read */
      RtlZeroMemory(DeviceExtension->DiskGeometry,
		    sizeof(DISK_GEOMETRY));
      DeviceExtension->DiskGeometry->BytesPerSector = 512;
      DeviceExtension->SectorShift = 9;
      DeviceExtension->PartitionLength.QuadPart = 0;

      if (DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA)
	{
	  DeviceExtension->DiskGeometry->MediaType = RemovableMedia;
	}
      else
	{
	  DeviceExtension->DiskGeometry->MediaType = FixedMedia;
	}

      DPRINT("SectorSize: 512  SectorCount: 0\n");
    }

  ExFreePool(CapacityBuffer);

  DPRINT("ScsiClassReadDriveCapacity() done\n");

  return(Status);
}


/*
 * @implemented
 */
VOID STDCALL
ScsiClassReleaseQueue(IN PDEVICE_OBJECT DeviceObject)
{
  PDEVICE_EXTENSION DeviceExtension;
  PCOMPLETION_CONTEXT Context;
  PIO_STACK_LOCATION Stack;
  PSCSI_REQUEST_BLOCK Srb;
  KIRQL Irql;
  PCDB Cdb;
  PIRP Irp;

  DPRINT("ScsiClassReleaseQueue() called\n");

  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;

  /* Allocate and initialize the completion context */
  Context = ExAllocatePool (NonPagedPoolMustSucceed,
			    sizeof (COMPLETION_CONTEXT));
  Context->DeviceObject = DeviceObject;

  /* Initialize the SRB */
  Srb = &Context->Srb;
  RtlZeroMemory (Srb,
		 sizeof (SCSI_REQUEST_BLOCK));
  Srb->Length = sizeof (SCSI_REQUEST_BLOCK);
  Srb->PathId = DeviceExtension->PathId;
  Srb->TargetId = DeviceExtension->TargetId;
  Srb->Lun = DeviceExtension->Lun;
  Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
  Srb->TimeOutValue = START_UNIT_TIMEOUT;
  Srb->SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
		  SRB_FLAGS_DISABLE_AUTOSENSE |
		  SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
  Srb->CdbLength = 6;

  /* Initialize the CDB */
  Cdb = (PCDB)&Srb->Cdb;
  Cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
  Cdb->START_STOP.Start = 1;
  Cdb->START_STOP.LogicalUnitNumber = Srb->Lun;

  /* Build the IRP */
  Irp = IoAllocateIrp (DeviceObject->StackSize, FALSE);
  IoSetCompletionRoutine (Irp,
			  (PIO_COMPLETION_ROUTINE)ScsiClassAsynchronousCompletion,
			  Context,
			  NULL,
			  NULL,
			  NULL);

  /* Attach SRB to the IRP */
  Irp->Tail.Overlay.Thread = PsGetCurrentThread();
  Stack = IoGetNextIrpStackLocation(Irp);
  Stack->MajorFunction = IRP_MJ_SCSI;
  Stack->Parameters.Scsi.Srb = Srb;
  Srb->OriginalRequest = Irp;

  /* Call the port driver */
  Irql = KeGetCurrentIrql ();
  if (Irql < DISPATCH_LEVEL)
    {
      KeRaiseIrql (DISPATCH_LEVEL, &Irql);
      IoCallDriver (DeviceExtension->PortDeviceObject, Irp);
      KeLowerIrql (Irql);
    }
  else
    {
      IoCallDriver (DeviceExtension->PortDeviceObject, Irp);
    }

  DPRINT("ScsiClassReleaseQueue() done\n");
}


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassSendSrbAsynchronous(PDEVICE_OBJECT DeviceObject,
			     PSCSI_REQUEST_BLOCK Srb,
			     PIRP Irp,
			     PVOID BufferAddress,
			     ULONG BufferLength,
			     BOOLEAN WriteToDevice)
{
  PDEVICE_EXTENSION DeviceExtension;
  PIO_STACK_LOCATION Stack;

  DPRINT("ScsiClassSendSrbAsynchronous() called\n");

  DeviceExtension = DeviceObject->DeviceExtension;

  /* Initialize the SRB */
  Srb->Length = SCSI_REQUEST_BLOCK_SIZE;
  Srb->PathId = DeviceExtension->PathId;
  Srb->TargetId = DeviceExtension->TargetId;
  Srb->Lun = DeviceExtension->Lun;
  Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
  Srb->Cdb[1] |= DeviceExtension->Lun << 5;

  Srb->SenseInfoBuffer = (SENSE_DATA*)ROUND_UP((ULONG_PTR)(Srb + 1), SENSEINFO_ALIGNMENT);
  Srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;

  Srb->DataBuffer = BufferAddress;
  Srb->DataTransferLength = BufferLength;

  Srb->ScsiStatus = 0;
  Srb->SrbStatus = 0;
  Srb->NextSrb = NULL;

  if (BufferAddress != NULL)
    {
      if (Irp->MdlAddress == NULL)
	{
	  /* Allocate an MDL */
	  if (!IoAllocateMdl(BufferAddress,
			     BufferLength,
			     FALSE,
			     FALSE,
			     Irp))
	    {
	      DPRINT("Mdl-Allocation failed\n");
	      return(STATUS_INSUFFICIENT_RESOURCES);
	    }

	  MmBuildMdlForNonPagedPool(Irp->MdlAddress);
	}

      /* Set data direction */
      Srb->SrbFlags = (WriteToDevice) ? SRB_FLAGS_DATA_OUT : SRB_FLAGS_DATA_IN;
    }
  else
    {
      /* Set data direction */
      Srb->SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER;
    }

  /* Set the retry counter */
  Stack = IoGetCurrentIrpStackLocation(Irp);
  Stack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES;

  /* Set the completion routine */
  IoSetCompletionRoutine(Irp,
			 ScsiClassIoComplete,
			 Srb,
			 TRUE,
			 TRUE,
			 TRUE);

  /* Attach Srb to the Irp */
  Stack = IoGetNextIrpStackLocation(Irp);
  Stack->MajorFunction = IRP_MJ_SCSI;
  Stack->Parameters.Scsi.Srb = Srb;
  Srb->OriginalRequest = Irp;

  /* Call the port driver */
  return(IoCallDriver(DeviceExtension->PortDeviceObject,
		      Irp));
}


/*
 * @implemented
 */
NTSTATUS STDCALL
ScsiClassSendSrbSynchronous(PDEVICE_OBJECT DeviceObject,
			    PSCSI_REQUEST_BLOCK Srb,
			    PVOID BufferAddress,
			    ULONG BufferLength,
			    BOOLEAN WriteToDevice)
{
  PDEVICE_EXTENSION DeviceExtension;
  IO_STATUS_BLOCK IoStatusBlock;
  PIO_STACK_LOCATION IrpStack;
  ULONG RequestType;
  BOOLEAN Retry;
  ULONG RetryCount;
  KEVENT Event;
  PIRP Irp;
  NTSTATUS Status;
  LARGE_INTEGER RetryWait;

  DPRINT("ScsiClassSendSrbSynchronous() called\n");

  RetryCount = MAXIMUM_RETRIES;
  DeviceExtension = DeviceObject->DeviceExtension;

  Srb->Length = SCSI_REQUEST_BLOCK_SIZE;
  Srb->PathId = DeviceExtension->PathId;
  Srb->TargetId = DeviceExtension->TargetId;
  Srb->Lun = DeviceExtension->Lun;
  Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;

  Srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
  Srb->SenseInfoBuffer = ExAllocatePool(NonPagedPool,
					SENSE_BUFFER_SIZE);
  if (Srb->SenseInfoBuffer == NULL)
    return(STATUS_INSUFFICIENT_RESOURCES);

  if (BufferAddress == NULL)
    {
        BufferLength = 0;
        RequestType = IOCTL_SCSI_EXECUTE_NONE;
        Srb->SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER;
    }
  else
    {
      if (WriteToDevice == TRUE)
	{
	  RequestType = IOCTL_SCSI_EXECUTE_IN;	// needs _in_ to the device
	  Srb->SrbFlags = SRB_FLAGS_DATA_OUT;	// needs _out_ from the caller
	}
      else
	{
	  RequestType = IOCTL_SCSI_EXECUTE_OUT;
	  Srb->SrbFlags = SRB_FLAGS_DATA_IN;
	}
    }

  Srb->DataBuffer = BufferAddress;

TryAgain:
  Srb->DataTransferLength = BufferLength;
  KeInitializeEvent(&Event,
		    NotificationEvent,
		    FALSE);

  Irp = IoBuildDeviceIoControlRequest(RequestType,
				      DeviceExtension->PortDeviceObject,
				      NULL,
				      0,
				      BufferAddress,
				      BufferLength,
				      TRUE,
				      &Event,
				      &IoStatusBlock);
  if (Irp == NULL)
    {
      DPRINT("IoBuildDeviceIoControlRequest() failed\n");
      ExFreePool(Srb->SenseInfoBuffer);
      Srb->SenseInfoBuffer = NULL;
      Srb->SenseInfoBufferLength = 0;
      return(STATUS_INSUFFICIENT_RESOURCES);
    }

  /* Attach Srb to the Irp */
  IrpStack = IoGetNextIrpStackLocation(Irp);
  IrpStack->Parameters.Scsi.Srb = Srb;
  Srb->OriginalRequest = Irp;

  /* Call the SCSI port driver */
  Status = IoCallDriver(DeviceExtension->PortDeviceObject,
			Irp);
  if (Status == STATUS_PENDING)
    {
      KeWaitForSingleObject(&Event,
			    Suspended,
			    KernelMode,
			    FALSE,
			    NULL);
    }

  if (SRB_STATUS(Srb->SrbStatus) != SRB_STATUS_SUCCESS)
    {
      /* Release the queue if it is frozen */
      if (Srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN)
	{
	  ScsiClassReleaseQueue (DeviceObject);
	}

      /* Get more detailed status information */
      Retry = ScsiClassInterpretSenseInfo(DeviceObject,
					  Srb,
					  IRP_MJ_SCSI,
					  0,
					  MAXIMUM_RETRIES - RetryCount,
					  &Status);
      if (Retry == TRUE)
	{
	  DPRINT("Try again (RetryCount %lu)\n", RetryCount);

	  /* FIXME: Wait a little if we got a timeout error */

	  if (RetryCount--)
	    {
	      RetryWait.QuadPart = - RETRY_WAIT;
	      KeDelayExecutionThread(KernelMode, FALSE, &RetryWait);
	      goto TryAgain;
	    }
	}
    }
  else
    {
      Status = STATUS_SUCCESS;
    }

  ExFreePool(Srb->SenseInfoBuffer);

  DPRINT("ScsiClassSendSrbSynchronous() done\n");

  return(Status);
}


/*
 * @implemented
 */
VOID STDCALL
ScsiClassSplitRequest(IN PDEVICE_OBJECT DeviceObject,
		      IN PIRP Irp,
		      IN ULONG MaximumBytes)
{
  PDEVICE_EXTENSION DeviceExtension;
  PIO_STACK_LOCATION CurrentStack;
  PIO_STACK_LOCATION NextStack;
  PIO_STACK_LOCATION NewStack;
  PSCSI_REQUEST_BLOCK Srb;
  LARGE_INTEGER Offset;
  PIRP NewIrp;
  PVOID DataBuffer;
  ULONG TransferLength;
  ULONG RequestCount;
  ULONG DataLength;
  ULONG i;

  DPRINT("ScsiClassSplitRequest(DeviceObject %lx  Irp %lx  MaximumBytes %lu)\n",
	 DeviceObject, Irp, MaximumBytes);

  DeviceExtension = DeviceObject->DeviceExtension;
  CurrentStack = IoGetCurrentIrpStackLocation(Irp);
  NextStack = IoGetNextIrpStackLocation(Irp);
  DataBuffer = MmGetSystemAddressForMdl(Irp->MdlAddress);

  /* Initialize transfer data for first request */
  Offset = CurrentStack->Parameters.Read.ByteOffset;
  TransferLength = CurrentStack->Parameters.Read.Length;

  /* Set the result length */
  Irp->IoStatus.Information = TransferLength;

  DataLength = MaximumBytes;
  RequestCount = ROUND_UP(TransferLength, MaximumBytes) / MaximumBytes;

  /* Save request count in the original IRP */
  NextStack->Parameters.Others.Argument1 = (PVOID)RequestCount;

  DPRINT("RequestCount %lu\n", RequestCount);

  for (i = 0; i < RequestCount; i++)
    {
      /* Create a new IRP */
      NewIrp = IoAllocateIrp(DeviceObject->StackSize,
			     FALSE);
      if (NewIrp == NULL)
	{
	  Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
	  Irp->IoStatus.Information = 0;

	  if (i == 0)
	    IoCompleteRequest(Irp,
			      IO_NO_INCREMENT);
	  return;
	}

      /* Initialize the new IRP */
      NewIrp->MdlAddress = Irp->MdlAddress;
      NewIrp->Tail.Overlay.Thread = PsGetCurrentThread();

      IoSetNextIrpStackLocation(NewIrp);
      NewStack = IoGetCurrentIrpStackLocation(NewIrp);

      NewStack->MajorFunction = CurrentStack->MajorFunction;
      NewStack->Parameters.Read.ByteOffset = Offset;
      NewStack->Parameters.Read.Length = DataLength;
      NewStack->DeviceObject = DeviceObject;

      ScsiClassBuildRequest(DeviceObject,
			    NewIrp);

      NewStack = IoGetNextIrpStackLocation(NewIrp);
      Srb = NewStack->Parameters.Others.Argument1;
      Srb->DataBuffer = DataBuffer;

      NewIrp->AssociatedIrp.MasterIrp = Irp;

      /* Initialize completion routine */
      IoSetCompletionRoutine(NewIrp,
			     ScsiClassIoCompleteAssociated,
			     Srb,
			     TRUE,
			     TRUE,
			     TRUE);

      /* Send the new IRP down to the port driver */
      IoCallDriver(DeviceExtension->PortDeviceObject,
		   NewIrp);

      /* Adjust transfer data for next request */
      DataBuffer = (PCHAR)DataBuffer + MaximumBytes;
      TransferLength -= MaximumBytes;
      DataLength = (TransferLength > MaximumBytes) ? MaximumBytes : TransferLength;
      Offset.QuadPart = Offset.QuadPart + MaximumBytes;
    }
}


/* INTERNAL FUNCTIONS *******************************************************/

static NTSTATUS STDCALL
ScsiClassCreateClose(IN PDEVICE_OBJECT DeviceObject,
		     IN PIRP Irp)
{
  PDEVICE_EXTENSION DeviceExtension;

  DPRINT("ScsiClassCreateClose() called\n");

  DeviceExtension = DeviceObject->DeviceExtension;

  if (DeviceExtension->ClassCreateClose)
    return(DeviceExtension->ClassCreateClose(DeviceObject,
					     Irp));

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

  return(STATUS_SUCCESS);
}


static NTSTATUS STDCALL
ScsiClassReadWrite(IN PDEVICE_OBJECT DeviceObject,
		   IN PIRP Irp)
{
  PDEVICE_EXTENSION DeviceExtension;
  PIO_STACK_LOCATION IrpStack;
  ULONG MaximumTransferLength;
  ULONG CurrentTransferLength;
  ULONG MaximumTransferPages;
  ULONG CurrentTransferPages;
  NTSTATUS Status;

  DPRINT("ScsiClassReadWrite() called\n");

  DeviceExtension = DeviceObject->DeviceExtension;
  IrpStack  = IoGetCurrentIrpStackLocation(Irp);

  DPRINT("Relative Offset: %I64u  Length: %lu\n",
	 IrpStack->Parameters.Read.ByteOffset.QuadPart,
	 IrpStack->Parameters.Read.Length);

  MaximumTransferLength = DeviceExtension->PortCapabilities->MaximumTransferLength;
  MaximumTransferPages = DeviceExtension->PortCapabilities->MaximumPhysicalPages;

  CurrentTransferLength = IrpStack->Parameters.Read.Length;

  if ((DeviceObject->Flags & DO_VERIFY_VOLUME) &&
      !(IrpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME))
    {
      IoSetHardErrorOrVerifyDevice(Irp,
				   DeviceObject);

      Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;
      Irp->IoStatus.Information = 0;

      IoCompleteRequest(Irp,
			IO_NO_INCREMENT);
      return(STATUS_VERIFY_REQUIRED);
    }

  /* Class driver verifies the IRP */
  Status = DeviceExtension->ClassReadWriteVerification(DeviceObject,
						       Irp);
  if (!NT_SUCCESS(Status))
    {
      IoCompleteRequest(Irp,
			IO_NO_INCREMENT);
      return(Status);
    }
  else if (Status == STATUS_PENDING)
    {
      IoMarkIrpPending(Irp);
      return(STATUS_PENDING);
    }

  /* Finish a zero-byte transfer */
  if (CurrentTransferLength == 0)
    {
      Irp->IoStatus.Status = STATUS_SUCCESS;
      Irp->IoStatus.Information = 0;
      IoCompleteRequest(Irp,
			IO_NO_INCREMENT);
      return(STATUS_SUCCESS);
    }

  if (DeviceExtension->ClassStartIo != NULL)
    {
      DPRINT("ScsiClassReadWrite() starting packet\n");

      IoMarkIrpPending(Irp);
      IoStartPacket(DeviceObject,
		    Irp,
		    NULL,
		    NULL);

      return(STATUS_PENDING);
    }

  /* Adjust partition-relative starting offset to absolute offset */
  IrpStack->Parameters.Read.ByteOffset.QuadPart += 
    (DeviceExtension->StartingOffset.QuadPart + DeviceExtension->DMByteSkew);

  /* Calculate number of pages in this transfer */
  CurrentTransferPages =
    ADDRESS_AND_SIZE_TO_SPAN_PAGES(MmGetMdlVirtualAddress(Irp->MdlAddress),
				   IrpStack->Parameters.Read.Length);

  if (CurrentTransferLength > MaximumTransferLength ||
      CurrentTransferPages > MaximumTransferPages)
    {
       DPRINT("Split current request: MaximumTransferLength %lu  CurrentTransferLength %lu\n",
	      MaximumTransferLength, CurrentTransferLength);

      /* Adjust the maximum transfer length */
      CurrentTransferPages = DeviceExtension->PortCapabilities->MaximumPhysicalPages;

      if (MaximumTransferLength > CurrentTransferPages * PAGE_SIZE)
	  MaximumTransferLength = CurrentTransferPages * PAGE_SIZE;

      if (MaximumTransferLength == 0)
	  MaximumTransferLength = PAGE_SIZE;

      IoMarkIrpPending(Irp);

      /* Split current request */
      ScsiClassSplitRequest(DeviceObject,
			    Irp,
			    MaximumTransferLength);

      return(STATUS_PENDING);
    }

  ScsiClassBuildRequest(DeviceObject,
			Irp);

  DPRINT("ScsiClassReadWrite() done\n");

  /* Call the port driver */
  return(IoCallDriver(DeviceExtension->PortDeviceObject,
		      Irp));
}


static NTSTATUS STDCALL
ScsiClassDeviceDispatch(IN PDEVICE_OBJECT DeviceObject,
			IN PIRP Irp)
{
  PDEVICE_EXTENSION DeviceExtension;

  DPRINT("ScsiClassDeviceDispatch() called\n");

  DeviceExtension = DeviceObject->DeviceExtension;
  if (DeviceExtension->ClassDeviceControl)
    {
      return(DeviceExtension->ClassDeviceControl(DeviceObject, Irp));
    }

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

  return(STATUS_INVALID_DEVICE_REQUEST);
}


static NTSTATUS STDCALL
ScsiClassShutdownFlush(IN PDEVICE_OBJECT DeviceObject,
		       IN PIRP Irp)
{
  PDEVICE_EXTENSION DeviceExtension;

  DPRINT("ScsiClassShutdownFlush() called\n");

  DeviceExtension = DeviceObject->DeviceExtension;
  if (DeviceExtension->ClassShutdownFlush)
    {
      return(DeviceExtension->ClassShutdownFlush(DeviceObject, Irp));
    }

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

  return(STATUS_INVALID_DEVICE_REQUEST);
}


static VOID
ScsiClassRetryRequest(PDEVICE_OBJECT DeviceObject,
		      PIRP Irp,
		      PSCSI_REQUEST_BLOCK Srb,
		      BOOLEAN Associated)
{
   11a30:	55                   	push   %ebp
   11a31:	89 e5                	mov    %esp,%ebp
   11a33:	57                   	push   %edi
   11a34:	56                   	push   %esi
   11a35:	53                   	push   %ebx
   11a36:	83 ec 0c             	sub    $0xc,%esp
   11a39:	89 d3                	mov    %edx,%ebx
   11a3b:	8a 4d 0c             	mov    0xc(%ebp),%cl
  PDEVICE_EXTENSION DeviceExtension;
  PIO_STACK_LOCATION CurrentIrpStack;
  PIO_STACK_LOCATION NextIrpStack;

  DPRINT ("ScsiPortRetryRequest() called\n");

  DeviceExtension = DeviceObject->DeviceExtension;
   11a3e:	8b 78 28             	mov    0x28(%eax),%edi
   11a41:	88 4d f3             	mov    %cl,0xfffffff3(%ebp)
   11a44:	8b 55 08             	mov    0x8(%ebp),%edx
  CurrentIrpStack = IoGetCurrentIrpStackLocation(Irp);
   11a47:	8b 43 60             	mov    0x60(%ebx),%eax
  NextIrpStack = IoGetNextIrpStackLocation(Irp);

  if (CurrentIrpStack->MajorFunction == IRP_MJ_READ)
   11a4a:	8a 08                	mov    (%eax),%cl
   11a4c:	8d 70 dc             	lea    0xffffffdc(%eax),%esi
   11a4f:	80 f9 03             	cmp    $0x3,%cl
   11a52:	0f 84 9a 00 00 00    	je     11af2 <_ScsiClassRetryRequest+0xc2>
    {
      Srb->DataTransferLength = CurrentIrpStack->Parameters.Read.Length;
    }
  else if (CurrentIrpStack->MajorFunction == IRP_MJ_WRITE)
   11a58:	80 f9 04             	cmp    $0x4,%cl
   11a5b:	0f 84 91 00 00 00    	je     11af2 <_ScsiClassRetryRequest+0xc2>
    {
      Srb->DataTransferLength = CurrentIrpStack->Parameters.Write.Length;
    }
  else if (Irp->MdlAddress != NULL)
   11a61:	8b 43 04             	mov    0x4(%ebx),%eax
   11a64:	85 c0                	test   %eax,%eax
   11a66:	75 48                	jne    11ab0 <_ScsiClassRetryRequest+0x80>
    {
      Srb->DataTransferLength = Irp->MdlAddress->ByteCount;
    }
  else
    {
      Srb->DataTransferLength = 0;
    }

  Srb->SrbStatus = 0;
   11a68:	c6 42 03 00          	movb   $0x0,0x3(%edx)
  Srb->ScsiStatus = 0;
   11a6c:	c6 42 04 00          	movb   $0x0,0x4(%edx)
   11a70:	c7 42 10 00 00 00 00 	movl   $0x0,0x10(%edx)

  /* Don't modify the flags */
//  Srb->Flags = 
//  Srb->QueueTag = SP_UNTAGGED;

  NextIrpStack->MajorFunction = IRP_MJ_SCSI;
   11a77:	c6 06 0f             	movb   $0xf,(%esi)
  NextIrpStack->Parameters.Scsi.Srb = Srb;
   11a7a:	89 56 04             	mov    %edx,0x4(%esi)

  if (Associated == FALSE)
   11a7d:	80 7d f3 00          	cmpb   $0x0,0xfffffff3(%ebp)
   11a81:	75 47                	jne    11aca <_ScsiClassRetryRequest+0x9a>
    {
      IoSetCompletionRoutine(Irp,
   11a83:	8b 43 60             	mov    0x60(%ebx),%eax
   11a86:	83 e8 24             	sub    $0x24,%eax
   11a89:	c7 40 1c 50 1f 01 00 	movl   $0x11f50,0x1c(%eax)
			     ScsiClassIoComplete,
			     Srb,
			     TRUE,
			     TRUE,
			     TRUE);
    }			
  else
    {
      IoSetCompletionRoutine(Irp,
   11a90:	89 50 20             	mov    %edx,0x20(%eax)
   11a93:	c6 40 03 e0          	movb   $0xe0,0x3(%eax)
			     ScsiClassIoCompleteAssociated,
			     Srb,
			     TRUE,
			     TRUE,
			     TRUE);
    }

  IoCallDriver(DeviceExtension->PortDeviceObject,
   11a97:	50                   	push   %eax
   11a98:	50                   	push   %eax
   11a99:	53                   	push   %ebx
   11a9a:	8b 47 04             	mov    0x4(%edi),%eax
   11a9d:	50                   	push   %eax
   11a9e:	e8 ed 15 00 00       	call   13090 <_IoCallDriver@8>
   11aa3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11aa6:	5b                   	pop    %ebx
   11aa7:	5e                   	pop    %esi
   11aa8:	5f                   	pop    %edi
   11aa9:	5d                   	pop    %ebp
   11aaa:	c3                   	ret    
   11aab:	90                   	nop    
   11aac:	8d 74 26 00          	lea    0x0(%esi),%esi
   11ab0:	8b 40 14             	mov    0x14(%eax),%eax
   11ab3:	89 42 10             	mov    %eax,0x10(%edx)
   11ab6:	c6 42 03 00          	movb   $0x0,0x3(%edx)
   11aba:	c6 42 04 00          	movb   $0x0,0x4(%edx)
   11abe:	c6 06 0f             	movb   $0xf,(%esi)
   11ac1:	89 56 04             	mov    %edx,0x4(%esi)
   11ac4:	80 7d f3 00          	cmpb   $0x0,0xfffffff3(%ebp)
   11ac8:	74 b9                	je     11a83 <_ScsiClassRetryRequest+0x53>
   11aca:	8b 43 60             	mov    0x60(%ebx),%eax
   11acd:	83 e8 24             	sub    $0x24,%eax
   11ad0:	c7 40 1c 20 1d 01 00 	movl   $0x11d20,0x1c(%eax)
   11ad7:	89 50 20             	mov    %edx,0x20(%eax)
   11ada:	c6 40 03 e0          	movb   $0xe0,0x3(%eax)
   11ade:	50                   	push   %eax
   11adf:	50                   	push   %eax
   11ae0:	53                   	push   %ebx
   11ae1:	8b 47 04             	mov    0x4(%edi),%eax
   11ae4:	50                   	push   %eax
   11ae5:	e8 a6 15 00 00       	call   13090 <_IoCallDriver@8>
   11aea:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11aed:	5b                   	pop    %ebx
   11aee:	5e                   	pop    %esi
   11aef:	5f                   	pop    %edi
   11af0:	5d                   	pop    %ebp
   11af1:	c3                   	ret    
   11af2:	8b 40 04             	mov    0x4(%eax),%eax
   11af5:	89 42 10             	mov    %eax,0x10(%edx)
   11af8:	eb bc                	jmp    11ab6 <_ScsiClassRetryRequest+0x86>
   11afa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011b00 <_ScsiClassQueryTimeOutRegistryValue@4>:
   11b00:	55                   	push   %ebp
   11b01:	31 c0                	xor    %eax,%eax
   11b03:	89 e5                	mov    %esp,%ebp
   11b05:	57                   	push   %edi
   11b06:	56                   	push   %esi
   11b07:	53                   	push   %ebx
   11b08:	83 ec 0c             	sub    $0xc,%esp
   11b0b:	8b 75 08             	mov    0x8(%ebp),%esi
   11b0e:	85 f6                	test   %esi,%esi
   11b10:	0f 84 bd 00 00 00    	je     11bd3 <_ScsiClassQueryTimeOutRegistryValue@4+0xd3>
   11b16:	66 8b 06             	mov    (%esi),%ax
   11b19:	25 ff ff 00 00       	and    $0xffff,%eax
   11b1e:	51                   	push   %ecx
   11b1f:	89 c3                	mov    %eax,%ebx
   11b21:	51                   	push   %ecx
   11b22:	83 c3 02             	add    $0x2,%ebx
   11b25:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   11b2c:	53                   	push   %ebx
   11b2d:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   11b34:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11b37:	6a 00                	push   $0x0
   11b39:	e8 d2 15 00 00       	call   13110 <_ExAllocatePool@8>
   11b3e:	89 c7                	mov    %eax,%edi
   11b40:	58                   	pop    %eax
   11b41:	31 c0                	xor    %eax,%eax
   11b43:	5a                   	pop    %edx
   11b44:	85 ff                	test   %edi,%edi
   11b46:	0f 84 87 00 00 00    	je     11bd3 <_ScsiClassQueryTimeOutRegistryValue@4+0xd3>
   11b4c:	50                   	push   %eax
   11b4d:	50                   	push   %eax
   11b4e:	53                   	push   %ebx
   11b4f:	57                   	push   %edi
   11b50:	e8 fb 14 00 00       	call   13050 <_RtlZeroMemory@8>
   11b55:	58                   	pop    %eax
   11b56:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11b59:	50                   	push   %eax
   11b5a:	8b 46 04             	mov    0x4(%esi),%eax
   11b5d:	50                   	push   %eax
   11b5e:	57                   	push   %edi
   11b5f:	e8 0c 17 00 00       	call   13270 <_memcpy>
   11b64:	5b                   	pop    %ebx
   11b65:	5e                   	pop    %esi
   11b66:	6a 38                	push   $0x38
   11b68:	6a 00                	push   $0x0
   11b6a:	e8 a1 15 00 00       	call   13110 <_ExAllocatePool@8>
   11b6f:	5a                   	pop    %edx
   11b70:	89 c3                	mov    %eax,%ebx
   11b72:	59                   	pop    %ecx
   11b73:	85 c0                	test   %eax,%eax
   11b75:	74 66                	je     11bdd <_ScsiClassQueryTimeOutRegistryValue@4+0xdd>
   11b77:	50                   	push   %eax
   11b78:	50                   	push   %eax
   11b79:	6a 38                	push   $0x38
   11b7b:	53                   	push   %ebx
   11b7c:	e8 cf 14 00 00       	call   13050 <_RtlZeroMemory@8>
   11b81:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11b84:	c7 43 04 20 00 00 00 	movl   $0x20,0x4(%ebx)
   11b8b:	89 43 0c             	mov    %eax,0xc(%ebx)
   11b8e:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
   11b91:	89 43 14             	mov    %eax,0x14(%ebx)
   11b94:	c7 43 08 f4 40 01 00 	movl   $0x140f4,0x8(%ebx)
   11b9b:	c7 43 10 04 00 00 00 	movl   $0x4,0x10(%ebx)
   11ba2:	c7 43 18 04 00 00 00 	movl   $0x4,0x18(%ebx)
   11ba9:	50                   	push   %eax
   11baa:	6a 00                	push   $0x0
   11bac:	6a 00                	push   $0x0
   11bae:	53                   	push   %ebx
   11baf:	57                   	push   %edi
   11bb0:	68 00 00 00 80       	push   $0x80000000
   11bb5:	e8 d6 15 00 00       	call   13190 <_RtlQueryRegistryValues@20>
   11bba:	83 c4 0c             	add    $0xc,%esp
   11bbd:	85 c0                	test   %eax,%eax
   11bbf:	78 29                	js     11bea <_ScsiClassQueryTimeOutRegistryValue@4+0xea>
   11bc1:	83 ec 0c             	sub    $0xc,%esp
   11bc4:	53                   	push   %ebx
   11bc5:	e8 56 15 00 00       	call   13120 <_ExFreePool@4>
   11bca:	57                   	push   %edi
   11bcb:	e8 50 15 00 00       	call   13120 <_ExFreePool@4>
   11bd0:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11bd3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11bd6:	5b                   	pop    %ebx
   11bd7:	5e                   	pop    %esi
   11bd8:	5f                   	pop    %edi
   11bd9:	5d                   	pop    %ebp
   11bda:	c2 04 00             	ret    $0x4
   11bdd:	83 ec 0c             	sub    $0xc,%esp
   11be0:	57                   	push   %edi
   11be1:	e8 3a 15 00 00       	call   13120 <_ExFreePool@4>
   11be6:	31 c0                	xor    %eax,%eax
   11be8:	eb e9                	jmp    11bd3 <_ScsiClassQueryTimeOutRegistryValue@4+0xd3>
   11bea:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   11bf1:	eb ce                	jmp    11bc1 <_ScsiClassQueryTimeOutRegistryValue@4+0xc1>
   11bf3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11bf9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011c00 <_ScsiClassReleaseQueue@4>:
   11c00:	55                   	push   %ebp
   11c01:	89 e5                	mov    %esp,%ebp
   11c03:	57                   	push   %edi
   11c04:	56                   	push   %esi
   11c05:	53                   	push   %ebx
   11c06:	83 ec 14             	sub    $0x14,%esp
   11c09:	8b 7d 08             	mov    0x8(%ebp),%edi
   11c0c:	8b 47 28             	mov    0x28(%edi),%eax
   11c0f:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   11c12:	6a 44                	push   $0x44
   11c14:	6a 02                	push   $0x2
   11c16:	e8 f5 14 00 00       	call   13110 <_ExAllocatePool@8>
   11c1b:	89 c6                	mov    %eax,%esi
   11c1d:	8d 58 04             	lea    0x4(%eax),%ebx
   11c20:	89 38                	mov    %edi,(%eax)
   11c22:	6a 40                	push   $0x40
   11c24:	53                   	push   %ebx
   11c25:	e8 26 14 00 00       	call   13050 <_RtlZeroMemory@8>
   11c2a:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11c2d:	66 c7 46 04 40 00    	movw   $0x40,0x4(%esi)
   11c33:	8d 4e 34             	lea    0x34(%esi),%ecx
   11c36:	8a 82 bd 00 00 00    	mov    0xbd(%edx),%al
   11c3c:	88 43 05             	mov    %al,0x5(%ebx)
   11c3f:	8a 82 be 00 00 00    	mov    0xbe(%edx),%al
   11c45:	88 43 06             	mov    %al,0x6(%ebx)
   11c48:	8a 82 bf 00 00 00    	mov    0xbf(%edx),%al
   11c4e:	c6 43 02 00          	movb   $0x0,0x2(%ebx)
   11c52:	88 43 07             	mov    %al,0x7(%ebx)
   11c55:	c7 43 14 1e 00 00 00 	movl   $0x1e,0x14(%ebx)
   11c5c:	c7 43 0c 28 00 00 00 	movl   $0x28,0xc(%ebx)
   11c63:	c6 43 0a 06          	movb   $0x6,0xa(%ebx)
   11c67:	c6 46 34 1b          	movb   $0x1b,0x34(%esi)
   11c6b:	80 49 04 01          	orb    $0x1,0x4(%ecx)
   11c6f:	8a 41 01             	mov    0x1(%ecx),%al
   11c72:	8a 53 07             	mov    0x7(%ebx),%dl
   11c75:	c1 e2 05             	shl    $0x5,%edx
   11c78:	83 e0 1f             	and    $0x1f,%eax
   11c7b:	09 d0                	or     %edx,%eax
   11c7d:	88 41 01             	mov    %al,0x1(%ecx)
   11c80:	6a 00                	push   $0x0
   11c82:	0f be 47 30          	movsbl 0x30(%edi),%eax
   11c86:	50                   	push   %eax
   11c87:	e8 14 15 00 00       	call   131a0 <_IoAllocateIrp@8>
   11c8c:	89 c7                	mov    %eax,%edi
   11c8e:	58                   	pop    %eax
   11c8f:	5a                   	pop    %edx
   11c90:	8b 47 60             	mov    0x60(%edi),%eax
   11c93:	83 e8 24             	sub    $0x24,%eax
   11c96:	c7 40 1c 50 21 01 00 	movl   $0x12150,0x1c(%eax)
   11c9d:	89 70 20             	mov    %esi,0x20(%eax)
   11ca0:	c6 40 03 00          	movb   $0x0,0x3(%eax)
   11ca4:	e8 07 15 00 00       	call   131b0 <_KeGetCurrentThread@0>
   11ca9:	89 47 50             	mov    %eax,0x50(%edi)
   11cac:	8b 47 60             	mov    0x60(%edi),%eax
   11caf:	c6 40 dc 0f          	movb   $0xf,0xffffffdc(%eax)
   11cb3:	89 58 e0             	mov    %ebx,0xffffffe0(%eax)
   11cb6:	89 7b 24             	mov    %edi,0x24(%ebx)
   11cb9:	e8 f2 15 00 00       	call   132b0 <_KeGetCurrentIrql@0>
   11cbe:	3c 01                	cmp    $0x1,%al
   11cc0:	88 45 f3             	mov    %al,0xfffffff3(%ebp)
   11cc3:	77 33                	ja     11cf8 <_ScsiClassReleaseQueue@4+0xf8>
   11cc5:	50                   	push   %eax
   11cc6:	50                   	push   %eax
   11cc7:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   11cca:	50                   	push   %eax
   11ccb:	6a 02                	push   $0x2
   11ccd:	e8 ee 15 00 00       	call   132c0 <_KeRaiseIrql@8>
   11cd2:	57                   	push   %edi
   11cd3:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11cd6:	8b 40 04             	mov    0x4(%eax),%eax
   11cd9:	50                   	push   %eax
   11cda:	e8 b1 13 00 00       	call   13090 <_IoCallDriver@8>
   11cdf:	50                   	push   %eax
   11ce0:	31 c0                	xor    %eax,%eax
   11ce2:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11ce5:	50                   	push   %eax
   11ce6:	e8 e5 15 00 00       	call   132d0 <_KeLowerIrql@4>
   11ceb:	83 c4 0c             	add    $0xc,%esp
   11cee:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11cf1:	5b                   	pop    %ebx
   11cf2:	5e                   	pop    %esi
   11cf3:	5f                   	pop    %edi
   11cf4:	5d                   	pop    %ebp
   11cf5:	c2 04 00             	ret    $0x4
   11cf8:	50                   	push   %eax
   11cf9:	50                   	push   %eax
   11cfa:	57                   	push   %edi
   11cfb:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11cfe:	8b 7a 04             	mov    0x4(%edx),%edi
   11d01:	57                   	push   %edi
   11d02:	e8 89 13 00 00       	call   13090 <_IoCallDriver@8>
   11d07:	5b                   	pop    %ebx
   11d08:	5e                   	pop    %esi
   11d09:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11d0c:	5b                   	pop    %ebx
   11d0d:	5e                   	pop    %esi
   11d0e:	5f                   	pop    %edi
   11d0f:	5d                   	pop    %ebp
   11d10:	c2 04 00             	ret    $0x4
   11d13:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11d19:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011d20 <_ScsiClassIoCompleteAssociated@12>:
   11d20:	55                   	push   %ebp
   11d21:	31 d2                	xor    %edx,%edx
   11d23:	89 e5                	mov    %esp,%ebp
   11d25:	57                   	push   %edi
   11d26:	56                   	push   %esi
   11d27:	53                   	push   %ebx
   11d28:	83 ec 1c             	sub    $0x1c,%esp
   11d2b:	8b 45 0c             	mov    0xc(%ebp),%eax
   11d2e:	8b 7d 08             	mov    0x8(%ebp),%edi
   11d31:	8b 75 10             	mov    0x10(%ebp),%esi
   11d34:	8b 40 0c             	mov    0xc(%eax),%eax
   11d37:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   11d3a:	8b 47 28             	mov    0x28(%edi),%eax
   11d3d:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11d40:	8b 45 0c             	mov    0xc(%ebp),%eax
   11d43:	8a 56 03             	mov    0x3(%esi),%dl
   11d46:	8b 58 60             	mov    0x60(%eax),%ebx
   11d49:	89 d0                	mov    %edx,%eax
   11d4b:	24 3f                	and    $0x3f,%al
   11d4d:	48                   	dec    %eax
   11d4e:	0f 84 d6 01 00 00    	je     11f2a <_ScsiClassIoCompleteAssociated@12+0x20a>
   11d54:	83 e2 40             	and    $0x40,%edx
   11d57:	0f 85 ab 01 00 00    	jne    11f08 <_ScsiClassIoCompleteAssociated@12+0x1e8>
   11d5d:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11d60:	51                   	push   %ecx
   11d61:	51                   	push   %ecx
   11d62:	50                   	push   %eax
   11d63:	b8 0f 00 00 00       	mov    $0xf,%eax
   11d68:	8b 53 10             	mov    0x10(%ebx),%edx
   11d6b:	29 d0                	sub    %edx,%eax
   11d6d:	50                   	push   %eax
   11d6e:	31 c0                	xor    %eax,%eax
   11d70:	6a 00                	push   $0x0
   11d72:	8a 03                	mov    (%ebx),%al
   11d74:	50                   	push   %eax
   11d75:	56                   	push   %esi
   11d76:	57                   	push   %edi
   11d77:	e8 a4 fa ff ff       	call   11820 <_ScsiClassInterpretSenseInfo@24>
   11d7c:	f6 43 02 02          	testb  $0x2,0x2(%ebx)
   11d80:	5a                   	pop    %edx
   11d81:	59                   	pop    %ecx
   11d82:	75 7c                	jne    11e00 <_ScsiClassIoCompleteAssociated@12+0xe0>
   11d84:	84 c0                	test   %al,%al
   11d86:	74 0b                	je     11d93 <_ScsiClassIoCompleteAssociated@12+0x73>
   11d88:	8b 43 10             	mov    0x10(%ebx),%eax
   11d8b:	85 c0                	test   %eax,%eax
   11d8d:	0f 85 a3 01 00 00    	jne    11f36 <_ScsiClassIoCompleteAssociated@12+0x216>
ExFreeToNPagedLookasideList (
	IN	PNPAGED_LOOKASIDE_LIST	Lookaside,
	IN	PVOID			Entry
	)
{
   11d93:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   11d96:	83 c1 68             	add    $0x68,%ecx
	Lookaside->TotalFrees++;
   11d99:	8b 41 14             	mov    0x14(%ecx),%eax
   11d9c:	40                   	inc    %eax
   11d9d:	89 41 14             	mov    %eax,0x14(%ecx)
	if (ExQueryDepthSList (&Lookaside->ListHead) >= Lookaside->Depth)
   11da0:	66 8b 41 08          	mov    0x8(%ecx),%ax
   11da4:	66 39 41 04          	cmp    %ax,0x4(%ecx)
   11da8:	72 76                	jb     11e20 <_ScsiClassIoCompleteAssociated@12+0x100>
	{
		Lookaside->FreeMisses++;
   11daa:	8b 41 18             	mov    0x18(%ecx),%eax
		(Lookaside->Free)(Entry);
   11dad:	83 ec 0c             	sub    $0xc,%esp
   11db0:	40                   	inc    %eax
   11db1:	89 41 18             	mov    %eax,0x18(%ecx)
   11db4:	56                   	push   %esi
   11db5:	ff 51 2c             	call   *0x2c(%ecx)
   11db8:	8b 45 0c             	mov    0xc(%ebp),%eax
   11dbb:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
		(Lookaside->Free)(Entry);
	}
	else
	{
		ExInterlockedPushEntrySList (&Lookaside->ListHead,
   11dbe:	83 c4 0c             	add    $0xc,%esp
   11dc1:	89 48 18             	mov    %ecx,0x18(%eax)
   11dc4:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11dc7:	8b 58 60             	mov    0x60(%eax),%ebx
   11dca:	83 eb 24             	sub    $0x24,%ebx
   11dcd:	85 c9                	test   %ecx,%ecx
   11dcf:	78 7b                	js     11e4c <_ScsiClassIoCompleteAssociated@12+0x12c>
   11dd1:	8d 4b 04             	lea    0x4(%ebx),%ecx
   11dd4:	e8 e7 13 00 00       	call   131c0 <@InterlockedDecrement@4>
   11dd9:	85 c0                	test   %eax,%eax
   11ddb:	0f 84 d5 00 00 00    	je     11eb6 <_ScsiClassIoCompleteAssociated@12+0x196>
   11de1:	83 ec 0c             	sub    $0xc,%esp
   11de4:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   11de7:	51                   	push   %ecx
   11de8:	e8 e3 13 00 00       	call   131d0 <_IoFreeIrp@4>
   11ded:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11df0:	b8 16 00 00 c0       	mov    $0xc0000016,%eax
   11df5:	5b                   	pop    %ebx
   11df6:	5e                   	pop    %esi
   11df7:	5f                   	pop    %edi
   11df8:	5d                   	pop    %ebp
   11df9:	c2 0c 00             	ret    $0xc
   11dfc:	8d 74 26 00          	lea    0x0(%esi),%esi
   11e00:	81 7d f0 16 00 00 80 	cmpl   $0x80000016,0xfffffff0(%ebp)
   11e07:	0f 85 77 ff ff ff    	jne    11d84 <_ScsiClassIoCompleteAssociated@12+0x64>
   11e0d:	c7 45 f0 85 01 00 c0 	movl   $0xc0000185,0xfffffff0(%ebp)
   11e14:	e9 6f ff ff ff       	jmp    11d88 <_ScsiClassIoCompleteAssociated@12+0x68>
   11e19:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
		(Lookaside->Free)(Entry);
	}
	else
	{
		ExInterlockedPushEntrySList (&Lookaside->ListHead,
   11e20:	83 ec 0c             	sub    $0xc,%esp
   11e23:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11e26:	05 b0 00 00 00       	add    $0xb0,%eax
   11e2b:	89 f2                	mov    %esi,%edx
   11e2d:	50                   	push   %eax
   11e2e:	e8 ad 13 00 00       	call   131e0 <@ExInterlockedPushEntrySList@12>
   11e33:	8b 45 0c             	mov    0xc(%ebp),%eax
   11e36:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
		(Lookaside->Free)(Entry);
	}
	else
	{
		ExInterlockedPushEntrySList (&Lookaside->ListHead,
   11e39:	83 c4 0c             	add    $0xc,%esp
   11e3c:	89 48 18             	mov    %ecx,0x18(%eax)
   11e3f:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11e42:	8b 58 60             	mov    0x60(%eax),%ebx
   11e45:	83 eb 24             	sub    $0x24,%ebx
   11e48:	85 c9                	test   %ecx,%ecx
   11e4a:	79 85                	jns    11dd1 <_ScsiClassIoCompleteAssociated@12+0xb1>
   11e4c:	81 f9 a3 00 00 c0    	cmp    $0xc00000a3,%ecx
   11e52:	89 48 18             	mov    %ecx,0x18(%eax)
   11e55:	0f 94 c2             	sete   %dl
   11e58:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   11e5f:	81 f9 b5 00 00 c0    	cmp    $0xc00000b5,%ecx
   11e65:	0f 94 c0             	sete   %al
   11e68:	08 c2                	or     %al,%dl
   11e6a:	75 2c                	jne    11e98 <_ScsiClassIoCompleteAssociated@12+0x178>
   11e6c:	81 f9 a2 00 00 c0    	cmp    $0xc00000a2,%ecx
   11e72:	74 24                	je     11e98 <_ScsiClassIoCompleteAssociated@12+0x178>
   11e74:	81 f9 06 00 00 c1    	cmp    $0xc1000006,%ecx
   11e7a:	74 1c                	je     11e98 <_ScsiClassIoCompleteAssociated@12+0x178>
   11e7c:	81 f9 16 00 00 80    	cmp    $0x80000016,%ecx
   11e82:	74 14                	je     11e98 <_ScsiClassIoCompleteAssociated@12+0x178>
   11e84:	81 f9 14 00 00 c0    	cmp    $0xc0000014,%ecx
   11e8a:	74 0c                	je     11e98 <_ScsiClassIoCompleteAssociated@12+0x178>
   11e8c:	81 f9 12 00 00 c0    	cmp    $0xc0000012,%ecx
   11e92:	0f 85 39 ff ff ff    	jne    11dd1 <_ScsiClassIoCompleteAssociated@12+0xb1>
   11e98:	50                   	push   %eax
   11e99:	50                   	push   %eax
   11e9a:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11e9d:	57                   	push   %edi
   11e9e:	50                   	push   %eax
   11e9f:	e8 4c 13 00 00       	call   131f0 <_IoSetHardErrorOrVerifyDevice@8>
   11ea4:	8d 4b 04             	lea    0x4(%ebx),%ecx
   11ea7:	5e                   	pop    %esi
   11ea8:	58                   	pop    %eax
   11ea9:	e8 12 13 00 00       	call   131c0 <@InterlockedDecrement@4>
   11eae:	85 c0                	test   %eax,%eax
   11eb0:	0f 85 2b ff ff ff    	jne    11de1 <_ScsiClassIoCompleteAssociated@12+0xc1>
   11eb6:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   11eb9:	53                   	push   %ebx
   11eba:	53                   	push   %ebx
   11ebb:	6a 04                	push   $0x4
   11ebd:	51                   	push   %ecx
   11ebe:	e8 ad 12 00 00       	call   13170 <_IoCompleteRequest@8>
   11ec3:	58                   	pop    %eax
   11ec4:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11ec7:	5a                   	pop    %edx
   11ec8:	8b 40 3c             	mov    0x3c(%eax),%eax
   11ecb:	85 c0                	test   %eax,%eax
   11ecd:	0f 84 0e ff ff ff    	je     11de1 <_ScsiClassIoCompleteAssociated@12+0xc1>
   11ed3:	e8 d8 13 00 00       	call   132b0 <_KeGetCurrentIrql@0>
   11ed8:	3c 01                	cmp    $0x1,%al
   11eda:	88 45 ef             	mov    %al,0xffffffef(%ebp)
   11edd:	77 3a                	ja     11f19 <_ScsiClassIoCompleteAssociated@12+0x1f9>
   11edf:	50                   	push   %eax
   11ee0:	50                   	push   %eax
   11ee1:	8d 45 ef             	lea    0xffffffef(%ebp),%eax
   11ee4:	50                   	push   %eax
   11ee5:	6a 02                	push   $0x2
   11ee7:	e8 d4 13 00 00       	call   132c0 <_KeRaiseIrql@8>
   11eec:	6a 00                	push   $0x0
   11eee:	57                   	push   %edi
   11eef:	e8 0c 13 00 00       	call   13200 <_IoStartNextPacket@8>
   11ef4:	50                   	push   %eax
   11ef5:	31 c0                	xor    %eax,%eax
   11ef7:	8a 45 ef             	mov    0xffffffef(%ebp),%al
   11efa:	50                   	push   %eax
   11efb:	e8 d0 13 00 00       	call   132d0 <_KeLowerIrql@4>
   11f00:	83 c4 0c             	add    $0xc,%esp
   11f03:	e9 d9 fe ff ff       	jmp    11de1 <_ScsiClassIoCompleteAssociated@12+0xc1>
   11f08:	83 ec 0c             	sub    $0xc,%esp
   11f0b:	57                   	push   %edi
   11f0c:	e8 ef fc ff ff       	call   11c00 <_ScsiClassReleaseQueue@4>
   11f11:	83 c4 0c             	add    $0xc,%esp
   11f14:	e9 44 fe ff ff       	jmp    11d5d <_ScsiClassIoCompleteAssociated@12+0x3d>
   11f19:	50                   	push   %eax
   11f1a:	50                   	push   %eax
   11f1b:	6a 00                	push   $0x0
   11f1d:	57                   	push   %edi
   11f1e:	e8 dd 12 00 00       	call   13200 <_IoStartNextPacket@8>
   11f23:	5b                   	pop    %ebx
   11f24:	5e                   	pop    %esi
   11f25:	e9 b7 fe ff ff       	jmp    11de1 <_ScsiClassIoCompleteAssociated@12+0xc1>
   11f2a:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   11f31:	e9 5d fe ff ff       	jmp    11d93 <_ScsiClassIoCompleteAssociated@12+0x73>
   11f36:	48                   	dec    %eax
   11f37:	8b 55 0c             	mov    0xc(%ebp),%edx
   11f3a:	89 43 10             	mov    %eax,0x10(%ebx)
   11f3d:	50                   	push   %eax
   11f3e:	50                   	push   %eax
   11f3f:	89 f8                	mov    %edi,%eax
   11f41:	6a 01                	push   $0x1
   11f43:	56                   	push   %esi
   11f44:	e8 e7 fa ff ff       	call   11a30 <_ScsiClassRetryRequest>
   11f49:	e9 9f fe ff ff       	jmp    11ded <_ScsiClassIoCompleteAssociated@12+0xcd>
   11f4e:	89 f6                	mov    %esi,%esi

00011f50 <_ScsiClassIoComplete@12>:
   11f50:	55                   	push   %ebp
   11f51:	31 d2                	xor    %edx,%edx
   11f53:	89 e5                	mov    %esp,%ebp
   11f55:	57                   	push   %edi
   11f56:	56                   	push   %esi
   11f57:	53                   	push   %ebx
   11f58:	83 ec 0c             	sub    $0xc,%esp
   11f5b:	8b 45 08             	mov    0x8(%ebp),%eax
   11f5e:	8b 75 10             	mov    0x10(%ebp),%esi
   11f61:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11f64:	8b 40 28             	mov    0x28(%eax),%eax
   11f67:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11f6a:	8a 56 03             	mov    0x3(%esi),%dl
   11f6d:	8b 7b 60             	mov    0x60(%ebx),%edi
   11f70:	89 d0                	mov    %edx,%eax
   11f72:	24 3f                	and    $0x3f,%al
   11f74:	48                   	dec    %eax
   11f75:	0f 84 7d 01 00 00    	je     120f8 <_ScsiClassIoComplete@12+0x1a8>
   11f7b:	83 e2 40             	and    $0x40,%edx
   11f7e:	0f 85 e0 00 00 00    	jne    12064 <_ScsiClassIoComplete@12+0x114>
   11f84:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11f87:	51                   	push   %ecx
   11f88:	51                   	push   %ecx
   11f89:	50                   	push   %eax
   11f8a:	b8 0f 00 00 00       	mov    $0xf,%eax
   11f8f:	8b 57 10             	mov    0x10(%edi),%edx
   11f92:	29 d0                	sub    %edx,%eax
   11f94:	50                   	push   %eax
   11f95:	31 c0                	xor    %eax,%eax
   11f97:	6a 00                	push   $0x0
   11f99:	8a 07                	mov    (%edi),%al
   11f9b:	50                   	push   %eax
   11f9c:	8b 45 08             	mov    0x8(%ebp),%eax
   11f9f:	56                   	push   %esi
   11fa0:	50                   	push   %eax
   11fa1:	e8 7a f8 ff ff       	call   11820 <_ScsiClassInterpretSenseInfo@24>
   11fa6:	f6 47 02 02          	testb  $0x2,0x2(%edi)
   11faa:	5a                   	pop    %edx
   11fab:	59                   	pop    %ecx
   11fac:	74 0d                	je     11fbb <_ScsiClassIoComplete@12+0x6b>
   11fae:	81 7d f0 16 00 00 80 	cmpl   $0x80000016,0xfffffff0(%ebp)
   11fb5:	0f 84 5d 01 00 00    	je     12118 <_ScsiClassIoComplete@12+0x1c8>
   11fbb:	84 c0                	test   %al,%al
   11fbd:	74 0b                	je     11fca <_ScsiClassIoComplete@12+0x7a>
   11fbf:	8b 47 10             	mov    0x10(%edi),%eax
   11fc2:	85 c0                	test   %eax,%eax
   11fc4:	0f 85 5a 01 00 00    	jne    12124 <_ScsiClassIoComplete@12+0x1d4>
ExFreeToNPagedLookasideList (
	IN	PNPAGED_LOOKASIDE_LIST	Lookaside,
	IN	PVOID			Entry
	)
{
   11fca:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   11fcd:	83 c1 68             	add    $0x68,%ecx
	Lookaside->TotalFrees++;
   11fd0:	8b 41 14             	mov    0x14(%ecx),%eax
   11fd3:	40                   	inc    %eax
   11fd4:	89 41 14             	mov    %eax,0x14(%ecx)
	if (ExQueryDepthSList (&Lookaside->ListHead) >= Lookaside->Depth)
   11fd7:	66 8b 41 08          	mov    0x8(%ecx),%ax
   11fdb:	66 39 41 04          	cmp    %ax,0x4(%ecx)
   11fdf:	0f 82 93 00 00 00    	jb     12078 <_ScsiClassIoComplete@12+0x128>
	{
		Lookaside->FreeMisses++;
   11fe5:	8b 41 18             	mov    0x18(%ecx),%eax
		(Lookaside->Free)(Entry);
   11fe8:	83 ec 0c             	sub    $0xc,%esp
   11feb:	40                   	inc    %eax
   11fec:	89 41 18             	mov    %eax,0x18(%ecx)
   11fef:	56                   	push   %esi
   11ff0:	ff 51 2c             	call   *0x2c(%ecx)
   11ff3:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
		(Lookaside->Free)(Entry);
	}
	else
	{
		ExInterlockedPushEntrySList (&Lookaside->ListHead,
   11ff6:	83 c4 0c             	add    $0xc,%esp
   11ff9:	89 4b 18             	mov    %ecx,0x18(%ebx)
   11ffc:	85 c9                	test   %ecx,%ecx
   11ffe:	0f 88 98 00 00 00    	js     1209c <_ScsiClassIoComplete@12+0x14c>
   12004:	80 7b 21 00          	cmpb   $0x0,0x21(%ebx)
   12008:	74 07                	je     12011 <_ScsiClassIoComplete@12+0xc1>
   1200a:	8b 43 60             	mov    0x60(%ebx),%eax
   1200d:	80 48 03 01          	orb    $0x1,0x3(%eax)
   12011:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   12014:	8b 40 3c             	mov    0x3c(%eax),%eax
   12017:	85 c0                	test   %eax,%eax
   12019:	74 3c                	je     12057 <_ScsiClassIoComplete@12+0x107>
   1201b:	80 3f 0e             	cmpb   $0xe,(%edi)
   1201e:	74 37                	je     12057 <_ScsiClassIoComplete@12+0x107>
   12020:	e8 8b 12 00 00       	call   132b0 <_KeGetCurrentIrql@0>
   12025:	3c 01                	cmp    $0x1,%al
   12027:	88 45 ef             	mov    %al,0xffffffef(%ebp)
   1202a:	0f 87 d4 00 00 00    	ja     12104 <_ScsiClassIoComplete@12+0x1b4>
   12030:	50                   	push   %eax
   12031:	50                   	push   %eax
   12032:	8d 45 ef             	lea    0xffffffef(%ebp),%eax
   12035:	50                   	push   %eax
   12036:	6a 02                	push   $0x2
   12038:	e8 83 12 00 00       	call   132c0 <_KeRaiseIrql@8>
   1203d:	8b 45 08             	mov    0x8(%ebp),%eax
   12040:	6a 00                	push   $0x0
   12042:	50                   	push   %eax
   12043:	e8 b8 11 00 00       	call   13200 <_IoStartNextPacket@8>
   12048:	50                   	push   %eax
   12049:	31 c0                	xor    %eax,%eax
   1204b:	8a 45 ef             	mov    0xffffffef(%ebp),%al
   1204e:	50                   	push   %eax
   1204f:	e8 7c 12 00 00       	call   132d0 <_KeLowerIrql@4>
   12054:	83 c4 0c             	add    $0xc,%esp
   12057:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   1205a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1205d:	5b                   	pop    %ebx
   1205e:	5e                   	pop    %esi
   1205f:	5f                   	pop    %edi
   12060:	5d                   	pop    %ebp
   12061:	c2 0c 00             	ret    $0xc
   12064:	83 ec 0c             	sub    $0xc,%esp
   12067:	8b 45 08             	mov    0x8(%ebp),%eax
   1206a:	50                   	push   %eax
   1206b:	e8 90 fb ff ff       	call   11c00 <_ScsiClassReleaseQueue@4>
   12070:	83 c4 0c             	add    $0xc,%esp
   12073:	e9 0c ff ff ff       	jmp    11f84 <_ScsiClassIoComplete@12+0x34>
		(Lookaside->Free)(Entry);
	}
	else
	{
		ExInterlockedPushEntrySList (&Lookaside->ListHead,
   12078:	83 ec 0c             	sub    $0xc,%esp
   1207b:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   1207e:	05 b0 00 00 00       	add    $0xb0,%eax
   12083:	89 f2                	mov    %esi,%edx
   12085:	50                   	push   %eax
   12086:	e8 55 11 00 00       	call   131e0 <@ExInterlockedPushEntrySList@12>
   1208b:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
		(Lookaside->Free)(Entry);
	}
	else
	{
		ExInterlockedPushEntrySList (&Lookaside->ListHead,
   1208e:	83 c4 0c             	add    $0xc,%esp
   12091:	89 4b 18             	mov    %ecx,0x18(%ebx)
   12094:	85 c9                	test   %ecx,%ecx
   12096:	0f 89 68 ff ff ff    	jns    12004 <_ScsiClassIoComplete@12+0xb4>
   1209c:	81 f9 a3 00 00 c0    	cmp    $0xc00000a3,%ecx
   120a2:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   120a9:	0f 94 c2             	sete   %dl
   120ac:	81 f9 b5 00 00 c0    	cmp    $0xc00000b5,%ecx
   120b2:	0f 94 c0             	sete   %al
   120b5:	08 c2                	or     %al,%dl
   120b7:	75 2c                	jne    120e5 <_ScsiClassIoComplete@12+0x195>
   120b9:	81 f9 a2 00 00 c0    	cmp    $0xc00000a2,%ecx
   120bf:	74 24                	je     120e5 <_ScsiClassIoComplete@12+0x195>
   120c1:	81 f9 06 00 00 c1    	cmp    $0xc1000006,%ecx
   120c7:	74 1c                	je     120e5 <_ScsiClassIoComplete@12+0x195>
   120c9:	81 f9 16 00 00 80    	cmp    $0x80000016,%ecx
   120cf:	74 14                	je     120e5 <_ScsiClassIoComplete@12+0x195>
   120d1:	81 f9 14 00 00 c0    	cmp    $0xc0000014,%ecx
   120d7:	74 0c                	je     120e5 <_ScsiClassIoComplete@12+0x195>
   120d9:	81 f9 12 00 00 c0    	cmp    $0xc0000012,%ecx
   120df:	0f 85 1f ff ff ff    	jne    12004 <_ScsiClassIoComplete@12+0xb4>
   120e5:	8b 4d 08             	mov    0x8(%ebp),%ecx
   120e8:	56                   	push   %esi
   120e9:	56                   	push   %esi
   120ea:	51                   	push   %ecx
   120eb:	53                   	push   %ebx
   120ec:	e8 ff 10 00 00       	call   131f0 <_IoSetHardErrorOrVerifyDevice@8>
   120f1:	58                   	pop    %eax
   120f2:	5a                   	pop    %edx
   120f3:	e9 0c ff ff ff       	jmp    12004 <_ScsiClassIoComplete@12+0xb4>
   120f8:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   120ff:	e9 c6 fe ff ff       	jmp    11fca <_ScsiClassIoComplete@12+0x7a>
   12104:	8b 7d 08             	mov    0x8(%ebp),%edi
   12107:	50                   	push   %eax
   12108:	50                   	push   %eax
   12109:	6a 00                	push   $0x0
   1210b:	57                   	push   %edi
   1210c:	e8 ef 10 00 00       	call   13200 <_IoStartNextPacket@8>
   12111:	5b                   	pop    %ebx
   12112:	5e                   	pop    %esi
   12113:	e9 3f ff ff ff       	jmp    12057 <_ScsiClassIoComplete@12+0x107>
   12118:	c7 45 f0 85 01 00 c0 	movl   $0xc0000185,0xfffffff0(%ebp)
   1211f:	e9 9b fe ff ff       	jmp    11fbf <_ScsiClassIoComplete@12+0x6f>
   12124:	48                   	dec    %eax
   12125:	89 da                	mov    %ebx,%edx
   12127:	89 47 10             	mov    %eax,0x10(%edi)
   1212a:	50                   	push   %eax
   1212b:	50                   	push   %eax
   1212c:	8b 45 08             	mov    0x8(%ebp),%eax
   1212f:	6a 00                	push   $0x0
   12131:	56                   	push   %esi
   12132:	e8 f9 f8 ff ff       	call   11a30 <_ScsiClassRetryRequest>
   12137:	b8 16 00 00 c0       	mov    $0xc0000016,%eax
   1213c:	e9 19 ff ff ff       	jmp    1205a <_ScsiClassIoComplete@12+0x10a>
   12141:	eb 0d                	jmp    12150 <_ScsiClassAsynchronousCompletion@12>
   12143:	90                   	nop    
   12144:	90                   	nop    
   12145:	90                   	nop    
   12146:	90                   	nop    
   12147:	90                   	nop    
   12148:	90                   	nop    
   12149:	90                   	nop    
   1214a:	90                   	nop    
   1214b:	90                   	nop    
   1214c:	90                   	nop    
   1214d:	90                   	nop    
   1214e:	90                   	nop    
   1214f:	90                   	nop    

00012150 <_ScsiClassAsynchronousCompletion@12>:
   12150:	55                   	push   %ebp
   12151:	89 e5                	mov    %esp,%ebp
   12153:	56                   	push   %esi
   12154:	53                   	push   %ebx
   12155:	8b 75 10             	mov    0x10(%ebp),%esi
   12158:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   1215b:	8d 46 04             	lea    0x4(%esi),%eax
   1215e:	80 78 02 00          	cmpb   $0x0,0x2(%eax)
   12162:	75 06                	jne    1216a <_ScsiClassAsynchronousCompletion@12+0x1a>
   12164:	f6 40 03 40          	testb  $0x40,0x3(%eax)
   12168:	75 66                	jne    121d0 <_ScsiClassAsynchronousCompletion@12+0x80>
   1216a:	8b 43 04             	mov    0x4(%ebx),%eax
   1216d:	85 c0                	test   %eax,%eax
   1216f:	75 1f                	jne    12190 <_ScsiClassAsynchronousCompletion@12+0x40>
   12171:	83 ec 0c             	sub    $0xc,%esp
   12174:	56                   	push   %esi
   12175:	e8 a6 0f 00 00       	call   13120 <_ExFreePool@4>
   1217a:	53                   	push   %ebx
   1217b:	e8 50 10 00 00       	call   131d0 <_IoFreeIrp@4>
   12180:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   12183:	b8 16 00 00 c0       	mov    $0xc0000016,%eax
   12188:	5b                   	pop    %ebx
   12189:	5e                   	pop    %esi
   1218a:	5d                   	pop    %ebp
   1218b:	c2 0c 00             	ret    $0xc
   1218e:	89 f6                	mov    %esi,%esi
   12190:	83 ec 0c             	sub    $0xc,%esp
   12193:	50                   	push   %eax
   12194:	e8 77 10 00 00       	call   13210 <_MmUnlockPages@4>
   12199:	8b 43 04             	mov    0x4(%ebx),%eax
   1219c:	50                   	push   %eax
   1219d:	e8 7e 10 00 00       	call   13220 <_IoFreeMdl@4>
   121a2:	83 c4 0c             	add    $0xc,%esp
   121a5:	c7 43 04 00 00 00 00 	movl   $0x0,0x4(%ebx)
   121ac:	83 ec 0c             	sub    $0xc,%esp
   121af:	56                   	push   %esi
   121b0:	e8 6b 0f 00 00       	call   13120 <_ExFreePool@4>
   121b5:	53                   	push   %ebx
   121b6:	e8 15 10 00 00       	call   131d0 <_IoFreeIrp@4>
   121bb:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   121be:	b8 16 00 00 c0       	mov    $0xc0000016,%eax
   121c3:	5b                   	pop    %ebx
   121c4:	5e                   	pop    %esi
   121c5:	5d                   	pop    %ebp
   121c6:	c2 0c 00             	ret    $0xc
   121c9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   121d0:	83 ec 0c             	sub    $0xc,%esp
   121d3:	8b 06                	mov    (%esi),%eax
   121d5:	50                   	push   %eax
   121d6:	e8 25 fa ff ff       	call   11c00 <_ScsiClassReleaseQueue@4>
   121db:	83 c4 0c             	add    $0xc,%esp
   121de:	eb 8a                	jmp    1216a <_ScsiClassAsynchronousCompletion@12+0x1a>

000121e0 <_ScsiClassSendSrbAsynchronous@24>:
   121e0:	55                   	push   %ebp
   121e1:	89 e5                	mov    %esp,%ebp
   121e3:	57                   	push   %edi
   121e4:	56                   	push   %esi
   121e5:	53                   	push   %ebx
   121e6:	83 ec 0c             	sub    $0xc,%esp
   121e9:	8a 45 1c             	mov    0x1c(%ebp),%al
   121ec:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   121ef:	88 45 f3             	mov    %al,0xfffffff3(%ebp)
   121f2:	8b 45 08             	mov    0x8(%ebp),%eax
   121f5:	66 c7 03 40 00       	movw   $0x40,(%ebx)
   121fa:	8b 55 14             	mov    0x14(%ebp),%edx
   121fd:	8b 70 28             	mov    0x28(%eax),%esi
   12200:	8b 4d 18             	mov    0x18(%ebp),%ecx
   12203:	8b 7d 10             	mov    0x10(%ebp),%edi
   12206:	8a 86 bd 00 00 00    	mov    0xbd(%esi),%al
   1220c:	88 43 05             	mov    %al,0x5(%ebx)
   1220f:	8a 86 be 00 00 00    	mov    0xbe(%esi),%al
   12215:	88 43 06             	mov    %al,0x6(%ebx)
   12218:	8a 86 bf 00 00 00    	mov    0xbf(%esi),%al
   1221e:	c6 43 02 00          	movb   $0x0,0x2(%ebx)
   12222:	88 43 07             	mov    %al,0x7(%ebx)
   12225:	31 c0                	xor    %eax,%eax
   12227:	8a 86 bf 00 00 00    	mov    0xbf(%esi),%al
   1222d:	c6 43 0b 12          	movb   $0x12,0xb(%ebx)
   12231:	c1 e0 05             	shl    $0x5,%eax
   12234:	89 53 18             	mov    %edx,0x18(%ebx)
   12237:	08 43 31             	or     %al,0x31(%ebx)
   1223a:	8d 43 5f             	lea    0x5f(%ebx),%eax
   1223d:	83 e0 e0             	and    $0xffffffe0,%eax
   12240:	89 4b 10             	mov    %ecx,0x10(%ebx)
   12243:	89 43 1c             	mov    %eax,0x1c(%ebx)
   12246:	c6 43 04 00          	movb   $0x0,0x4(%ebx)
   1224a:	c6 43 03 00          	movb   $0x0,0x3(%ebx)
   1224e:	c7 43 20 00 00 00 00 	movl   $0x0,0x20(%ebx)
   12255:	85 d2                	test   %edx,%edx
   12257:	0f 84 87 00 00 00    	je     122e4 <_ScsiClassSendSrbAsynchronous@24+0x104>
   1225d:	8b 47 04             	mov    0x4(%edi),%eax
   12260:	85 c0                	test   %eax,%eax
   12262:	74 54                	je     122b8 <_ScsiClassSendSrbAsynchronous@24+0xd8>
   12264:	80 7d f3 01          	cmpb   $0x1,0xfffffff3(%ebp)
   12268:	19 c0                	sbb    %eax,%eax
   1226a:	83 e0 c0             	and    $0xffffffc0,%eax
   1226d:	83 e8 80             	sub    $0xffffff80,%eax
   12270:	89 43 0c             	mov    %eax,0xc(%ebx)
   12273:	8b 47 60             	mov    0x60(%edi),%eax
   12276:	c7 40 10 0f 00 00 00 	movl   $0xf,0x10(%eax)
   1227d:	8b 47 60             	mov    0x60(%edi),%eax
   12280:	83 e8 24             	sub    $0x24,%eax
   12283:	c6 40 03 e0          	movb   $0xe0,0x3(%eax)
   12287:	89 58 20             	mov    %ebx,0x20(%eax)
   1228a:	c7 40 1c 50 1f 01 00 	movl   $0x11f50,0x1c(%eax)
   12291:	8b 47 60             	mov    0x60(%edi),%eax
   12294:	c6 40 dc 0f          	movb   $0xf,0xffffffdc(%eax)
   12298:	89 58 e0             	mov    %ebx,0xffffffe0(%eax)
   1229b:	89 7b 24             	mov    %edi,0x24(%ebx)
   1229e:	50                   	push   %eax
   1229f:	50                   	push   %eax
   122a0:	57                   	push   %edi
   122a1:	8b 46 04             	mov    0x4(%esi),%eax
   122a4:	50                   	push   %eax
   122a5:	e8 e6 0d 00 00       	call   13090 <_IoCallDriver@8>
   122aa:	89 c2                	mov    %eax,%edx
   122ac:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   122af:	89 d0                	mov    %edx,%eax
   122b1:	5b                   	pop    %ebx
   122b2:	5e                   	pop    %esi
   122b3:	5f                   	pop    %edi
   122b4:	5d                   	pop    %ebp
   122b5:	c2 18 00             	ret    $0x18
   122b8:	83 ec 0c             	sub    $0xc,%esp
   122bb:	57                   	push   %edi
   122bc:	6a 00                	push   $0x0
   122be:	6a 00                	push   $0x0
   122c0:	51                   	push   %ecx
   122c1:	52                   	push   %edx
   122c2:	e8 69 0f 00 00       	call   13230 <_IoAllocateMdl@20>
   122c7:	ba 9a 00 00 c0       	mov    $0xc000009a,%edx
   122cc:	83 c4 0c             	add    $0xc,%esp
   122cf:	85 c0                	test   %eax,%eax
   122d1:	74 d9                	je     122ac <_ScsiClassSendSrbAsynchronous@24+0xcc>
   122d3:	83 ec 0c             	sub    $0xc,%esp
   122d6:	8b 47 04             	mov    0x4(%edi),%eax
   122d9:	50                   	push   %eax
   122da:	e8 61 0f 00 00       	call   13240 <_MmBuildMdlForNonPagedPool@4>
   122df:	83 c4 0c             	add    $0xc,%esp
   122e2:	eb 80                	jmp    12264 <_ScsiClassSendSrbAsynchronous@24+0x84>
   122e4:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)
   122eb:	eb 86                	jmp    12273 <_ScsiClassSendSrbAsynchronous@24+0x93>
   122ed:	8d 76 00             	lea    0x0(%esi),%esi

000122f0 <_ScsiClassDeviceControl@8>:
   122f0:	55                   	push   %ebp
   122f1:	89 e5                	mov    %esp,%ebp
   122f3:	57                   	push   %edi
   122f4:	56                   	push   %esi
   122f5:	53                   	push   %ebx
   122f6:	83 ec 1c             	sub    $0x1c,%esp
   122f9:	8b 45 08             	mov    0x8(%ebp),%eax
   122fc:	8b 7d 0c             	mov    0xc(%ebp),%edi
   122ff:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   12302:	8b 50 28             	mov    0x28(%eax),%edx
   12305:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   12308:	8b 5f 60             	mov    0x60(%edi),%ebx
   1230b:	8b 73 0c             	mov    0xc(%ebx),%esi
   1230e:	8b 43 04             	mov    0x4(%ebx),%eax
   12311:	8b 4b 08             	mov    0x8(%ebx),%ecx
   12314:	81 fe 20 10 04 00    	cmp    $0x41020,%esi
   1231a:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   1231d:	0f 84 9d 00 00 00    	je     123c0 <_ScsiClassDeviceControl@8+0xd0>
   12323:	81 fe 18 10 04 00    	cmp    $0x41018,%esi
   12329:	0f 84 d8 00 00 00    	je     12407 <_ScsiClassDeviceControl@8+0x117>
   1232f:	81 fe 04 d0 04 00    	cmp    $0x4d004,%esi
   12335:	0f 94 c2             	sete   %dl
   12338:	81 fe 14 d0 04 00    	cmp    $0x4d014,%esi
   1233e:	0f 94 c0             	sete   %al
   12341:	09 d0                	or     %edx,%eax
   12343:	a8 01                	test   $0x1,%al
   12345:	0f 84 1a 01 00 00    	je     12465 <_ScsiClassDeviceControl@8+0x175>
   1234b:	83 f9 2b             	cmp    $0x2b,%ecx
   1234e:	0f 86 ed 02 00 00    	jbe    12641 <_ScsiClassDeviceControl@8+0x351>
   12354:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
   12357:	8b 57 0c             	mov    0xc(%edi),%edx
   1235a:	8d 4b dc             	lea    0xffffffdc(%ebx),%ecx
   1235d:	8a 86 bd 00 00 00    	mov    0xbd(%esi),%al
   12363:	88 42 03             	mov    %al,0x3(%edx)
   12366:	8a 86 be 00 00 00    	mov    0xbe(%esi),%al
   1236c:	88 42 04             	mov    %al,0x4(%edx)
   1236f:	8a 86 bf 00 00 00    	mov    0xbf(%esi),%al
   12375:	88 42 05             	mov    %al,0x5(%edx)
   12378:	31 c0                	xor    %eax,%eax
   1237a:	8a 86 bf 00 00 00    	mov    0xbf(%esi),%al
   12380:	c1 e0 05             	shl    $0x5,%eax
   12383:	08 42 1d             	or     %al,0x1d(%edx)
   12386:	8b 43 04             	mov    0x4(%ebx),%eax
   12389:	89 41 04             	mov    %eax,0x4(%ecx)
   1238c:	8b 43 08             	mov    0x8(%ebx),%eax
   1238f:	89 41 08             	mov    %eax,0x8(%ecx)
   12392:	8b 43 0c             	mov    0xc(%ebx),%eax
   12395:	89 41 0c             	mov    %eax,0xc(%ecx)
   12398:	8b 43 10             	mov    0x10(%ebx),%eax
   1239b:	89 41 10             	mov    %eax,0x10(%ecx)
   1239e:	8a 03                	mov    (%ebx),%al
   123a0:	88 43 dc             	mov    %al,0xffffffdc(%ebx)
   123a3:	8a 43 01             	mov    0x1(%ebx),%al
   123a6:	88 41 01             	mov    %al,0x1(%ecx)
   123a9:	89 7d 0c             	mov    %edi,0xc(%ebp)
   123ac:	8b 46 04             	mov    0x4(%esi),%eax
   123af:	89 45 08             	mov    %eax,0x8(%ebp)
   123b2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   123b5:	5b                   	pop    %ebx
   123b6:	5e                   	pop    %esi
   123b7:	5f                   	pop    %edi
   123b8:	5d                   	pop    %ebp
   123b9:	e9 d2 0c 00 00       	jmp    13090 <_IoCallDriver@8>
   123be:	89 f6                	mov    %esi,%esi
   123c0:	83 f8 23             	cmp    $0x23,%eax
   123c3:	0f 86 5d 01 00 00    	jbe    12526 <_ScsiClassDeviceControl@8+0x236>
   123c9:	8d 4b dc             	lea    0xffffffdc(%ebx),%ecx
   123cc:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   123cf:	89 51 04             	mov    %edx,0x4(%ecx)
   123d2:	8b 43 08             	mov    0x8(%ebx),%eax
   123d5:	89 41 08             	mov    %eax,0x8(%ecx)
   123d8:	8b 43 0c             	mov    0xc(%ebx),%eax
   123db:	89 41 0c             	mov    %eax,0xc(%ecx)
   123de:	8b 43 10             	mov    0x10(%ebx),%eax
   123e1:	89 41 10             	mov    %eax,0x10(%ecx)
   123e4:	8a 03                	mov    (%ebx),%al
   123e6:	88 43 dc             	mov    %al,0xffffffdc(%ebx)
   123e9:	8a 43 01             	mov    0x1(%ebx),%al
   123ec:	88 41 01             	mov    %al,0x1(%ecx)
   123ef:	89 7d 0c             	mov    %edi,0xc(%ebp)
   123f2:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   123f5:	8b 41 04             	mov    0x4(%ecx),%eax
   123f8:	89 45 08             	mov    %eax,0x8(%ebp)
   123fb:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   123fe:	5b                   	pop    %ebx
   123ff:	5e                   	pop    %esi
   12400:	5f                   	pop    %edi
   12401:	5d                   	pop    %ebp
   12402:	e9 89 0c 00 00       	jmp    13090 <_IoCallDriver@8>
   12407:	83 7d e8 07          	cmpl   $0x7,0xffffffe8(%ebp)
   1240b:	0f 86 15 01 00 00    	jbe    12526 <_ScsiClassDeviceControl@8+0x236>
   12411:	8b 57 0c             	mov    0xc(%edi),%edx
   12414:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
   12417:	c7 02 08 00 00 00    	movl   $0x8,(%edx)
   1241d:	8a 86 bc 00 00 00    	mov    0xbc(%esi),%al
   12423:	88 42 04             	mov    %al,0x4(%edx)
   12426:	8a 86 bd 00 00 00    	mov    0xbd(%esi),%al
   1242c:	88 42 05             	mov    %al,0x5(%edx)
   1242f:	8a 86 be 00 00 00    	mov    0xbe(%esi),%al
   12435:	88 42 06             	mov    %al,0x6(%edx)
   12438:	8a 86 bf 00 00 00    	mov    0xbf(%esi),%al
   1243e:	88 42 07             	mov    %al,0x7(%edx)
   12441:	c7 47 1c 08 00 00 00 	movl   $0x8,0x1c(%edi)
   12448:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
   1244f:	53                   	push   %ebx
   12450:	53                   	push   %ebx
   12451:	6a 00                	push   $0x0
   12453:	57                   	push   %edi
   12454:	e8 17 0d 00 00       	call   13170 <_IoCompleteRequest@8>
   12459:	31 c0                	xor    %eax,%eax
   1245b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1245e:	5b                   	pop    %ebx
   1245f:	5e                   	pop    %esi
   12460:	5f                   	pop    %edi
   12461:	5d                   	pop    %ebp
   12462:	c2 08 00             	ret    $0x8
PVOID
ExAllocateFromNPagedLookasideList (
	IN	PNPAGED_LOOKASIDE_LIST	Lookaside
	)
{
   12465:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12468:	83 c0 68             	add    $0x68,%eax
   1246b:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
	PVOID Entry;

	Lookaside->TotalAllocates++;
	Entry = ExInterlockedPopEntrySList (&Lookaside->ListHead,
   1246e:	89 c1                	mov    %eax,%ecx
   12470:	8b 50 0c             	mov    0xc(%eax),%edx
   12473:	42                   	inc    %edx
   12474:	89 50 0c             	mov    %edx,0xc(%eax)
   12477:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   1247a:	81 c2 b0 00 00 00    	add    $0xb0,%edx
   12480:	89 55 d8             	mov    %edx,0xffffffd8(%ebp)
   12483:	e8 b8 0b 00 00       	call   13040 <@ExInterlockedPopEntrySList@8>
	                                    &Lookaside->Obsoleted);
	if (Entry == NULL)
   12488:	85 c0                	test   %eax,%eax
   1248a:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   1248d:	0f 84 66 01 00 00    	je     125f9 <_ScsiClassDeviceControl@8+0x309>
   12493:	50                   	push   %eax
   12494:	50                   	push   %eax
   12495:	6a 40                	push   $0x40
   12497:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   1249a:	50                   	push   %eax
   1249b:	e8 b0 0b 00 00       	call   13050 <_RtlZeroMemory@8>
   124a0:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   124a3:	83 c0 30             	add    $0x30,%eax
   124a6:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   124a9:	89 f0                	mov    %esi,%eax
   124ab:	25 ff ff 00 00       	and    $0xffff,%eax
   124b0:	5a                   	pop    %edx
   124b1:	0d 00 00 07 00       	or     $0x70000,%eax
   124b6:	59                   	pop    %ecx
   124b7:	3d 00 48 07 00       	cmp    $0x74800,%eax
   124bc:	0f 84 86 00 00 00    	je     12548 <_ScsiClassDeviceControl@8+0x258>
	IN	PNPAGED_LOOKASIDE_LIST	Lookaside,
	IN	PVOID			Entry
	)
{
	Lookaside->TotalFrees++;
   124c2:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
   124c5:	8b 42 14             	mov    0x14(%edx),%eax
   124c8:	40                   	inc    %eax
   124c9:	89 42 14             	mov    %eax,0x14(%edx)
	if (ExQueryDepthSList (&Lookaside->ListHead) >= Lookaside->Depth)
   124cc:	66 8b 42 08          	mov    0x8(%edx),%ax
   124d0:	66 39 42 04          	cmp    %ax,0x4(%edx)
   124d4:	72 3c                	jb     12512 <_ScsiClassDeviceControl@8+0x222>
	{
		Lookaside->FreeMisses++;
   124d6:	8b 42 18             	mov    0x18(%edx),%eax
		(Lookaside->Free)(Entry);
   124d9:	83 ec 0c             	sub    $0xc,%esp
   124dc:	40                   	inc    %eax
   124dd:	89 42 18             	mov    %eax,0x18(%edx)
   124e0:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   124e3:	50                   	push   %eax
   124e4:	ff 52 2c             	call   *0x2c(%edx)
   124e7:	8b 57 60             	mov    0x60(%edi),%edx
   124ea:	8b 43 04             	mov    0x4(%ebx),%eax
		(Lookaside->Free)(Entry);
	}
	else
	{
		ExInterlockedPushEntrySList (&Lookaside->ListHead,
   124ed:	83 c4 0c             	add    $0xc,%esp
   124f0:	8d 4a dc             	lea    0xffffffdc(%edx),%ecx
   124f3:	89 41 04             	mov    %eax,0x4(%ecx)
   124f6:	8b 43 08             	mov    0x8(%ebx),%eax
   124f9:	89 41 08             	mov    %eax,0x8(%ecx)
   124fc:	8b 43 0c             	mov    0xc(%ebx),%eax
   124ff:	89 41 0c             	mov    %eax,0xc(%ecx)
   12502:	8b 43 10             	mov    0x10(%ebx),%eax
   12505:	89 41 10             	mov    %eax,0x10(%ecx)
   12508:	8a 03                	mov    (%ebx),%al
   1250a:	88 42 dc             	mov    %al,0xffffffdc(%edx)
   1250d:	e9 d7 fe ff ff       	jmp    123e9 <_ScsiClassDeviceControl@8+0xf9>
		(Lookaside->Free)(Entry);
	}
	else
	{
		ExInterlockedPushEntrySList (&Lookaside->ListHead,
   12512:	83 ec 0c             	sub    $0xc,%esp
   12515:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   12518:	50                   	push   %eax
   12519:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   1251c:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   1251f:	e8 bc 0c 00 00       	call   131e0 <@ExInterlockedPushEntrySList@12>
   12524:	eb c1                	jmp    124e7 <_ScsiClassDeviceControl@8+0x1f7>
   12526:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
   1252d:	c7 47 18 23 00 00 c0 	movl   $0xc0000023,0x18(%edi)
   12534:	53                   	push   %ebx
   12535:	53                   	push   %ebx
   12536:	6a 00                	push   $0x0
   12538:	57                   	push   %edi
   12539:	e8 32 0c 00 00       	call   13170 <_IoCompleteRequest@8>
   1253e:	b8 23 00 00 c0       	mov    $0xc0000023,%eax
   12543:	e9 13 ff ff ff       	jmp    1245b <_ScsiClassDeviceControl@8+0x16b>
   12548:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   1254b:	85 c0                	test   %eax,%eax
   1254d:	74 7c                	je     125cb <_ScsiClassDeviceControl@8+0x2db>
   1254f:	83 7d e8 03          	cmpl   $0x3,0xffffffe8(%ebp)
   12553:	0f 86 0a 01 00 00    	jbe    12663 <_ScsiClassDeviceControl@8+0x373>
   12559:	51                   	push   %ecx
   1255a:	51                   	push   %ecx
   1255b:	6a 00                	push   $0x0
   1255d:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   12560:	8a 41 30             	mov    0x30(%ecx),%al
   12563:	83 c0 03             	add    $0x3,%eax
   12566:	0f be c0             	movsbl %al,%eax
   12569:	50                   	push   %eax
   1256a:	e8 31 0c 00 00       	call   131a0 <_IoAllocateIrp@8>
   1256f:	89 c3                	mov    %eax,%ebx
   12571:	58                   	pop    %eax
   12572:	85 db                	test   %ebx,%ebx
   12574:	5a                   	pop    %edx
   12575:	0f 84 3d 01 00 00    	je     126b8 <_ScsiClassDeviceControl@8+0x3c8>
   1257b:	8b 47 50             	mov    0x50(%edi),%eax
   1257e:	fe 4b 23             	decb   0x23(%ebx)
   12581:	89 43 50             	mov    %eax,0x50(%ebx)
   12584:	8b 43 60             	mov    0x60(%ebx),%eax
   12587:	83 e8 24             	sub    $0x24,%eax
   1258a:	89 43 60             	mov    %eax,0x60(%ebx)
   1258d:	89 c1                	mov    %eax,%ecx
   1258f:	89 78 04             	mov    %edi,0x4(%eax)
   12592:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   12595:	89 41 14             	mov    %eax,0x14(%ecx)
   12598:	8b 43 60             	mov    0x60(%ebx),%eax
   1259b:	83 e8 24             	sub    $0x24,%eax
   1259e:	c6 40 03 e0          	movb   $0xe0,0x3(%eax)
   125a2:	c7 40 1c e0 2f 01 00 	movl   $0x12fe0,0x1c(%eax)
   125a9:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%eax)
   125b0:	8b 43 60             	mov    0x60(%ebx),%eax
   125b3:	fe 4b 23             	decb   0x23(%ebx)
   125b6:	83 e8 24             	sub    $0x24,%eax
   125b9:	89 43 60             	mov    %eax,0x60(%ebx)
   125bc:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   125bf:	89 50 14             	mov    %edx,0x14(%eax)
   125c2:	8b 47 60             	mov    0x60(%edi),%eax
   125c5:	89 df                	mov    %ebx,%edi
   125c7:	80 48 03 01          	orb    $0x1,0x3(%eax)
   125cb:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx
   125ce:	c6 41 0a 06          	movb   $0x6,0xa(%ecx)
   125d2:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
   125d5:	8b 46 50             	mov    0x50(%esi),%eax
   125d8:	89 41 14             	mov    %eax,0x14(%ecx)
   125db:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   125de:	c6 00 00             	movb   $0x0,(%eax)
   125e1:	52                   	push   %edx
   125e2:	52                   	push   %edx
   125e3:	6a 00                	push   $0x0
   125e5:	6a 00                	push   $0x0
   125e7:	6a 00                	push   $0x0
   125e9:	57                   	push   %edi
   125ea:	51                   	push   %ecx
   125eb:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   125ee:	50                   	push   %eax
   125ef:	e8 ec fb ff ff       	call   121e0 <_ScsiClassSendSrbAsynchronous@24>
   125f4:	e9 62 fe ff ff       	jmp    1245b <_ScsiClassDeviceControl@8+0x16b>
	Entry = ExInterlockedPopEntrySList (&Lookaside->ListHead,
	                                    &Lookaside->Obsoleted);
	if (Entry == NULL)
	{
		Lookaside->AllocateMisses++;
   125f9:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   125fc:	8b 41 10             	mov    0x10(%ecx),%eax
   125ff:	40                   	inc    %eax
   12600:	89 41 10             	mov    %eax,0x10(%ecx)
		Entry = (Lookaside->Allocate)(Lookaside->Type,
   12603:	50                   	push   %eax
   12604:	8b 41 20             	mov    0x20(%ecx),%eax
   12607:	50                   	push   %eax
   12608:	8b 41 24             	mov    0x24(%ecx),%eax
   1260b:	50                   	push   %eax
   1260c:	8b 41 1c             	mov    0x1c(%ecx),%eax
   1260f:	50                   	push   %eax
   12610:	ff 51 28             	call   *0x28(%ecx)
   12613:	5a                   	pop    %edx
   12614:	85 c0                	test   %eax,%eax
	                                    &Lookaside->Obsoleted);
	if (Entry == NULL)
	{
		Lookaside->AllocateMisses++;
		Entry = (Lookaside->Allocate)(Lookaside->Type,
   12616:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   12619:	0f 85 74 fe ff ff    	jne    12493 <_ScsiClassDeviceControl@8+0x1a3>
   1261f:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
   12626:	c7 47 18 9a 00 00 c0 	movl   $0xc000009a,0x18(%edi)
   1262d:	51                   	push   %ecx
   1262e:	51                   	push   %ecx
   1262f:	6a 00                	push   $0x0
   12631:	57                   	push   %edi
   12632:	e8 39 0b 00 00       	call   13170 <_IoCompleteRequest@8>
   12637:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   1263c:	e9 1a fe ff ff       	jmp    1245b <_ScsiClassDeviceControl@8+0x16b>
   12641:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
   12648:	c7 47 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%edi)
   1264f:	51                   	push   %ecx
   12650:	51                   	push   %ecx
   12651:	6a 00                	push   $0x0
   12653:	57                   	push   %edi
   12654:	e8 17 0b 00 00       	call   13170 <_IoCompleteRequest@8>
   12659:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
   1265e:	e9 f8 fd ff ff       	jmp    1245b <_ScsiClassDeviceControl@8+0x16b>
	IN	PNPAGED_LOOKASIDE_LIST	Lookaside,
	IN	PVOID			Entry
	)
{
	Lookaside->TotalFrees++;
   12663:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
   12666:	c7 47 18 23 00 00 c0 	movl   $0xc0000023,0x18(%edi)
   1266d:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
	IN	PNPAGED_LOOKASIDE_LIST	Lookaside,
	IN	PVOID			Entry
	)
{
	Lookaside->TotalFrees++;
   12674:	8b 42 14             	mov    0x14(%edx),%eax
   12677:	40                   	inc    %eax
   12678:	89 42 14             	mov    %eax,0x14(%edx)
	if (ExQueryDepthSList (&Lookaside->ListHead) >= Lookaside->Depth)
   1267b:	66 8b 42 08          	mov    0x8(%edx),%ax
   1267f:	66 39 42 04          	cmp    %ax,0x4(%edx)
   12683:	72 19                	jb     1269e <_ScsiClassDeviceControl@8+0x3ae>
	{
		Lookaside->FreeMisses++;
   12685:	8b 42 18             	mov    0x18(%edx),%eax
		(Lookaside->Free)(Entry);
   12688:	83 ec 0c             	sub    $0xc,%esp
   1268b:	40                   	inc    %eax
   1268c:	89 42 18             	mov    %eax,0x18(%edx)
   1268f:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   12692:	50                   	push   %eax
   12693:	ff 52 2c             	call   *0x2c(%edx)
	}
	else
	{
		ExInterlockedPushEntrySList (&Lookaside->ListHead,
   12696:	83 c4 0c             	add    $0xc,%esp
   12699:	e9 96 fe ff ff       	jmp    12534 <_ScsiClassDeviceControl@8+0x244>
   1269e:	83 ec 0c             	sub    $0xc,%esp
   126a1:	8b 75 d8             	mov    0xffffffd8(%ebp),%esi
   126a4:	56                   	push   %esi
   126a5:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   126a8:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   126ab:	e8 30 0b 00 00       	call   131e0 <@ExInterlockedPushEntrySList@12>
   126b0:	83 c4 0c             	add    $0xc,%esp
   126b3:	e9 7c fe ff ff       	jmp    12534 <_ScsiClassDeviceControl@8+0x244>
   126b8:	8b 75 e0             	mov    0xffffffe0(%ebp),%esi
   126bb:	c7 47 18 9a 00 00 c0 	movl   $0xc000009a,0x18(%edi)
   126c2:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
	IN	PNPAGED_LOOKASIDE_LIST	Lookaside,
	IN	PVOID			Entry
	)
{
	Lookaside->TotalFrees++;
   126c9:	8b 46 14             	mov    0x14(%esi),%eax
   126cc:	40                   	inc    %eax
   126cd:	89 46 14             	mov    %eax,0x14(%esi)
	if (ExQueryDepthSList (&Lookaside->ListHead) >= Lookaside->Depth)
   126d0:	66 8b 46 08          	mov    0x8(%esi),%ax
   126d4:	66 39 46 04          	cmp    %ax,0x4(%esi)
   126d8:	72 19                	jb     126f3 <_ScsiClassDeviceControl@8+0x403>
	{
		Lookaside->FreeMisses++;
   126da:	8b 46 18             	mov    0x18(%esi),%eax
		(Lookaside->Free)(Entry);
   126dd:	83 ec 0c             	sub    $0xc,%esp
   126e0:	40                   	inc    %eax
   126e1:	89 46 18             	mov    %eax,0x18(%esi)
   126e4:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   126e7:	50                   	push   %eax
   126e8:	ff 56 2c             	call   *0x2c(%esi)
	}
	else
	{
		ExInterlockedPushEntrySList (&Lookaside->ListHead,
   126eb:	83 c4 0c             	add    $0xc,%esp
   126ee:	e9 3a ff ff ff       	jmp    1262d <_ScsiClassDeviceControl@8+0x33d>
   126f3:	83 ec 0c             	sub    $0xc,%esp
   126f6:	8b 5d d8             	mov    0xffffffd8(%ebp),%ebx
   126f9:	53                   	push   %ebx
   126fa:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   126fd:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   12700:	e8 db 0a 00 00       	call   131e0 <@ExInterlockedPushEntrySList@12>
   12705:	83 c4 0c             	add    $0xc,%esp
   12708:	e9 20 ff ff ff       	jmp    1262d <_ScsiClassDeviceControl@8+0x33d>
   1270d:	8d 76 00             	lea    0x0(%esi),%esi

00012710 <_ScsiClassSendSrbSynchronous@20>:
   12710:	55                   	push   %ebp
   12711:	89 e5                	mov    %esp,%ebp
   12713:	57                   	push   %edi
   12714:	56                   	push   %esi
   12715:	53                   	push   %ebx
   12716:	83 ec 54             	sub    $0x54,%esp
   12719:	c7 45 b4 0f 00 00 00 	movl   $0xf,0xffffffb4(%ebp)
   12720:	8a 45 18             	mov    0x18(%ebp),%al
   12723:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   12726:	88 45 bf             	mov    %al,0xffffffbf(%ebp)
   12729:	8b 45 08             	mov    0x8(%ebp),%eax
   1272c:	66 c7 03 40 00       	movw   $0x40,(%ebx)
   12731:	8b 7d 14             	mov    0x14(%ebp),%edi
   12734:	8b 70 28             	mov    0x28(%eax),%esi
   12737:	8a 86 bd 00 00 00    	mov    0xbd(%esi),%al
   1273d:	88 43 05             	mov    %al,0x5(%ebx)
   12740:	8a 86 be 00 00 00    	mov    0xbe(%esi),%al
   12746:	88 43 06             	mov    %al,0x6(%ebx)
   12749:	8a 86 bf 00 00 00    	mov    0xbf(%esi),%al
   1274f:	c6 43 02 00          	movb   $0x0,0x2(%ebx)
   12753:	88 43 07             	mov    %al,0x7(%ebx)
   12756:	c6 43 0b 12          	movb   $0x12,0xb(%ebx)
   1275a:	6a 12                	push   $0x12
   1275c:	6a 00                	push   $0x0
   1275e:	e8 ad 09 00 00       	call   13110 <_ExAllocatePool@8>
   12763:	85 c0                	test   %eax,%eax
   12765:	89 43 1c             	mov    %eax,0x1c(%ebx)
   12768:	5a                   	pop    %edx
   12769:	ba 9a 00 00 c0       	mov    $0xc000009a,%edx
   1276e:	59                   	pop    %ecx
   1276f:	0f 84 48 01 00 00    	je     128bd <_ScsiClassSendSrbSynchronous@20+0x1ad>
   12775:	8b 45 10             	mov    0x10(%ebp),%eax
   12778:	85 c0                	test   %eax,%eax
   1277a:	0f 84 84 01 00 00    	je     12904 <_ScsiClassSendSrbSynchronous@20+0x1f4>
   12780:	80 7d bf 01          	cmpb   $0x1,0xffffffbf(%ebp)
   12784:	0f 84 67 01 00 00    	je     128f1 <_ScsiClassSendSrbSynchronous@20+0x1e1>
   1278a:	c7 45 b8 12 00 1b 00 	movl   $0x1b0012,0xffffffb8(%ebp)
   12791:	c7 43 0c 40 00 00 00 	movl   $0x40,0xc(%ebx)
   12798:	8b 45 10             	mov    0x10(%ebp),%eax
   1279b:	89 43 18             	mov    %eax,0x18(%ebx)
   1279e:	eb 57                	jmp    127f7 <_ScsiClassSendSrbSynchronous@20+0xe7>
   127a0:	8d 45 cc             	lea    0xffffffcc(%ebp),%eax
   127a3:	51                   	push   %ecx
   127a4:	51                   	push   %ecx
   127a5:	50                   	push   %eax
   127a6:	b8 0f 00 00 00       	mov    $0xf,%eax
   127ab:	8b 55 b4             	mov    0xffffffb4(%ebp),%edx
   127ae:	29 d0                	sub    %edx,%eax
   127b0:	50                   	push   %eax
   127b1:	6a 00                	push   $0x0
   127b3:	6a 0f                	push   $0xf
   127b5:	53                   	push   %ebx
   127b6:	8b 45 08             	mov    0x8(%ebp),%eax
   127b9:	50                   	push   %eax
   127ba:	e8 61 f0 ff ff       	call   11820 <_ScsiClassInterpretSenseInfo@24>
   127bf:	5a                   	pop    %edx
   127c0:	fe c8                	dec    %al
   127c2:	59                   	pop    %ecx
   127c3:	0f 85 e5 00 00 00    	jne    128ae <_ScsiClassSendSrbSynchronous@20+0x19e>
   127c9:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
   127cc:	48                   	dec    %eax
   127cd:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
   127d0:	83 7d b4 ff          	cmpl   $0xffffffff,0xffffffb4(%ebp)
   127d4:	0f 84 d4 00 00 00    	je     128ae <_ScsiClassSendSrbSynchronous@20+0x19e>
   127da:	c7 45 c0 80 7b e1 ff 	movl   $0xffe17b80,0xffffffc0(%ebp)
   127e1:	c7 45 c4 ff ff ff ff 	movl   $0xffffffff,0xffffffc4(%ebp)
   127e8:	50                   	push   %eax
   127e9:	8d 45 c0             	lea    0xffffffc0(%ebp),%eax
   127ec:	50                   	push   %eax
   127ed:	6a 00                	push   $0x0
   127ef:	6a 00                	push   $0x0
   127f1:	e8 5a 0a 00 00       	call   13250 <_KeDelayExecutionThread@12>
   127f6:	58                   	pop    %eax
   127f7:	89 7b 10             	mov    %edi,0x10(%ebx)
   127fa:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
   127fd:	51                   	push   %ecx
   127fe:	6a 00                	push   $0x0
   12800:	6a 00                	push   $0x0
   12802:	50                   	push   %eax
   12803:	e8 68 08 00 00       	call   13070 <_KeInitializeEvent@12>
   12808:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
   1280b:	52                   	push   %edx
   1280c:	52                   	push   %edx
   1280d:	50                   	push   %eax
   1280e:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
   12811:	50                   	push   %eax
   12812:	6a 01                	push   $0x1
   12814:	57                   	push   %edi
   12815:	8b 45 10             	mov    0x10(%ebp),%eax
   12818:	50                   	push   %eax
   12819:	6a 00                	push   $0x0
   1281b:	6a 00                	push   $0x0
   1281d:	8b 46 04             	mov    0x4(%esi),%eax
   12820:	50                   	push   %eax
   12821:	8b 45 b8             	mov    0xffffffb8(%ebp),%eax
   12824:	50                   	push   %eax
   12825:	e8 56 08 00 00       	call   13080 <_IoBuildDeviceIoControlRequest@36>
   1282a:	83 c4 0c             	add    $0xc,%esp
   1282d:	89 c2                	mov    %eax,%edx
   1282f:	85 c0                	test   %eax,%eax
   12831:	0f 84 92 00 00 00    	je     128c9 <_ScsiClassSendSrbSynchronous@20+0x1b9>
   12837:	8b 40 60             	mov    0x60(%eax),%eax
   1283a:	83 e8 24             	sub    $0x24,%eax
   1283d:	89 58 04             	mov    %ebx,0x4(%eax)
   12840:	89 53 24             	mov    %edx,0x24(%ebx)
   12843:	50                   	push   %eax
   12844:	50                   	push   %eax
   12845:	52                   	push   %edx
   12846:	8b 46 04             	mov    0x4(%esi),%eax
   12849:	50                   	push   %eax
   1284a:	e8 41 08 00 00       	call   13090 <_IoCallDriver@8>
   1284f:	3d 03 01 00 00       	cmp    $0x103,%eax
   12854:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   12857:	5a                   	pop    %edx
   12858:	59                   	pop    %ecx
   12859:	74 29                	je     12884 <_ScsiClassSendSrbSynchronous@20+0x174>
   1285b:	31 d2                	xor    %edx,%edx
   1285d:	8a 53 03             	mov    0x3(%ebx),%dl
   12860:	89 d0                	mov    %edx,%eax
   12862:	24 3f                	and    $0x3f,%al
   12864:	48                   	dec    %eax
   12865:	74 40                	je     128a7 <_ScsiClassSendSrbSynchronous@20+0x197>
   12867:	83 e2 40             	and    $0x40,%edx
   1286a:	0f 84 30 ff ff ff    	je     127a0 <_ScsiClassSendSrbSynchronous@20+0x90>
   12870:	83 ec 0c             	sub    $0xc,%esp
   12873:	8b 45 08             	mov    0x8(%ebp),%eax
   12876:	50                   	push   %eax
   12877:	e8 84 f3 ff ff       	call   11c00 <_ScsiClassReleaseQueue@4>
   1287c:	83 c4 0c             	add    $0xc,%esp
   1287f:	e9 1c ff ff ff       	jmp    127a0 <_ScsiClassSendSrbSynchronous@20+0x90>
   12884:	83 ec 0c             	sub    $0xc,%esp
   12887:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
   1288a:	6a 00                	push   $0x0
   1288c:	6a 00                	push   $0x0
   1288e:	6a 00                	push   $0x0
   12890:	6a 05                	push   $0x5
   12892:	50                   	push   %eax
   12893:	e8 28 08 00 00       	call   130c0 <_KeWaitForSingleObject@20>
   12898:	31 d2                	xor    %edx,%edx
   1289a:	83 c4 0c             	add    $0xc,%esp
   1289d:	8a 53 03             	mov    0x3(%ebx),%dl
   128a0:	89 d0                	mov    %edx,%eax
   128a2:	24 3f                	and    $0x3f,%al
   128a4:	48                   	dec    %eax
   128a5:	75 c0                	jne    12867 <_ScsiClassSendSrbSynchronous@20+0x157>
   128a7:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
   128ae:	83 ec 0c             	sub    $0xc,%esp
   128b1:	8b 73 1c             	mov    0x1c(%ebx),%esi
   128b4:	56                   	push   %esi
   128b5:	e8 66 08 00 00       	call   13120 <_ExFreePool@4>
   128ba:	8b 55 cc             	mov    0xffffffcc(%ebp),%edx
   128bd:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   128c0:	89 d0                	mov    %edx,%eax
   128c2:	5b                   	pop    %ebx
   128c3:	5e                   	pop    %esi
   128c4:	5f                   	pop    %edi
   128c5:	5d                   	pop    %ebp
   128c6:	c2 14 00             	ret    $0x14
   128c9:	83 ec 0c             	sub    $0xc,%esp
   128cc:	8b 43 1c             	mov    0x1c(%ebx),%eax
   128cf:	50                   	push   %eax
   128d0:	e8 4b 08 00 00       	call   13120 <_ExFreePool@4>
   128d5:	ba 9a 00 00 c0       	mov    $0xc000009a,%edx
   128da:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   128e1:	c6 43 0b 00          	movb   $0x0,0xb(%ebx)
   128e5:	89 d0                	mov    %edx,%eax
   128e7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   128ea:	5b                   	pop    %ebx
   128eb:	5e                   	pop    %esi
   128ec:	5f                   	pop    %edi
   128ed:	5d                   	pop    %ebp
   128ee:	c2 14 00             	ret    $0x14
   128f1:	c7 45 b8 11 00 1b 00 	movl   $0x1b0011,0xffffffb8(%ebp)
   128f8:	c7 43 0c 80 00 00 00 	movl   $0x80,0xc(%ebx)
   128ff:	e9 94 fe ff ff       	jmp    12798 <_ScsiClassSendSrbSynchronous@20+0x88>
   12904:	31 ff                	xor    %edi,%edi
   12906:	c7 45 b8 13 00 1b 00 	movl   $0x1b0013,0xffffffb8(%ebp)
   1290d:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)
   12914:	e9 7f fe ff ff       	jmp    12798 <_ScsiClassSendSrbSynchronous@20+0x88>
   12919:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00012920 <_ScsiClassReadDriveCapacity@4>:
   12920:	55                   	push   %ebp
   12921:	89 e5                	mov    %esp,%ebp
   12923:	57                   	push   %edi
   12924:	56                   	push   %esi
   12925:	53                   	push   %ebx
   12926:	83 ec 64             	sub    $0x64,%esp
   12929:	c7 45 9c 01 00 00 00 	movl   $0x1,0xffffff9c(%ebp)
   12930:	8b 45 08             	mov    0x8(%ebp),%eax
   12933:	8b 70 28             	mov    0x28(%eax),%esi
   12936:	6a 08                	push   $0x8
   12938:	6a 04                	push   $0x4
   1293a:	e8 d1 07 00 00       	call   13110 <_ExAllocatePool@8>
   1293f:	59                   	pop    %ecx
   12940:	5b                   	pop    %ebx
   12941:	89 45 a4             	mov    %eax,0xffffffa4(%ebp)
   12944:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   12949:	8b 55 a4             	mov    0xffffffa4(%ebp),%edx
   1294c:	85 d2                	test   %edx,%edx
   1294e:	0f 84 91 01 00 00    	je     12ae5 <_ScsiClassReadDriveCapacity@4+0x1c5>
   12954:	8d 55 a8             	lea    0xffffffa8(%ebp),%edx
   12957:	57                   	push   %edi
   12958:	57                   	push   %edi
   12959:	6a 40                	push   $0x40
   1295b:	52                   	push   %edx
   1295c:	e8 ef 06 00 00       	call   13050 <_RtlZeroMemory@8>
   12961:	c6 45 b2 0a          	movb   $0xa,0xffffffb2(%ebp)
   12965:	8b 46 50             	mov    0x50(%esi),%eax
   12968:	59                   	pop    %ecx
   12969:	89 45 bc             	mov    %eax,0xffffffbc(%ebp)
   1296c:	c6 45 d8 25          	movb   $0x25,0xffffffd8(%ebp)
   12970:	5b                   	pop    %ebx
   12971:	83 ec 0c             	sub    $0xc,%esp
   12974:	8b 55 a4             	mov    0xffffffa4(%ebp),%edx
   12977:	8d 4d a8             	lea    0xffffffa8(%ebp),%ecx
   1297a:	8b 45 08             	mov    0x8(%ebp),%eax
   1297d:	6a 00                	push   $0x0
   1297f:	6a 08                	push   $0x8
   12981:	52                   	push   %edx
   12982:	51                   	push   %ecx
   12983:	50                   	push   %eax
   12984:	e8 87 fd ff ff       	call   12710 <_ScsiClassSendSrbSynchronous@20>
   12989:	83 c4 0c             	add    $0xc,%esp
   1298c:	85 c0                	test   %eax,%eax
   1298e:	89 45 a0             	mov    %eax,0xffffffa0(%ebp)
   12991:	0f 88 d7 00 00 00    	js     12a6e <_ScsiClassReadDriveCapacity@4+0x14e>
   12997:	8b 5d a4             	mov    0xffffffa4(%ebp),%ebx
   1299a:	31 c9                	xor    %ecx,%ecx
   1299c:	31 c0                	xor    %eax,%eax
   1299e:	31 d2                	xor    %edx,%edx
   129a0:	8a 4b 04             	mov    0x4(%ebx),%cl
   129a3:	8a 43 05             	mov    0x5(%ebx),%al
   129a6:	c1 e0 10             	shl    $0x10,%eax
   129a9:	8a 13                	mov    (%ebx),%dl
   129ab:	c1 e1 18             	shl    $0x18,%ecx
   129ae:	c1 e2 18             	shl    $0x18,%edx
   129b1:	09 c1                	or     %eax,%ecx
   129b3:	31 c0                	xor    %eax,%eax
   129b5:	8a 43 06             	mov    0x6(%ebx),%al
   129b8:	c1 e0 08             	shl    $0x8,%eax
   129bb:	09 c1                	or     %eax,%ecx
   129bd:	31 c0                	xor    %eax,%eax
   129bf:	8a 43 07             	mov    0x7(%ebx),%al
   129c2:	09 c1                	or     %eax,%ecx
   129c4:	31 c0                	xor    %eax,%eax
   129c6:	8a 43 01             	mov    0x1(%ebx),%al
   129c9:	c1 e0 10             	shl    $0x10,%eax
   129cc:	09 c2                	or     %eax,%edx
   129ce:	31 c0                	xor    %eax,%eax
   129d0:	8a 43 02             	mov    0x2(%ebx),%al
   129d3:	c1 e0 08             	shl    $0x8,%eax
   129d6:	09 c2                	or     %eax,%edx
   129d8:	31 c0                	xor    %eax,%eax
   129da:	8a 43 03             	mov    0x3(%ebx),%al
   129dd:	8b 5e 44             	mov    0x44(%esi),%ebx
   129e0:	09 c2                	or     %eax,%edx
   129e2:	89 4b 14             	mov    %ecx,0x14(%ebx)
   129e5:	c7 46 0c 00 00 00 00 	movl   $0x0,0xc(%esi)
   129ec:	8d 7a 01             	lea    0x1(%edx),%edi
   129ef:	c6 86 c0 00 00 00 00 	movb   $0x0,0xc0(%esi)
   129f6:	89 7e 08             	mov    %edi,0x8(%esi)
   129f9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   12a00:	8a 8e c0 00 00 00    	mov    0xc0(%esi),%cl
   12a06:	8b 43 14             	mov    0x14(%ebx),%eax
   12a09:	d3 e8                	shr    %cl,%eax
   12a0b:	48                   	dec    %eax
   12a0c:	74 0c                	je     12a1a <_ScsiClassReadDriveCapacity@4+0xfa>
   12a0e:	41                   	inc    %ecx
   12a0f:	88 8e c0 00 00 00    	mov    %cl,0xc0(%esi)
   12a15:	80 f9 1f             	cmp    $0x1f,%cl
   12a18:	76 e6                	jbe    12a00 <_ScsiClassReadDriveCapacity@4+0xe0>
   12a1a:	8b 46 08             	mov    0x8(%esi),%eax
   12a1d:	8b 56 0c             	mov    0xc(%esi),%edx
   12a20:	0f a5 c2             	shld   %cl,%eax,%edx
   12a23:	d3 e0                	shl    %cl,%eax
   12a25:	83 e1 20             	and    $0x20,%ecx
   12a28:	74 04                	je     12a2e <_ScsiClassReadDriveCapacity@4+0x10e>
   12a2a:	89 c2                	mov    %eax,%edx
   12a2c:	31 c0                	xor    %eax,%eax
   12a2e:	2b 46 10             	sub    0x10(%esi),%eax
   12a31:	1b 56 14             	sbb    0x14(%esi),%edx
   12a34:	89 46 08             	mov    %eax,0x8(%esi)
   12a37:	89 56 0c             	mov    %edx,0xc(%esi)
   12a3a:	8b 55 08             	mov    0x8(%ebp),%edx
   12a3d:	8b 42 20             	mov    0x20(%edx),%eax
   12a40:	c7 43 04 00 00 00 00 	movl   $0x0,0x4(%ebx)
   12a47:	83 e0 01             	and    $0x1,%eax
   12a4a:	83 f8 01             	cmp    $0x1,%eax
   12a4d:	19 c0                	sbb    %eax,%eax
   12a4f:	c1 ef 0b             	shr    $0xb,%edi
   12a52:	83 f0 ff             	xor    $0xffffffff,%eax
   12a55:	83 c0 0c             	add    $0xc,%eax
   12a58:	89 3b                	mov    %edi,(%ebx)
   12a5a:	89 43 08             	mov    %eax,0x8(%ebx)
   12a5d:	8b 46 44             	mov    0x44(%esi),%eax
   12a60:	c7 40 10 20 00 00 00 	movl   $0x20,0x10(%eax)
   12a67:	c7 40 0c 40 00 00 00 	movl   $0x40,0xc(%eax)
   12a6e:	81 7d a0 16 00 00 80 	cmpl   $0x80000016,0xffffffa0(%ebp)
   12a75:	75 13                	jne    12a8a <_ScsiClassReadDriveCapacity@4+0x16a>
   12a77:	8b 45 9c             	mov    0xffffff9c(%ebp),%eax
   12a7a:	85 c0                	test   %eax,%eax
   12a7c:	74 13                	je     12a91 <_ScsiClassReadDriveCapacity@4+0x171>
   12a7e:	8b 45 9c             	mov    0xffffff9c(%ebp),%eax
   12a81:	48                   	dec    %eax
   12a82:	89 45 9c             	mov    %eax,0xffffff9c(%ebp)
   12a85:	e9 e7 fe ff ff       	jmp    12971 <_ScsiClassReadDriveCapacity@4+0x51>
   12a8a:	8b 45 a0             	mov    0xffffffa0(%ebp),%eax
   12a8d:	85 c0                	test   %eax,%eax
   12a8f:	79 45                	jns    12ad6 <_ScsiClassReadDriveCapacity@4+0x1b6>
   12a91:	50                   	push   %eax
   12a92:	50                   	push   %eax
   12a93:	6a 18                	push   $0x18
   12a95:	8b 46 44             	mov    0x44(%esi),%eax
   12a98:	50                   	push   %eax
   12a99:	e8 b2 05 00 00       	call   13050 <_RtlZeroMemory@8>
   12a9e:	8b 56 44             	mov    0x44(%esi),%edx
   12aa1:	c7 42 14 00 02 00 00 	movl   $0x200,0x14(%edx)
   12aa8:	c6 86 c0 00 00 00 09 	movb   $0x9,0xc0(%esi)
   12aaf:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12ab2:	c7 46 08 00 00 00 00 	movl   $0x0,0x8(%esi)
   12ab9:	c7 46 0c 00 00 00 00 	movl   $0x0,0xc(%esi)
   12ac0:	8b 41 20             	mov    0x20(%ecx),%eax
   12ac3:	5e                   	pop    %esi
   12ac4:	83 e0 01             	and    $0x1,%eax
   12ac7:	5f                   	pop    %edi
   12ac8:	83 f8 01             	cmp    $0x1,%eax
   12acb:	19 c0                	sbb    %eax,%eax
   12acd:	83 f0 ff             	xor    $0xffffffff,%eax
   12ad0:	83 c0 0c             	add    $0xc,%eax
   12ad3:	89 42 08             	mov    %eax,0x8(%edx)
   12ad6:	83 ec 0c             	sub    $0xc,%esp
   12ad9:	8b 5d a4             	mov    0xffffffa4(%ebp),%ebx
   12adc:	53                   	push   %ebx
   12add:	e8 3e 06 00 00       	call   13120 <_ExFreePool@4>
   12ae2:	8b 45 a0             	mov    0xffffffa0(%ebp),%eax
   12ae5:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12ae8:	5b                   	pop    %ebx
   12ae9:	5e                   	pop    %esi
   12aea:	5f                   	pop    %edi
   12aeb:	5d                   	pop    %ebp
   12aec:	c2 04 00             	ret    $0x4
   12aef:	90                   	nop    

00012af0 <_ScsiClassModeSense@16>:
   12af0:	55                   	push   %ebp
   12af1:	89 e5                	mov    %esp,%ebp
   12af3:	57                   	push   %edi
   12af4:	56                   	push   %esi
   12af5:	53                   	push   %ebx
   12af6:	83 ec 54             	sub    $0x54,%esp
   12af9:	bf 01 00 00 00       	mov    $0x1,%edi
   12afe:	8b 45 08             	mov    0x8(%ebp),%eax
   12b01:	8a 5d 14             	mov    0x14(%ebp),%bl
   12b04:	83 e3 3f             	and    $0x3f,%ebx
   12b07:	8b 70 28             	mov    0x28(%eax),%esi
   12b0a:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
   12b0d:	6a 40                	push   $0x40
   12b0f:	50                   	push   %eax
   12b10:	e8 3b 05 00 00       	call   13050 <_RtlZeroMemory@8>
   12b15:	c6 45 b2 06          	movb   $0x6,0xffffffb2(%ebp)
   12b19:	8b 46 50             	mov    0x50(%esi),%eax
   12b1c:	c6 45 d8 1a          	movb   $0x1a,0xffffffd8(%ebp)
   12b20:	89 45 bc             	mov    %eax,0xffffffbc(%ebp)
   12b23:	8a 45 da             	mov    0xffffffda(%ebp),%al
   12b26:	83 e0 c0             	and    $0xffffffc0,%eax
   12b29:	09 d8                	or     %ebx,%eax
   12b2b:	88 45 da             	mov    %al,0xffffffda(%ebp)
   12b2e:	8a 45 10             	mov    0x10(%ebp),%al
   12b31:	88 45 dc             	mov    %al,0xffffffdc(%ebp)
   12b34:	58                   	pop    %eax
   12b35:	5a                   	pop    %edx
   12b36:	83 ec 0c             	sub    $0xc,%esp
   12b39:	8b 45 10             	mov    0x10(%ebp),%eax
   12b3c:	8b 75 08             	mov    0x8(%ebp),%esi
   12b3f:	6a 00                	push   $0x0
   12b41:	50                   	push   %eax
   12b42:	8b 45 0c             	mov    0xc(%ebp),%eax
   12b45:	50                   	push   %eax
   12b46:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
   12b49:	50                   	push   %eax
   12b4a:	56                   	push   %esi
   12b4b:	e8 c0 fb ff ff       	call   12710 <_ScsiClassSendSrbSynchronous@20>
   12b50:	83 c4 0c             	add    $0xc,%esp
   12b53:	89 c2                	mov    %eax,%edx
   12b55:	3d 16 00 00 80       	cmp    $0x80000016,%eax
   12b5a:	75 07                	jne    12b63 <_ScsiClassModeSense@16+0x73>
   12b5c:	85 ff                	test   %edi,%edi
   12b5e:	74 13                	je     12b73 <_ScsiClassModeSense@16+0x83>
   12b60:	4f                   	dec    %edi
   12b61:	eb d3                	jmp    12b36 <_ScsiClassModeSense@16+0x46>
   12b63:	31 c0                	xor    %eax,%eax
   12b65:	8a 45 ab             	mov    0xffffffab(%ebp),%al
   12b68:	24 3f                	and    $0x3f,%al
   12b6a:	83 f8 12             	cmp    $0x12,%eax
   12b6d:	74 10                	je     12b7f <_ScsiClassModeSense@16+0x8f>
   12b6f:	85 d2                	test   %edx,%edx
   12b71:	79 0c                	jns    12b7f <_ScsiClassModeSense@16+0x8f>
   12b73:	31 c0                	xor    %eax,%eax
   12b75:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12b78:	5b                   	pop    %ebx
   12b79:	5e                   	pop    %esi
   12b7a:	5f                   	pop    %edi
   12b7b:	5d                   	pop    %ebp
   12b7c:	c2 10 00             	ret    $0x10
   12b7f:	8b 45 b8             	mov    0xffffffb8(%ebp),%eax
   12b82:	eb f1                	jmp    12b75 <_ScsiClassModeSense@16+0x85>
   12b84:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12b8a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00012b90 <_ScsiClassSplitRequest@12>:
   12b90:	55                   	push   %ebp
   12b91:	89 e5                	mov    %esp,%ebp
   12b93:	57                   	push   %edi
   12b94:	56                   	push   %esi
   12b95:	53                   	push   %ebx
   12b96:	83 ec 2c             	sub    $0x2c,%esp
   12b99:	8b 45 08             	mov    0x8(%ebp),%eax
   12b9c:	8b 55 0c             	mov    0xc(%ebp),%edx
   12b9f:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   12ba2:	8b 40 28             	mov    0x28(%eax),%eax
   12ba5:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   12ba8:	8b 52 60             	mov    0x60(%edx),%edx
   12bab:	89 d3                	mov    %edx,%ebx
   12bad:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   12bb0:	8b 51 04             	mov    0x4(%ecx),%edx
   12bb3:	83 eb 24             	sub    $0x24,%ebx
   12bb6:	66 8b 42 06          	mov    0x6(%edx),%ax
   12bba:	a8 05                	test   $0x5,%al
   12bbc:	0f 84 2e 01 00 00    	je     12cf0 <_ScsiClassSplitRequest@12+0x160>
   12bc2:	8b 52 0c             	mov    0xc(%edx),%edx
   12bc5:	89 55 e8             	mov    %edx,0xffffffe8(%ebp)
   12bc8:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12bcb:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   12bce:	8b 50 04             	mov    0x4(%eax),%edx
   12bd1:	8b 70 0c             	mov    0xc(%eax),%esi
   12bd4:	8b 78 10             	mov    0x10(%eax),%edi
   12bd7:	8b 45 10             	mov    0x10(%ebp),%eax
   12bda:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   12bdd:	89 51 1c             	mov    %edx,0x1c(%ecx)
   12be0:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   12be3:	8d 44 02 ff          	lea    0xffffffff(%edx,%eax,1),%eax
   12be7:	31 d2                	xor    %edx,%edx
   12be9:	f7 75 10             	divl   0x10(%ebp)
   12bec:	8b 55 10             	mov    0x10(%ebp),%edx
   12bef:	0f af c2             	imul   %edx,%eax
   12bf2:	31 d2                	xor    %edx,%edx
   12bf4:	f7 75 10             	divl   0x10(%ebp)
   12bf7:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   12bfa:	89 43 04             	mov    %eax,0x4(%ebx)
   12bfd:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   12c04:	39 45 dc             	cmp    %eax,0xffffffdc(%ebp)
   12c07:	0f 83 d5 00 00 00    	jae    12ce2 <_ScsiClassSplitRequest@12+0x152>
   12c0d:	8d 76 00             	lea    0x0(%esi),%esi
   12c10:	8b 55 08             	mov    0x8(%ebp),%edx
   12c13:	51                   	push   %ecx
   12c14:	51                   	push   %ecx
   12c15:	6a 00                	push   $0x0
   12c17:	0f be 42 30          	movsbl 0x30(%edx),%eax
   12c1b:	50                   	push   %eax
   12c1c:	e8 7f 05 00 00       	call   131a0 <_IoAllocateIrp@8>
   12c21:	89 c3                	mov    %eax,%ebx
   12c23:	58                   	pop    %eax
   12c24:	85 db                	test   %ebx,%ebx
   12c26:	5a                   	pop    %edx
   12c27:	0f 84 d7 00 00 00    	je     12d04 <_ScsiClassSplitRequest@12+0x174>
   12c2d:	8b 55 0c             	mov    0xc(%ebp),%edx
   12c30:	8b 42 04             	mov    0x4(%edx),%eax
   12c33:	89 43 04             	mov    %eax,0x4(%ebx)
   12c36:	e8 75 05 00 00       	call   131b0 <_KeGetCurrentThread@0>
   12c3b:	8b 4b 60             	mov    0x60(%ebx),%ecx
   12c3e:	fe 4b 23             	decb   0x23(%ebx)
   12c41:	8d 51 dc             	lea    0xffffffdc(%ecx),%edx
   12c44:	89 53 60             	mov    %edx,0x60(%ebx)
   12c47:	89 43 50             	mov    %eax,0x50(%ebx)
   12c4a:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12c4d:	89 72 0c             	mov    %esi,0xc(%edx)
   12c50:	89 7a 10             	mov    %edi,0x10(%edx)
   12c53:	8a 00                	mov    (%eax),%al
   12c55:	88 41 dc             	mov    %al,0xffffffdc(%ecx)
   12c58:	8b 45 08             	mov    0x8(%ebp),%eax
   12c5b:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   12c5e:	89 4a 04             	mov    %ecx,0x4(%edx)
   12c61:	89 42 14             	mov    %eax,0x14(%edx)
   12c64:	52                   	push   %edx
   12c65:	52                   	push   %edx
   12c66:	53                   	push   %ebx
   12c67:	50                   	push   %eax
   12c68:	e8 d3 e3 ff ff       	call   11040 <_ScsiClassBuildRequest@8>
   12c6d:	8b 43 60             	mov    0x60(%ebx),%eax
   12c70:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   12c73:	83 e8 24             	sub    $0x24,%eax
   12c76:	8b 50 04             	mov    0x4(%eax),%edx
   12c79:	8b 45 0c             	mov    0xc(%ebp),%eax
   12c7c:	89 4a 18             	mov    %ecx,0x18(%edx)
   12c7f:	89 43 0c             	mov    %eax,0xc(%ebx)
   12c82:	8b 43 60             	mov    0x60(%ebx),%eax
   12c85:	83 e8 24             	sub    $0x24,%eax
   12c88:	c6 40 03 e0          	movb   $0xe0,0x3(%eax)
   12c8c:	89 50 20             	mov    %edx,0x20(%eax)
   12c8f:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   12c92:	c7 40 1c 20 1d 01 00 	movl   $0x11d20,0x1c(%eax)
   12c99:	53                   	push   %ebx
   12c9a:	8b 42 04             	mov    0x4(%edx),%eax
   12c9d:	50                   	push   %eax
   12c9e:	e8 ed 03 00 00       	call   13090 <_IoCallDriver@8>
   12ca3:	8b 4d 10             	mov    0x10(%ebp),%ecx
   12ca6:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   12ca9:	01 c8                	add    %ecx,%eax
   12cab:	5b                   	pop    %ebx
   12cac:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   12caf:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   12cb2:	29 c8                	sub    %ecx,%eax
   12cb4:	89 4d e0             	mov    %ecx,0xffffffe0(%ebp)
   12cb7:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   12cba:	58                   	pop    %eax
   12cbb:	39 4d e4             	cmp    %ecx,0xffffffe4(%ebp)
   12cbe:	77 06                	ja     12cc6 <_ScsiClassSplitRequest@12+0x136>
   12cc0:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   12cc3:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   12cc6:	8b 45 10             	mov    0x10(%ebp),%eax
   12cc9:	31 d2                	xor    %edx,%edx
   12ccb:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx
   12cce:	01 c6                	add    %eax,%esi
   12cd0:	11 d7                	adc    %edx,%edi
   12cd2:	41                   	inc    %ecx
   12cd3:	89 4d dc             	mov    %ecx,0xffffffdc(%ebp)
   12cd6:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   12cd9:	39 55 dc             	cmp    %edx,0xffffffdc(%ebp)
   12cdc:	0f 82 2e ff ff ff    	jb     12c10 <_ScsiClassSplitRequest@12+0x80>
   12ce2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12ce5:	5b                   	pop    %ebx
   12ce6:	5e                   	pop    %esi
   12ce7:	5f                   	pop    %edi
   12ce8:	5d                   	pop    %ebp
   12ce9:	c2 0c 00             	ret    $0xc
   12cec:	8d 74 26 00          	lea    0x0(%esi),%esi
   12cf0:	57                   	push   %edi
   12cf1:	57                   	push   %edi
   12cf2:	6a 00                	push   $0x0
   12cf4:	52                   	push   %edx
   12cf5:	e8 66 03 00 00       	call   13060 <_MmMapLockedPages@8>
   12cfa:	59                   	pop    %ecx
   12cfb:	5e                   	pop    %esi
   12cfc:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   12cff:	e9 c4 fe ff ff       	jmp    12bc8 <_ScsiClassSplitRequest@12+0x38>
   12d04:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   12d07:	8b 7d dc             	mov    0xffffffdc(%ebp),%edi
   12d0a:	85 ff                	test   %edi,%edi
   12d0c:	c7 41 18 9a 00 00 c0 	movl   $0xc000009a,0x18(%ecx)
   12d13:	c7 41 1c 00 00 00 00 	movl   $0x0,0x1c(%ecx)
   12d1a:	75 c6                	jne    12ce2 <_ScsiClassSplitRequest@12+0x152>
   12d1c:	56                   	push   %esi
   12d1d:	56                   	push   %esi
   12d1e:	6a 00                	push   $0x0
   12d20:	51                   	push   %ecx
   12d21:	e8 4a 04 00 00       	call   13170 <_IoCompleteRequest@8>
   12d26:	59                   	pop    %ecx
   12d27:	5b                   	pop    %ebx
   12d28:	eb b8                	jmp    12ce2 <_ScsiClassSplitRequest@12+0x152>
   12d2a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00012d30 <_ScsiClassCreateClose@8>:
   12d30:	55                   	push   %ebp
   12d31:	89 e5                	mov    %esp,%ebp
   12d33:	50                   	push   %eax
   12d34:	50                   	push   %eax
   12d35:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12d38:	8b 55 0c             	mov    0xc(%ebp),%edx
   12d3b:	8b 41 28             	mov    0x28(%ecx),%eax
   12d3e:	8b 40 38             	mov    0x38(%eax),%eax
   12d41:	85 c0                	test   %eax,%eax
   12d43:	74 03                	je     12d48 <_ScsiClassCreateClose@8+0x18>
   12d45:	c9                   	leave  
   12d46:	ff e0                	jmp    *%eax
   12d48:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)
   12d4f:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   12d56:	50                   	push   %eax
   12d57:	50                   	push   %eax
   12d58:	6a 00                	push   $0x0
   12d5a:	52                   	push   %edx
   12d5b:	e8 10 04 00 00       	call   13170 <_IoCompleteRequest@8>
   12d60:	31 c0                	xor    %eax,%eax
   12d62:	c9                   	leave  
   12d63:	c2 08 00             	ret    $0x8
   12d66:	8d 76 00             	lea    0x0(%esi),%esi
   12d69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012d70 <_ScsiClassReadWrite@8>:
   12d70:	55                   	push   %ebp
   12d71:	89 e5                	mov    %esp,%ebp
   12d73:	57                   	push   %edi
   12d74:	56                   	push   %esi
   12d75:	53                   	push   %ebx
   12d76:	83 ec 1c             	sub    $0x1c,%esp
   12d79:	8b 45 08             	mov    0x8(%ebp),%eax
   12d7c:	8b 55 0c             	mov    0xc(%ebp),%edx
   12d7f:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   12d82:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   12d85:	8b 78 28             	mov    0x28(%eax),%edi
   12d88:	8b 72 60             	mov    0x60(%edx),%esi
   12d8b:	8b 47 40             	mov    0x40(%edi),%eax
   12d8e:	8b 50 04             	mov    0x4(%eax),%edx
   12d91:	8b 40 08             	mov    0x8(%eax),%eax
   12d94:	89 55 e8             	mov    %edx,0xffffffe8(%ebp)
   12d97:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   12d9a:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   12d9d:	8b 46 04             	mov    0x4(%esi),%eax
   12da0:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   12da3:	f6 42 1c 02          	testb  $0x2,0x1c(%edx)
   12da7:	74 0a                	je     12db3 <_ScsiClassReadWrite@8+0x43>
   12da9:	f6 46 02 02          	testb  $0x2,0x2(%esi)
   12dad:	0f 84 7a 01 00 00    	je     12f2d <_ScsiClassReadWrite@8+0x1bd>
   12db3:	50                   	push   %eax
   12db4:	50                   	push   %eax
   12db5:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   12db8:	53                   	push   %ebx
   12db9:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   12dbc:	51                   	push   %ecx
   12dbd:	ff 57 28             	call   *0x28(%edi)
   12dc0:	89 c3                	mov    %eax,%ebx
   12dc2:	58                   	pop    %eax
   12dc3:	85 db                	test   %ebx,%ebx
   12dc5:	5a                   	pop    %edx
   12dc6:	0f 88 d4 00 00 00    	js     12ea0 <_ScsiClassReadWrite@8+0x130>
   12dcc:	81 fb 03 01 00 00    	cmp    $0x103,%ebx
   12dd2:	0f 84 22 01 00 00    	je     12efa <_ScsiClassReadWrite@8+0x18a>
   12dd8:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   12ddb:	85 c9                	test   %ecx,%ecx
   12ddd:	0f 84 8f 00 00 00    	je     12e72 <_ScsiClassReadWrite@8+0x102>
   12de3:	8b 47 3c             	mov    0x3c(%edi),%eax
   12de6:	85 c0                	test   %eax,%eax
   12de8:	0f 85 1d 01 00 00    	jne    12f0b <_ScsiClassReadWrite@8+0x19b>
   12dee:	8b 47 18             	mov    0x18(%edi),%eax
   12df1:	31 d2                	xor    %edx,%edx
   12df3:	03 47 10             	add    0x10(%edi),%eax
   12df6:	8b 4e 04             	mov    0x4(%esi),%ecx
   12df9:	13 57 14             	adc    0x14(%edi),%edx
   12dfc:	01 46 0c             	add    %eax,0xc(%esi)
   12dff:	11 56 10             	adc    %edx,0x10(%esi)
   12e02:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12e05:	8b 50 04             	mov    0x4(%eax),%edx
   12e08:	8b 42 18             	mov    0x18(%edx),%eax
   12e0b:	8b 5a 10             	mov    0x10(%edx),%ebx
   12e0e:	01 d8                	add    %ebx,%eax
   12e10:	89 c2                	mov    %eax,%edx
   12e12:	01 c8                	add    %ecx,%eax
   12e14:	81 e2 00 f0 ff ff    	and    $0xfffff000,%edx
   12e1a:	a9 ff 0f 00 00       	test   $0xfff,%eax
   12e1f:	75 43                	jne    12e64 <_ScsiClassReadWrite@8+0xf4>
   12e21:	29 d0                	sub    %edx,%eax
   12e23:	c1 e8 0c             	shr    $0xc,%eax
   12e26:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   12e29:	39 55 e4             	cmp    %edx,0xffffffe4(%ebp)
   12e2c:	0f 97 c2             	seta   %dl
   12e2f:	3b 45 e0             	cmp    0xffffffe0(%ebp),%eax
   12e32:	0f 97 c0             	seta   %al
   12e35:	09 d0                	or     %edx,%eax
   12e37:	a8 01                	test   $0x1,%al
   12e39:	75 7e                	jne    12eb9 <_ScsiClassReadWrite@8+0x149>
   12e3b:	56                   	push   %esi
   12e3c:	56                   	push   %esi
   12e3d:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   12e40:	53                   	push   %ebx
   12e41:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   12e44:	51                   	push   %ecx
   12e45:	e8 f6 e1 ff ff       	call   11040 <_ScsiClassBuildRequest@8>
   12e4a:	58                   	pop    %eax
   12e4b:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12e4e:	5a                   	pop    %edx
   12e4f:	89 45 0c             	mov    %eax,0xc(%ebp)
   12e52:	8b 47 04             	mov    0x4(%edi),%eax
   12e55:	89 45 08             	mov    %eax,0x8(%ebp)
   12e58:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12e5b:	5b                   	pop    %ebx
   12e5c:	5e                   	pop    %esi
   12e5d:	5f                   	pop    %edi
   12e5e:	5d                   	pop    %ebp
   12e5f:	e9 2c 02 00 00       	jmp    13090 <_IoCallDriver@8>
   12e64:	25 00 f0 ff ff       	and    $0xfffff000,%eax
   12e69:	29 d0                	sub    %edx,%eax
   12e6b:	05 00 10 00 00       	add    $0x1000,%eax
   12e70:	eb b1                	jmp    12e23 <_ScsiClassReadWrite@8+0xb3>
   12e72:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12e75:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
   12e7c:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   12e83:	52                   	push   %edx
   12e84:	52                   	push   %edx
   12e85:	6a 00                	push   $0x0
   12e87:	50                   	push   %eax
   12e88:	e8 e3 02 00 00       	call   13170 <_IoCompleteRequest@8>
   12e8d:	31 c0                	xor    %eax,%eax
   12e8f:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12e92:	5b                   	pop    %ebx
   12e93:	5e                   	pop    %esi
   12e94:	5f                   	pop    %edi
   12e95:	5d                   	pop    %ebp
   12e96:	c2 08 00             	ret    $0x8
   12e99:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   12ea0:	57                   	push   %edi
   12ea1:	57                   	push   %edi
   12ea2:	6a 00                	push   $0x0
   12ea4:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
   12ea7:	56                   	push   %esi
   12ea8:	e8 c3 02 00 00       	call   13170 <_IoCompleteRequest@8>
   12ead:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12eb0:	89 d8                	mov    %ebx,%eax
   12eb2:	5b                   	pop    %ebx
   12eb3:	5e                   	pop    %esi
   12eb4:	5f                   	pop    %edi
   12eb5:	5d                   	pop    %ebp
   12eb6:	c2 08 00             	ret    $0x8
   12eb9:	8b 47 40             	mov    0x40(%edi),%eax
   12ebc:	8b 40 08             	mov    0x8(%eax),%eax
   12ebf:	c1 e0 0c             	shl    $0xc,%eax
   12ec2:	3b 45 e8             	cmp    0xffffffe8(%ebp),%eax
   12ec5:	72 2e                	jb     12ef5 <_ScsiClassReadWrite@8+0x185>
   12ec7:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   12eca:	85 c0                	test   %eax,%eax
   12ecc:	75 07                	jne    12ed5 <_ScsiClassReadWrite@8+0x165>
   12ece:	c7 45 e8 00 10 00 00 	movl   $0x1000,0xffffffe8(%ebp)
   12ed5:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   12ed8:	8b 42 60             	mov    0x60(%edx),%eax
   12edb:	80 48 03 01          	orb    $0x1,0x3(%eax)
   12edf:	50                   	push   %eax
   12ee0:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   12ee3:	50                   	push   %eax
   12ee4:	52                   	push   %edx
   12ee5:	8b 7d f0             	mov    0xfffffff0(%ebp),%edi
   12ee8:	57                   	push   %edi
   12ee9:	e8 a2 fc ff ff       	call   12b90 <_ScsiClassSplitRequest@12>
   12eee:	b8 03 01 00 00       	mov    $0x103,%eax
   12ef3:	eb 9a                	jmp    12e8f <_ScsiClassReadWrite@8+0x11f>
   12ef5:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   12ef8:	eb cd                	jmp    12ec7 <_ScsiClassReadWrite@8+0x157>
   12efa:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   12efd:	8b 42 60             	mov    0x60(%edx),%eax
   12f00:	80 48 03 01          	orb    $0x1,0x3(%eax)
   12f04:	b8 03 01 00 00       	mov    $0x103,%eax
   12f09:	eb 84                	jmp    12e8f <_ScsiClassReadWrite@8+0x11f>
   12f0b:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   12f0e:	8b 42 60             	mov    0x60(%edx),%eax
   12f11:	80 48 03 01          	orb    $0x1,0x3(%eax)
   12f15:	6a 00                	push   $0x0
   12f17:	6a 00                	push   $0x0
   12f19:	52                   	push   %edx
   12f1a:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
   12f1d:	56                   	push   %esi
   12f1e:	e8 3d 03 00 00       	call   13260 <_IoStartPacket@16>
   12f23:	b8 03 01 00 00       	mov    $0x103,%eax
   12f28:	e9 62 ff ff ff       	jmp    12e8f <_ScsiClassReadWrite@8+0x11f>
   12f2d:	50                   	push   %eax
   12f2e:	50                   	push   %eax
   12f2f:	52                   	push   %edx
   12f30:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12f33:	50                   	push   %eax
   12f34:	e8 b7 02 00 00       	call   131f0 <_IoSetHardErrorOrVerifyDevice@8>
   12f39:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   12f3c:	c7 40 18 16 00 00 80 	movl   $0x80000016,0x18(%eax)
   12f43:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   12f4a:	6a 00                	push   $0x0
   12f4c:	50                   	push   %eax
   12f4d:	e8 1e 02 00 00       	call   13170 <_IoCompleteRequest@8>
   12f52:	b8 16 00 00 80       	mov    $0x80000016,%eax
   12f57:	e9 33 ff ff ff       	jmp    12e8f <_ScsiClassReadWrite@8+0x11f>
   12f5c:	8d 74 26 00          	lea    0x0(%esi),%esi

00012f60 <_ScsiClassDeviceDispatch@8>:
   12f60:	55                   	push   %ebp
   12f61:	89 e5                	mov    %esp,%ebp
   12f63:	50                   	push   %eax
   12f64:	50                   	push   %eax
   12f65:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12f68:	8b 55 0c             	mov    0xc(%ebp),%edx
   12f6b:	8b 41 28             	mov    0x28(%ecx),%eax
   12f6e:	8b 40 30             	mov    0x30(%eax),%eax
   12f71:	85 c0                	test   %eax,%eax
   12f73:	74 03                	je     12f78 <_ScsiClassDeviceDispatch@8+0x18>
   12f75:	c9                   	leave  
   12f76:	ff e0                	jmp    *%eax
   12f78:	c7 42 18 10 00 00 c0 	movl   $0xc0000010,0x18(%edx)
   12f7f:	50                   	push   %eax
   12f80:	50                   	push   %eax
   12f81:	6a 00                	push   $0x0
   12f83:	52                   	push   %edx
   12f84:	e8 e7 01 00 00       	call   13170 <_IoCompleteRequest@8>
   12f89:	b8 10 00 00 c0       	mov    $0xc0000010,%eax
   12f8e:	c9                   	leave  
   12f8f:	c2 08 00             	ret    $0x8
   12f92:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   12f99:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012fa0 <_ScsiClassShutdownFlush@8>:
   12fa0:	55                   	push   %ebp
   12fa1:	89 e5                	mov    %esp,%ebp
   12fa3:	52                   	push   %edx
   12fa4:	52                   	push   %edx
   12fa5:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12fa8:	8b 55 0c             	mov    0xc(%ebp),%edx
   12fab:	8b 41 28             	mov    0x28(%ecx),%eax
   12fae:	8b 40 34             	mov    0x34(%eax),%eax
   12fb1:	85 c0                	test   %eax,%eax
   12fb3:	74 03                	je     12fb8 <_ScsiClassShutdownFlush@8+0x18>
   12fb5:	c9                   	leave  
   12fb6:	ff e0                	jmp    *%eax
   12fb8:	c7 42 18 10 00 00 c0 	movl   $0xc0000010,0x18(%edx)
   12fbf:	50                   	push   %eax
   12fc0:	50                   	push   %eax
   12fc1:	6a 00                	push   $0x0
   12fc3:	52                   	push   %edx
   12fc4:	e8 a7 01 00 00       	call   13170 <_IoCompleteRequest@8>
   12fc9:	b8 10 00 00 c0       	mov    $0xc0000010,%eax
   12fce:	c9                   	leave  
   12fcf:	c2 08 00             	ret    $0x8
   12fd2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   12fd9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012fe0 <_ScsiClassCheckVerifyCompletion@12>:
	       Irp);

  DPRINT("ScsiPortRetryRequest() done\n");
}


static NTSTATUS STDCALL
ScsiClassCheckVerifyCompletion (IN PDEVICE_OBJECT DeviceObject,
				IN PIRP Irp,
				IN PVOID Context)
{
   12fe0:	55                   	push   %ebp
   12fe1:	89 e5                	mov    %esp,%ebp
   12fe3:	56                   	push   %esi
   12fe4:	53                   	push   %ebx
  PDEVICE_EXTENSION DeviceExtension;
  PDEVICE_EXTENSION PhysicalExtension;
  PIO_STACK_LOCATION Stack;
  PIRP OrigIrp;

  DPRINT ("ScsiClassCheckVerifyCompletion() called\n");

  /* Get the physical device extension */
  DeviceExtension = DeviceObject->DeviceExtension;
   12fe5:	8b 45 08             	mov    0x8(%ebp),%eax
   12fe8:	8b 75 0c             	mov    0xc(%ebp),%esi
   12feb:	8b 40 28             	mov    0x28(%eax),%eax
  PhysicalExtension = DeviceExtension->PhysicalDevice->DeviceExtension;
   12fee:	8b 40 48             	mov    0x48(%eax),%eax
   12ff1:	8b 58 28             	mov    0x28(%eax),%ebx

  /* Get the original IRP */
  Stack = IoGetCurrentIrpStackLocation (Irp);
   12ff4:	8b 46 60             	mov    0x60(%esi),%eax
  OrigIrp = (PIRP)Stack->Parameters.Others.Argument1;
   12ff7:	8b 50 04             	mov    0x4(%eax),%edx

  /* Copy the media change count */
  *((PULONG)(OrigIrp->AssociatedIrp.SystemBuffer)) =
   12ffa:	8b 83 d0 00 00 00    	mov    0xd0(%ebx),%eax
   13000:	8b 4a 0c             	mov    0xc(%edx),%ecx
   13003:	89 01                	mov    %eax,(%ecx)
    PhysicalExtension->MediaChangeCount;

  /* Complete the original IRP */
  OrigIrp->IoStatus.Status = Irp->IoStatus.Status;
  OrigIrp->IoStatus.Information = sizeof(ULONG);
   13005:	c7 42 1c 04 00 00 00 	movl   $0x4,0x1c(%edx)
   1300c:	8b 46 18             	mov    0x18(%esi),%eax
   1300f:	89 42 18             	mov    %eax,0x18(%edx)

  IoCompleteRequest (OrigIrp,
   13012:	53                   	push   %ebx
   13013:	53                   	push   %ebx
   13014:	6a 04                	push   $0x4
   13016:	52                   	push   %edx
   13017:	e8 54 01 00 00       	call   13170 <_IoCompleteRequest@8>
		     IO_DISK_INCREMENT);

  /* Release the current IRP */
  IoFreeIrp (Irp);
   1301c:	51                   	push   %ecx
   1301d:	56                   	push   %esi
   1301e:	e8 ad 01 00 00       	call   131d0 <_IoFreeIrp@4>

  return STATUS_MORE_PROCESSING_REQUIRED;
}
   13023:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   13026:	b8 16 00 00 c0       	mov    $0xc0000016,%eax
   1302b:	5b                   	pop    %ebx
   1302c:	5e                   	pop    %esi
   1302d:	5d                   	pop    %ebp
   1302e:	c2 0c 00             	ret    $0xc
   13031:	90                   	nop    
   13032:	90                   	nop    
   13033:	90                   	nop    
   13034:	90                   	nop    
   13035:	90                   	nop    
   13036:	90                   	nop    
   13037:	90                   	nop    
   13038:	90                   	nop    
   13039:	90                   	nop    
   1303a:	90                   	nop    
   1303b:	90                   	nop    
   1303c:	90                   	nop    
   1303d:	90                   	nop    
   1303e:	90                   	nop    
   1303f:	90                   	nop    

00013040 <@ExInterlockedPopEntrySList@8>:
   13040:	ff 25 0c 61 01 00    	jmp    *0x1610c
   13046:	90                   	nop    
   13047:	90                   	nop    
	...

00013050 <_RtlZeroMemory@8>:
   13050:	ff 25 98 61 01 00    	jmp    *0x16198
   13056:	90                   	nop    
   13057:	90                   	nop    
	...

00013060 <_MmMapLockedPages@8>:
   13060:	ff 25 78 61 01 00    	jmp    *0x16178
   13066:	90                   	nop    
   13067:	90                   	nop    
	...

00013070 <_KeInitializeEvent@12>:
   13070:	ff 25 68 61 01 00    	jmp    *0x16168
   13076:	90                   	nop    
   13077:	90                   	nop    
	...

00013080 <_IoBuildDeviceIoControlRequest@36>:
   13080:	ff 25 34 61 01 00    	jmp    *0x16134
   13086:	90                   	nop    
   13087:	90                   	nop    
	...

00013090 <_IoCallDriver@8>:
   13090:	ff 25 38 61 01 00    	jmp    *0x16138
   13096:	90                   	nop    
   13097:	90                   	nop    
	...

000130a0 <_ObReferenceObjectByPointer@16>:
   130a0:	ff 25 80 61 01 00    	jmp    *0x16180
   130a6:	90                   	nop    
   130a7:	90                   	nop    
	...

000130b0 <@ObfDereferenceObject@4>:
   130b0:	ff 25 18 61 01 00    	jmp    *0x16118
   130b6:	90                   	nop    
   130b7:	90                   	nop    
	...

000130c0 <_KeWaitForSingleObject@20>:
   130c0:	ff 25 70 61 01 00    	jmp    *0x16170
   130c6:	90                   	nop    
   130c7:	90                   	nop    
	...

000130d0 <_RtlInitAnsiString@8>:
   130d0:	ff 25 8c 61 01 00    	jmp    *0x1618c
   130d6:	90                   	nop    
   130d7:	90                   	nop    
	...

000130e0 <_RtlAnsiStringToUnicodeString@12>:
   130e0:	ff 25 84 61 01 00    	jmp    *0x16184
   130e6:	90                   	nop    
   130e7:	90                   	nop    
	...

000130f0 <_IoCreateDevice@28>:
   130f0:	ff 25 40 61 01 00    	jmp    *0x16140
   130f6:	90                   	nop    
   130f7:	90                   	nop    
	...

00013100 <_RtlFreeUnicodeString@4>:
   13100:	ff 25 88 61 01 00    	jmp    *0x16188
   13106:	90                   	nop    
   13107:	90                   	nop    
	...

00013110 <_ExAllocatePool@8>:
   13110:	ff 25 20 61 01 00    	jmp    *0x16120
   13116:	90                   	nop    
   13117:	90                   	nop    
	...

00013120 <_ExFreePool@4>:
   13120:	ff 25 24 61 01 00    	jmp    *0x16124
   13126:	90                   	nop    
   13127:	90                   	nop    
	...

00013130 <_IoGetConfigurationInformation@0>:
   13130:	ff 25 4c 61 01 00    	jmp    *0x1614c
   13136:	90                   	nop    
   13137:	90                   	nop    
	...

00013140 <_RtlInitUnicodeString@8>:
   13140:	ff 25 90 61 01 00    	jmp    *0x16190
   13146:	90                   	nop    
   13147:	90                   	nop    
	...

00013150 <_IoGetDeviceObjectPointer@16>:
   13150:	ff 25 50 61 01 00    	jmp    *0x16150
   13156:	90                   	nop    
   13157:	90                   	nop    
	...

00013160 <_ExInitializeNPagedLookasideList@28>:
   13160:	ff 25 28 61 01 00    	jmp    *0x16128
   13166:	90                   	nop    
   13167:	90                   	nop    
	...

00013170 <_IoCompleteRequest@8>:
   13170:	ff 25 3c 61 01 00    	jmp    *0x1613c
   13176:	90                   	nop    
   13177:	90                   	nop    
	...

00013180 <_KeSetEvent@12>:
   13180:	ff 25 6c 61 01 00    	jmp    *0x1616c
   13186:	90                   	nop    
   13187:	90                   	nop    
	...

00013190 <_RtlQueryRegistryValues@20>:
   13190:	ff 25 94 61 01 00    	jmp    *0x16194
   13196:	90                   	nop    
   13197:	90                   	nop    
	...

000131a0 <_IoAllocateIrp@8>:
   131a0:	ff 25 2c 61 01 00    	jmp    *0x1612c
   131a6:	90                   	nop    
   131a7:	90                   	nop    
	...

000131b0 <_KeGetCurrentThread@0>:
   131b0:	ff 25 64 61 01 00    	jmp    *0x16164
   131b6:	90                   	nop    
   131b7:	90                   	nop    
	...

000131c0 <@InterlockedDecrement@4>:
   131c0:	ff 25 14 61 01 00    	jmp    *0x16114
   131c6:	90                   	nop    
   131c7:	90                   	nop    
	...

000131d0 <_IoFreeIrp@4>:
   131d0:	ff 25 44 61 01 00    	jmp    *0x16144
   131d6:	90                   	nop    
   131d7:	90                   	nop    
	...

000131e0 <@ExInterlockedPushEntrySList@12>:
   131e0:	ff 25 10 61 01 00    	jmp    *0x16110
   131e6:	90                   	nop    
   131e7:	90                   	nop    
	...

000131f0 <_IoSetHardErrorOrVerifyDevice@8>:
   131f0:	ff 25 54 61 01 00    	jmp    *0x16154
   131f6:	90                   	nop    
   131f7:	90                   	nop    
	...

00013200 <_IoStartNextPacket@8>:
   13200:	ff 25 58 61 01 00    	jmp    *0x16158
   13206:	90                   	nop    
   13207:	90                   	nop    
	...

00013210 <_MmUnlockPages@4>:
   13210:	ff 25 7c 61 01 00    	jmp    *0x1617c
   13216:	90                   	nop    
   13217:	90                   	nop    
	...

00013220 <_IoFreeMdl@4>:
   13220:	ff 25 48 61 01 00    	jmp    *0x16148
   13226:	90                   	nop    
   13227:	90                   	nop    
	...

00013230 <_IoAllocateMdl@20>:
   13230:	ff 25 30 61 01 00    	jmp    *0x16130
   13236:	90                   	nop    
   13237:	90                   	nop    
	...

00013240 <_MmBuildMdlForNonPagedPool@4>:
   13240:	ff 25 74 61 01 00    	jmp    *0x16174
   13246:	90                   	nop    
   13247:	90                   	nop    
	...

00013250 <_KeDelayExecutionThread@12>:
   13250:	ff 25 60 61 01 00    	jmp    *0x16160
   13256:	90                   	nop    
   13257:	90                   	nop    
	...

00013260 <_IoStartPacket@16>:
   13260:	ff 25 5c 61 01 00    	jmp    *0x1615c
   13266:	90                   	nop    
   13267:	90                   	nop    
	...

00013270 <_memcpy>:
   13270:	ff 25 9c 61 01 00    	jmp    *0x1619c
   13276:	90                   	nop    
   13277:	90                   	nop    
	...

00013280 <_swprintf>:
   13280:	ff 25 a0 61 01 00    	jmp    *0x161a0
   13286:	90                   	nop    
   13287:	90                   	nop    
	...

00013290 <_DbgPrint>:
   13290:	ff 25 1c 61 01 00    	jmp    *0x1611c
   13296:	90                   	nop    
   13297:	90                   	nop    
	...

000132a0 <_vsprintf>:
   132a0:	ff 25 a4 61 01 00    	jmp    *0x161a4
   132a6:	90                   	nop    
   132a7:	90                   	nop    
	...

000132b0 <_KeGetCurrentIrql@0>:
   132b0:	ff 25 f8 60 01 00    	jmp    *0x160f8
   132b6:	90                   	nop    
   132b7:	90                   	nop    
	...

000132c0 <_KeRaiseIrql@8>:
   132c0:	ff 25 00 61 01 00    	jmp    *0x16100
   132c6:	90                   	nop    
   132c7:	90                   	nop    
	...

000132d0 <_KeLowerIrql@4>:
   132d0:	ff 25 fc 60 01 00    	jmp    *0x160fc
   132d6:	90                   	nop    
   132d7:	90                   	nop    
	...

000132e0 <__CTOR_LIST__>:
   132e0:	ff                   	(bad)  
   132e1:	ff                   	(bad)  
   132e2:	ff                   	(bad)  
   132e3:	ff 00                	incl   (%eax)
   132e5:	00 00                	add    %al,(%eax)
	...

000132e8 <__DTOR_LIST__>:
   132e8:	ff                   	(bad)  
   132e9:	ff                   	(bad)  
   132ea:	ff                   	(bad)  
   132eb:	ff 00                	incl   (%eax)
   132ed:	00 00                	add    %al,(%eax)
	...
