
cdrom.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
   11001:	89 e5                	mov    %esp,%ebp
   11003:	83 ec 3c             	sub    $0x3c,%esp
  CLASS_INIT_DATA InitData;

  DPRINT("CD-ROM Class Driver %s\n",
	 VERSION);
  DPRINT("RegistryPath '%wZ'\n",
	 RegistryPath);

  InitData.InitializationDataSize = sizeof(CLASS_INIT_DATA);
  InitData.DeviceExtensionSize = sizeof(DEVICE_EXTENSION) + sizeof(CDROM_DATA);
  InitData.DeviceType = FILE_DEVICE_CD_ROM;
  InitData.DeviceCharacteristics = FILE_REMOVABLE_MEDIA | FILE_READ_ONLY_DEVICE;

  InitData.ClassError = NULL;
  InitData.ClassReadWriteVerification = CdromClassCheckReadWrite;
  InitData.ClassFindDeviceCallBack = CdromClassCheckDevice;
  InitData.ClassFindDevices = CdromClassFindDevices;
  InitData.ClassDeviceControl = CdromClassDeviceControl;
  InitData.ClassShutdownFlush = NULL;
  InitData.ClassCreateClose = NULL;
  InitData.ClassStartIo = CdromClassStartIo;

  return(ScsiClassInitialize(DriverObject,
   11006:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
   11009:	8b 55 0c             	mov    0xc(%ebp),%edx
   1100c:	50                   	push   %eax
   1100d:	8b 45 08             	mov    0x8(%ebp),%eax
   11010:	c7 45 c8 30 00 00 00 	movl   $0x30,0xffffffc8(%ebp)
   11017:	c7 45 cc dc 00 00 00 	movl   $0xdc,0xffffffcc(%ebp)
   1101e:	c7 45 d0 02 00 00 00 	movl   $0x2,0xffffffd0(%ebp)
   11025:	c7 45 d4 03 00 00 00 	movl   $0x3,0xffffffd4(%ebp)
   1102c:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
   11033:	c7 45 dc 90 10 01 00 	movl   $0x11090,0xffffffdc(%ebp)
   1103a:	c7 45 e0 70 10 01 00 	movl   $0x11070,0xffffffe0(%ebp)
   11041:	c7 45 e4 a0 10 01 00 	movl   $0x110a0,0xffffffe4(%ebp)
   11048:	c7 45 e8 30 18 01 00 	movl   $0x11830,0xffffffe8(%ebp)
   1104f:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   11056:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   1105d:	c7 45 f4 80 1a 01 00 	movl   $0x11a80,0xfffffff4(%ebp)
   11064:	52                   	push   %edx
   11065:	50                   	push   %eax
   11066:	e8 d5 12 00 00       	call   12340 <_ScsiClassInitialize@12>
			     RegistryPath,
			     &InitData));
}
   1106b:	c9                   	leave  
   1106c:	c2 08 00             	ret    $0x8
   1106f:	90                   	nop    

00011070 <_CdromClassCheckDevice@4>:


/**********************************************************************
 * NAME							EXPORTED
 *	CdromClassFindDevices
 *
 * DESCRIPTION:
 *	This function searches for device that are attached to the
 *	given scsi port.
 *
 * RUN LEVEL:
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS:
 *	DriverObject
 *		System allocated Driver Object for this driver
 *	RegistryPath
 *		Name of registry driver service key.
 *	InitializationData
 *		Pointer to the main initialization data
 *	PortDeviceObject
 *		Scsi port device object
 *	PortNumber
 *		Port number
 *
 * RETURNS:
 *	TRUE: At least one disk drive was found
 *	FALSE: No disk drive found
 */

BOOLEAN STDCALL
CdromClassFindDevices(IN PDRIVER_OBJECT DriverObject,
		      IN PUNICODE_STRING RegistryPath,
		      IN PCLASS_INIT_DATA InitializationData,
		      IN PDEVICE_OBJECT PortDeviceObject,
		      IN ULONG PortNumber)
{
  PCONFIGURATION_INFORMATION ConfigInfo;
  PIO_SCSI_CAPABILITIES PortCapabilities;
  PSCSI_ADAPTER_BUS_INFO AdapterBusInfo;
  PSCSI_INQUIRY_DATA UnitInfo;
  PINQUIRYDATA InquiryData;
  PCHAR Buffer;
  ULONG Bus;
  ULONG DeviceCount;
  BOOLEAN FoundDevice = FALSE;
  NTSTATUS Status;

  DPRINT("CdromClassFindDevices() called.\n");

  /* Get port capabilities */
  Status = ScsiClassGetCapabilities(PortDeviceObject,
				    &PortCapabilities);
  if (!NT_SUCCESS(Status))
    {
      DPRINT1("ScsiClassGetCapabilities() failed! (Status 0x%lX)\n", Status);
      return(FALSE);
    }

  DPRINT("PortCapabilities: %p\n", PortCapabilities);
  DPRINT("MaximumTransferLength: %lu\n", PortCapabilities->MaximumTransferLength);
  DPRINT("MaximumPhysicalPages: %lu\n", PortCapabilities->MaximumPhysicalPages);

  /* Get inquiry data */
  Status = ScsiClassGetInquiryData(PortDeviceObject,
				   (PSCSI_ADAPTER_BUS_INFO *)&Buffer);
  if (!NT_SUCCESS(Status))
    {
      DPRINT1("ScsiClassGetInquiryData() failed! (Status 0x%lX)\n", Status);
      return(FALSE);
    }

  /* Check whether there are unclaimed devices */
  AdapterBusInfo = (PSCSI_ADAPTER_BUS_INFO)Buffer;
  DeviceCount = ScsiClassFindUnclaimedDevices(InitializationData,
					      AdapterBusInfo);
  if (DeviceCount == 0)
    {
      DPRINT("No unclaimed devices!\n");
      return(FALSE);
    }

  DPRINT("Found %lu unclaimed devices!\n", DeviceCount);

  ConfigInfo = IoGetConfigurationInformation();
  DPRINT("Number of SCSI ports: %lu\n", ConfigInfo->ScsiPortCount);

  /* Search each bus of this adapter */
  for (Bus = 0; Bus < (ULONG)AdapterBusInfo->NumberOfBuses; Bus++)
    {
      DPRINT("Searching bus %lu\n", Bus);

      UnitInfo = (PSCSI_INQUIRY_DATA)(Buffer + AdapterBusInfo->BusData[Bus].InquiryDataOffset);

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

	  if ((InquiryData->DeviceType == READ_ONLY_DIRECT_ACCESS_DEVICE) &&
	      (InquiryData->DeviceTypeQualifier == 0) &&
	      (UnitInfo->DeviceClaimed == FALSE))
	    {
	      DPRINT("Vendor: '%.24s'\n",
		     InquiryData->VendorId);

	      /* Create device objects for disk */
	      Status = CdromClassCreateDeviceObject(DriverObject,
						    RegistryPath,
						    PortDeviceObject,
						    PortNumber,
						    ConfigInfo->CdRomCount,
						    PortCapabilities,
						    UnitInfo,
						    InitializationData);
	      if (NT_SUCCESS(Status))
		{
		  ConfigInfo->CdRomCount++;
		  FoundDevice = TRUE;
		}
	    }

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

	  UnitInfo = (PSCSI_INQUIRY_DATA)(Buffer + UnitInfo->NextInquiryDataOffset);
	}
    }

  ExFreePool(Buffer);

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

  return(FoundDevice);
}


/**********************************************************************
 * NAME							EXPORTED
 *	CdromClassCheckDevice
 *
 * DESCRIPTION
 *	This function checks the InquiryData for the correct device
 *	type and qualifier.
 *
 * RUN LEVEL
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS
 *	InquiryData
 *		Pointer to the inquiry data for the device in question.
 *
 * RETURN VALUE
 *	TRUE: A disk device was found.
 *	FALSE: Otherwise.
 */

BOOLEAN STDCALL
CdromClassCheckDevice(IN PINQUIRYDATA InquiryData)
{
   11070:	55                   	push   %ebp
   11071:	89 e5                	mov    %esp,%ebp
  return((InquiryData->DeviceType == READ_ONLY_DIRECT_ACCESS_DEVICE) &&
   11073:	8b 45 08             	mov    0x8(%ebp),%eax
	 (InquiryData->DeviceTypeQualifier == 0));
}
   11076:	5d                   	pop    %ebp
   11077:	80 38 05             	cmpb   $0x5,(%eax)
   1107a:	0f 94 c0             	sete   %al
   1107d:	25 ff 00 00 00       	and    $0xff,%eax
   11082:	c2 04 00             	ret    $0x4
   11085:	8d 74 26 00          	lea    0x0(%esi),%esi
   11089:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011090 <_CdromClassCheckReadWrite@8>:


/**********************************************************************
 * NAME							EXPORTED
 *	CdromClassCheckReadWrite
 *
 * DESCRIPTION
 *	This function checks the given IRP for correct data.
 *
 * RUN LEVEL
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS
 *	DeviceObject
 *		Pointer to the device.
 *	Irp
 *		Irp to check.
 *
 * RETURN VALUE
 *	STATUS_SUCCESS: The IRP matches the requirements of the given device.
 *	Others: Failure.
 */

NTSTATUS STDCALL
CdromClassCheckReadWrite(IN PDEVICE_OBJECT DeviceObject,
			 IN PIRP Irp)
{
   11090:	55                   	push   %ebp
  DPRINT("CdromClassCheckReadWrite() called\n");

  return(STATUS_SUCCESS);
}
   11091:	31 c0                	xor    %eax,%eax
   11093:	89 e5                	mov    %esp,%ebp
   11095:	5d                   	pop    %ebp
   11096:	c2 08 00             	ret    $0x8
   11099:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000110a0 <_CdromClassFindDevices@20>:
   110a0:	55                   	push   %ebp
   110a1:	89 e5                	mov    %esp,%ebp
   110a3:	57                   	push   %edi
   110a4:	56                   	push   %esi
   110a5:	53                   	push   %ebx
   110a6:	81 ec f4 02 00 00    	sub    $0x2f4,%esp
   110ac:	8d 85 44 fd ff ff    	lea    0xfffffd44(%ebp),%eax
   110b2:	c6 85 23 fd ff ff 00 	movb   $0x0,0xfffffd23(%ebp)
   110b9:	50                   	push   %eax
   110ba:	8b 4d 14             	mov    0x14(%ebp),%ecx
   110bd:	51                   	push   %ecx
   110be:	e8 8d 12 00 00       	call   12350 <_ScsiClassGetCapabilities@8>
   110c3:	89 c3                	mov    %eax,%ebx
   110c5:	58                   	pop    %eax
   110c6:	85 db                	test   %ebx,%ebx
   110c8:	5a                   	pop    %edx
   110c9:	78 4a                	js     11115 <_CdromClassFindDevices@20+0x75>
   110cb:	8d 85 40 fd ff ff    	lea    0xfffffd40(%ebp),%eax
   110d1:	53                   	push   %ebx
   110d2:	53                   	push   %ebx
   110d3:	50                   	push   %eax
   110d4:	8b 4d 14             	mov    0x14(%ebp),%ecx
   110d7:	51                   	push   %ecx
   110d8:	e8 83 12 00 00       	call   12360 <_ScsiClassGetInquiryData@8>
   110dd:	89 c3                	mov    %eax,%ebx
   110df:	58                   	pop    %eax
   110e0:	85 db                	test   %ebx,%ebx
   110e2:	5a                   	pop    %edx
   110e3:	0f 88 e1 02 00 00    	js     113ca <_CdromClassFindDevices@20+0x32a>
   110e9:	8b 85 40 fd ff ff    	mov    0xfffffd40(%ebp),%eax
   110ef:	89 85 28 fd ff ff    	mov    %eax,0xfffffd28(%ebp)
   110f5:	52                   	push   %edx
   110f6:	52                   	push   %edx
   110f7:	50                   	push   %eax
   110f8:	8b 7d 10             	mov    0x10(%ebp),%edi
   110fb:	57                   	push   %edi
   110fc:	e8 6f 12 00 00       	call   12370 <_ScsiClassFindUnclaimedDevices@8>
   11101:	31 d2                	xor    %edx,%edx
   11103:	5b                   	pop    %ebx
   11104:	85 c0                	test   %eax,%eax
   11106:	5e                   	pop    %esi
   11107:	75 3c                	jne    11145 <_CdromClassFindDevices@20+0xa5>
   11109:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1110c:	89 d0                	mov    %edx,%eax
   1110e:	5b                   	pop    %ebx
   1110f:	5e                   	pop    %esi
   11110:	5f                   	pop    %edi
   11111:	5d                   	pop    %ebp
   11112:	c2 14 00             	ret    $0x14
   11115:	50                   	push   %eax
   11116:	68 fa 00 00 00       	push   $0xfa
   1111b:	68 00 30 01 00       	push   $0x13000
   11120:	68 08 30 01 00       	push   $0x13008
   11125:	e8 c6 14 00 00       	call   125f0 <_DbgPrint>
   1112a:	5e                   	pop    %esi
   1112b:	5f                   	pop    %edi
   1112c:	53                   	push   %ebx
   1112d:	68 14 30 01 00       	push   $0x13014
   11132:	e8 b9 14 00 00       	call   125f0 <_DbgPrint>
   11137:	31 d2                	xor    %edx,%edx
   11139:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1113c:	89 d0                	mov    %edx,%eax
   1113e:	5b                   	pop    %ebx
   1113f:	5e                   	pop    %esi
   11140:	5f                   	pop    %edi
   11141:	5d                   	pop    %ebp
   11142:	c2 14 00             	ret    $0x14
   11145:	e8 d6 12 00 00       	call   12420 <_IoGetConfigurationInformation@0>
   1114a:	8b 8d 28 fd ff ff    	mov    0xfffffd28(%ebp),%ecx
   11150:	c7 85 24 fd ff ff 00 	movl   $0x0,0xfffffd24(%ebp)
   11157:	00 00 00 
   1115a:	89 85 2c fd ff ff    	mov    %eax,0xfffffd2c(%ebp)
   11160:	8a 11                	mov    (%ecx),%dl
   11162:	84 d2                	test   %dl,%dl
   11164:	0f 84 39 02 00 00    	je     113a3 <_CdromClassFindDevices@20+0x303>
   1116a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11170:	8b 8d 28 fd ff ff    	mov    0xfffffd28(%ebp),%ecx
   11176:	8b 9d 24 fd ff ff    	mov    0xfffffd24(%ebp),%ebx
   1117c:	8b 44 d9 08          	mov    0x8(%ecx,%ebx,8),%eax
   11180:	8b 8d 40 fd ff ff    	mov    0xfffffd40(%ebp),%ecx
   11186:	89 c6                	mov    %eax,%esi
   11188:	01 ce                	add    %ecx,%esi
   1118a:	85 c0                	test   %eax,%eax
   1118c:	75 32                	jne    111c0 <_CdromClassFindDevices@20+0x120>
   1118e:	e9 f3 01 00 00       	jmp    11386 <_CdromClassFindDevices@20+0x2e6>
   11193:	8b 46 08             	mov    0x8(%esi),%eax
   11196:	85 c0                	test   %eax,%eax
   11198:	0f 84 e0 01 00 00    	je     1137e <_CdromClassFindDevices@20+0x2de>
   1119e:	8b 95 24 fd ff ff    	mov    0xfffffd24(%ebp),%edx
   111a4:	8b 8d 28 fd ff ff    	mov    0xfffffd28(%ebp),%ecx
   111aa:	89 c6                	mov    %eax,%esi
   111ac:	8b 85 40 fd ff ff    	mov    0xfffffd40(%ebp),%eax
   111b2:	8b 7c d1 08          	mov    0x8(%ecx,%edx,8),%edi
   111b6:	01 c6                	add    %eax,%esi
   111b8:	85 ff                	test   %edi,%edi
   111ba:	0f 84 06 02 00 00    	je     113c6 <_CdromClassFindDevices@20+0x326>
   111c0:	80 7e 0c 05          	cmpb   $0x5,0xc(%esi)
   111c4:	75 cd                	jne    11193 <_CdromClassFindDevices@20+0xf3>
   111c6:	80 7e 03 00          	cmpb   $0x0,0x3(%esi)
   111ca:	75 c7                	jne    11193 <_CdromClassFindDevices@20+0xf3>


static VOID
CdromClassCreateMediaChangeEvent(IN PDEVICE_EXTENSION DeviceExtension,
				 IN ULONG DeviceNumber)
{
  WCHAR NameBuffer[MAX_PATH];
  UNICODE_STRING Name;

  swprintf (NameBuffer,
	    L"\\Device\\MediaChangeEvent%lu",
	    DeviceNumber);
  RtlInitUnicodeString (&Name,
			NameBuffer);

  DeviceExtension->MediaChangeEvent =
    IoCreateSynchronizationEvent (&Name,
				  &DeviceExtension->MediaChangeEventHandle);

  KeClearEvent (DeviceExtension->MediaChangeEvent);
}


/**********************************************************************
 * NAME							EXPORTED
 *	CdromClassCreateDeviceObject
 *
 * DESCRIPTION:
 *	Create the raw device and any partition devices on this drive
 *
 * RUN LEVEL:
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS:
 *	DriverObject
 *		System allocated Driver Object for this driver.
 *	RegistryPath
 *		Name of registry driver service key.
 *	PortDeviceObject
 *	PortNumber
 *	DeviceNumber
 *	Capabilities
 *	InquiryData
 *	InitializationData
 *
 * RETURNS:
 *	Status.
 */

static NTSTATUS
CdromClassCreateDeviceObject(IN PDRIVER_OBJECT DriverObject,
			     IN PUNICODE_STRING RegistryPath,
			     IN PDEVICE_OBJECT PortDeviceObject,
			     IN ULONG PortNumber,
			     IN ULONG DeviceNumber,
			     IN PIO_SCSI_CAPABILITIES Capabilities,
			     IN PSCSI_INQUIRY_DATA InquiryData,
			     IN PCLASS_INIT_DATA InitializationData)
{
   111cc:	8b 85 2c fd ff ff    	mov    0xfffffd2c(%ebp),%eax
   111d2:	8b 5d 14             	mov    0x14(%ebp),%ebx
   111d5:	8b 95 44 fd ff ff    	mov    0xfffffd44(%ebp),%edx
   111db:	89 9d 3c fd ff ff    	mov    %ebx,0xfffffd3c(%ebp)
   111e1:	8b 40 08             	mov    0x8(%eax),%eax
   111e4:	89 95 18 fd ff ff    	mov    %edx,0xfffffd18(%ebp)
   111ea:	89 85 1c fd ff ff    	mov    %eax,0xfffffd1c(%ebp)
  PDEVICE_EXTENSION DiskDeviceExtension; /* defined in class2.h */
  PDEVICE_OBJECT DiskDeviceObject;
  PCDROM_DATA CdromData;
  CHAR NameBuffer[80];
  SCSI_REQUEST_BLOCK Srb;
  PUCHAR Buffer;
  ULONG Length;
  PCDB Cdb;
  NTSTATUS Status;

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

  /* Claim the cdrom device */
  Status = ScsiClassClaimDevice(PortDeviceObject,
   111f0:	8d 85 3c fd ff ff    	lea    0xfffffd3c(%ebp),%eax
   111f6:	50                   	push   %eax
   111f7:	6a 00                	push   $0x0
   111f9:	56                   	push   %esi
   111fa:	53                   	push   %ebx
   111fb:	e8 80 11 00 00       	call   12380 <_ScsiClassClaimDevice@16>
   11200:	89 c3                	mov    %eax,%ebx
				InquiryData,
				FALSE,
				&PortDeviceObject);
  if (!NT_SUCCESS(Status))
   11202:	85 c0                	test   %eax,%eax
   11204:	0f 88 50 02 00 00    	js     1145a <_CdromClassFindDevices@20+0x3ba>
    {
      DbgPrint("Could not claim cdrom device\n");
      return(Status);
    }

  /* Create cdrom device */
  sprintf(NameBuffer,
   1120a:	52                   	push   %edx
   1120b:	8b 85 1c fd ff ff    	mov    0xfffffd1c(%ebp),%eax
   11211:	8d 5d 98             	lea    0xffffff98(%ebp),%ebx
   11214:	50                   	push   %eax
   11215:	68 47 30 01 00       	push   $0x13047
   1121a:	53                   	push   %ebx
   1121b:	e8 b0 13 00 00       	call   125d0 <_sprintf>
   11220:	58                   	pop    %eax
	  "\\Device\\CdRom%lu",
	  DeviceNumber);

  Status = ScsiClassCreateDeviceObject(DriverObject,
   11221:	8b 45 10             	mov    0x10(%ebp),%eax
   11224:	50                   	push   %eax
   11225:	8d 85 38 fd ff ff    	lea    0xfffffd38(%ebp),%eax
   1122b:	50                   	push   %eax
   1122c:	6a 00                	push   $0x0
   1122e:	53                   	push   %ebx
   1122f:	8b 45 08             	mov    0x8(%ebp),%eax
   11232:	50                   	push   %eax
   11233:	e8 58 11 00 00       	call   12390 <_ScsiClassCreateDeviceObject@20>
   11238:	83 c4 0c             	add    $0xc,%esp
   1123b:	89 c3                	mov    %eax,%ebx
				       NameBuffer,
				       NULL,
				       &DiskDeviceObject,
				       InitializationData);
  if (!NT_SUCCESS(Status))
   1123d:	85 c0                	test   %eax,%eax
   1123f:	0f 88 9e 03 00 00    	js     115e3 <_CdromClassFindDevices@20+0x543>
    {
      DPRINT1("ScsiClassCreateDeviceObject() failed (Status %x)\n", Status);

      /* Release (unclaim) the disk */
      ScsiClassClaimDevice(PortDeviceObject,
			   InquiryData,
			   TRUE,
			   NULL);

      return(Status);
    }

  DiskDeviceObject->Flags |= DO_DIRECT_IO;
   11245:	8b 85 38 fd ff ff    	mov    0xfffffd38(%ebp),%eax
   1124b:	8b 50 1c             	mov    0x1c(%eax),%edx
  DiskDeviceObject->Characteristics |= FILE_REMOVABLE_MEDIA;
   1124e:	8b 78 20             	mov    0x20(%eax),%edi
   11251:	83 ca 10             	or     $0x10,%edx
   11254:	83 cf 01             	or     $0x1,%edi
   11257:	89 50 1c             	mov    %edx,0x1c(%eax)
  DiskDeviceObject->StackSize = (CCHAR)PortDeviceObject->StackSize + 1;
   1125a:	8b 95 3c fd ff ff    	mov    0xfffffd3c(%ebp),%edx
   11260:	89 78 20             	mov    %edi,0x20(%eax)
   11263:	8a 52 30             	mov    0x30(%edx),%dl
   11266:	42                   	inc    %edx
   11267:	88 50 30             	mov    %dl,0x30(%eax)

  if (PortDeviceObject->AlignmentRequirement > DiskDeviceObject->AlignmentRequirement)
   1126a:	8b 85 3c fd ff ff    	mov    0xfffffd3c(%ebp),%eax
   11270:	8b 95 38 fd ff ff    	mov    0xfffffd38(%ebp),%edx
   11276:	8b 40 5c             	mov    0x5c(%eax),%eax
   11279:	3b 42 5c             	cmp    0x5c(%edx),%eax
   1127c:	76 03                	jbe    11281 <_CdromClassFindDevices@20+0x1e1>
    {
      DiskDeviceObject->AlignmentRequirement = PortDeviceObject->AlignmentRequirement;
   1127e:	89 42 5c             	mov    %eax,0x5c(%edx)
    }

  DiskDeviceExtension = DiskDeviceObject->DeviceExtension;
   11281:	8b 7a 28             	mov    0x28(%edx),%edi
  DiskDeviceExtension->LockCount = 0;
  DiskDeviceExtension->DeviceNumber = DeviceNumber;
  DiskDeviceExtension->DeviceObject = DiskDeviceObject;
  DiskDeviceExtension->PortDeviceObject = PortDeviceObject;
   11284:	8b 85 3c fd ff ff    	mov    0xfffffd3c(%ebp),%eax
   1128a:	8b 8d 1c fd ff ff    	mov    0xfffffd1c(%ebp),%ecx
  DiskDeviceExtension->PhysicalDevice = DiskDeviceObject;
  DiskDeviceExtension->PortCapabilities = Capabilities;
   11290:	8b 9d 18 fd ff ff    	mov    0xfffffd18(%ebp),%ebx
   11296:	89 47 04             	mov    %eax,0x4(%edi)
  DiskDeviceExtension->StartingOffset.QuadPart = 0;
  DiskDeviceExtension->PortNumber = (UCHAR)PortNumber;
   11299:	8a 45 18             	mov    0x18(%ebp),%al
   1129c:	89 4f 54             	mov    %ecx,0x54(%edi)
   1129f:	89 17                	mov    %edx,(%edi)
   112a1:	89 57 48             	mov    %edx,0x48(%edi)
   112a4:	89 5f 40             	mov    %ebx,0x40(%edi)
   112a7:	c7 47 10 00 00 00 00 	movl   $0x0,0x10(%edi)
   112ae:	c7 47 14 00 00 00 00 	movl   $0x0,0x14(%edi)
   112b5:	88 87 bc 00 00 00    	mov    %al,0xbc(%edi)
   112bb:	c7 87 b8 00 00 00 00 	movl   $0x0,0xb8(%edi)
   112c2:	00 00 00 
  DiskDeviceExtension->PathId = InquiryData->PathId;
   112c5:	8a 06                	mov    (%esi),%al
  DiskDeviceExtension->TargetId = InquiryData->TargetId;
  DiskDeviceExtension->Lun = InquiryData->Lun;

  /* zero-out disk data */
  CdromData = (PCDROM_DATA)(DiskDeviceExtension + 1);
   112c7:	8d 97 d8 00 00 00    	lea    0xd8(%edi),%edx
   112cd:	88 87 bd 00 00 00    	mov    %al,0xbd(%edi)
   112d3:	8a 46 01             	mov    0x1(%esi),%al
   112d6:	88 87 be 00 00 00    	mov    %al,0xbe(%edi)
   112dc:	8a 46 02             	mov    0x2(%esi),%al
   112df:	88 87 bf 00 00 00    	mov    %al,0xbf(%edi)
   112e5:	89 95 14 fd ff ff    	mov    %edx,0xfffffd14(%ebp)
  RtlZeroMemory(CdromData,
   112eb:	53                   	push   %ebx
   112ec:	53                   	push   %ebx
   112ed:	6a 04                	push   $0x4
   112ef:	52                   	push   %edx
   112f0:	e8 3b 11 00 00       	call   12430 <_RtlZeroMemory@8>
		sizeof(CDROM_DATA));

  DiskDeviceExtension->SenseData = ExAllocatePool(NonPagedPool,
   112f5:	6a 12                	push   $0x12
   112f7:	6a 00                	push   $0x0
   112f9:	e8 42 11 00 00       	call   12440 <_ExAllocatePool@8>
   112fe:	5a                   	pop    %edx
						  sizeof(SENSE_DATA));
  if (DiskDeviceExtension->SenseData == NULL)
   112ff:	85 c0                	test   %eax,%eax
   11301:	59                   	pop    %ecx
   11302:	89 47 4c             	mov    %eax,0x4c(%edi)
   11305:	0f 85 e1 00 00 00    	jne    113ec <_CdromClassFindDevices@20+0x34c>
    {
      DPRINT1("Failed to allocate sense data buffer!\n");
   1130b:	50                   	push   %eax
   1130c:	68 0c 02 00 00       	push   $0x20c
   11311:	68 00 30 01 00       	push   $0x13000
   11316:	68 08 30 01 00       	push   $0x13008
   1131b:	e8 d0 12 00 00       	call   125f0 <_DbgPrint>
   11320:	c7 04 24 58 30 01 00 	movl   $0x13058,(%esp)
   11327:	e8 c4 12 00 00       	call   125f0 <_DbgPrint>
   1132c:	83 c4 10             	add    $0x10,%esp

      IoDeleteDevice(DiskDeviceObject);

      /* Release (unclaim) the disk */
      ScsiClassClaimDevice(PortDeviceObject,
			   InquiryData,
			   TRUE,
			   NULL);

      return(STATUS_INSUFFICIENT_RESOURCES);
    }

  /* Get timeout value */
  DiskDeviceExtension->TimeOutValue =
    ScsiClassQueryTimeOutRegistryValue(RegistryPath);
  if (DiskDeviceExtension->TimeOutValue == 0)
    DiskDeviceExtension->TimeOutValue = SCSI_CDROM_TIMEOUT;

  /* Initialize lookaside list for SRBs */
  ScsiClassInitializeSrbLookasideList(DiskDeviceExtension,
				      4);

  /* Get disk geometry */
  DiskDeviceExtension->DiskGeometry = ExAllocatePool(NonPagedPool,
						     sizeof(DISK_GEOMETRY));
  if (DiskDeviceExtension->DiskGeometry == NULL)
    {
      DPRINT1("Failed to allocate geometry buffer!\n");

      ExDeleteNPagedLookasideList(&DiskDeviceExtension->SrbLookasideListHead);

      IoDeleteDevice(DiskDeviceObject);
   1132f:	83 ec 0c             	sub    $0xc,%esp
   11332:	8b bd 38 fd ff ff    	mov    0xfffffd38(%ebp),%edi
   11338:	57                   	push   %edi
   11339:	e8 12 11 00 00       	call   12450 <_IoDeleteDevice@4>
   1133e:	83 c4 0c             	add    $0xc,%esp

      /* Release (unclaim) the disk */
      ScsiClassClaimDevice(PortDeviceObject,
   11341:	6a 00                	push   $0x0
   11343:	6a 01                	push   $0x1
   11345:	56                   	push   %esi
   11346:	8b 9d 3c fd ff ff    	mov    0xfffffd3c(%ebp),%ebx
   1134c:	53                   	push   %ebx
   1134d:	e8 2e 10 00 00       	call   12380 <_ScsiClassClaimDevice@16>
			   InquiryData,
			   TRUE,
			   NULL);

      return(STATUS_INSUFFICIENT_RESOURCES);
    }

  /* Read the drive's capacity */
  Status = ScsiClassReadDriveCapacity(DiskDeviceObject);
  if (!NT_SUCCESS(Status) ||
      DiskDeviceExtension->DiskGeometry->BytesPerSector == 0)
    {
      /* Set ISO9660 defaults */
      DiskDeviceExtension->DiskGeometry->BytesPerSector = 2048;
      DiskDeviceExtension->DiskGeometry->MediaType = RemovableMedia;
      DiskDeviceExtension->SectorShift = 11;
      DiskDeviceExtension->PartitionLength.QuadPart = (ULONGLONG)0x7fffffff;
    }
  else
    {
      /* Make sure the BytesPerSector value is a power of 2 */
//      DiskDeviceExtension->DiskGeometry->BytesPerSector = 2048;
    }

  DPRINT("SectorSize: %lu\n", DiskDeviceExtension->DiskGeometry->BytesPerSector);

  /* Initialize media change support */
  CdromClassCreateMediaChangeEvent (DiskDeviceExtension,
				    DeviceNumber);
  if (DiskDeviceExtension->MediaChangeEvent != NULL)
    {
      DPRINT("Allocated media change event!\n");

      /* FIXME: Allocate media change IRP and SRB */
    }

  /* Use 6 byte xa commands by default */
  CdromData->XaFlags |= XA_USE_6_BYTE;

  /* Read 'error recovery page' to get additional drive capabilities */
  Length = sizeof(MODE_READ_RECOVERY_PAGE) + MODE_HEADER_LENGTH;

  RtlZeroMemory (&Srb,
		 sizeof(SCSI_REQUEST_BLOCK));
  Srb.CdbLength = 6;
  Srb.TimeOutValue = DiskDeviceExtension->TimeOutValue;

  Cdb = (PCDB)Srb.Cdb;
  Cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
  Cdb->MODE_SENSE.PageCode = 0x01;
  Cdb->MODE_SENSE.AllocationLength = (UCHAR)Length;

  Buffer = ExAllocatePool (NonPagedPool,
                           max(sizeof(ERROR_RECOVERY_DATA6), 
			       max(sizeof(ERROR_RECOVERY_DATA10), 
			           max(sizeof(MODE_CAPABILITIES_DATA6), 
				       sizeof(MODE_CAPABILITIES_DATA10)))));
  if (Buffer == NULL)
    {
      DPRINT1("Allocating recovery page buffer failed!\n");
   11352:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   11357:	85 c0                	test   %eax,%eax
   11359:	0f 88 34 fe ff ff    	js     11193 <_CdromClassFindDevices@20+0xf3>
   1135f:	8b 85 2c fd ff ff    	mov    0xfffffd2c(%ebp),%eax
   11365:	c6 85 23 fd ff ff 01 	movb   $0x1,0xfffffd23(%ebp)
   1136c:	8b 50 08             	mov    0x8(%eax),%edx
   1136f:	42                   	inc    %edx
   11370:	89 50 08             	mov    %edx,0x8(%eax)
   11373:	8b 46 08             	mov    0x8(%esi),%eax
   11376:	85 c0                	test   %eax,%eax
   11378:	0f 85 20 fe ff ff    	jne    1119e <_CdromClassFindDevices@20+0xfe>
   1137e:	8b 9d 28 fd ff ff    	mov    0xfffffd28(%ebp),%ebx
   11384:	8a 13                	mov    (%ebx),%dl
   11386:	8b 9d 24 fd ff ff    	mov    0xfffffd24(%ebp),%ebx
   1138c:	31 c0                	xor    %eax,%eax
   1138e:	43                   	inc    %ebx
   1138f:	88 d0                	mov    %dl,%al
   11391:	89 9d 24 fd ff ff    	mov    %ebx,0xfffffd24(%ebp)
   11397:	3b 85 24 fd ff ff    	cmp    0xfffffd24(%ebp),%eax
   1139d:	0f 87 cd fd ff ff    	ja     11170 <_CdromClassFindDevices@20+0xd0>
   113a3:	83 ec 0c             	sub    $0xc,%esp
   113a6:	8b 8d 40 fd ff ff    	mov    0xfffffd40(%ebp),%ecx
   113ac:	51                   	push   %ecx
   113ad:	e8 ae 10 00 00       	call   12460 <_ExFreePool@4>
   113b2:	31 d2                	xor    %edx,%edx
   113b4:	8a 95 23 fd ff ff    	mov    0xfffffd23(%ebp),%dl
   113ba:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   113bd:	89 d0                	mov    %edx,%eax
   113bf:	5b                   	pop    %ebx
   113c0:	5e                   	pop    %esi
   113c1:	5f                   	pop    %edi
   113c2:	5d                   	pop    %ebp
   113c3:	c2 14 00             	ret    $0x14
   113c6:	8a 11                	mov    (%ecx),%dl
   113c8:	eb bc                	jmp    11386 <_CdromClassFindDevices@20+0x2e6>
   113ca:	57                   	push   %edi
   113cb:	68 07 01 00 00       	push   $0x107
   113d0:	68 00 30 01 00       	push   $0x13000
   113d5:	68 08 30 01 00       	push   $0x13008
   113da:	e8 11 12 00 00       	call   125f0 <_DbgPrint>
   113df:	59                   	pop    %ecx
   113e0:	5e                   	pop    %esi
   113e1:	53                   	push   %ebx
   113e2:	68 80 30 01 00       	push   $0x13080
   113e7:	e9 46 fd ff ff       	jmp    11132 <_CdromClassFindDevices@20+0x92>
   113ec:	83 ec 0c             	sub    $0xc,%esp
   113ef:	8b 45 0c             	mov    0xc(%ebp),%eax
   113f2:	50                   	push   %eax
   113f3:	e8 a8 0f 00 00       	call   123a0 <_ScsiClassQueryTimeOutRegistryValue@4>
   113f8:	83 c4 0c             	add    $0xc,%esp
   113fb:	85 c0                	test   %eax,%eax
   113fd:	0f 85 ad 01 00 00    	jne    115b0 <_CdromClassFindDevices@20+0x510>
   11403:	c7 47 50 0a 00 00 00 	movl   $0xa,0x50(%edi)
   1140a:	53                   	push   %ebx
   1140b:	53                   	push   %ebx
   1140c:	6a 04                	push   $0x4
   1140e:	57                   	push   %edi
   1140f:	e8 9c 0f 00 00       	call   123b0 <_ScsiClassInitializeSrbLookasideList@8>
   11414:	6a 18                	push   $0x18
   11416:	6a 00                	push   $0x0
   11418:	e8 23 10 00 00       	call   12440 <_ExAllocatePool@8>
   1141d:	5a                   	pop    %edx
   1141e:	85 c0                	test   %eax,%eax
   11420:	59                   	pop    %ecx
   11421:	89 47 44             	mov    %eax,0x44(%edi)
   11424:	75 4b                	jne    11471 <_CdromClassFindDevices@20+0x3d1>
   11426:	50                   	push   %eax
   11427:	68 28 02 00 00       	push   $0x228
   1142c:	68 00 30 01 00       	push   $0x13000
   11431:	68 08 30 01 00       	push   $0x13008
   11436:	e8 b5 11 00 00       	call   125f0 <_DbgPrint>
   1143b:	c7 04 24 b4 30 01 00 	movl   $0x130b4,(%esp)
   11442:	e8 a9 11 00 00       	call   125f0 <_DbgPrint>
   11447:	8d 47 68             	lea    0x68(%edi),%eax
   1144a:	89 04 24             	mov    %eax,(%esp)
   1144d:	e8 1e 10 00 00       	call   12470 <_ExDeleteNPagedLookasideList@4>
   11452:	83 c4 0c             	add    $0xc,%esp
   11455:	e9 d5 fe ff ff       	jmp    1132f <_CdromClassFindDevices@20+0x28f>
   1145a:	83 ec 0c             	sub    $0xc,%esp
   1145d:	68 d9 30 01 00       	push   $0x130d9
   11462:	e8 89 11 00 00       	call   125f0 <_DbgPrint>
   11467:	83 c4 10             	add    $0x10,%esp
   1146a:	89 d8                	mov    %ebx,%eax
   1146c:	e9 e6 fe ff ff       	jmp    11357 <_CdromClassFindDevices@20+0x2b7>
   11471:	83 ec 0c             	sub    $0xc,%esp
   11474:	8b 8d 38 fd ff ff    	mov    0xfffffd38(%ebp),%ecx
   1147a:	51                   	push   %ecx
   1147b:	e8 40 0f 00 00       	call   123c0 <_ScsiClassReadDriveCapacity@4>
   11480:	83 c4 0c             	add    $0xc,%esp
   11483:	85 c0                	test   %eax,%eax
   11485:	0f 88 2d 01 00 00    	js     115b8 <_CdromClassFindDevices@20+0x518>
   1148b:	8b 47 44             	mov    0x44(%edi),%eax
   1148e:	8b 50 14             	mov    0x14(%eax),%edx
   11491:	85 d2                	test   %edx,%edx
   11493:	0f 84 22 01 00 00    	je     115bb <_CdromClassFindDevices@20+0x51b>
   11499:	50                   	push   %eax
   1149a:	8b 85 1c fd ff ff    	mov    0xfffffd1c(%ebp),%eax
   114a0:	8d 9d 48 fd ff ff    	lea    0xfffffd48(%ebp),%ebx
   114a6:	50                   	push   %eax
   114a7:	68 f8 30 01 00       	push   $0x130f8
   114ac:	53                   	push   %ebx
   114ad:	e8 2e 11 00 00       	call   125e0 <_swprintf>
   114b2:	59                   	pop    %ecx
   114b3:	58                   	pop    %eax
   114b4:	53                   	push   %ebx
   114b5:	8d 9d 30 fd ff ff    	lea    0xfffffd30(%ebp),%ebx
   114bb:	53                   	push   %ebx
   114bc:	e8 bf 0f 00 00       	call   12480 <_RtlInitUnicodeString@8>
   114c1:	8d 87 c8 00 00 00    	lea    0xc8(%edi),%eax
   114c7:	50                   	push   %eax
   114c8:	53                   	push   %ebx
   114c9:	e8 c2 0f 00 00       	call   12490 <_IoCreateSynchronizationEvent@8>
   114ce:	8d 9d 58 ff ff ff    	lea    0xffffff58(%ebp),%ebx
   114d4:	52                   	push   %edx
   114d5:	89 87 c4 00 00 00    	mov    %eax,0xc4(%edi)
   114db:	50                   	push   %eax
   114dc:	e8 bf 0f 00 00       	call   124a0 <_KeClearEvent@4>
   114e1:	8b 8d 14 fd ff ff    	mov    0xfffffd14(%ebp),%ecx
   114e7:	66 83 49 02 01       	orw    $0x1,0x2(%ecx)
   114ec:	c7 04 24 40 00 00 00 	movl   $0x40,(%esp)
   114f3:	53                   	push   %ebx
   114f4:	e8 37 0f 00 00       	call   12430 <_RtlZeroMemory@8>
   114f9:	c6 85 62 ff ff ff 06 	movb   $0x6,0xffffff62(%ebp)
   11500:	8b 47 50             	mov    0x50(%edi),%eax
   11503:	c6 45 88 1a          	movb   $0x1a,0xffffff88(%ebp)
   11507:	89 85 6c ff ff ff    	mov    %eax,0xffffff6c(%ebp)
   1150d:	8a 45 8a             	mov    0xffffff8a(%ebp),%al
   11510:	83 e0 c0             	and    $0xffffffc0,%eax
   11513:	c6 45 8c 0c          	movb   $0xc,0xffffff8c(%ebp)
   11517:	83 c8 01             	or     $0x1,%eax
   1151a:	88 45 8a             	mov    %al,0xffffff8a(%ebp)
   1151d:	6a 1c                	push   $0x1c
   1151f:	6a 00                	push   $0x0
   11521:	e8 1a 0f 00 00       	call   12440 <_ExAllocatePool@8>
   11526:	59                   	pop    %ecx
   11527:	85 c0                	test   %eax,%eax
   11529:	5b                   	pop    %ebx
   1152a:	89 85 10 fd ff ff    	mov    %eax,0xfffffd10(%ebp)
   11530:	0f 84 74 01 00 00    	je     116aa <_CdromClassFindDevices@20+0x60a>
      return STATUS_INSUFFICIENT_RESOURCES;
    }

  Status = ScsiClassSendSrbSynchronous (DiskDeviceObject,
   11536:	83 ec 0c             	sub    $0xc,%esp
   11539:	6a 00                	push   $0x0
   1153b:	6a 0c                	push   $0xc
   1153d:	8b 85 10 fd ff ff    	mov    0xfffffd10(%ebp),%eax
   11543:	50                   	push   %eax
   11544:	8d 85 58 ff ff ff    	lea    0xffffff58(%ebp),%eax
   1154a:	50                   	push   %eax
   1154b:	8b 85 38 fd ff ff    	mov    0xfffffd38(%ebp),%eax
   11551:	50                   	push   %eax
   11552:	e8 79 0e 00 00       	call   123d0 <_ScsiClassSendSrbSynchronous@20>
   11557:	83 c4 0c             	add    $0xc,%esp
					&Srb,
					Buffer,
					Length,
					FALSE);

  if (!NT_SUCCESS (Status))
   1155a:	85 c0                	test   %eax,%eax
   1155c:	0f 88 96 01 00 00    	js     116f8 <_CdromClassFindDevices@20+0x658>
   11562:	8b 9d 14 fd ff ff    	mov    0xfffffd14(%ebp),%ebx
   11568:	66 8b 43 02          	mov    0x2(%ebx),%ax
    {
      DPRINT("MODE_SENSE(6) failed\n");

      /* Try the 10 byte version */
      Length = sizeof(MODE_READ_RECOVERY_PAGE) + MODE_HEADER_LENGTH10;

      RtlZeroMemory (&Srb, 
		     sizeof(SCSI_REQUEST_BLOCK));
      Srb.CdbLength = 10;
      Srb.TimeOutValue = DiskDeviceExtension->TimeOutValue;

      Cdb = (PCDB)Srb.Cdb;
      Cdb->MODE_SENSE10.OperationCode = SCSIOP_MODE_SENSE10;
      Cdb->MODE_SENSE10.PageCode = 0x01;
      Cdb->MODE_SENSE10.AllocationLength[0] = (UCHAR)(Length >> 8);
      Cdb->MODE_SENSE10.AllocationLength[1] = (UCHAR)(Length & 0xFF);

      Status = ScsiClassSendSrbSynchronous (DiskDeviceObject,
					    &Srb,
					    Buffer,
					    Length,
					    FALSE);

      if (Status == STATUS_DATA_OVERRUN)
	{
	  DPRINT1("Data overrun\n");

	  /* FIXME */
	}
      else if (NT_SUCCESS (Status))
	{
	  DPRINT("Use 10 byte commands\n");
	  CdromData->XaFlags &= XA_USE_6_BYTE;
	  CdromData->XaFlags |= XA_USE_10_BYTE;
	}
      else
	{
	  DPRINT("XA not supported\n");
	  CdromData->XaFlags |= XA_NOT_SUPPORTED;
	}
    }
  else
    {
      DPRINT("Use 6 byte commands\n");
    }

  /* Read 'capabilities & mechanical status page' to get additional drive capabilities */
  Length = sizeof(MODE_READ_RECOVERY_PAGE) + MODE_HEADER_LENGTH;

  if (!(CdromData->XaFlags & XA_NOT_SUPPORTED))
   1156c:	a8 08                	test   $0x8,%al
   1156e:	0f 84 ac 00 00 00    	je     11620 <_CdromClassFindDevices@20+0x580>
    {
      RtlZeroMemory (&Srb, sizeof(SCSI_REQUEST_BLOCK));
      Srb.TimeOutValue = DiskDeviceExtension->TimeOutValue;
      Cdb = (PCDB)Srb.Cdb;

      if (CdromData->XaFlags & XA_USE_10_BYTE)
        {
          /* Try the 10 byte version */
          Length = sizeof(MODE_CAPABILITIES_PAGE2) + MODE_HEADER_LENGTH10;

          Srb.CdbLength = 10;
          Cdb->MODE_SENSE10.OperationCode = SCSIOP_MODE_SENSE10;
          Cdb->MODE_SENSE10.PageCode = 0x2a;
          Cdb->MODE_SENSE10.AllocationLength[0] = (UCHAR)(Length >> 8);
          Cdb->MODE_SENSE10.AllocationLength[1] = (UCHAR)(Length & 0xFF);
	}
      else
        {
          Length = sizeof(MODE_CAPABILITIES_PAGE2) + MODE_HEADER_LENGTH;

          Srb.CdbLength = 6;
          Cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
          Cdb->MODE_SENSE.PageCode = 0x2a;
          Cdb->MODE_SENSE.AllocationLength = (UCHAR)Length;
        }
      Status = ScsiClassSendSrbSynchronous (DiskDeviceObject,
					    &Srb,
					    Buffer,
					    Length,
					    FALSE);
      if (NT_SUCCESS (Status))
	{
#if 0
          PMODE_CAPABILITIES_PAGE2 CapabilitiesData;
	  if (CdromData->XaFlags & XA_USE_10_BYTE)
	    {
	      CapabilitiesData = (PMODE_CAPABILITIES_PAGE2)(Buffer + sizeof(MODE_PARAMETER_HEADER10));
	    }
	  else
	    {
	      CapabilitiesData = (PMODE_CAPABILITIES_PAGE2)(Buffer + sizeof(MODE_PARAMETER_HEADER));
	    }

	  DbgPrint("Capabilities for '%s':\n", NameBuffer);
	  if (CapabilitiesData->Reserved2[0] & 0x20)
	    {
	      DbgPrint("  Drive supports reading of DVD-RAM discs\n");
	    }
	  if (CapabilitiesData->Reserved2[0] & 0x10)
	    {
	      DbgPrint("  Drive supports reading of DVD-R discs\n");
	    }
	  if (CapabilitiesData->Reserved2[0] & 0x08)
	    {
	      DbgPrint("  Drive supports reading of DVD-ROM discs\n");
	    }
	  if (CapabilitiesData->Reserved2[0] & 0x04)
	    {
	      DbgPrint("  Drive supports reading CD-R discs with addressing method 2\n");
	    }
	  if (CapabilitiesData->Reserved2[0] & 0x02)
	    {
	      DbgPrint("  Drive can read from CD-R/W (CD-E) discs (orange book, part III)\n");
	    }
	  if (CapabilitiesData->Reserved2[0] & 0x01)
	    {
	      DbgPrint("  Drive supports read from CD-R discs (orange book, part II)\n");
	    }
	  DPRINT("CapabilitiesData.Reserved2[1] %x\n", CapabilitiesData->Reserved2[1]);
	  if (CapabilitiesData->Reserved2[1] & 0x01)
	    {
	      DbgPrint("  Drive can write to CD-R discs (orange book, part II)\n");
	    }
	  if (CapabilitiesData->Reserved2[1] & 0x02)
	    {
	      DbgPrint("  Drive can write to CD-R/W (CD-E) discs (orange book, part III)\n");
	    }
	  if (CapabilitiesData->Reserved2[1] & 0x04)
	    {
	      DbgPrint("  Drive can fake writes\n");
	    }
	  if (CapabilitiesData->Reserved2[1] & 0x10)
	    {
	      DbgPrint("  Drive can write DVD-R discs\n");
	    }
	  if (CapabilitiesData->Reserved2[1] & 0x20)
	    {
	      DbgPrint("  Drive can write DVD-RAM discs\n");
	    }
	  DPRINT("CapabilitiesData.Capabilities[0] %x\n", CapabilitiesData->Capabilities[0]);
	  if (CapabilitiesData->Capabilities[0] & 0x01)
	    {
	      DbgPrint("  Drive supports audio play operations\n");
	    }
	  if (CapabilitiesData->Capabilities[0] & 0x02)
	    {
	      DbgPrint("  Drive can deliver a composite audio/video data stream\n");
	    }
	  if (CapabilitiesData->Capabilities[0] & 0x04)
	    {
	      DbgPrint("  Drive supports digital output on port 1\n");
	    }
	  if (CapabilitiesData->Capabilities[0] & 0x08)
	    {
	      DbgPrint("  Drive supports digital output on port 2\n");
	    }
	  if (CapabilitiesData->Capabilities[0] & 0x10)
	    {
	      DbgPrint("  Drive can read mode 2, form 1 (XA) data\n");
	    }
	  if (CapabilitiesData->Capabilities[0] & 0x20)
	    {
	      DbgPrint("  Drive can read mode 2, form 2 data\n");
	    }
	  if (CapabilitiesData->Capabilities[0] & 0x40)
	    {
	      DbgPrint("  Drive can read multisession discs\n");
	    }
	  DPRINT("CapabilitiesData.Capabilities[1] %x\n", CapabilitiesData->Capabilities[1]);
	  if (CapabilitiesData->Capabilities[1] & 0x01)
	    {
	      DbgPrint("  Drive can read Red Book audio data\n");
	    }
	  if (CapabilitiesData->Capabilities[1] & 0x02)
	    {
	      DbgPrint("  Drive can continue a read cdda operation from a loss of streaming\n");
	    }
	  if (CapabilitiesData->Capabilities[1] & 0x04)
	    {
	      DbgPrint("  Subchannel reads can return combined R-W information\n");
	    }
	  if (CapabilitiesData->Capabilities[1] & 0x08)
	    {
	      DbgPrint("  R-W data will be returned deinterleaved and error corrected\n");
	    }
	  if (CapabilitiesData->Capabilities[1] & 0x10)
	    {
	      DbgPrint("  Drive supports C2 error pointers\n");
	    }
	  if (CapabilitiesData->Capabilities[1] & 0x20)
	    {
	      DbgPrint("  Drive can return International Standard Recording Code info\n");
	    }
	  if (CapabilitiesData->Capabilities[1] & 0x40)
	    {
	      DbgPrint("  Drive can return Media Catalog Number (UPC) info\n");
	    }
	  DPRINT("CapabilitiesData.Capabilities[2] %x\n", CapabilitiesData->Capabilities[2]);
	  if (CapabilitiesData->Capabilities[2] & 0x01)
	    {
	      DbgPrint("  Drive can lock the door\n");
	    }
	  if (CapabilitiesData->Capabilities[2] & 0x02)
	    {
	      DbgPrint("  The door is locked\n");
	    }
	  if (CapabilitiesData->Capabilities[2] & 0x04)
	    {
	    }
	  if (CapabilitiesData->Capabilities[2] & 0x08)
	    {
	      DbgPrint("  Drive can eject a disc or changer cartridge\n");
	    }
	  if (CapabilitiesData->Capabilities[2] & 0x10)
	    {
	      DbgPrint("  Drive supports C2 error pointers\n");
	    }
	  switch (CapabilitiesData->Capabilities[2] >> 5)
	    {
	      case 0:
	        DbgPrint("  Drive use a caddy type loading mechanism\n");
		break;
	      case 1:
	        DbgPrint("  Drive use a tray type loading mechanism\n");
		break;
	      case 2:
	        DbgPrint("  Drive use a pop-up type loading mechanism\n");
		break;
	      case 4:
	        DbgPrint("  Drive is a changer with individually changeable discs\n");
		break;
	      case 5:
	        DbgPrint("  Drive is a changer with cartridge mechanism\n");
		break;
	    }
	  DPRINT("CapabilitiesData.Capabilities[3] %x\n", CapabilitiesData->Capabilities[3]);
	  if (CapabilitiesData->Capabilities[3] & 0x01)
	    {
	      DbgPrint("  Audio level for each channel can be controlled independently\n");
	    }
	  if (CapabilitiesData->Capabilities[3] & 0x02)
	    {
	      DbgPrint("  Audio for each channel can be muted independently\n");
	    }
	  if (CapabilitiesData->Capabilities[3] & 0x04)
	    {
	      DbgPrint("  Changer can report exact contents of slots\n");
	    }
	  if (CapabilitiesData->Capabilities[3] & 0x08)
	    {
	      DbgPrint("  Drive supports software slot selection\n");
	    }
	  DbgPrint("  Maximum speed is %d kB/s\n", 
	          (CapabilitiesData->MaximumSpeedSupported[0] << 8) 
		  | CapabilitiesData->MaximumSpeedSupported[1]);
	  DbgPrint("  Current speed is %d kB/s\n", 
	          (CapabilitiesData->CurrentSpeed[0] << 8) 
		  | CapabilitiesData->CurrentSpeed[1]);
	  DbgPrint("  Number of discrete volume levels is %d\n",
	          (CapabilitiesData->Reserved3 << 8) 
		  | CapabilitiesData->NumberVolumeLevels);
	  DbgPrint("  Buffer size is %d kB\n",
	          (CapabilitiesData->BufferSize[0] << 8) 
		  | CapabilitiesData->BufferSize[1]);
#endif
	}
      else
	{
	  DPRINT("XA not supported\n");
	  CdromData->XaFlags |= XA_NOT_SUPPORTED;
	}

    }


  ExFreePool (Buffer);
   11574:	83 ec 0c             	sub    $0xc,%esp
   11577:	8b 8d 10 fd ff ff    	mov    0xfffffd10(%ebp),%ecx
   1157d:	51                   	push   %ecx
   1157e:	e8 dd 0e 00 00       	call   12460 <_ExFreePool@4>
   11583:	58                   	pop    %eax
   11584:	5a                   	pop    %edx

  /* Initialize device timer */
  IoInitializeTimer(DiskDeviceObject,
   11585:	6a 00                	push   $0x0
   11587:	68 90 22 01 00       	push   $0x12290
   1158c:	8b bd 38 fd ff ff    	mov    0xfffffd38(%ebp),%edi
   11592:	57                   	push   %edi
   11593:	e8 18 0f 00 00       	call   124b0 <_IoInitializeTimer@12>
   11598:	53                   	push   %ebx
   11599:	53                   	push   %ebx
		    CdromTimerRoutine,
		    NULL);
  IoStartTimer(DiskDeviceObject);
   1159a:	8b 8d 38 fd ff ff    	mov    0xfffffd38(%ebp),%ecx
   115a0:	51                   	push   %ecx
   115a1:	e8 1a 0f 00 00       	call   124c0 <_IoStartTimer@4>
   115a6:	31 c0                	xor    %eax,%eax
   115a8:	83 c4 0c             	add    $0xc,%esp
   115ab:	e9 a7 fd ff ff       	jmp    11357 <_CdromClassFindDevices@20+0x2b7>
   115b0:	89 47 50             	mov    %eax,0x50(%edi)
   115b3:	e9 52 fe ff ff       	jmp    1140a <_CdromClassFindDevices@20+0x36a>
   115b8:	8b 47 44             	mov    0x44(%edi),%eax
   115bb:	c7 40 14 00 08 00 00 	movl   $0x800,0x14(%eax)
   115c2:	c7 40 08 0b 00 00 00 	movl   $0xb,0x8(%eax)
   115c9:	c6 87 c0 00 00 00 0b 	movb   $0xb,0xc0(%edi)
   115d0:	c7 47 08 ff ff ff 7f 	movl   $0x7fffffff,0x8(%edi)
   115d7:	c7 47 0c 00 00 00 00 	movl   $0x0,0xc(%edi)
   115de:	e9 b6 fe ff ff       	jmp    11499 <_CdromClassFindDevices@20+0x3f9>
   115e3:	50                   	push   %eax
   115e4:	68 e2 01 00 00       	push   $0x1e2
   115e9:	68 00 30 01 00       	push   $0x13000
   115ee:	68 08 30 01 00       	push   $0x13008
   115f3:	e8 f8 0f 00 00       	call   125f0 <_DbgPrint>
   115f8:	5f                   	pop    %edi
   115f9:	58                   	pop    %eax
   115fa:	53                   	push   %ebx
   115fb:	68 30 31 01 00       	push   $0x13130
   11600:	e8 eb 0f 00 00       	call   125f0 <_DbgPrint>
   11605:	83 c4 10             	add    $0x10,%esp
   11608:	6a 00                	push   $0x0
   1160a:	6a 01                	push   $0x1
   1160c:	56                   	push   %esi
   1160d:	8b 8d 3c fd ff ff    	mov    0xfffffd3c(%ebp),%ecx
   11613:	51                   	push   %ecx
   11614:	e8 67 0d 00 00       	call   12380 <_ScsiClassClaimDevice@16>
   11619:	89 d8                	mov    %ebx,%eax
   1161b:	e9 37 fd ff ff       	jmp    11357 <_CdromClassFindDevices@20+0x2b7>
   11620:	8d 85 58 ff ff ff    	lea    0xffffff58(%ebp),%eax
   11626:	51                   	push   %ecx
   11627:	51                   	push   %ecx
   11628:	6a 40                	push   $0x40
   1162a:	50                   	push   %eax
   1162b:	e8 00 0e 00 00       	call   12430 <_RtlZeroMemory@8>
   11630:	58                   	pop    %eax
   11631:	5a                   	pop    %edx
   11632:	8b 95 14 fd ff ff    	mov    0xfffffd14(%ebp),%edx
   11638:	8b 47 50             	mov    0x50(%edi),%eax
   1163b:	89 85 6c ff ff ff    	mov    %eax,0xffffff6c(%ebp)
   11641:	f6 42 02 02          	testb  $0x2,0x2(%edx)
   11645:	0f 84 88 00 00 00    	je     116d3 <_CdromClassFindDevices@20+0x633>
   1164b:	8a 45 8a             	mov    0xffffff8a(%ebp),%al
   1164e:	ba 1c 00 00 00       	mov    $0x1c,%edx
   11653:	83 e0 c0             	and    $0xffffffc0,%eax
   11656:	c6 85 62 ff ff ff 0a 	movb   $0xa,0xffffff62(%ebp)
   1165d:	83 c8 2a             	or     $0x2a,%eax
   11660:	c6 45 88 5a          	movb   $0x5a,0xffffff88(%ebp)
   11664:	88 45 8a             	mov    %al,0xffffff8a(%ebp)
   11667:	c6 45 8f 00          	movb   $0x0,0xffffff8f(%ebp)
   1166b:	c6 45 90 1c          	movb   $0x1c,0xffffff90(%ebp)
   1166f:	83 ec 0c             	sub    $0xc,%esp
   11672:	8d 8d 58 ff ff ff    	lea    0xffffff58(%ebp),%ecx
   11678:	6a 00                	push   $0x0
   1167a:	52                   	push   %edx
   1167b:	8b bd 10 fd ff ff    	mov    0xfffffd10(%ebp),%edi
   11681:	57                   	push   %edi
   11682:	51                   	push   %ecx
   11683:	8b 9d 38 fd ff ff    	mov    0xfffffd38(%ebp),%ebx
   11689:	53                   	push   %ebx
   1168a:	e8 41 0d 00 00       	call   123d0 <_ScsiClassSendSrbSynchronous@20>
   1168f:	83 c4 0c             	add    $0xc,%esp
   11692:	85 c0                	test   %eax,%eax
   11694:	0f 89 da fe ff ff    	jns    11574 <_CdromClassFindDevices@20+0x4d4>
   1169a:	8b 9d 14 fd ff ff    	mov    0xfffffd14(%ebp),%ebx
   116a0:	66 83 4b 02 08       	orw    $0x8,0x2(%ebx)
   116a5:	e9 ca fe ff ff       	jmp    11574 <_CdromClassFindDevices@20+0x4d4>
   116aa:	52                   	push   %edx
   116ab:	68 6b 02 00 00       	push   $0x26b
   116b0:	68 00 30 01 00       	push   $0x13000
   116b5:	68 08 30 01 00       	push   $0x13008
   116ba:	e8 31 0f 00 00       	call   125f0 <_DbgPrint>
   116bf:	c7 04 24 64 31 01 00 	movl   $0x13164,(%esp)
   116c6:	e8 25 0f 00 00       	call   125f0 <_DbgPrint>
   116cb:	83 c4 10             	add    $0x10,%esp
   116ce:	e9 7f fc ff ff       	jmp    11352 <_CdromClassFindDevices@20+0x2b2>
   116d3:	8a 45 8a             	mov    0xffffff8a(%ebp),%al
   116d6:	ba 18 00 00 00       	mov    $0x18,%edx
   116db:	83 e0 c0             	and    $0xffffffc0,%eax
   116de:	c6 85 62 ff ff ff 06 	movb   $0x6,0xffffff62(%ebp)
   116e5:	83 c8 2a             	or     $0x2a,%eax
   116e8:	c6 45 88 1a          	movb   $0x1a,0xffffff88(%ebp)
   116ec:	88 45 8a             	mov    %al,0xffffff8a(%ebp)
   116ef:	c6 45 8c 18          	movb   $0x18,0xffffff8c(%ebp)
   116f3:	e9 77 ff ff ff       	jmp    1166f <_CdromClassFindDevices@20+0x5cf>
   116f8:	8d 95 58 ff ff ff    	lea    0xffffff58(%ebp),%edx
   116fe:	50                   	push   %eax
   116ff:	50                   	push   %eax
   11700:	6a 40                	push   $0x40
   11702:	52                   	push   %edx
   11703:	e8 28 0d 00 00       	call   12430 <_RtlZeroMemory@8>
   11708:	8d 8d 58 ff ff ff    	lea    0xffffff58(%ebp),%ecx
   1170e:	50                   	push   %eax
   1170f:	c6 85 62 ff ff ff 0a 	movb   $0xa,0xffffff62(%ebp)
   11716:	8b 47 50             	mov    0x50(%edi),%eax
   11719:	c6 45 88 5a          	movb   $0x5a,0xffffff88(%ebp)
   1171d:	89 85 6c ff ff ff    	mov    %eax,0xffffff6c(%ebp)
   11723:	8a 45 8a             	mov    0xffffff8a(%ebp),%al
   11726:	83 e0 c0             	and    $0xffffffc0,%eax
   11729:	c6 45 8f 00          	movb   $0x0,0xffffff8f(%ebp)
   1172d:	83 c8 01             	or     $0x1,%eax
   11730:	c6 45 90 10          	movb   $0x10,0xffffff90(%ebp)
   11734:	88 45 8a             	mov    %al,0xffffff8a(%ebp)
   11737:	6a 00                	push   $0x0
   11739:	6a 10                	push   $0x10
   1173b:	8b 85 10 fd ff ff    	mov    0xfffffd10(%ebp),%eax
   11741:	50                   	push   %eax
   11742:	51                   	push   %ecx
   11743:	8b 85 38 fd ff ff    	mov    0xfffffd38(%ebp),%eax
   11749:	50                   	push   %eax
   1174a:	e8 81 0c 00 00       	call   123d0 <_ScsiClassSendSrbSynchronous@20>
   1174f:	83 c4 0c             	add    $0xc,%esp
   11752:	3d 3c 00 00 c0       	cmp    $0xc000003c,%eax
   11757:	74 1d                	je     11776 <_CdromClassFindDevices@20+0x6d6>
   11759:	85 c0                	test   %eax,%eax
   1175b:	78 42                	js     1179f <_CdromClassFindDevices@20+0x6ff>
   1175d:	8b 95 14 fd ff ff    	mov    0xfffffd14(%ebp),%edx
   11763:	66 8b 42 02          	mov    0x2(%edx),%ax
   11767:	83 e0 01             	and    $0x1,%eax
   1176a:	83 c8 02             	or     $0x2,%eax
   1176d:	66 89 42 02          	mov    %ax,0x2(%edx)
   11771:	e9 f6 fd ff ff       	jmp    1156c <_CdromClassFindDevices@20+0x4cc>
   11776:	53                   	push   %ebx
   11777:	68 8f 02 00 00       	push   $0x28f
   1177c:	68 00 30 01 00       	push   $0x13000
   11781:	68 08 30 01 00       	push   $0x13008
   11786:	e8 65 0e 00 00       	call   125f0 <_DbgPrint>
   1178b:	c7 04 24 8d 31 01 00 	movl   $0x1318d,(%esp)
   11792:	e8 59 0e 00 00       	call   125f0 <_DbgPrint>
   11797:	83 c4 10             	add    $0x10,%esp
   1179a:	e9 c3 fd ff ff       	jmp    11562 <_CdromClassFindDevices@20+0x4c2>
   1179f:	8b 8d 14 fd ff ff    	mov    0xfffffd14(%ebp),%ecx
   117a5:	66 8b 41 02          	mov    0x2(%ecx),%ax
   117a9:	83 c8 08             	or     $0x8,%eax
   117ac:	66 89 41 02          	mov    %ax,0x2(%ecx)
   117b0:	e9 b7 fd ff ff       	jmp    1156c <_CdromClassFindDevices@20+0x4cc>
   117b5:	8d 74 26 00          	lea    0x0(%esi),%esi
   117b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000117c0 <_CdromClassReadTocEntry>:

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

  return(STATUS_SUCCESS);
}


/**********************************************************************
 * NAME
 *	CdromClassReadTocEntry
 *
 * ARGUMENTS:
 *      DeviceObject
 *      TrackNo
 *      Buffer
 *      Length
 *
 * RETURNS:
 *	Status.
 */
static NTSTATUS
CdromClassReadTocEntry (PDEVICE_OBJECT DeviceObject,
			UINT TrackNo,
			PVOID Buffer,
			UINT Length)
{
   117c0:	55                   	push   %ebp
   117c1:	89 e5                	mov    %esp,%ebp
   117c3:	57                   	push   %edi
   117c4:	56                   	push   %esi
   117c5:	53                   	push   %ebx
   117c6:	83 ec 54             	sub    $0x54,%esp
   117c9:	89 c3                	mov    %eax,%ebx
  PDEVICE_EXTENSION DeviceExtension;
  SCSI_REQUEST_BLOCK Srb;
  PCDB Cdb;

  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
   117cb:	8b 70 28             	mov    0x28(%eax),%esi

  RtlZeroMemory(&Srb, sizeof(SCSI_REQUEST_BLOCK));
   117ce:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
   117d1:	89 d7                	mov    %edx,%edi
   117d3:	6a 40                	push   $0x40
   117d5:	50                   	push   %eax
   117d6:	e8 55 0c 00 00       	call   12430 <_RtlZeroMemory@8>
  Srb.CdbLength = 10;
   117db:	c6 45 b2 0a          	movb   $0xa,0xffffffb2(%ebp)
  Srb.TimeOutValue = DeviceExtension->TimeOutValue;
   117df:	8b 46 50             	mov    0x50(%esi),%eax

  Cdb = (PCDB)Srb.Cdb;
  Cdb->READ_TOC.OperationCode = SCSIOP_READ_TOC;
  Cdb->READ_TOC.StartingTrack = TrackNo;
  Cdb->READ_TOC.Format = 0;
  Cdb->READ_TOC.AllocationLength[0] = Length >> 8;
  Cdb->READ_TOC.AllocationLength[1] = Length & 0xff;
  Cdb->READ_TOC.Msf = 1;

  return(ScsiClassSendSrbSynchronous(DeviceObject,
   117e2:	8b 75 08             	mov    0x8(%ebp),%esi
   117e5:	89 45 bc             	mov    %eax,0xffffffbc(%ebp)
   117e8:	89 f8                	mov    %edi,%eax
   117ea:	88 45 de             	mov    %al,0xffffffde(%ebp)
   117ed:	8b 45 0c             	mov    0xc(%ebp),%eax
   117f0:	c1 e8 08             	shr    $0x8,%eax
   117f3:	8b 7d 0c             	mov    0xc(%ebp),%edi
   117f6:	88 45 df             	mov    %al,0xffffffdf(%ebp)
   117f9:	8a 45 0c             	mov    0xc(%ebp),%al
   117fc:	88 45 e0             	mov    %al,0xffffffe0(%ebp)
   117ff:	50                   	push   %eax
   11800:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
   11803:	6a 00                	push   $0x0
   11805:	c6 45 d8 43          	movb   $0x43,0xffffffd8(%ebp)
   11809:	57                   	push   %edi
   1180a:	56                   	push   %esi
   1180b:	80 65 e1 3f          	andb   $0x3f,0xffffffe1(%ebp)
   1180f:	80 4d d9 02          	orb    $0x2,0xffffffd9(%ebp)
   11813:	50                   	push   %eax
   11814:	53                   	push   %ebx
   11815:	e8 b6 0b 00 00       	call   123d0 <_ScsiClassSendSrbSynchronous@20>
				     &Srb,
				     Buffer,
				     Length,
				     FALSE));
}
   1181a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1181d:	5b                   	pop    %ebx
   1181e:	5e                   	pop    %esi
   1181f:	5f                   	pop    %edi
   11820:	5d                   	pop    %ebp
   11821:	c3                   	ret    
   11822:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11829:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011830 <_CdromClassDeviceControl@8>:


static NTSTATUS
CdromClassReadLastSession (PDEVICE_OBJECT DeviceObject,
			   UINT TrackNo,
			   PVOID Buffer,
			   UINT Length)
{
  PDEVICE_EXTENSION DeviceExtension;
  SCSI_REQUEST_BLOCK Srb;
  PCDB Cdb;

  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;

  RtlZeroMemory(&Srb, sizeof(SCSI_REQUEST_BLOCK));
  Srb.CdbLength = 10;
  Srb.TimeOutValue = DeviceExtension->TimeOutValue;

  Cdb = (PCDB)Srb.Cdb;
  Cdb->READ_TOC.OperationCode = SCSIOP_READ_TOC;
  Cdb->READ_TOC.StartingTrack = TrackNo;
  Cdb->READ_TOC.Format = 1;
  Cdb->READ_TOC.AllocationLength[0] = Length >> 8;
  Cdb->READ_TOC.AllocationLength[1] = Length & 0xff;
  Cdb->READ_TOC.Msf = 0;

  return(ScsiClassSendSrbSynchronous(DeviceObject,
				     &Srb,
				     Buffer,
				     Length,
				     FALSE));
}


/**********************************************************************
 * NAME							EXPORTED
 *	CdromClassDeviceControl
 *
 * DESCRIPTION:
 *	Answer requests for device control calls
 *
 * RUN LEVEL:
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS:
 *	DeviceObject
 *	Irp
 *		Standard dispatch arguments
 *
 * RETURNS:
 *	Status.
 */

NTSTATUS STDCALL
CdromClassDeviceControl(IN PDEVICE_OBJECT DeviceObject,
			IN PIRP Irp)
{
   11830:	55                   	push   %ebp
   11831:	89 e5                	mov    %esp,%ebp
   11833:	57                   	push   %edi
   11834:	56                   	push   %esi
   11835:	53                   	push   %ebx
   11836:	83 ec 5c             	sub    $0x5c,%esp
  PDEVICE_EXTENSION DeviceExtension;
  PIO_STACK_LOCATION IrpStack;
  ULONG ControlCode, InputLength, OutputLength;
  PCDROM_DATA CdromData;
  ULONG Information;
  NTSTATUS Status;

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

  Status = STATUS_INVALID_DEVICE_REQUEST;
  Information = 0;
   11839:	c7 45 a4 00 00 00 00 	movl   $0x0,0xffffffa4(%ebp)
   11840:	8b 7d 0c             	mov    0xc(%ebp),%edi
   11843:	8b 75 08             	mov    0x8(%ebp),%esi
  IrpStack = IoGetCurrentIrpStackLocation(Irp);
   11846:	8b 4f 60             	mov    0x60(%edi),%ecx
  ControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
   11849:	8b 51 0c             	mov    0xc(%ecx),%edx
  InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
  OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;
   1184c:	8b 41 04             	mov    0x4(%ecx),%eax
  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
  CdromData = (PCDROM_DATA)(DeviceExtension + 1);

  switch (ControlCode)
   1184f:	81 fa 38 40 02 00    	cmp    $0x24038,%edx
   11855:	74 6a                	je     118c1 <_CdromClassDeviceControl@8+0x91>
   11857:	77 1f                	ja     11878 <_CdromClassDeviceControl@8+0x48>
   11859:	81 fa 00 40 02 00    	cmp    $0x24000,%edx
   1185f:	0f 84 eb 00 00 00    	je     11950 <_CdromClassDeviceControl@8+0x120>
    {
      case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
	DPRINT ("CdromClassDeviceControl: IOCTL_CDROM_GET_DRIVE_GEOMETRY\n");
	if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DISK_GEOMETRY))
	  {
	    Status = STATUS_INFO_LENGTH_MISMATCH;
	    break;
	  }
	IoMarkIrpPending (Irp);
	IoStartPacket (DeviceObject,
		       Irp,
		       NULL,
		       NULL);
	return STATUS_PENDING;

      case IOCTL_CDROM_CHECK_VERIFY:
	DPRINT ("CdromClassDeviceControl: IOCTL_CDROM_CHECK_VERIFY\n");
	if (OutputLength != 0 && OutputLength < sizeof (ULONG))
	  {
	    DPRINT1("Buffer too small\n");
	    Status = STATUS_BUFFER_TOO_SMALL;
	    break;
	  }
	IoMarkIrpPending (Irp);
	IoStartPacket (DeviceObject,
		       Irp,
		       NULL,
		       NULL);
	return STATUS_PENDING;

      case IOCTL_CDROM_READ_TOC:
	DPRINT("IOCTL_CDROM_READ_TOC\n");
	if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(CDROM_TOC))
	  {
	    Status = STATUS_INFO_LENGTH_MISMATCH;
	  }
	else
	  {
	    PCDROM_TOC TocBuffer;
	    USHORT Length;

	    TocBuffer = Irp->AssociatedIrp.SystemBuffer;

	    /* First read the lead out */
	    Length = 4 + sizeof(TRACK_DATA);
	    Status = CdromClassReadTocEntry(DeviceObject,
					    0xAA,
					    TocBuffer,
					    Length);
	    if (NT_SUCCESS(Status))
	      {
		if (TocBuffer->FirstTrack == 0xaa)
		  {
		    /* there is an empty cd */
		    Information = Length;
		  }
		else
		  {
		    /* read the toc */
		    Length = 4 + sizeof(TRACK_DATA) * (TocBuffer->LastTrack - TocBuffer->FirstTrack + 2);
		    Status = CdromClassReadTocEntry(DeviceObject,
						    TocBuffer->FirstTrack,
						    TocBuffer, Length);
		    if (NT_SUCCESS(Status))
		      {
			Information = Length;
		      }
		  }
	      }
	  }
	break;

      case IOCTL_CDROM_GET_LAST_SESSION:
	DPRINT("IOCTL_CDROM_GET_LAST_SESSION\n");
	if (IrpStack->Parameters.DeviceIoControl.OutputBufferLength < 4 + sizeof(TRACK_DATA))
	  {
	    Status = STATUS_INFO_LENGTH_MISMATCH;
	  }
	else
	  {
	    PCDROM_TOC TocBuffer;
	    USHORT Length;

	    TocBuffer = Irp->AssociatedIrp.SystemBuffer;
	    Length = 4 + sizeof(TRACK_DATA);
	    Status = CdromClassReadLastSession(DeviceObject,
					       0,
					       TocBuffer,
					       Length);
	    if (NT_SUCCESS(Status))
	      {
		Information = Length;
	      }
	  }
	break;

      default:
	/* Call the common device control function */
	return(ScsiClassDeviceControl(DeviceObject, Irp));
   11865:	53                   	push   %ebx
   11866:	53                   	push   %ebx
   11867:	57                   	push   %edi
   11868:	56                   	push   %esi
   11869:	e8 72 0b 00 00       	call   123e0 <_ScsiClassDeviceControl@8>
    }

  /* Verify the device if the user caused the error */
  if (!NT_SUCCESS(Status) && IoIsErrorUserInduced(Status))
    {
      IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
    }

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

  return Status;
}
   1186e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11871:	5b                   	pop    %ebx
   11872:	5e                   	pop    %esi
   11873:	5f                   	pop    %edi
   11874:	5d                   	pop    %ebp
   11875:	c2 08 00             	ret    $0x8
   11878:	81 fa 4c 40 02 00    	cmp    $0x2404c,%edx
   1187e:	0f 84 51 01 00 00    	je     119d5 <_CdromClassDeviceControl@8+0x1a5>
   11884:	81 fa 00 48 02 00    	cmp    $0x24800,%edx
   1188a:	75 d9                	jne    11865 <_CdromClassDeviceControl@8+0x35>
   1188c:	48                   	dec    %eax
   1188d:	83 f8 02             	cmp    $0x2,%eax
   11890:	0f 87 4d 01 00 00    	ja     119e3 <_CdromClassDeviceControl@8+0x1b3>
   11896:	51                   	push   %ecx
   11897:	68 21 04 00 00       	push   $0x421
   1189c:	68 00 30 01 00       	push   $0x13000
   118a1:	68 08 30 01 00       	push   $0x13008
   118a6:	e8 45 0d 00 00       	call   125f0 <_DbgPrint>
   118ab:	c7 04 24 9b 31 01 00 	movl   $0x1319b,(%esp)
   118b2:	bb 23 00 00 c0       	mov    $0xc0000023,%ebx
   118b7:	e8 34 0d 00 00       	call   125f0 <_DbgPrint>
   118bc:	83 c4 10             	add    $0x10,%esp
   118bf:	eb 0e                	jmp    118cf <_CdromClassDeviceControl@8+0x9f>
   118c1:	bb 04 00 00 c0       	mov    $0xc0000004,%ebx
   118c6:	83 f8 0b             	cmp    $0xb,%eax
   118c9:	0f 87 31 01 00 00    	ja     11a00 <_CdromClassDeviceControl@8+0x1d0>
   118cf:	81 fb a3 00 00 c0    	cmp    $0xc00000a3,%ebx
   118d5:	0f 94 c2             	sete   %dl
   118d8:	81 fb b5 00 00 c0    	cmp    $0xc00000b5,%ebx
   118de:	0f 94 c0             	sete   %al
   118e1:	09 d0                	or     %edx,%eax
   118e3:	a8 01                	test   $0x1,%al
   118e5:	75 39                	jne    11920 <_CdromClassDeviceControl@8+0xf0>
   118e7:	81 fb a2 00 00 c0    	cmp    $0xc00000a2,%ebx
   118ed:	0f 94 c2             	sete   %dl
   118f0:	81 fb 06 00 00 c1    	cmp    $0xc1000006,%ebx
   118f6:	0f 94 c0             	sete   %al
   118f9:	09 d0                	or     %edx,%eax
   118fb:	a8 01                	test   $0x1,%al
   118fd:	75 21                	jne    11920 <_CdromClassDeviceControl@8+0xf0>
   118ff:	81 fb 16 00 00 80    	cmp    $0x80000016,%ebx
   11905:	0f 94 c2             	sete   %dl
   11908:	81 fb 14 00 00 c0    	cmp    $0xc0000014,%ebx
   1190e:	0f 94 c0             	sete   %al
   11911:	09 d0                	or     %edx,%eax
   11913:	a8 01                	test   $0x1,%al
   11915:	75 09                	jne    11920 <_CdromClassDeviceControl@8+0xf0>
   11917:	81 fb 12 00 00 c0    	cmp    $0xc0000012,%ebx
   1191d:	75 0c                	jne    1192b <_CdromClassDeviceControl@8+0xfb>
   1191f:	90                   	nop    
   11920:	51                   	push   %ecx
   11921:	51                   	push   %ecx
   11922:	56                   	push   %esi
   11923:	57                   	push   %edi
   11924:	e8 a7 0b 00 00       	call   124d0 <_IoSetHardErrorOrVerifyDevice@8>
   11929:	58                   	pop    %eax
   1192a:	5a                   	pop    %edx
   1192b:	8b 45 a4             	mov    0xffffffa4(%ebp),%eax
   1192e:	89 5f 18             	mov    %ebx,0x18(%edi)
   11931:	89 47 1c             	mov    %eax,0x1c(%edi)
   11934:	50                   	push   %eax
   11935:	50                   	push   %eax
   11936:	6a 04                	push   $0x4
   11938:	57                   	push   %edi
   11939:	e8 a2 0b 00 00       	call   124e0 <_IoCompleteRequest@8>
   1193e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11941:	89 d8                	mov    %ebx,%eax
   11943:	5b                   	pop    %ebx
   11944:	5e                   	pop    %esi
   11945:	5f                   	pop    %edi
   11946:	5d                   	pop    %ebp
   11947:	c2 08 00             	ret    $0x8
   1194a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11950:	bb 04 00 00 c0       	mov    $0xc0000004,%ebx
   11955:	3d 23 03 00 00       	cmp    $0x323,%eax
   1195a:	0f 86 6f ff ff ff    	jbe    118cf <_CdromClassDeviceControl@8+0x9f>
   11960:	8b 47 0c             	mov    0xc(%edi),%eax
   11963:	89 45 a0             	mov    %eax,0xffffffa0(%ebp)
   11966:	52                   	push   %edx
   11967:	52                   	push   %edx
   11968:	ba aa 00 00 00       	mov    $0xaa,%edx
   1196d:	6a 0c                	push   $0xc
   1196f:	50                   	push   %eax
   11970:	89 f0                	mov    %esi,%eax
   11972:	e8 49 fe ff ff       	call   117c0 <_CdromClassReadTocEntry>
   11977:	83 c4 10             	add    $0x10,%esp
   1197a:	89 c3                	mov    %eax,%ebx
   1197c:	85 c0                	test   %eax,%eax
   1197e:	0f 88 4b ff ff ff    	js     118cf <_CdromClassDeviceControl@8+0x9f>
   11984:	8b 4d a0             	mov    0xffffffa0(%ebp),%ecx
   11987:	8a 51 02             	mov    0x2(%ecx),%dl
   1198a:	80 fa aa             	cmp    $0xaa,%dl
   1198d:	0f 84 cd 00 00 00    	je     11a60 <_CdromClassDeviceControl@8+0x230>
   11993:	8b 4d a0             	mov    0xffffffa0(%ebp),%ecx
   11996:	31 c0                	xor    %eax,%eax
   11998:	81 e2 ff 00 00 00    	and    $0xff,%edx
   1199e:	8a 41 03             	mov    0x3(%ecx),%al
   119a1:	53                   	push   %ebx
   119a2:	29 d0                	sub    %edx,%eax
   119a4:	53                   	push   %ebx
   119a5:	8d 04 c5 14 00 00 00 	lea    0x14(,%eax,8),%eax
   119ac:	25 ff ff 00 00       	and    $0xffff,%eax
   119b1:	89 45 9c             	mov    %eax,0xffffff9c(%ebp)
   119b4:	50                   	push   %eax
   119b5:	89 f0                	mov    %esi,%eax
   119b7:	51                   	push   %ecx
   119b8:	e8 03 fe ff ff       	call   117c0 <_CdromClassReadTocEntry>
   119bd:	83 c4 10             	add    $0x10,%esp
   119c0:	89 c3                	mov    %eax,%ebx
   119c2:	85 c0                	test   %eax,%eax
   119c4:	0f 88 05 ff ff ff    	js     118cf <_CdromClassDeviceControl@8+0x9f>
   119ca:	8b 45 9c             	mov    0xffffff9c(%ebp),%eax
   119cd:	89 45 a4             	mov    %eax,0xffffffa4(%ebp)
   119d0:	e9 92 00 00 00       	jmp    11a67 <_CdromClassDeviceControl@8+0x237>
   119d5:	bb 04 00 00 c0       	mov    $0xc0000004,%ebx
   119da:	83 f8 17             	cmp    $0x17,%eax
   119dd:	0f 86 ec fe ff ff    	jbe    118cf <_CdromClassDeviceControl@8+0x9f>
   119e3:	80 49 03 01          	orb    $0x1,0x3(%ecx)
   119e7:	6a 00                	push   $0x0
   119e9:	6a 00                	push   $0x0
   119eb:	57                   	push   %edi
   119ec:	56                   	push   %esi
   119ed:	e8 fe 0a 00 00       	call   124f0 <_IoStartPacket@16>
   119f2:	b8 03 01 00 00       	mov    $0x103,%eax
   119f7:	e9 72 fe ff ff       	jmp    1186e <_CdromClassDeviceControl@8+0x3e>
   119fc:	8d 74 26 00          	lea    0x0(%esi),%esi
   11a00:	8b 4f 0c             	mov    0xc(%edi),%ecx
   11a03:	8b 5e 28             	mov    0x28(%esi),%ebx
   11a06:	89 4d 98             	mov    %ecx,0xffffff98(%ebp)
   11a09:	50                   	push   %eax
   11a0a:	50                   	push   %eax
   11a0b:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
   11a0e:	6a 40                	push   $0x40
   11a10:	50                   	push   %eax
   11a11:	e8 1a 0a 00 00       	call   12430 <_RtlZeroMemory@8>
   11a16:	8d 4d a8             	lea    0xffffffa8(%ebp),%ecx
   11a19:	50                   	push   %eax
   11a1a:	c6 45 b2 0a          	movb   $0xa,0xffffffb2(%ebp)
   11a1e:	8b 43 50             	mov    0x50(%ebx),%eax
   11a21:	c6 45 d8 43          	movb   $0x43,0xffffffd8(%ebp)
   11a25:	89 45 bc             	mov    %eax,0xffffffbc(%ebp)
   11a28:	8a 45 e1             	mov    0xffffffe1(%ebp),%al
   11a2b:	83 e0 3f             	and    $0x3f,%eax
   11a2e:	c6 45 de 00          	movb   $0x0,0xffffffde(%ebp)
   11a32:	80 65 d9 fd          	andb   $0xfd,0xffffffd9(%ebp)
   11a36:	83 c8 40             	or     $0x40,%eax
   11a39:	c6 45 df 00          	movb   $0x0,0xffffffdf(%ebp)
   11a3d:	88 45 e1             	mov    %al,0xffffffe1(%ebp)
   11a40:	c6 45 e0 0c          	movb   $0xc,0xffffffe0(%ebp)
   11a44:	6a 00                	push   $0x0
   11a46:	6a 0c                	push   $0xc
   11a48:	8b 45 98             	mov    0xffffff98(%ebp),%eax
   11a4b:	50                   	push   %eax
   11a4c:	51                   	push   %ecx
   11a4d:	56                   	push   %esi
   11a4e:	e8 7d 09 00 00       	call   123d0 <_ScsiClassSendSrbSynchronous@20>
   11a53:	83 c4 0c             	add    $0xc,%esp
   11a56:	89 c3                	mov    %eax,%ebx
   11a58:	85 c0                	test   %eax,%eax
   11a5a:	0f 88 6f fe ff ff    	js     118cf <_CdromClassDeviceControl@8+0x9f>
   11a60:	c7 45 a4 0c 00 00 00 	movl   $0xc,0xffffffa4(%ebp)
   11a67:	85 db                	test   %ebx,%ebx
   11a69:	0f 89 bc fe ff ff    	jns    1192b <_CdromClassDeviceControl@8+0xfb>
   11a6f:	e9 5b fe ff ff       	jmp    118cf <_CdromClassDeviceControl@8+0x9f>
   11a74:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11a7a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011a80 <_CdromClassStartIo@8>:


/**********************************************************************
 * NAME
 *	CdromClassStartIo
 *
 * DESCRIPTION:
 *	Starts IRP processing.
 *
 * RUN LEVEL:
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS:
 *	DeviceObject
 *	Irp
 *		Standard dispatch arguments
 *
 * RETURNS:
 *	None.
 */
VOID STDCALL
CdromClassStartIo (IN PDEVICE_OBJECT DeviceObject,
		   IN PIRP Irp)
{
   11a80:	55                   	push   %ebp
   11a81:	89 e5                	mov    %esp,%ebp
   11a83:	57                   	push   %edi
   11a84:	56                   	push   %esi
   11a85:	53                   	push   %ebx
   11a86:	83 ec 1c             	sub    $0x1c,%esp
   11a89:	8b 45 08             	mov    0x8(%ebp),%eax
   11a8c:	8b 75 0c             	mov    0xc(%ebp),%esi
   11a8f:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
  PDEVICE_EXTENSION DeviceExtension;
  PIO_STACK_LOCATION IrpStack;
  PIO_STACK_LOCATION SubIrpStack;
  ULONG MaximumTransferLength;
  ULONG TransferPages;
  PSCSI_REQUEST_BLOCK Srb;
  PIRP SubIrp;
  PUCHAR SenseBuffer;
  PVOID DataBuffer;
  PCDB Cdb;

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

  IoMarkIrpPending (Irp);
   11a92:	8b 46 60             	mov    0x60(%esi),%eax
   11a95:	80 48 03 01          	orb    $0x1,0x3(%eax)

  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
   11a99:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
  IrpStack = IoGetCurrentIrpStackLocation (Irp);

  MaximumTransferLength = DeviceExtension->PortCapabilities->MaximumTransferLength;

  if (DeviceObject->Flags & DO_VERIFY_VOLUME)
   11a9c:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11a9f:	8b 52 28             	mov    0x28(%edx),%edx
   11aa2:	f6 40 1c 02          	testb  $0x2,0x1c(%eax)
   11aa6:	8b 4a 40             	mov    0x40(%edx),%ecx
   11aa9:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   11aac:	8b 7e 60             	mov    0x60(%esi),%edi
   11aaf:	8b 59 04             	mov    0x4(%ecx),%ebx
   11ab2:	74 0a                	je     11abe <_CdromClassStartIo@8+0x3e>
    {
      if (!(IrpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME))
   11ab4:	f6 47 02 02          	testb  $0x2,0x2(%edi)
   11ab8:	0f 84 85 00 00 00    	je     11b43 <_CdromClassStartIo@8+0xc3>
	{
	  DPRINT1 ("Verify required\n");

	  if (Irp->Tail.Overlay.Thread)
	    {
	      IoSetHardErrorOrVerifyDevice (Irp,
					    DeviceObject);
	    }
	  Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;

	  /* FIXME: Update drive capacity */
	  IoCompleteRequest (Irp,
			     IO_DISK_INCREMENT);
	  IoStartNextPacket (DeviceObject,
			     FALSE);
	  return;
	}
    }

  if (IrpStack->MajorFunction == IRP_MJ_READ)
   11abe:	8a 07                	mov    (%edi),%al
   11ac0:	3c 03                	cmp    $0x3,%al
   11ac2:	74 20                	je     11ae4 <_CdromClassStartIo@8+0x64>
    {
      DPRINT ("CdromClassStartIo: IRP_MJ_READ\n");

      TransferPages =
	ADDRESS_AND_SIZE_TO_SPAN_PAGES (MmGetMdlVirtualAddress(Irp->MdlAddress),
					IrpStack->Parameters.Read.Length);

      /* Check transfer size */
      if ((IrpStack->Parameters.Read.Length > MaximumTransferLength) ||
	  (TransferPages > DeviceExtension->PortCapabilities->MaximumPhysicalPages))
	{
	  /* Transfer size is too large - split it */
	  TransferPages =
	    DeviceExtension->PortCapabilities->MaximumPhysicalPages - 1;

	  /* Adjust transfer size */
	  if (MaximumTransferLength > TransferPages * PAGE_SIZE)
	    MaximumTransferLength = TransferPages * PAGE_SIZE;

	  if (MaximumTransferLength == 0)
	    MaximumTransferLength = PAGE_SIZE;

	  /* Split the transfer */
	  ScsiClassSplitRequest (DeviceObject,
				 Irp,
				 MaximumTransferLength);
	  return;
	}
      else
	{
	  /* Build SRB */
	  ScsiClassBuildRequest (DeviceObject,
				 Irp);
	}
    }
  else if (IrpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL)
   11ac4:	3c 0e                	cmp    $0xe,%al
   11ac6:	0f 84 e5 00 00 00    	je     11bb1 <_CdromClassStartIo@8+0x131>
    {
      DPRINT ("CdromClassStartIo: IRP_MJ_IRP_MJ_DEVICE_CONTROL\n");

      /* Allocate an IRP for sending requests to the port driver */
      SubIrp = IoAllocateIrp ((CCHAR)(DeviceObject->StackSize + 1),
			      FALSE);
      if (SubIrp == NULL)
	{
	  Irp->IoStatus.Information = 0;
	  Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
	  IoCompleteRequest (Irp,
			     IO_DISK_INCREMENT);
	  IoStartNextPacket (DeviceObject,
			     FALSE);
	  return;
	}

      /* Allocate an SRB */
      Srb = ExAllocatePool (NonPagedPool,
			    sizeof (SCSI_REQUEST_BLOCK));
      if (Srb == NULL)
	{
	  IoFreeIrp (SubIrp);
	  Irp->IoStatus.Information = 0;
	  Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
	  IoCompleteRequest (Irp,
			     IO_DISK_INCREMENT);
	  IoStartNextPacket (DeviceObject,
			     FALSE);
	  return;
	}

      /* Allocte a sense buffer */
      SenseBuffer = ExAllocatePool (NonPagedPoolCacheAligned,
				    SENSE_BUFFER_SIZE);
      if (SenseBuffer == NULL)
	{
	  ExFreePool (Srb);
	  IoFreeIrp (SubIrp);
	  Irp->IoStatus.Information = 0;
	  Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
	  IoCompleteRequest (Irp,
			     IO_DISK_INCREMENT);
	  IoStartNextPacket (DeviceObject,
			     FALSE);
	  return;
	}

      /* Initialize the IRP */
      IoSetNextIrpStackLocation (SubIrp);
      SubIrp->IoStatus.Information = 0;
      SubIrp->IoStatus.Status = STATUS_SUCCESS;
      SubIrp->Flags = 0;
      SubIrp->UserBuffer = NULL;

      SubIrpStack = IoGetCurrentIrpStackLocation (SubIrp);
      SubIrpStack->DeviceObject = DeviceExtension->DeviceObject;
      SubIrpStack->Parameters.Others.Argument2 = (PVOID)Irp;

      /* Initialize next stack location */
      SubIrpStack = IoGetNextIrpStackLocation (SubIrp);
      SubIrpStack->MajorFunction = IRP_MJ_SCSI;
      SubIrpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_SCSI_EXECUTE_IN;
      SubIrpStack->Parameters.Scsi.Srb = Srb;

      /* Initialize the 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->SrbStatus = SRB_STATUS_SUCCESS;
      Srb->ScsiStatus = 0;
      Srb->NextSrb = 0;
      Srb->OriginalRequest = SubIrp;
      Srb->SenseInfoBuffer = SenseBuffer;
      Srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;

      /* Initialize the CDB */
      Cdb = (PCDB)Srb->Cdb;

      /* Set the completion routine */
      IoSetCompletionRoutine (SubIrp,
			      CdromDeviceControlCompletion,
			      Srb,
			      TRUE,
			      TRUE,
			      TRUE);

      switch (IrpStack->Parameters.DeviceIoControl.IoControlCode)
	{
	  case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
	    DPRINT ("CdromClassStartIo: IOCTL_CDROM_GET_DRIVE_GEOMETRY\n");
	    Srb->DataTransferLength = sizeof(READ_CAPACITY_DATA);
	    Srb->CdbLength = 10;
	    Srb->TimeOutValue = DeviceExtension->TimeOutValue;
	    Srb->SrbFlags = SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_DATA_IN;
	    Cdb->CDB10.OperationCode = SCSIOP_READ_CAPACITY;

	    /* Allocate data buffer */
	    DataBuffer = ExAllocatePool (NonPagedPoolCacheAligned,
					 sizeof(READ_CAPACITY_DATA));
	    if (DataBuffer == NULL)
	      {
		Irp->IoStatus.Information = 0;
		Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
		IoCompleteRequest (Irp,
				   IO_DISK_INCREMENT);
		ExFreePool (SenseBuffer);
		ExFreePool (Srb);
		IoFreeIrp (SubIrp);
		IoStartNextPacket (DeviceObject,
				   FALSE);
		return;
	      }

	    /* Allocate an MDL for the data buffer */
	    SubIrp->MdlAddress = IoAllocateMdl (DataBuffer,
						sizeof(READ_CAPACITY_DATA),
						FALSE,
						FALSE,
						NULL);
	    if (SubIrp->MdlAddress == NULL)
	      {
		Irp->IoStatus.Information = 0;
		Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
		IoCompleteRequest (Irp,
				   IO_DISK_INCREMENT);
		ExFreePool (DataBuffer);
		ExFreePool (SenseBuffer);
		ExFreePool (Srb);
		IoFreeIrp (SubIrp);
		IoStartNextPacket (DeviceObject,
				   FALSE);
		return;
	      }

	    MmBuildMdlForNonPagedPool (SubIrp->MdlAddress);
	    Srb->DataBuffer = DataBuffer;

	    IoCallDriver (DeviceExtension->PortDeviceObject,
			  SubIrp);
	    return;

	  case IOCTL_CDROM_CHECK_VERIFY:
	    DPRINT ("CdromClassStartIo: IOCTL_CDROM_CHECK_VERIFY\n");
	    Srb->CdbLength = 6;
	    Srb->TimeOutValue = DeviceExtension->TimeOutValue * 2;
	    Srb->SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER;
	    Cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;

	    IoCallDriver (DeviceExtension->PortDeviceObject,
			  SubIrp);
	    return;

	  default:
	    IoCompleteRequest (Irp,
			       IO_NO_INCREMENT);
	    return;
	}
    }

  /* Call the SCSI port driver */
  IoCallDriver (DeviceExtension->PortDeviceObject,
   11acc:	89 75 0c             	mov    %esi,0xc(%ebp)
   11acf:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11ad2:	8b 42 04             	mov    0x4(%edx),%eax
   11ad5:	89 45 08             	mov    %eax,0x8(%ebp)
		Irp);
}
   11ad8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11adb:	5b                   	pop    %ebx
   11adc:	5e                   	pop    %esi
   11add:	5f                   	pop    %edi
   11ade:	5d                   	pop    %ebp
   11adf:	e9 1c 0a 00 00       	jmp    12500 <_IoCallDriver@8>
   11ae4:	8b 56 04             	mov    0x4(%esi),%edx
   11ae7:	8b 7f 04             	mov    0x4(%edi),%edi
   11aea:	8b 42 18             	mov    0x18(%edx),%eax
   11aed:	03 42 10             	add    0x10(%edx),%eax
   11af0:	89 c2                	mov    %eax,%edx
   11af2:	8d 04 07             	lea    (%edi,%eax,1),%eax
   11af5:	81 e2 00 f0 ff ff    	and    $0xfffff000,%edx
   11afb:	a9 ff 0f 00 00       	test   $0xfff,%eax
   11b00:	0f 85 9a 00 00 00    	jne    11ba0 <_CdromClassStartIo@8+0x120>
   11b06:	29 d0                	sub    %edx,%eax
   11b08:	c1 e8 0c             	shr    $0xc,%eax
   11b0b:	39 df                	cmp    %ebx,%edi
   11b0d:	77 09                	ja     11b18 <_CdromClassStartIo@8+0x98>
   11b0f:	39 41 08             	cmp    %eax,0x8(%ecx)
   11b12:	0f 83 ce 01 00 00    	jae    11ce6 <_CdromClassStartIo@8+0x266>
   11b18:	8b 41 08             	mov    0x8(%ecx),%eax
   11b1b:	48                   	dec    %eax
   11b1c:	c1 e0 0c             	shl    $0xc,%eax
   11b1f:	39 d8                	cmp    %ebx,%eax
   11b21:	73 02                	jae    11b25 <_CdromClassStartIo@8+0xa5>
   11b23:	89 c3                	mov    %eax,%ebx
   11b25:	85 db                	test   %ebx,%ebx
   11b27:	75 04                	jne    11b2d <_CdromClassStartIo@8+0xad>
   11b29:	66 bb 00 10          	mov    $0x1000,%bx
   11b2d:	50                   	push   %eax
   11b2e:	53                   	push   %ebx
   11b2f:	56                   	push   %esi
   11b30:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11b33:	50                   	push   %eax
   11b34:	e8 b7 08 00 00       	call   123f0 <_ScsiClassSplitRequest@12>
   11b39:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11b3c:	5b                   	pop    %ebx
   11b3d:	5e                   	pop    %esi
   11b3e:	5f                   	pop    %edi
   11b3f:	5d                   	pop    %ebp
   11b40:	c2 08 00             	ret    $0x8
   11b43:	50                   	push   %eax
   11b44:	68 b0 04 00 00       	push   $0x4b0
   11b49:	68 00 30 01 00       	push   $0x13000
   11b4e:	68 08 30 01 00       	push   $0x13008
   11b53:	e8 98 0a 00 00       	call   125f0 <_DbgPrint>
   11b58:	c7 04 24 ad 31 01 00 	movl   $0x131ad,(%esp)
   11b5f:	e8 8c 0a 00 00       	call   125f0 <_DbgPrint>
   11b64:	8b 46 50             	mov    0x50(%esi),%eax
   11b67:	83 c4 10             	add    $0x10,%esp
   11b6a:	85 c0                	test   %eax,%eax
   11b6c:	0f 85 87 01 00 00    	jne    11cf9 <_CdromClassStartIo@8+0x279>
   11b72:	c7 46 18 16 00 00 80 	movl   $0x80000016,0x18(%esi)
   11b79:	50                   	push   %eax
   11b7a:	50                   	push   %eax
   11b7b:	6a 04                	push   $0x4
   11b7d:	56                   	push   %esi
   11b7e:	e8 5d 09 00 00       	call   124e0 <_IoCompleteRequest@8>
   11b83:	58                   	pop    %eax
   11b84:	5a                   	pop    %edx
   11b85:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   11b88:	c7 45 0c 00 00 00 00 	movl   $0x0,0xc(%ebp)
   11b8f:	89 55 08             	mov    %edx,0x8(%ebp)
   11b92:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11b95:	5b                   	pop    %ebx
   11b96:	5e                   	pop    %esi
   11b97:	5f                   	pop    %edi
   11b98:	5d                   	pop    %ebp
   11b99:	e9 72 09 00 00       	jmp    12510 <_IoStartNextPacket@8>
   11b9e:	89 f6                	mov    %esi,%esi
   11ba0:	25 00 f0 ff ff       	and    $0xfffff000,%eax
   11ba5:	29 d0                	sub    %edx,%eax
   11ba7:	05 00 10 00 00       	add    $0x1000,%eax
   11bac:	e9 57 ff ff ff       	jmp    11b08 <_CdromClassStartIo@8+0x88>
   11bb1:	53                   	push   %ebx
   11bb2:	53                   	push   %ebx
   11bb3:	6a 00                	push   $0x0
   11bb5:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   11bb8:	8a 41 30             	mov    0x30(%ecx),%al
   11bbb:	40                   	inc    %eax
   11bbc:	0f be c0             	movsbl %al,%eax
   11bbf:	50                   	push   %eax
   11bc0:	e8 5b 09 00 00       	call   12520 <_IoAllocateIrp@8>
   11bc5:	85 c0                	test   %eax,%eax
   11bc7:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11bca:	5a                   	pop    %edx
   11bcb:	59                   	pop    %ecx
   11bcc:	0f 84 3a 01 00 00    	je     11d0c <_CdromClassStartIo@8+0x28c>
   11bd2:	51                   	push   %ecx
   11bd3:	51                   	push   %ecx
   11bd4:	6a 40                	push   $0x40
   11bd6:	6a 00                	push   $0x0
   11bd8:	e8 63 08 00 00       	call   12440 <_ExAllocatePool@8>
   11bdd:	89 c3                	mov    %eax,%ebx
   11bdf:	58                   	pop    %eax
   11be0:	85 db                	test   %ebx,%ebx
   11be2:	5a                   	pop    %edx
   11be3:	0f 84 4f 01 00 00    	je     11d38 <_CdromClassStartIo@8+0x2b8>
   11be9:	50                   	push   %eax
   11bea:	50                   	push   %eax
   11beb:	6a 12                	push   $0x12
   11bed:	6a 04                	push   $0x4
   11bef:	e8 4c 08 00 00       	call   12440 <_ExAllocatePool@8>
   11bf4:	85 c0                	test   %eax,%eax
   11bf6:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   11bf9:	5a                   	pop    %edx
   11bfa:	59                   	pop    %ecx
   11bfb:	0f 84 57 01 00 00    	je     11d58 <_CdromClassStartIo@8+0x2d8>
   11c01:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11c04:	fe 48 23             	decb   0x23(%eax)
   11c07:	8b 50 60             	mov    0x60(%eax),%edx
   11c0a:	83 ea 24             	sub    $0x24,%edx
   11c0d:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   11c14:	89 50 60             	mov    %edx,0x60(%eax)
   11c17:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
   11c1e:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   11c21:	c7 40 08 00 00 00 00 	movl   $0x0,0x8(%eax)
   11c28:	c7 40 3c 00 00 00 00 	movl   $0x0,0x3c(%eax)
   11c2f:	8b 01                	mov    (%ecx),%eax
   11c31:	89 72 08             	mov    %esi,0x8(%edx)
   11c34:	89 42 14             	mov    %eax,0x14(%edx)
   11c37:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   11c3a:	8b 42 60             	mov    0x60(%edx),%eax
   11c3d:	8d 50 dc             	lea    0xffffffdc(%eax),%edx
   11c40:	c6 40 dc 0f          	movb   $0xf,0xffffffdc(%eax)
   11c44:	c7 42 0c 11 00 1b 00 	movl   $0x1b0011,0xc(%edx)
   11c4b:	89 5a 04             	mov    %ebx,0x4(%edx)
   11c4e:	51                   	push   %ecx
   11c4f:	51                   	push   %ecx
   11c50:	6a 40                	push   $0x40
   11c52:	53                   	push   %ebx
   11c53:	e8 d8 07 00 00       	call   12430 <_RtlZeroMemory@8>
   11c58:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   11c5b:	66 c7 03 40 00       	movw   $0x40,(%ebx)
   11c60:	8a 81 bd 00 00 00    	mov    0xbd(%ecx),%al
   11c66:	88 43 05             	mov    %al,0x5(%ebx)
   11c69:	8a 81 be 00 00 00    	mov    0xbe(%ecx),%al
   11c6f:	88 43 06             	mov    %al,0x6(%ebx)
   11c72:	8a 81 bf 00 00 00    	mov    0xbf(%ecx),%al
   11c78:	c6 43 02 00          	movb   $0x0,0x2(%ebx)
   11c7c:	88 43 07             	mov    %al,0x7(%ebx)
   11c7f:	c6 43 03 01          	movb   $0x1,0x3(%ebx)
   11c83:	c6 43 04 00          	movb   $0x0,0x4(%ebx)
   11c87:	c7 43 20 00 00 00 00 	movl   $0x0,0x20(%ebx)
   11c8e:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11c91:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   11c94:	c6 43 0b 12          	movb   $0x12,0xb(%ebx)
   11c98:	89 43 24             	mov    %eax,0x24(%ebx)
   11c9b:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   11c9e:	89 53 1c             	mov    %edx,0x1c(%ebx)
   11ca1:	58                   	pop    %eax
   11ca2:	5a                   	pop    %edx
   11ca3:	8b 41 60             	mov    0x60(%ecx),%eax
   11ca6:	83 e8 24             	sub    $0x24,%eax
   11ca9:	c7 40 1c 90 1e 01 00 	movl   $0x11e90,0x1c(%eax)
   11cb0:	89 58 20             	mov    %ebx,0x20(%eax)
   11cb3:	c6 40 03 e0          	movb   $0xe0,0x3(%eax)
   11cb7:	8b 47 0c             	mov    0xc(%edi),%eax
   11cba:	3d 4c 40 02 00       	cmp    $0x2404c,%eax
   11cbf:	0f 84 fc 00 00 00    	je     11dc1 <_CdromClassStartIo@8+0x341>
   11cc5:	3d 00 48 02 00       	cmp    $0x24800,%eax
   11cca:	0f 84 c9 00 00 00    	je     11d99 <_CdromClassStartIo@8+0x319>
   11cd0:	c7 45 0c 00 00 00 00 	movl   $0x0,0xc(%ebp)
   11cd7:	89 75 08             	mov    %esi,0x8(%ebp)
   11cda:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11cdd:	5b                   	pop    %ebx
   11cde:	5e                   	pop    %esi
   11cdf:	5f                   	pop    %edi
   11ce0:	5d                   	pop    %ebp
   11ce1:	e9 fa 07 00 00       	jmp    124e0 <_IoCompleteRequest@8>
   11ce6:	50                   	push   %eax
   11ce7:	50                   	push   %eax
   11ce8:	56                   	push   %esi
   11ce9:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11cec:	50                   	push   %eax
   11ced:	e8 0e 07 00 00       	call   12400 <_ScsiClassBuildRequest@8>
   11cf2:	5f                   	pop    %edi
   11cf3:	58                   	pop    %eax
   11cf4:	e9 d3 fd ff ff       	jmp    11acc <_CdromClassStartIo@8+0x4c>
   11cf9:	57                   	push   %edi
   11cfa:	57                   	push   %edi
   11cfb:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
   11cfe:	53                   	push   %ebx
   11cff:	56                   	push   %esi
   11d00:	e8 cb 07 00 00       	call   124d0 <_IoSetHardErrorOrVerifyDevice@8>
   11d05:	5a                   	pop    %edx
   11d06:	59                   	pop    %ecx
   11d07:	e9 66 fe ff ff       	jmp    11b72 <_CdromClassStartIo@8+0xf2>
   11d0c:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   11d13:	c7 46 18 9a 00 00 c0 	movl   $0xc000009a,0x18(%esi)
   11d1a:	57                   	push   %edi
   11d1b:	57                   	push   %edi
   11d1c:	6a 04                	push   $0x4
   11d1e:	56                   	push   %esi
   11d1f:	e8 bc 07 00 00       	call   124e0 <_IoCompleteRequest@8>
   11d24:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11d27:	5b                   	pop    %ebx
   11d28:	5e                   	pop    %esi
   11d29:	c7 45 0c 00 00 00 00 	movl   $0x0,0xc(%ebp)
   11d30:	89 45 08             	mov    %eax,0x8(%ebp)
   11d33:	e9 5a fe ff ff       	jmp    11b92 <_CdromClassStartIo@8+0x112>
   11d38:	83 ec 0c             	sub    $0xc,%esp
   11d3b:	8b 5d e8             	mov    0xffffffe8(%ebp),%ebx
   11d3e:	53                   	push   %ebx
   11d3f:	e8 ec 07 00 00       	call   12530 <_IoFreeIrp@4>
   11d44:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   11d4b:	c7 46 18 9a 00 00 c0 	movl   $0xc000009a,0x18(%esi)
   11d52:	59                   	pop    %ecx
   11d53:	e9 23 fe ff ff       	jmp    11b7b <_CdromClassStartIo@8+0xfb>
   11d58:	83 ec 0c             	sub    $0xc,%esp
   11d5b:	53                   	push   %ebx
   11d5c:	e8 ff 06 00 00       	call   12460 <_ExFreePool@4>
   11d61:	8b 7d e8             	mov    0xffffffe8(%ebp),%edi
   11d64:	57                   	push   %edi
   11d65:	e8 c6 07 00 00       	call   12530 <_IoFreeIrp@4>
   11d6a:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   11d71:	c7 46 18 9a 00 00 c0 	movl   $0xc000009a,0x18(%esi)
   11d78:	c7 04 24 04 00 00 00 	movl   $0x4,(%esp)
   11d7f:	56                   	push   %esi
   11d80:	e8 5b 07 00 00       	call   124e0 <_IoCompleteRequest@8>
   11d85:	5b                   	pop    %ebx
   11d86:	5e                   	pop    %esi
   11d87:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   11d8a:	c7 45 0c 00 00 00 00 	movl   $0x0,0xc(%ebp)
   11d91:	89 4d 08             	mov    %ecx,0x8(%ebp)
   11d94:	e9 f9 fd ff ff       	jmp    11b92 <_CdromClassStartIo@8+0x112>
   11d99:	c6 43 0a 06          	movb   $0x6,0xa(%ebx)
   11d9d:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   11da0:	8b 41 50             	mov    0x50(%ecx),%eax
   11da3:	c6 43 30 00          	movb   $0x0,0x30(%ebx)
   11da7:	01 c0                	add    %eax,%eax
   11da9:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)
   11db0:	89 43 14             	mov    %eax,0x14(%ebx)
   11db3:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11db6:	89 45 0c             	mov    %eax,0xc(%ebp)
   11db9:	8b 41 04             	mov    0x4(%ecx),%eax
   11dbc:	e9 14 fd ff ff       	jmp    11ad5 <_CdromClassStartIo@8+0x55>
   11dc1:	c6 43 0a 0a          	movb   $0xa,0xa(%ebx)
   11dc5:	c7 43 10 08 00 00 00 	movl   $0x8,0x10(%ebx)
   11dcc:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11dcf:	8b 42 50             	mov    0x50(%edx),%eax
   11dd2:	c7 43 0c 48 00 00 00 	movl   $0x48,0xc(%ebx)
   11dd9:	89 43 14             	mov    %eax,0x14(%ebx)
   11ddc:	c6 43 30 25          	movb   $0x25,0x30(%ebx)
   11de0:	51                   	push   %ecx
   11de1:	51                   	push   %ecx
   11de2:	6a 08                	push   $0x8
   11de4:	6a 04                	push   $0x4
   11de6:	e8 55 06 00 00       	call   12440 <_ExAllocatePool@8>
   11deb:	89 c7                	mov    %eax,%edi
   11ded:	58                   	pop    %eax
   11dee:	85 ff                	test   %edi,%edi
   11df0:	5a                   	pop    %edx
   11df1:	74 77                	je     11e6a <_CdromClassStartIo@8+0x3ea>
   11df3:	83 ec 0c             	sub    $0xc,%esp
   11df6:	6a 00                	push   $0x0
   11df8:	6a 00                	push   $0x0
   11dfa:	6a 00                	push   $0x0
   11dfc:	6a 08                	push   $0x8
   11dfe:	57                   	push   %edi
   11dff:	e8 3c 07 00 00       	call   12540 <_IoAllocateMdl@20>
   11e04:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   11e07:	83 c4 0c             	add    $0xc,%esp
   11e0a:	85 c0                	test   %eax,%eax
   11e0c:	89 42 04             	mov    %eax,0x4(%edx)
   11e0f:	75 3f                	jne    11e50 <_CdromClassStartIo@8+0x3d0>
   11e11:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   11e18:	c7 46 18 9a 00 00 c0 	movl   $0xc000009a,0x18(%esi)
   11e1f:	50                   	push   %eax
   11e20:	50                   	push   %eax
   11e21:	6a 04                	push   $0x4
   11e23:	56                   	push   %esi
   11e24:	e8 b7 06 00 00       	call   124e0 <_IoCompleteRequest@8>
   11e29:	50                   	push   %eax
   11e2a:	57                   	push   %edi
   11e2b:	e8 30 06 00 00       	call   12460 <_ExFreePool@4>
   11e30:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
   11e33:	56                   	push   %esi
   11e34:	e8 27 06 00 00       	call   12460 <_ExFreePool@4>
   11e39:	53                   	push   %ebx
   11e3a:	e8 21 06 00 00       	call   12460 <_ExFreePool@4>
   11e3f:	8b 5d e8             	mov    0xffffffe8(%ebp),%ebx
   11e42:	53                   	push   %ebx
   11e43:	e8 e8 06 00 00       	call   12530 <_IoFreeIrp@4>
   11e48:	83 c4 0c             	add    $0xc,%esp
   11e4b:	e9 37 ff ff ff       	jmp    11d87 <_CdromClassStartIo@8+0x307>
   11e50:	83 ec 0c             	sub    $0xc,%esp
   11e53:	50                   	push   %eax
   11e54:	e8 f7 06 00 00       	call   12550 <_MmBuildMdlForNonPagedPool@4>
   11e59:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11e5c:	83 c4 0c             	add    $0xc,%esp
   11e5f:	89 7b 18             	mov    %edi,0x18(%ebx)
   11e62:	89 45 0c             	mov    %eax,0xc(%ebp)
   11e65:	e9 65 fc ff ff       	jmp    11acf <_CdromClassStartIo@8+0x4f>
   11e6a:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   11e71:	c7 46 18 9a 00 00 c0 	movl   $0xc000009a,0x18(%esi)
   11e78:	50                   	push   %eax
   11e79:	50                   	push   %eax
   11e7a:	6a 04                	push   $0x4
   11e7c:	56                   	push   %esi
   11e7d:	e8 5e 06 00 00       	call   124e0 <_IoCompleteRequest@8>
   11e82:	50                   	push   %eax
   11e83:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11e86:	50                   	push   %eax
   11e87:	e8 d4 05 00 00       	call   12460 <_ExFreePool@4>
   11e8c:	eb ab                	jmp    11e39 <_CdromClassStartIo@8+0x3b9>
   11e8e:	89 f6                	mov    %esi,%esi

00011e90 <_CdromDeviceControlCompletion@12>:


NTSTATUS STDCALL
CdromDeviceControlCompletion (IN PDEVICE_OBJECT DeviceObject,
			      IN PIRP Irp,
			      IN PVOID Context)
{
   11e90:	55                   	push   %ebp
   11e91:	89 e5                	mov    %esp,%ebp
   11e93:	57                   	push   %edi
   11e94:	56                   	push   %esi
   11e95:	53                   	push   %ebx
   11e96:	83 ec 1c             	sub    $0x1c,%esp
  PDEVICE_EXTENSION DeviceExtension;
  PDEVICE_EXTENSION PhysicalExtension;
  PIO_STACK_LOCATION IrpStack;
  PIO_STACK_LOCATION OrigCurrentIrpStack;
  PIO_STACK_LOCATION OrigNextIrpStack;
  PSCSI_REQUEST_BLOCK Srb;
  PIRP OrigIrp;
  BOOLEAN Retry;
  NTSTATUS Status;

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

  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
   11e99:	8b 45 08             	mov    0x8(%ebp),%eax
  PhysicalExtension = (PDEVICE_EXTENSION)DeviceExtension->PhysicalDevice->DeviceExtension;
  Srb = (PSCSI_REQUEST_BLOCK) Context;

  IrpStack = IoGetCurrentIrpStackLocation (Irp);
   11e9c:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   11e9f:	8b 78 28             	mov    0x28(%eax),%edi
   11ea2:	8b 47 48             	mov    0x48(%edi),%eax
   11ea5:	8b 40 28             	mov    0x28(%eax),%eax
   11ea8:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   11eab:	8b 51 60             	mov    0x60(%ecx),%edx

  /* Get the original IRP */
  OrigIrp = (PIRP)IrpStack->Parameters.Others.Argument2;
  OrigCurrentIrpStack = IoGetCurrentIrpStackLocation (OrigIrp);
  OrigNextIrpStack = IoGetNextIrpStackLocation (OrigIrp);

  if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_SUCCESS)
   11eae:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11eb1:	8b 42 08             	mov    0x8(%edx),%eax
   11eb4:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11eb7:	8b 58 60             	mov    0x60(%eax),%ebx
   11eba:	31 c0                	xor    %eax,%eax
   11ebc:	8a 41 03             	mov    0x3(%ecx),%al
   11ebf:	24 3f                	and    $0x3f,%al
   11ec1:	8d 73 dc             	lea    0xffffffdc(%ebx),%esi
   11ec4:	48                   	dec    %eax
   11ec5:	0f 84 95 03 00 00    	je     12260 <_CdromDeviceControlCompletion@12+0x3d0>
    {
      Status = STATUS_SUCCESS;
    }
  else
    {
      DPRINT ("SrbStatus %lx\n", Srb->SrbStatus);

      /* Interpret sense info */
      Retry = ScsiClassInterpretSenseInfo (DeviceObject,
   11ecb:	50                   	push   %eax
   11ecc:	50                   	push   %eax
   11ecd:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11ed0:	50                   	push   %eax
   11ed1:	b8 0f 00 00 00       	mov    $0xf,%eax
   11ed6:	8b 4e 04             	mov    0x4(%esi),%ecx
   11ed9:	29 c8                	sub    %ecx,%eax
   11edb:	50                   	push   %eax
   11edc:	8b 42 0c             	mov    0xc(%edx),%eax
   11edf:	50                   	push   %eax
   11ee0:	31 c0                	xor    %eax,%eax
   11ee2:	8a 02                	mov    (%edx),%al
   11ee4:	50                   	push   %eax
   11ee5:	8b 45 10             	mov    0x10(%ebp),%eax
   11ee8:	50                   	push   %eax
   11ee9:	8b 45 08             	mov    0x8(%ebp),%eax
   11eec:	50                   	push   %eax
   11eed:	e8 1e 05 00 00       	call   12410 <_ScsiClassInterpretSenseInfo@24>
					   Srb,
					   IrpStack->MajorFunction,
					   IrpStack->Parameters.DeviceIoControl.IoControlCode,
					   MAXIMUM_RETRIES - (ULONG)OrigNextIrpStack->Parameters.Others.Argument1,
					   &Status);
      DPRINT ("Retry %u\n", Retry);

      if (Retry == TRUE &&
   11ef2:	5a                   	pop    %edx
   11ef3:	fe c8                	dec    %al
   11ef5:	59                   	pop    %ecx
   11ef6:	0f 84 54 01 00 00    	je     12050 <_CdromDeviceControlCompletion@12+0x1c0>
	  (ULONG)OrigNextIrpStack->Parameters.Others.Argument1 > 0)
	{
	  DPRINT1 ("Try again (Retry count %lu)\n",
		   (ULONG)OrigNextIrpStack->Parameters.Others.Argument1);

	  (ULONG)OrigNextIrpStack->Parameters.Others.Argument1--;

	  /* Release 'old' buffers */
	  ExFreePool (Srb->SenseInfoBuffer);
	  if (Srb->DataBuffer)
	    ExFreePool(Srb->DataBuffer);
	  ExFreePool(Srb);

	  if (Irp->MdlAddress != NULL)
	    IoFreeMdl(Irp->MdlAddress);

	  IoFreeIrp(Irp);

	  /* Call the StartIo routine again */
	  CdromClassStartIo (DeviceObject,
			     OrigIrp);

	  return STATUS_MORE_PROCESSING_REQUIRED;
	}

      DPRINT ("Status %lx\n", Status);
    }

  if (NT_SUCCESS (Status))
   11efc:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11eff:	85 c0                	test   %eax,%eax
   11f01:	78 2a                	js     11f2d <_CdromDeviceControlCompletion@12+0x9d>
    {
      switch (OrigCurrentIrpStack->Parameters.DeviceIoControl.IoControlCode)
   11f03:	8b 43 0c             	mov    0xc(%ebx),%eax
   11f06:	3d 4c 40 02 00       	cmp    $0x2404c,%eax
   11f0b:	0f 84 f2 01 00 00    	je     12103 <_CdromDeviceControlCompletion@12+0x273>
   11f11:	3d 00 48 02 00       	cmp    $0x24800,%eax
   11f16:	0f 84 04 03 00 00    	je     12220 <_CdromDeviceControlCompletion@12+0x390>
	{
	  case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
	    {
	      PREAD_CAPACITY_DATA CapacityBuffer;
	      ULONG LastSector;
	      ULONG SectorSize;

	      DPRINT ("CdromClassControlCompletion: IOCTL_CDROM_GET_DRIVE_GEOMETRY\n");

	      CapacityBuffer = (PREAD_CAPACITY_DATA)Srb->DataBuffer;
	      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];

	      if (SectorSize == 0)
		SectorSize = 2048;
	      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);

	      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;

	      RtlCopyMemory (OrigIrp->AssociatedIrp.SystemBuffer,
			     DeviceExtension->DiskGeometry,
			     sizeof(DISK_GEOMETRY));
	      OrigIrp->IoStatus.Information = sizeof(DISK_GEOMETRY);
	    }
	    break;

	  case IOCTL_CDROM_CHECK_VERIFY:
	    DPRINT ("CdromDeviceControlCompletion: IOCTL_CDROM_CHECK_VERIFY\n");
	    if (OrigCurrentIrpStack->Parameters.DeviceIoControl.OutputBufferLength != 0)
	      {
		/* Return the media change counter */
		*((PULONG)(OrigIrp->AssociatedIrp.SystemBuffer)) =
		  PhysicalExtension->MediaChangeCount;
		OrigIrp->IoStatus.Information = sizeof(ULONG);
	      }
	    else
	      {
		OrigIrp->IoStatus.Information = 0;
	      }
	    break;

	  default:
	    OrigIrp->IoStatus.Information = 0;
   11f1c:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   11f1f:	c7 41 1c 00 00 00 00 	movl   $0x0,0x1c(%ecx)
	    Status = STATUS_INVALID_DEVICE_REQUEST;
   11f26:	c7 45 f0 10 00 00 c0 	movl   $0xc0000010,0xfffffff0(%ebp)
	    break;
	}
    }

  /* Release the SRB and associated buffers */
  if (Srb != NULL)
   11f2d:	8b 45 10             	mov    0x10(%ebp),%eax
   11f30:	85 c0                	test   %eax,%eax
   11f32:	74 2b                	je     11f5f <_CdromDeviceControlCompletion@12+0xcf>
    {
      DPRINT("Srb %p\n", Srb);

      if (Srb->DataBuffer != NULL)
   11f34:	8b 55 10             	mov    0x10(%ebp),%edx
   11f37:	8b 42 18             	mov    0x18(%edx),%eax
   11f3a:	85 c0                	test   %eax,%eax
   11f3c:	0f 85 b0 01 00 00    	jne    120f2 <_CdromDeviceControlCompletion@12+0x262>
	ExFreePool (Srb->DataBuffer);

      if (Srb->SenseInfoBuffer != NULL)
   11f42:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11f45:	8b 41 1c             	mov    0x1c(%ecx),%eax
   11f48:	85 c0                	test   %eax,%eax
   11f4a:	0f 85 91 01 00 00    	jne    120e1 <_CdromDeviceControlCompletion@12+0x251>
	ExFreePool (Srb->SenseInfoBuffer);

      ExFreePool (Srb);
   11f50:	83 ec 0c             	sub    $0xc,%esp
   11f53:	8b 45 10             	mov    0x10(%ebp),%eax
   11f56:	50                   	push   %eax
   11f57:	e8 04 05 00 00       	call   12460 <_ExFreePool@4>
   11f5c:	83 c4 0c             	add    $0xc,%esp
    }

  if (OrigIrp->PendingReturned)
   11f5f:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11f62:	80 78 21 00          	cmpb   $0x0,0x21(%eax)
   11f66:	74 07                	je     11f6f <_CdromDeviceControlCompletion@12+0xdf>
    {
      IoMarkIrpPending (OrigIrp);
   11f68:	8b 40 60             	mov    0x60(%eax),%eax
   11f6b:	80 48 03 01          	orb    $0x1,0x3(%eax)
    }

  /* Release the MDL */
  if (Irp->MdlAddress != NULL)
   11f6f:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   11f72:	8b 41 04             	mov    0x4(%ecx),%eax
   11f75:	85 c0                	test   %eax,%eax
   11f77:	75 47                	jne    11fc0 <_CdromDeviceControlCompletion@12+0x130>
    {
      IoFreeMdl (Irp->MdlAddress);
    }

  /* Release the sub irp */
  IoFreeIrp (Irp);
   11f79:	83 ec 0c             	sub    $0xc,%esp
   11f7c:	8b 7d 0c             	mov    0xc(%ebp),%edi
   11f7f:	57                   	push   %edi
   11f80:	e8 ab 05 00 00       	call   12530 <_IoFreeIrp@4>

  /* Set io status information */
  OrigIrp->IoStatus.Status = Status;
   11f85:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11f88:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
  if (!NT_SUCCESS(Status) && IoIsErrorUserInduced (Status))
   11f8b:	83 c4 0c             	add    $0xc,%esp
   11f8e:	85 c9                	test   %ecx,%ecx
   11f90:	89 48 18             	mov    %ecx,0x18(%eax)
   11f93:	78 53                	js     11fe8 <_CdromDeviceControlCompletion@12+0x158>
    {
      IoSetHardErrorOrVerifyDevice (OrigIrp,
				    DeviceObject);
      OrigIrp->IoStatus.Information = 0;
    }

  /* Complete the original IRP */
  IoCompleteRequest (OrigIrp,
   11f95:	50                   	push   %eax
   11f96:	50                   	push   %eax
   11f97:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11f9a:	6a 04                	push   $0x4
   11f9c:	50                   	push   %eax
   11f9d:	e8 3e 05 00 00       	call   124e0 <_IoCompleteRequest@8>
		     IO_DISK_INCREMENT);
  IoStartNextPacket (DeviceObject,
   11fa2:	8b 45 08             	mov    0x8(%ebp),%eax
   11fa5:	6a 00                	push   $0x0
   11fa7:	50                   	push   %eax
   11fa8:	e8 63 05 00 00       	call   12510 <_IoStartNextPacket@8>
		     FALSE);

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

  return STATUS_MORE_PROCESSING_REQUIRED;
}
   11fad:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11fb0:	b8 16 00 00 c0       	mov    $0xc0000016,%eax
   11fb5:	5b                   	pop    %ebx
   11fb6:	5e                   	pop    %esi
   11fb7:	5f                   	pop    %edi
   11fb8:	5d                   	pop    %ebp
   11fb9:	c2 0c 00             	ret    $0xc
   11fbc:	8d 74 26 00          	lea    0x0(%esi),%esi
   11fc0:	83 ec 0c             	sub    $0xc,%esp
   11fc3:	50                   	push   %eax
   11fc4:	e8 97 05 00 00       	call   12560 <_IoFreeMdl@4>
   11fc9:	83 c4 0c             	add    $0xc,%esp
   11fcc:	8b 7d 0c             	mov    0xc(%ebp),%edi
   11fcf:	83 ec 0c             	sub    $0xc,%esp
   11fd2:	57                   	push   %edi
   11fd3:	e8 58 05 00 00       	call   12530 <_IoFreeIrp@4>
   11fd8:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11fdb:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   11fde:	83 c4 0c             	add    $0xc,%esp
   11fe1:	85 c9                	test   %ecx,%ecx
   11fe3:	89 48 18             	mov    %ecx,0x18(%eax)
   11fe6:	79 ad                	jns    11f95 <_CdromDeviceControlCompletion@12+0x105>
   11fe8:	81 f9 a3 00 00 c0    	cmp    $0xc00000a3,%ecx
   11fee:	0f 94 c2             	sete   %dl
   11ff1:	81 f9 b5 00 00 c0    	cmp    $0xc00000b5,%ecx
   11ff7:	0f 94 c0             	sete   %al
   11ffa:	09 d0                	or     %edx,%eax
   11ffc:	a8 01                	test   $0x1,%al
   11ffe:	75 30                	jne    12030 <_CdromDeviceControlCompletion@12+0x1a0>
   12000:	81 f9 a2 00 00 c0    	cmp    $0xc00000a2,%ecx
   12006:	74 28                	je     12030 <_CdromDeviceControlCompletion@12+0x1a0>
   12008:	81 f9 06 00 00 c1    	cmp    $0xc1000006,%ecx
   1200e:	74 20                	je     12030 <_CdromDeviceControlCompletion@12+0x1a0>
   12010:	81 f9 16 00 00 80    	cmp    $0x80000016,%ecx
   12016:	74 18                	je     12030 <_CdromDeviceControlCompletion@12+0x1a0>
   12018:	81 f9 14 00 00 c0    	cmp    $0xc0000014,%ecx
   1201e:	74 10                	je     12030 <_CdromDeviceControlCompletion@12+0x1a0>
   12020:	81 f9 12 00 00 c0    	cmp    $0xc0000012,%ecx
   12026:	0f 85 69 ff ff ff    	jne    11f95 <_CdromDeviceControlCompletion@12+0x105>
   1202c:	8d 74 26 00          	lea    0x0(%esi),%esi
   12030:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12033:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   12036:	56                   	push   %esi
   12037:	56                   	push   %esi
   12038:	53                   	push   %ebx
   12039:	51                   	push   %ecx
   1203a:	e8 91 04 00 00       	call   124d0 <_IoSetHardErrorOrVerifyDevice@8>
   1203f:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   12042:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   12049:	58                   	pop    %eax
   1204a:	5a                   	pop    %edx
   1204b:	e9 45 ff ff ff       	jmp    11f95 <_CdromDeviceControlCompletion@12+0x105>
   12050:	8b 46 04             	mov    0x4(%esi),%eax
   12053:	85 c0                	test   %eax,%eax
   12055:	0f 84 a1 fe ff ff    	je     11efc <_CdromDeviceControlCompletion@12+0x6c>
   1205b:	51                   	push   %ecx
   1205c:	68 c1 05 00 00       	push   $0x5c1
   12061:	68 00 30 01 00       	push   $0x13000
   12066:	68 08 30 01 00       	push   $0x13008
   1206b:	e8 80 05 00 00       	call   125f0 <_DbgPrint>
   12070:	58                   	pop    %eax
   12071:	8b 46 04             	mov    0x4(%esi),%eax
   12074:	5a                   	pop    %edx
   12075:	50                   	push   %eax
   12076:	68 be 31 01 00       	push   $0x131be
   1207b:	e8 70 05 00 00       	call   125f0 <_DbgPrint>
   12080:	8b 46 04             	mov    0x4(%esi),%eax
   12083:	48                   	dec    %eax
   12084:	89 46 04             	mov    %eax,0x4(%esi)
   12087:	58                   	pop    %eax
   12088:	8b 45 10             	mov    0x10(%ebp),%eax
   1208b:	8b 78 1c             	mov    0x1c(%eax),%edi
   1208e:	57                   	push   %edi
   1208f:	e8 cc 03 00 00       	call   12460 <_ExFreePool@4>
   12094:	8b 55 10             	mov    0x10(%ebp),%edx
   12097:	83 c4 0c             	add    $0xc,%esp
   1209a:	8b 42 18             	mov    0x18(%edx),%eax
   1209d:	85 c0                	test   %eax,%eax
   1209f:	0f 85 d8 01 00 00    	jne    1227d <_CdromDeviceControlCompletion@12+0x3ed>
   120a5:	83 ec 0c             	sub    $0xc,%esp
   120a8:	8b 75 10             	mov    0x10(%ebp),%esi
   120ab:	56                   	push   %esi
   120ac:	e8 af 03 00 00       	call   12460 <_ExFreePool@4>
   120b1:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   120b4:	83 c4 0c             	add    $0xc,%esp
   120b7:	8b 41 04             	mov    0x4(%ecx),%eax
   120ba:	85 c0                	test   %eax,%eax
   120bc:	0f 85 aa 01 00 00    	jne    1226c <_CdromDeviceControlCompletion@12+0x3dc>
   120c2:	83 ec 0c             	sub    $0xc,%esp
   120c5:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   120c8:	53                   	push   %ebx
   120c9:	e8 62 04 00 00       	call   12530 <_IoFreeIrp@4>
   120ce:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   120d1:	59                   	pop    %ecx
   120d2:	8b 45 08             	mov    0x8(%ebp),%eax
   120d5:	52                   	push   %edx
   120d6:	50                   	push   %eax
   120d7:	e8 a4 f9 ff ff       	call   11a80 <_CdromClassStartIo@8>
   120dc:	e9 cc fe ff ff       	jmp    11fad <_CdromDeviceControlCompletion@12+0x11d>
   120e1:	83 ec 0c             	sub    $0xc,%esp
   120e4:	50                   	push   %eax
   120e5:	e8 76 03 00 00       	call   12460 <_ExFreePool@4>
   120ea:	83 c4 0c             	add    $0xc,%esp
   120ed:	e9 5e fe ff ff       	jmp    11f50 <_CdromDeviceControlCompletion@12+0xc0>
   120f2:	83 ec 0c             	sub    $0xc,%esp
   120f5:	50                   	push   %eax
   120f6:	e8 65 03 00 00       	call   12460 <_ExFreePool@4>
   120fb:	83 c4 0c             	add    $0xc,%esp
   120fe:	e9 3f fe ff ff       	jmp    11f42 <_CdromDeviceControlCompletion@12+0xb2>
   12103:	8b 45 10             	mov    0x10(%ebp),%eax
   12106:	31 c9                	xor    %ecx,%ecx
   12108:	31 db                	xor    %ebx,%ebx
   1210a:	8b 50 18             	mov    0x18(%eax),%edx
   1210d:	31 c0                	xor    %eax,%eax
   1210f:	8a 4a 04             	mov    0x4(%edx),%cl
   12112:	8a 42 05             	mov    0x5(%edx),%al
   12115:	c1 e0 10             	shl    $0x10,%eax
   12118:	8a 5a 07             	mov    0x7(%edx),%bl
   1211b:	c1 e1 18             	shl    $0x18,%ecx
   1211e:	09 c1                	or     %eax,%ecx
   12120:	31 c0                	xor    %eax,%eax
   12122:	8a 42 06             	mov    0x6(%edx),%al
   12125:	c1 e0 08             	shl    $0x8,%eax
   12128:	09 c1                	or     %eax,%ecx
   1212a:	8a 02                	mov    (%edx),%al
   1212c:	25 ff 00 00 00       	and    $0xff,%eax
   12131:	89 c6                	mov    %eax,%esi
   12133:	31 c0                	xor    %eax,%eax
   12135:	c1 e6 18             	shl    $0x18,%esi
   12138:	8a 42 01             	mov    0x1(%edx),%al
   1213b:	c1 e0 10             	shl    $0x10,%eax
   1213e:	09 c6                	or     %eax,%esi
   12140:	31 c0                	xor    %eax,%eax
   12142:	8a 42 02             	mov    0x2(%edx),%al
   12145:	c1 e0 08             	shl    $0x8,%eax
   12148:	09 c6                	or     %eax,%esi
   1214a:	31 c0                	xor    %eax,%eax
   1214c:	8a 42 03             	mov    0x3(%edx),%al
   1214f:	09 c6                	or     %eax,%esi
   12151:	89 c8                	mov    %ecx,%eax
   12153:	09 d8                	or     %ebx,%eax
   12155:	0f 84 ec 00 00 00    	je     12247 <_CdromDeviceControlCompletion@12+0x3b7>
   1215b:	46                   	inc    %esi
   1215c:	8b 57 44             	mov    0x44(%edi),%edx
   1215f:	89 75 e4             	mov    %esi,0xffffffe4(%ebp)
   12162:	31 f6                	xor    %esi,%esi
   12164:	8b 5d e4             	mov    0xffffffe4(%ebp),%ebx
   12167:	89 42 14             	mov    %eax,0x14(%edx)
   1216a:	89 5f 08             	mov    %ebx,0x8(%edi)
   1216d:	89 77 0c             	mov    %esi,0xc(%edi)
   12170:	c6 87 c0 00 00 00 00 	movb   $0x0,0xc0(%edi)
   12177:	8a 8f c0 00 00 00    	mov    0xc0(%edi),%cl
   1217d:	8b 42 14             	mov    0x14(%edx),%eax
   12180:	d3 e8                	shr    %cl,%eax
   12182:	48                   	dec    %eax
   12183:	74 0c                	je     12191 <_CdromDeviceControlCompletion@12+0x301>
   12185:	41                   	inc    %ecx
   12186:	88 8f c0 00 00 00    	mov    %cl,0xc0(%edi)
   1218c:	80 f9 1f             	cmp    $0x1f,%cl
   1218f:	76 e6                	jbe    12177 <_CdromDeviceControlCompletion@12+0x2e7>
   12191:	0f a5 de             	shld   %cl,%ebx,%esi
   12194:	d3 e3                	shl    %cl,%ebx
   12196:	83 e1 20             	and    $0x20,%ecx
   12199:	74 04                	je     1219f <_CdromDeviceControlCompletion@12+0x30f>
   1219b:	89 de                	mov    %ebx,%esi
   1219d:	31 db                	xor    %ebx,%ebx
   1219f:	8b 4d 08             	mov    0x8(%ebp),%ecx
   121a2:	89 5f 08             	mov    %ebx,0x8(%edi)
   121a5:	89 77 0c             	mov    %esi,0xc(%edi)
   121a8:	8b 41 20             	mov    0x20(%ecx),%eax
   121ab:	83 e0 01             	and    $0x1,%eax
   121ae:	83 f8 01             	cmp    $0x1,%eax
   121b1:	19 c0                	sbb    %eax,%eax
   121b3:	83 f0 ff             	xor    $0xffffffff,%eax
   121b6:	83 c0 0c             	add    $0xc,%eax
   121b9:	89 42 08             	mov    %eax,0x8(%edx)
   121bc:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   121bf:	c1 e8 0b             	shr    $0xb,%eax
   121c2:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   121c5:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   121c8:	c7 42 04 00 00 00 00 	movl   $0x0,0x4(%edx)
   121cf:	89 02                	mov    %eax,(%edx)
   121d1:	8b 57 44             	mov    0x44(%edi),%edx
   121d4:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   121d7:	c7 42 10 20 00 00 00 	movl   $0x20,0x10(%edx)
   121de:	c7 42 0c 40 00 00 00 	movl   $0x40,0xc(%edx)
   121e5:	8b 48 0c             	mov    0xc(%eax),%ecx
   121e8:	8b 02                	mov    (%edx),%eax
   121ea:	89 01                	mov    %eax,(%ecx)
   121ec:	8b 42 04             	mov    0x4(%edx),%eax
   121ef:	89 41 04             	mov    %eax,0x4(%ecx)
   121f2:	8b 42 08             	mov    0x8(%edx),%eax
   121f5:	89 41 08             	mov    %eax,0x8(%ecx)
   121f8:	8b 42 0c             	mov    0xc(%edx),%eax
   121fb:	89 41 0c             	mov    %eax,0xc(%ecx)
   121fe:	8b 42 10             	mov    0x10(%edx),%eax
   12201:	89 41 10             	mov    %eax,0x10(%ecx)
   12204:	8b 42 14             	mov    0x14(%edx),%eax
   12207:	89 41 14             	mov    %eax,0x14(%ecx)
   1220a:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   1220d:	c7 42 1c 18 00 00 00 	movl   $0x18,0x1c(%edx)
   12214:	e9 14 fd ff ff       	jmp    11f2d <_CdromDeviceControlCompletion@12+0x9d>
   12219:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   12220:	8b 43 04             	mov    0x4(%ebx),%eax
   12223:	85 c0                	test   %eax,%eax
   12225:	74 2a                	je     12251 <_CdromDeviceControlCompletion@12+0x3c1>
   12227:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   1222a:	8b 51 0c             	mov    0xc(%ecx),%edx
   1222d:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   12230:	8b 81 d0 00 00 00    	mov    0xd0(%ecx),%eax
   12236:	89 02                	mov    %eax,(%edx)
   12238:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   1223b:	c7 40 1c 04 00 00 00 	movl   $0x4,0x1c(%eax)
   12242:	e9 e6 fc ff ff       	jmp    11f2d <_CdromDeviceControlCompletion@12+0x9d>
   12247:	b8 00 08 00 00       	mov    $0x800,%eax
   1224c:	e9 0a ff ff ff       	jmp    1215b <_CdromDeviceControlCompletion@12+0x2cb>
   12251:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   12254:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   1225b:	e9 cd fc ff ff       	jmp    11f2d <_CdromDeviceControlCompletion@12+0x9d>
   12260:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   12267:	e9 90 fc ff ff       	jmp    11efc <_CdromDeviceControlCompletion@12+0x6c>
   1226c:	83 ec 0c             	sub    $0xc,%esp
   1226f:	50                   	push   %eax
   12270:	e8 eb 02 00 00       	call   12560 <_IoFreeMdl@4>
   12275:	83 c4 0c             	add    $0xc,%esp
   12278:	e9 45 fe ff ff       	jmp    120c2 <_CdromDeviceControlCompletion@12+0x232>
   1227d:	83 ec 0c             	sub    $0xc,%esp
   12280:	50                   	push   %eax
   12281:	e8 da 01 00 00       	call   12460 <_ExFreePool@4>
   12286:	83 c4 0c             	add    $0xc,%esp
   12289:	e9 17 fe ff ff       	jmp    120a5 <_CdromDeviceControlCompletion@12+0x215>
   1228e:	89 f6                	mov    %esi,%esi

00012290 <_CdromTimerRoutine@8>:


VOID STDCALL
CdromTimerRoutine(IN PDEVICE_OBJECT DeviceObject,
		  IN PVOID Context)
{
   12290:	55                   	push   %ebp
   12291:	89 e5                	mov    %esp,%ebp
   12293:	83 ec 14             	sub    $0x14,%esp
  PIO_WORKITEM WorkItem;

  DPRINT ("CdromTimerRoutine() called\n");
  WorkItem = IoAllocateWorkItem(DeviceObject);
   12296:	8b 45 08             	mov    0x8(%ebp),%eax
   12299:	50                   	push   %eax
   1229a:	e8 d1 02 00 00       	call   12570 <_IoAllocateWorkItem@4>
  if (!WorkItem)
   1229f:	83 c4 0c             	add    $0xc,%esp
   122a2:	85 c0                	test   %eax,%eax
   122a4:	74 0e                	je     122b4 <_CdromTimerRoutine@8+0x24>
    {
      return;
    }

  IoQueueWorkItem(WorkItem,
   122a6:	50                   	push   %eax
   122a7:	6a 01                	push   $0x1
   122a9:	68 c0 22 01 00       	push   $0x122c0
   122ae:	50                   	push   %eax
   122af:	e8 cc 02 00 00       	call   12580 <_IoQueueWorkItem@16>
		  CdromWorkItem,
		  DelayedWorkQueue,
		  WorkItem);
}
   122b4:	c9                   	leave  
   122b5:	c2 08 00             	ret    $0x8
   122b8:	90                   	nop    
   122b9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000122c0 <_CdromWorkItem>:


VOID
CdromWorkItem(IN PDEVICE_OBJECT DeviceObject,
	      IN PVOID Context)
{
   122c0:	55                   	push   %ebp
   122c1:	89 e5                	mov    %esp,%ebp
   122c3:	56                   	push   %esi
   122c4:	53                   	push   %ebx
   122c5:	83 ec 2c             	sub    $0x2c,%esp
  PIRP Irp;
  KEVENT Event;
  IO_STATUS_BLOCK IoStatus;
  NTSTATUS Status;

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

  IoFreeWorkItem((PIO_WORKITEM) Context);
   122c8:	8b 45 0c             	mov    0xc(%ebp),%eax
   122cb:	8b 75 08             	mov    0x8(%ebp),%esi
   122ce:	50                   	push   %eax
   122cf:	e8 bc 02 00 00       	call   12590 <_IoFreeWorkItem@4>

  KeInitializeEvent(&Event,
   122d4:	5b                   	pop    %ebx
   122d5:	8d 5d e8             	lea    0xffffffe8(%ebp),%ebx
   122d8:	58                   	pop    %eax
   122d9:	6a 00                	push   $0x0
   122db:	6a 00                	push   $0x0
   122dd:	53                   	push   %ebx
   122de:	e8 bd 02 00 00       	call   125a0 <_KeInitializeEvent@12>
		    NotificationEvent,
		    FALSE);

  Irp = IoBuildDeviceIoControlRequest(IOCTL_CDROM_CHECK_VERIFY,
   122e3:	8d 45 e0             	lea    0xffffffe0(%ebp),%eax
   122e6:	51                   	push   %ecx
   122e7:	51                   	push   %ecx
   122e8:	50                   	push   %eax
   122e9:	53                   	push   %ebx
   122ea:	6a 00                	push   $0x0
   122ec:	6a 00                	push   $0x0
   122ee:	6a 00                	push   $0x0
   122f0:	6a 00                	push   $0x0
   122f2:	6a 00                	push   $0x0
   122f4:	56                   	push   %esi
   122f5:	68 00 48 02 00       	push   $0x24800
   122fa:	e8 b1 02 00 00       	call   125b0 <_IoBuildDeviceIoControlRequest@36>
				      DeviceObject,
				      NULL,
				      0,
				      NULL,
				      0,
				      FALSE,
				      &Event,
				      &IoStatus);
  if (Irp == NULL)
   122ff:	83 c4 0c             	add    $0xc,%esp
   12302:	85 c0                	test   %eax,%eax
   12304:	74 12                	je     12318 <_CdromWorkItem+0x58>
    {
      DPRINT("IoBuildDeviceIoControlRequest failed\n");
      return;
    }

  Status = IoCallDriver(DeviceObject, Irp);
   12306:	52                   	push   %edx
   12307:	52                   	push   %edx
   12308:	50                   	push   %eax
   12309:	56                   	push   %esi
   1230a:	e8 f1 01 00 00       	call   12500 <_IoCallDriver@8>
  DPRINT("Status: %x\n", Status);

  if (Status == STATUS_PENDING)
   1230f:	5a                   	pop    %edx
   12310:	3d 03 01 00 00       	cmp    $0x103,%eax
   12315:	59                   	pop    %ecx
   12316:	74 07                	je     1231f <_CdromWorkItem+0x5f>
    {
      KeWaitForSingleObject(&Event,
			    Suspended,
			    KernelMode,
			    FALSE,
			    NULL);
    }
}
   12318:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1231b:	5b                   	pop    %ebx
   1231c:	5e                   	pop    %esi
   1231d:	5d                   	pop    %ebp
   1231e:	c3                   	ret    
   1231f:	83 ec 0c             	sub    $0xc,%esp
   12322:	6a 00                	push   $0x0
   12324:	6a 00                	push   $0x0
   12326:	6a 00                	push   $0x0
   12328:	6a 05                	push   $0x5
   1232a:	53                   	push   %ebx
   1232b:	e8 90 02 00 00       	call   125c0 <_KeWaitForSingleObject@20>
   12330:	83 c4 0c             	add    $0xc,%esp
   12333:	eb e3                	jmp    12318 <_CdromWorkItem+0x58>
   12335:	90                   	nop    
   12336:	90                   	nop    
   12337:	90                   	nop    
   12338:	90                   	nop    
   12339:	90                   	nop    
   1233a:	90                   	nop    
   1233b:	90                   	nop    
   1233c:	90                   	nop    
   1233d:	90                   	nop    
   1233e:	90                   	nop    
   1233f:	90                   	nop    

00012340 <_ScsiClassInitialize@12>:
   12340:	ff 25 1c 41 01 00    	jmp    *0x1411c
   12346:	90                   	nop    
   12347:	90                   	nop    
	...

00012350 <_ScsiClassGetCapabilities@8>:
   12350:	ff 25 14 41 01 00    	jmp    *0x14114
   12356:	90                   	nop    
   12357:	90                   	nop    
	...

00012360 <_ScsiClassGetInquiryData@8>:
   12360:	ff 25 18 41 01 00    	jmp    *0x14118
   12366:	90                   	nop    
   12367:	90                   	nop    
	...

00012370 <_ScsiClassFindUnclaimedDevices@8>:
   12370:	ff 25 10 41 01 00    	jmp    *0x14110
   12376:	90                   	nop    
   12377:	90                   	nop    
	...

00012380 <_ScsiClassClaimDevice@16>:
   12380:	ff 25 04 41 01 00    	jmp    *0x14104
   12386:	90                   	nop    
   12387:	90                   	nop    
	...

00012390 <_ScsiClassCreateDeviceObject@20>:
   12390:	ff 25 08 41 01 00    	jmp    *0x14108
   12396:	90                   	nop    
   12397:	90                   	nop    
	...

000123a0 <_ScsiClassQueryTimeOutRegistryValue@4>:
   123a0:	ff 25 28 41 01 00    	jmp    *0x14128
   123a6:	90                   	nop    
   123a7:	90                   	nop    
	...

000123b0 <_ScsiClassInitializeSrbLookasideList@8>:
   123b0:	ff 25 20 41 01 00    	jmp    *0x14120
   123b6:	90                   	nop    
   123b7:	90                   	nop    
	...

000123c0 <_ScsiClassReadDriveCapacity@4>:
   123c0:	ff 25 2c 41 01 00    	jmp    *0x1412c
   123c6:	90                   	nop    
   123c7:	90                   	nop    
	...

000123d0 <_ScsiClassSendSrbSynchronous@20>:
   123d0:	ff 25 30 41 01 00    	jmp    *0x14130
   123d6:	90                   	nop    
   123d7:	90                   	nop    
	...

000123e0 <_ScsiClassDeviceControl@8>:
   123e0:	ff 25 0c 41 01 00    	jmp    *0x1410c
   123e6:	90                   	nop    
   123e7:	90                   	nop    
	...

000123f0 <_ScsiClassSplitRequest@12>:
   123f0:	ff 25 34 41 01 00    	jmp    *0x14134
   123f6:	90                   	nop    
   123f7:	90                   	nop    
	...

00012400 <_ScsiClassBuildRequest@8>:
   12400:	ff 25 00 41 01 00    	jmp    *0x14100
   12406:	90                   	nop    
   12407:	90                   	nop    
	...

00012410 <_ScsiClassInterpretSenseInfo@24>:
   12410:	ff 25 24 41 01 00    	jmp    *0x14124
   12416:	90                   	nop    
   12417:	90                   	nop    
	...

00012420 <_IoGetConfigurationInformation@0>:
   12420:	ff 25 7c 41 01 00    	jmp    *0x1417c
   12426:	90                   	nop    
   12427:	90                   	nop    
	...

00012430 <_RtlZeroMemory@8>:
   12430:	ff 25 ac 41 01 00    	jmp    *0x141ac
   12436:	90                   	nop    
   12437:	90                   	nop    
	...

00012440 <_ExAllocatePool@8>:
   12440:	ff 25 44 41 01 00    	jmp    *0x14144
   12446:	90                   	nop    
   12447:	90                   	nop    
	...

00012450 <_IoDeleteDevice@4>:
   12450:	ff 25 6c 41 01 00    	jmp    *0x1416c
   12456:	90                   	nop    
   12457:	90                   	nop    
	...

00012460 <_ExFreePool@4>:
   12460:	ff 25 4c 41 01 00    	jmp    *0x1414c
   12466:	90                   	nop    
   12467:	90                   	nop    
	...

00012470 <_ExDeleteNPagedLookasideList@4>:
   12470:	ff 25 48 41 01 00    	jmp    *0x14148
   12476:	90                   	nop    
   12477:	90                   	nop    
	...

00012480 <_RtlInitUnicodeString@8>:
   12480:	ff 25 a8 41 01 00    	jmp    *0x141a8
   12486:	90                   	nop    
   12487:	90                   	nop    
	...

00012490 <_IoCreateSynchronizationEvent@8>:
   12490:	ff 25 68 41 01 00    	jmp    *0x14168
   12496:	90                   	nop    
   12497:	90                   	nop    
	...

000124a0 <_KeClearEvent@4>:
   124a0:	ff 25 98 41 01 00    	jmp    *0x14198
   124a6:	90                   	nop    
   124a7:	90                   	nop    
	...

000124b0 <_IoInitializeTimer@12>:
   124b0:	ff 25 80 41 01 00    	jmp    *0x14180
   124b6:	90                   	nop    
   124b7:	90                   	nop    
	...

000124c0 <_IoStartTimer@4>:
   124c0:	ff 25 94 41 01 00    	jmp    *0x14194
   124c6:	90                   	nop    
   124c7:	90                   	nop    
	...

000124d0 <_IoSetHardErrorOrVerifyDevice@8>:
   124d0:	ff 25 88 41 01 00    	jmp    *0x14188
   124d6:	90                   	nop    
   124d7:	90                   	nop    
	...

000124e0 <_IoCompleteRequest@8>:
   124e0:	ff 25 64 41 01 00    	jmp    *0x14164
   124e6:	90                   	nop    
   124e7:	90                   	nop    
	...

000124f0 <_IoStartPacket@16>:
   124f0:	ff 25 90 41 01 00    	jmp    *0x14190
   124f6:	90                   	nop    
   124f7:	90                   	nop    
	...

00012500 <_IoCallDriver@8>:
   12500:	ff 25 60 41 01 00    	jmp    *0x14160
   12506:	90                   	nop    
   12507:	90                   	nop    
	...

00012510 <_IoStartNextPacket@8>:
   12510:	ff 25 8c 41 01 00    	jmp    *0x1418c
   12516:	90                   	nop    
   12517:	90                   	nop    
	...

00012520 <_IoAllocateIrp@8>:
   12520:	ff 25 50 41 01 00    	jmp    *0x14150
   12526:	90                   	nop    
   12527:	90                   	nop    
	...

00012530 <_IoFreeIrp@4>:
   12530:	ff 25 70 41 01 00    	jmp    *0x14170
   12536:	90                   	nop    
   12537:	90                   	nop    
	...

00012540 <_IoAllocateMdl@20>:
   12540:	ff 25 54 41 01 00    	jmp    *0x14154
   12546:	90                   	nop    
   12547:	90                   	nop    
	...

00012550 <_MmBuildMdlForNonPagedPool@4>:
   12550:	ff 25 a4 41 01 00    	jmp    *0x141a4
   12556:	90                   	nop    
   12557:	90                   	nop    
	...

00012560 <_IoFreeMdl@4>:
   12560:	ff 25 74 41 01 00    	jmp    *0x14174
   12566:	90                   	nop    
   12567:	90                   	nop    
	...

00012570 <_IoAllocateWorkItem@4>:
   12570:	ff 25 58 41 01 00    	jmp    *0x14158
   12576:	90                   	nop    
   12577:	90                   	nop    
	...

00012580 <_IoQueueWorkItem@16>:
   12580:	ff 25 84 41 01 00    	jmp    *0x14184
   12586:	90                   	nop    
   12587:	90                   	nop    
	...

00012590 <_IoFreeWorkItem@4>:
   12590:	ff 25 78 41 01 00    	jmp    *0x14178
   12596:	90                   	nop    
   12597:	90                   	nop    
	...

000125a0 <_KeInitializeEvent@12>:
   125a0:	ff 25 9c 41 01 00    	jmp    *0x1419c
   125a6:	90                   	nop    
   125a7:	90                   	nop    
	...

000125b0 <_IoBuildDeviceIoControlRequest@36>:
   125b0:	ff 25 5c 41 01 00    	jmp    *0x1415c
   125b6:	90                   	nop    
   125b7:	90                   	nop    
	...

000125c0 <_KeWaitForSingleObject@20>:
   125c0:	ff 25 a0 41 01 00    	jmp    *0x141a0
   125c6:	90                   	nop    
   125c7:	90                   	nop    
	...

000125d0 <_sprintf>:
   125d0:	ff 25 b0 41 01 00    	jmp    *0x141b0
   125d6:	90                   	nop    
   125d7:	90                   	nop    
	...

000125e0 <_swprintf>:
   125e0:	ff 25 b4 41 01 00    	jmp    *0x141b4
   125e6:	90                   	nop    
   125e7:	90                   	nop    
	...

000125f0 <_DbgPrint>:
   125f0:	ff 25 40 41 01 00    	jmp    *0x14140
   125f6:	90                   	nop    
   125f7:	90                   	nop    
	...

00012600 <__CTOR_LIST__>:
   12600:	ff                   	(bad)  
   12601:	ff                   	(bad)  
   12602:	ff                   	(bad)  
   12603:	ff 00                	incl   (%eax)
   12605:	00 00                	add    %al,(%eax)
	...

00012608 <__DTOR_LIST__>:
   12608:	ff                   	(bad)  
   12609:	ff                   	(bad)  
   1260a:	ff                   	(bad)  
   1260b:	ff 00                	incl   (%eax)
   1260d:	00 00                	add    %al,(%eax)
	...
