
floppy.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <___crt_xc_end__>:
 * NOTES:
 *     - Must set an event to let other threads know we're done turning off the motor
 *     - Called back at DISPATCH_LEVEL
 */
{
   11000:	55                   	push   %ebp
   11001:	89 e5                	mov    %esp,%ebp
   11003:	53                   	push   %ebx
   11004:	51                   	push   %ecx
   11005:	8b 5d 0c             	mov    0xc(%ebp),%ebx
  PCONTROLLER_INFO ControllerInfo = (PCONTROLLER_INFO)DeferredContext;

  UNREFERENCED_PARAMETER(SystemArgument1);
  UNREFERENCED_PARAMETER(SystemArgument2);
  UNREFERENCED_PARAMETER(UnusedDpc);

  ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
   11008:	e8 c3 29 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   1100d:	3c 02                	cmp    $0x2,%al
   1100f:	74 01                	je     11012 <___crt_xc_end__+0x12>
   11011:	cc                   	int3   
  ASSERT(ControllerInfo);
   11012:	85 db                	test   %ebx,%ebx
   11014:	74 2a                	je     11040 <___crt_xc_end__+0x40>

  KdPrint(("floppy: MotorStopDpcFunc called\n"));

  HwTurnOffMotor(ControllerInfo);
   11016:	83 ec 0c             	sub    $0xc,%esp
   11019:	53                   	push   %ebx
   1101a:	e8 11 13 00 00       	call   12330 <_HwTurnOffMotor@4>
  ControllerInfo->StopDpcQueued = FALSE;
   1101f:	c6 83 38 12 00 00 00 	movb   $0x0,0x1238(%ebx)
  KeSetEvent(&ControllerInfo->MotorStoppedEvent, EVENT_INCREMENT, FALSE);
   11026:	58                   	pop    %eax
   11027:	8d 83 dd 11 00 00    	lea    0x11dd(%ebx),%eax
   1102d:	5a                   	pop    %edx
   1102e:	6a 00                	push   $0x0
   11030:	6a 01                	push   $0x1
   11032:	50                   	push   %eax
   11033:	e8 48 27 00 00       	call   13780 <_KeSetEvent@12>
   11038:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1103b:	c9                   	leave  
   1103c:	c2 10 00             	ret    $0x10
   1103f:	90                   	nop    
   11040:	cc                   	int3   
   11041:	eb d3                	jmp    11016 <___crt_xc_end__+0x16>
   11043:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11049:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011050 <_StartMotor@4>:
}


VOID NTAPI StartMotor(PDRIVE_INFO DriveInfo)
/*
 * FUNCTION: Start the motor, taking into account proper handling of the timer race
 * ARGUMENTS:
 *     DriveInfo: drive to start
 * NOTES:
 *     - Never call HwTurnOnMotor() directly
 *     - This protocol manages a race between the cancel timer and the requesting thread.
 *       You wouldn't want to turn on the motor and then cancel the timer, because the
 *       cancel dpc might fire in the meantime, and that'd un-do what you just did.  If you
 *       cancel the timer first, but KeCancelTimer returns false, the dpc is already running,
 *       so you have to wait until the dpc is completly done running, or else you'll race
 *       with the turner-offer
 *     - PAGED_CODE because we wait
 */
{
   11050:	55                   	push   %ebp
   11051:	89 e5                	mov    %esp,%ebp
   11053:	53                   	push   %ebx
   11054:	53                   	push   %ebx
   11055:	8b 5d 08             	mov    0x8(%ebp),%ebx
  PAGED_CODE();
   11058:	e8 73 29 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   1105d:	3c 01                	cmp    $0x1,%al
   1105f:	76 01                	jbe    11062 <_StartMotor@4+0x12>
   11061:	cc                   	int3   
  ASSERT(DriveInfo);
   11062:	85 db                	test   %ebx,%ebx
   11064:	74 7a                	je     110e0 <_StartMotor@4+0x90>

  KdPrint(("floppy: StartMotor called\n"));

  if(DriveInfo->ControllerInfo->StopDpcQueued && !KeCancelTimer(&DriveInfo->ControllerInfo->MotorTimer))
   11066:	8b 03                	mov    (%ebx),%eax
   11068:	80 b8 38 12 00 00 00 	cmpb   $0x0,0x1238(%eax)
   1106f:	75 1f                	jne    11090 <_StartMotor@4+0x40>
    {
      /* Motor turner-offer is already running; wait for it to finish */
      KdPrint(("floppy: StartMotor: motor turner-offer is already running; waiting for it\n"));
      KeWaitForSingleObject(&DriveInfo->ControllerInfo->MotorStoppedEvent, Executive, KernelMode, FALSE, NULL);
      KdPrint(("floppy: StartMotor: wait satisfied\n"));
    }

  DriveInfo->ControllerInfo->StopDpcQueued = FALSE;

  if(HwTurnOnMotor(DriveInfo) != STATUS_SUCCESS)
   11071:	83 ec 0c             	sub    $0xc,%esp
   11074:	c6 80 38 12 00 00 00 	movb   $0x0,0x1238(%eax)
   1107b:	53                   	push   %ebx
   1107c:	e8 cf 12 00 00       	call   12350 <_HwTurnOnMotor@4>
   11081:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11084:	83 c4 0c             	add    $0xc,%esp
   11087:	c9                   	leave  
   11088:	c2 04 00             	ret    $0x4
   1108b:	90                   	nop    
   1108c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11090:	83 ec 0c             	sub    $0xc,%esp
   11093:	05 f0 11 00 00       	add    $0x11f0,%eax
   11098:	50                   	push   %eax
   11099:	e8 f2 26 00 00       	call   13790 <_KeCancelTimer@4>
   1109e:	83 c4 0c             	add    $0xc,%esp
   110a1:	84 c0                	test   %al,%al
   110a3:	74 1c                	je     110c1 <_StartMotor@4+0x71>
   110a5:	8b 03                	mov    (%ebx),%eax
   110a7:	83 ec 0c             	sub    $0xc,%esp
   110aa:	c6 80 38 12 00 00 00 	movb   $0x0,0x1238(%eax)
   110b1:	53                   	push   %ebx
   110b2:	e8 99 12 00 00       	call   12350 <_HwTurnOnMotor@4>
   110b7:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   110ba:	83 c4 0c             	add    $0xc,%esp
   110bd:	c9                   	leave  
   110be:	c2 04 00             	ret    $0x4
   110c1:	83 ec 0c             	sub    $0xc,%esp
   110c4:	6a 00                	push   $0x0
   110c6:	6a 00                	push   $0x0
   110c8:	6a 00                	push   $0x0
   110ca:	6a 00                	push   $0x0
   110cc:	8b 03                	mov    (%ebx),%eax
   110ce:	05 dd 11 00 00       	add    $0x11dd,%eax
   110d3:	50                   	push   %eax
   110d4:	e8 c7 26 00 00       	call   137a0 <_KeWaitForSingleObject@20>
   110d9:	8b 03                	mov    (%ebx),%eax
   110db:	83 c4 0c             	add    $0xc,%esp
   110de:	eb c7                	jmp    110a7 <_StartMotor@4+0x57>
   110e0:	cc                   	int3   
   110e1:	eb 83                	jmp    11066 <_StartMotor@4+0x16>
   110e3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   110e9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000110f0 <_StopMotor@4>:
    KdPrint(("floppy: StartMotor(): warning: HwTurnOnMotor failed\n"));
}


VOID NTAPI StopMotor(PCONTROLLER_INFO ControllerInfo)
/*
 * FUNCTION: Stop all motors on the controller
 * ARGUMENTS:
 *     DriveInfo: Drive to stop
 * NOTES:
 *     - Never call HwTurnOffMotor() directly
 *     - This manages the timer cancelation race (see StartMotor for details).
 *       All we have to do is set up a timer.
 */
{
   110f0:	55                   	push   %ebp
   110f1:	89 e5                	mov    %esp,%ebp
   110f3:	53                   	push   %ebx
   110f4:	50                   	push   %eax
   110f5:	8b 5d 08             	mov    0x8(%ebp),%ebx
  LARGE_INTEGER StopTime;

  ASSERT(ControllerInfo);
   110f8:	85 db                	test   %ebx,%ebx
   110fa:	74 3a                	je     11136 <_StopMotor@4+0x46>

  KdPrint(("floppy: StopMotor called\n"));

  /* one relative second, in 100-ns units */
  StopTime.QuadPart = 10000000;
  StopTime.QuadPart *= -1;

  KeClearEvent(&ControllerInfo->MotorStoppedEvent);
   110fc:	83 ec 0c             	sub    $0xc,%esp
   110ff:	8d 83 dd 11 00 00    	lea    0x11dd(%ebx),%eax
   11105:	50                   	push   %eax
   11106:	e8 a5 26 00 00       	call   137b0 <_KeClearEvent@4>
  KeSetTimer(&ControllerInfo->MotorTimer, StopTime, &ControllerInfo->MotorStopDpc);
   1110b:	83 c4 0c             	add    $0xc,%esp
   1110e:	8d 83 18 12 00 00    	lea    0x1218(%ebx),%eax
   11114:	50                   	push   %eax
   11115:	8d 83 f0 11 00 00    	lea    0x11f0(%ebx),%eax
   1111b:	6a ff                	push   $0xffffffff
   1111d:	68 80 69 67 ff       	push   $0xff676980
   11122:	50                   	push   %eax
   11123:	e8 98 26 00 00       	call   137c0 <_KeSetTimer@16>
  ControllerInfo->StopDpcQueued = TRUE;
   11128:	c6 83 38 12 00 00 01 	movb   $0x1,0x1238(%ebx)
   1112f:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11132:	c9                   	leave  
   11133:	c2 04 00             	ret    $0x4
   11136:	cc                   	int3   
   11137:	eb c3                	jmp    110fc <_StopMotor@4+0xc>
   11139:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011140 <_WaitForControllerInterrupt@4>:
}


VOID NTAPI WaitForControllerInterrupt(PCONTROLLER_INFO ControllerInfo)
/*
 * FUNCTION: Wait for the controller to interrupt, and then clear the event
 * ARGUMENTS:
 *     ControllerInfo: Controller to wait for
 * NOTES:
 *     - There is a small chance that an unexpected or spurious interrupt could
 *       be lost with this clear/wait/clear scheme used in this driver.  This is
 *       deemed to be an acceptable risk due to the unlikeliness of the scenario,
 *       and the fact that it'll probably work fine next time.
 *     - PAGED_CODE because it waits
 */
{
   11140:	55                   	push   %ebp
   11141:	89 e5                	mov    %esp,%ebp
   11143:	53                   	push   %ebx
   11144:	50                   	push   %eax
   11145:	8b 5d 08             	mov    0x8(%ebp),%ebx
  PAGED_CODE();
   11148:	e8 83 28 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   1114d:	3c 01                	cmp    $0x1,%al
   1114f:	76 01                	jbe    11152 <_WaitForControllerInterrupt@4+0x12>
   11151:	cc                   	int3   
  ASSERT(ControllerInfo);
   11152:	85 db                	test   %ebx,%ebx
   11154:	74 2a                	je     11180 <_WaitForControllerInterrupt@4+0x40>

  KeWaitForSingleObject(&ControllerInfo->SynchEvent, Executive, KernelMode, FALSE, NULL);
   11156:	83 ec 0c             	sub    $0xc,%esp
   11159:	83 c3 35             	add    $0x35,%ebx
   1115c:	6a 00                	push   $0x0
   1115e:	6a 00                	push   $0x0
   11160:	6a 00                	push   $0x0
   11162:	6a 00                	push   $0x0
   11164:	53                   	push   %ebx
   11165:	e8 36 26 00 00       	call   137a0 <_KeWaitForSingleObject@20>
  KeClearEvent(&ControllerInfo->SynchEvent);
   1116a:	89 5d 08             	mov    %ebx,0x8(%ebp)
   1116d:	83 c4 0c             	add    $0xc,%esp
   11170:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11173:	c9                   	leave  
   11174:	e9 37 26 00 00       	jmp    137b0 <_KeClearEvent@4>
   11179:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11180:	cc                   	int3   
   11181:	83 ec 0c             	sub    $0xc,%esp
   11184:	83 c3 35             	add    $0x35,%ebx
   11187:	6a 00                	push   $0x0
   11189:	6a 00                	push   $0x0
   1118b:	6a 00                	push   $0x0
   1118d:	6a 00                	push   $0x0
   1118f:	53                   	push   %ebx
   11190:	e8 0b 26 00 00       	call   137a0 <_KeWaitForSingleObject@20>
   11195:	89 5d 08             	mov    %ebx,0x8(%ebp)
   11198:	83 c4 0c             	add    $0xc,%esp
   1119b:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1119e:	c9                   	leave  
   1119f:	e9 0c 26 00 00       	jmp    137b0 <_KeClearEvent@4>
   111a4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   111aa:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

000111b0 <_CreateClose@8>:
}


static NTSTATUS NTAPI CreateClose(PDEVICE_OBJECT DeviceObject, 
                                  PIRP Irp)
/*
 * FUNCTION: Dispatch function called for Create and Close IRPs
 * ARGUMENTS:
 *     DeviceObject: DeviceObject that is the target of the IRP
 *     Irp: IRP to process
 * RETURNS:
 *     STATUS_SUCCESS in all cases
 * NOTES:
 *     - The Microsoft sample drivers tend to return FILE_OPENED in Information, so I do too.
 *     - No reason to fail the device open
 *     - No state to track, so this routine is easy
 *     - Can be called <= DISPATCH_LEVEL
 *
 * TODO: Figure out why this isn't getting called 
 */
{
   111b0:	55                   	push   %ebp
   111b1:	89 e5                	mov    %esp,%ebp
   111b3:	83 ec 10             	sub    $0x10,%esp
   111b6:	8b 45 0c             	mov    0xc(%ebp),%eax
  UNREFERENCED_PARAMETER(DeviceObject);

  KdPrint(("floppy: CreateClose called\n"));

  Irp->IoStatus.Status = STATUS_SUCCESS;
   111b9:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
  Irp->IoStatus.Information = FILE_OPENED;
   111c0:	c7 40 1c 01 00 00 00 	movl   $0x1,0x1c(%eax)

  IoCompleteRequest(Irp, IO_DISK_INCREMENT);
   111c7:	6a 04                	push   $0x4
   111c9:	50                   	push   %eax
   111ca:	e8 01 26 00 00       	call   137d0 <_IoCompleteRequest@8>

  return STATUS_SUCCESS;
}
   111cf:	31 c0                	xor    %eax,%eax
   111d1:	c9                   	leave  
   111d2:	c2 08 00             	ret    $0x8
   111d5:	8d 74 26 00          	lea    0x0(%esi),%esi
   111d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000111e0 <_Recalibrate@4>:


static NTSTATUS NTAPI Recalibrate(PDRIVE_INFO DriveInfo)
/*
 * FUNCTION: Start the recalibration process
 * ARGUMENTS:
 *     DriveInfo: Pointer to the driveinfo struct associated with the targeted drive
 * RETURNS:
 *     STATUS_SUCCESS on successful starting of the process
 *     STATUS_IO_DEVICE_ERROR if it fails
 * NOTES:
 *     - Sometimes you have to do two recalibrations, particularly if the disk has <80 tracks.
 *     - PAGED_CODE because we wait
 */
{
   111e0:	55                   	push   %ebp
   111e1:	89 e5                	mov    %esp,%ebp
   111e3:	57                   	push   %edi
   111e4:	56                   	push   %esi
   111e5:	53                   	push   %ebx
   111e6:	83 ec 0c             	sub    $0xc,%esp
   111e9:	89 c6                	mov    %eax,%esi
  NTSTATUS Status;
  ULONG i;

  PAGED_CODE();
   111eb:	e8 e0 27 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   111f0:	3c 01                	cmp    $0x1,%al
   111f2:	76 01                	jbe    111f5 <_Recalibrate@4+0x15>
   111f4:	cc                   	int3   
  ASSERT(DriveInfo);
   111f5:	85 f6                	test   %esi,%esi
   111f7:	0f 84 87 00 00 00    	je     11284 <_Recalibrate@4+0xa4>

  /* first turn on the motor */
  /* Must stop after every start, prior to return */
  StartMotor(DriveInfo);
   111fd:	83 ec 0c             	sub    $0xc,%esp
   11200:	56                   	push   %esi
   11201:	e8 4a fe ff ff       	call   11050 <_StartMotor@4>

  /* set the data rate */
  KdPrint(("floppy: FIXME: UN-HARDCODE DATA RATE\n"));
  if(HwSetDataRate(DriveInfo->ControllerInfo, 0) != STATUS_SUCCESS)
   11206:	8b 1e                	mov    (%esi),%ebx
   11208:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1120f:	53                   	push   %ebx
   11210:	e8 eb 10 00 00       	call   12300 <_HwSetDataRate@8>
   11215:	5a                   	pop    %edx
   11216:	85 c0                	test   %eax,%eax
   11218:	59                   	pop    %ecx
   11219:	75 6f                	jne    1128a <_Recalibrate@4+0xaa>
    {
      KdPrint(("floppy: Recalibrate: HwSetDataRate failed\n"));
      StopMotor(DriveInfo->ControllerInfo);
      return STATUS_IO_DEVICE_ERROR;
    }

  /* clear the event just in case the last call forgot */
  KeClearEvent(&DriveInfo->ControllerInfo->SynchEvent);
   1121b:	83 ec 0c             	sub    $0xc,%esp
   1121e:	8b 06                	mov    (%esi),%eax
   11220:	83 c0 35             	add    $0x35,%eax

  /* sometimes you have to do this twice; we'll just do it twice all the time since
   * we don't know if the people calling this Recalibrate routine expect a disk to
   * even be in the drive, and if so, if that disk is formatted.
   */
  for(i = 0; i < 2; i++)
   11223:	31 ff                	xor    %edi,%edi
   11225:	50                   	push   %eax
   11226:	e8 85 25 00 00       	call   137b0 <_KeClearEvent@4>
   1122b:	83 c4 0c             	add    $0xc,%esp
    {
      /* Send the command */
      Status = HwRecalibrate(DriveInfo);
   1122e:	83 ec 0c             	sub    $0xc,%esp
   11231:	56                   	push   %esi
   11232:	e8 a9 13 00 00       	call   125e0 <_HwRecalibrate@4>
      if(Status != STATUS_SUCCESS)
   11237:	83 c4 0c             	add    $0xc,%esp
   1123a:	89 c3                	mov    %eax,%ebx
   1123c:	85 c0                	test   %eax,%eax
   1123e:	74 26                	je     11266 <_Recalibrate@4+0x86>
   11240:	47                   	inc    %edi
   11241:	83 ff 01             	cmp    $0x1,%edi
   11244:	76 e8                	jbe    1122e <_Recalibrate@4+0x4e>
	{
	  KdPrint(("floppy: Recalibrate: HwRecalibrate returned error\n"));
          continue;
	}

      WaitForControllerInterrupt(DriveInfo->ControllerInfo);

      /* Get the results */
      Status = HwRecalibrateResult(DriveInfo->ControllerInfo);
      if(Status != STATUS_SUCCESS)
	{
	  KdPrint(("floppy: Recalibrate: HwRecalibrateResult returned error\n"));
          break;
        }
    }

  KeClearEvent(&DriveInfo->ControllerInfo->SynchEvent);
   11246:	83 ec 0c             	sub    $0xc,%esp
   11249:	8b 06                	mov    (%esi),%eax
   1124b:	83 c0 35             	add    $0x35,%eax
   1124e:	50                   	push   %eax
   1124f:	e8 5c 25 00 00       	call   137b0 <_KeClearEvent@4>

  /* Must stop after every start, prior to return */
  StopMotor(DriveInfo->ControllerInfo);
   11254:	8b 06                	mov    (%esi),%eax
   11256:	50                   	push   %eax
   11257:	e8 94 fe ff ff       	call   110f0 <_StopMotor@4>

  return Status;
   1125c:	89 d8                	mov    %ebx,%eax
}
   1125e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11261:	5b                   	pop    %ebx
   11262:	5e                   	pop    %esi
   11263:	5f                   	pop    %edi
   11264:	5d                   	pop    %ebp
   11265:	c3                   	ret    
   11266:	83 ec 0c             	sub    $0xc,%esp
   11269:	8b 06                	mov    (%esi),%eax
   1126b:	50                   	push   %eax
   1126c:	e8 cf fe ff ff       	call   11140 <_WaitForControllerInterrupt@4>
   11271:	8b 06                	mov    (%esi),%eax
   11273:	50                   	push   %eax
   11274:	e8 97 12 00 00       	call   12510 <_HwRecalibrateResult@4>
   11279:	83 c4 0c             	add    $0xc,%esp
   1127c:	89 c3                	mov    %eax,%ebx
   1127e:	85 c0                	test   %eax,%eax
   11280:	74 be                	je     11240 <_Recalibrate@4+0x60>
   11282:	eb c2                	jmp    11246 <_Recalibrate@4+0x66>
   11284:	cc                   	int3   
   11285:	e9 73 ff ff ff       	jmp    111fd <_Recalibrate@4+0x1d>
   1128a:	83 ec 0c             	sub    $0xc,%esp
   1128d:	8b 06                	mov    (%esi),%eax
   1128f:	50                   	push   %eax
   11290:	e8 5b fe ff ff       	call   110f0 <_StopMotor@4>
   11295:	b8 85 01 00 c0       	mov    $0xc0000185,%eax
   1129a:	eb c2                	jmp    1125e <_Recalibrate@4+0x7e>
   1129c:	8d 74 26 00          	lea    0x0(%esi),%esi

000112a0 <_ResetChangeFlag@4>:


NTSTATUS NTAPI ResetChangeFlag(PDRIVE_INFO DriveInfo)
/*
 * FUNCTION: Reset the drive's change flag (as reflected in the DIR)
 * ARGUMENTS:
 *     DriveInfo: the drive to reset
 * RETURNS:
 *     STATUS_SUCCESS if the changeline is cleared
 *     STATUS_NO_MEDIA_IN_DEVICE if the changeline cannot be cleared
 *     STATUS_IO_DEVICE_ERROR if the controller cannot be communicated with
 * NOTES:
 *     - Change reset procedure: recalibrate, seek 1, seek 0
 *     - If the line is still set after that, there's clearly no disk in the
 *       drive, so we return STATUS_NO_MEDIA_IN_DEVICE
 *     - PAGED_CODE because we wait
 */
{
   112a0:	55                   	push   %ebp
   112a1:	89 e5                	mov    %esp,%ebp
   112a3:	53                   	push   %ebx
   112a4:	53                   	push   %ebx
   112a5:	8b 5d 08             	mov    0x8(%ebp),%ebx
  BOOLEAN DiskChanged;

  PAGED_CODE();
   112a8:	e8 23 27 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   112ad:	3c 01                	cmp    $0x1,%al
   112af:	76 01                	jbe    112b2 <_ResetChangeFlag@4+0x12>
   112b1:	cc                   	int3   
  ASSERT(DriveInfo);
   112b2:	85 db                	test   %ebx,%ebx
   112b4:	0f 84 a7 00 00 00    	je     11361 <_ResetChangeFlag@4+0xc1>

  KdPrint(("floppy: ResetChangeFlag called\n"));

  /* Try to recalibrate.  We don't care if it works. */
  Recalibrate(DriveInfo);
   112ba:	89 d8                	mov    %ebx,%eax
   112bc:	e8 1f ff ff ff       	call   111e0 <_Recalibrate@4>

  /* clear spurious interrupts in prep for seeks */
  KeClearEvent(&DriveInfo->ControllerInfo->SynchEvent);
   112c1:	83 ec 0c             	sub    $0xc,%esp
   112c4:	8b 03                	mov    (%ebx),%eax
   112c6:	83 c0 35             	add    $0x35,%eax
   112c9:	50                   	push   %eax
   112ca:	e8 e1 24 00 00       	call   137b0 <_KeClearEvent@4>

  /* must re-start the drive because Recalibrate() stops it */
  StartMotor(DriveInfo);
   112cf:	53                   	push   %ebx
   112d0:	e8 7b fd ff ff       	call   11050 <_StartMotor@4>

  /* Seek to 1 */
  if(HwSeek(DriveInfo, 1) != STATUS_SUCCESS)
   112d5:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
   112dc:	53                   	push   %ebx
   112dd:	e8 ae 14 00 00       	call   12790 <_HwSeek@8>
   112e2:	5a                   	pop    %edx
   112e3:	85 c0                	test   %eax,%eax
   112e5:	59                   	pop    %ecx
   112e6:	75 7f                	jne    11367 <_ResetChangeFlag@4+0xc7>
    {
      KdPrint(("floppy: ResetChangeFlag(): HwSeek failed; returning STATUS_IO_DEVICE_ERROR\n"));
      StopMotor(DriveInfo->ControllerInfo);
      return STATUS_IO_DEVICE_ERROR;
    }

  WaitForControllerInterrupt(DriveInfo->ControllerInfo);
   112e8:	83 ec 0c             	sub    $0xc,%esp
   112eb:	8b 03                	mov    (%ebx),%eax
   112ed:	50                   	push   %eax
   112ee:	e8 4d fe ff ff       	call   11140 <_WaitForControllerInterrupt@4>

  if(HwSenseInterruptStatus(DriveInfo->ControllerInfo) != STATUS_SUCCESS)
   112f3:	8b 03                	mov    (%ebx),%eax
   112f5:	50                   	push   %eax
   112f6:	e8 35 13 00 00       	call   12630 <_HwSenseInterruptStatus@4>
   112fb:	83 c4 0c             	add    $0xc,%esp
   112fe:	85 c0                	test   %eax,%eax
   11300:	75 65                	jne    11367 <_ResetChangeFlag@4+0xc7>
    {
      KdPrint(("floppy: ResetChangeFlag(): HwSenseInterruptStatus failed; bailing out\n"));
      StopMotor(DriveInfo->ControllerInfo);
      return STATUS_IO_DEVICE_ERROR;
    }

  /* Seek back to 0 */
  if(HwSeek(DriveInfo, 0) != STATUS_SUCCESS)
   11302:	50                   	push   %eax
   11303:	50                   	push   %eax
   11304:	6a 00                	push   $0x0
   11306:	53                   	push   %ebx
   11307:	e8 84 14 00 00       	call   12790 <_HwSeek@8>
   1130c:	5a                   	pop    %edx
   1130d:	85 c0                	test   %eax,%eax
   1130f:	59                   	pop    %ecx
   11310:	75 55                	jne    11367 <_ResetChangeFlag@4+0xc7>
    {
      KdPrint(("floppy: ResetChangeFlag(): HwSeek failed; returning STATUS_IO_DEVICE_ERROR\n"));
      StopMotor(DriveInfo->ControllerInfo);
      return STATUS_IO_DEVICE_ERROR;
    }

  WaitForControllerInterrupt(DriveInfo->ControllerInfo);
   11312:	83 ec 0c             	sub    $0xc,%esp
   11315:	8b 03                	mov    (%ebx),%eax
   11317:	50                   	push   %eax
   11318:	e8 23 fe ff ff       	call   11140 <_WaitForControllerInterrupt@4>

  if(HwSenseInterruptStatus(DriveInfo->ControllerInfo) != STATUS_SUCCESS)
   1131d:	8b 03                	mov    (%ebx),%eax
   1131f:	50                   	push   %eax
   11320:	e8 0b 13 00 00       	call   12630 <_HwSenseInterruptStatus@4>
   11325:	83 c4 0c             	add    $0xc,%esp
   11328:	85 c0                	test   %eax,%eax
   1132a:	75 3b                	jne    11367 <_ResetChangeFlag@4+0xc7>
    {
      KdPrint(("floppy: ResetChangeFlag(): HwSenseInterruptStatus #2 failed; bailing\n"));
      StopMotor(DriveInfo->ControllerInfo);
      return STATUS_IO_DEVICE_ERROR;
    }

  /* Check the change bit */
  if(HwDiskChanged(DriveInfo, &DiskChanged) != STATUS_SUCCESS)
   1132c:	50                   	push   %eax
   1132d:	50                   	push   %eax
   1132e:	8d 45 fb             	lea    0xfffffffb(%ebp),%eax
   11331:	50                   	push   %eax
   11332:	53                   	push   %ebx
   11333:	e8 e8 15 00 00       	call   12920 <_HwDiskChanged@8>
   11338:	5a                   	pop    %edx
   11339:	85 c0                	test   %eax,%eax
   1133b:	59                   	pop    %ecx
   1133c:	75 29                	jne    11367 <_ResetChangeFlag@4+0xc7>
    {
      KdPrint(("floppy: ResetChangeFlag(): HwDiskChagned failed; returning STATUS_IO_DEVICE_ERROR\n"));
      StopMotor(DriveInfo->ControllerInfo);
      return STATUS_IO_DEVICE_ERROR;
    }

  StopMotor(DriveInfo->ControllerInfo);
   1133e:	83 ec 0c             	sub    $0xc,%esp
   11341:	8b 03                	mov    (%ebx),%eax
   11343:	50                   	push   %eax
   11344:	e8 a7 fd ff ff       	call   110f0 <_StopMotor@4>

  /* if the change flag is still set, there's probably no media in the drive. */
  if(DiskChanged)
   11349:	83 c4 0c             	add    $0xc,%esp
    return STATUS_NO_MEDIA_IN_DEVICE;

  /* else we're done! */
  return STATUS_SUCCESS;
}
   1134c:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1134f:	80 7d fb 01          	cmpb   $0x1,0xfffffffb(%ebp)
   11353:	19 c0                	sbb    %eax,%eax
   11355:	c9                   	leave  
   11356:	83 f0 ff             	xor    $0xffffffff,%eax
   11359:	25 13 00 00 c0       	and    $0xc0000013,%eax
   1135e:	c2 04 00             	ret    $0x4
   11361:	cc                   	int3   
   11362:	e9 53 ff ff ff       	jmp    112ba <_ResetChangeFlag@4+0x1a>
   11367:	83 ec 0c             	sub    $0xc,%esp
   1136a:	8b 03                	mov    (%ebx),%eax
   1136c:	50                   	push   %eax
   1136d:	e8 7e fd ff ff       	call   110f0 <_StopMotor@4>
   11372:	b8 85 01 00 c0       	mov    $0xc0000185,%eax
   11377:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1137a:	c9                   	leave  
   1137b:	c2 04 00             	ret    $0x4
   1137e:	89 f6                	mov    %esi,%esi

00011380 <_Unload@4>:


static VOID NTAPI Unload(PDRIVER_OBJECT DriverObject)
/*
 * FUNCTION: Unload the driver from memory
 * ARGUMENTS:
 *     DriverObject - The driver that is being unloaded
 */
{
   11380:	55                   	push   %ebp
   11381:	89 e5                	mov    %esp,%ebp
   11383:	57                   	push   %edi
   11384:	56                   	push   %esi
   11385:	53                   	push   %ebx
   11386:	83 ec 1c             	sub    $0x1c,%esp
  ULONG i,j;

  PAGED_CODE();
   11389:	e8 42 26 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   1138e:	3c 01                	cmp    $0x1,%al
   11390:	76 01                	jbe    11393 <_Unload@4+0x13>
   11392:	cc                   	int3   
  UNREFERENCED_PARAMETER(DriverObject);

  KdPrint(("floppy: unloading\n"));

  KeSetEvent(&QueueThreadTerminate, 0, FALSE);
   11393:	56                   	push   %esi
   11394:	6a 00                	push   $0x0
   11396:	6a 00                	push   $0x0
   11398:	68 10 99 01 00       	push   $0x19910
   1139d:	e8 de 23 00 00       	call   13780 <_KeSetEvent@12>
  KeWaitForSingleObject(QueueThreadObject, Executive, KernelMode, FALSE, 0);
   113a2:	8b 0d 20 99 01 00    	mov    0x19920,%ecx
   113a8:	53                   	push   %ebx
   113a9:	53                   	push   %ebx
   113aa:	6a 00                	push   $0x0
   113ac:	6a 00                	push   $0x0
   113ae:	6a 00                	push   $0x0
   113b0:	6a 00                	push   $0x0
   113b2:	51                   	push   %ecx
   113b3:	e8 e8 23 00 00       	call   137a0 <_KeWaitForSingleObject@20>
  ObDereferenceObject(QueueThreadObject);
   113b8:	8b 0d 20 99 01 00    	mov    0x19920,%ecx
   113be:	83 c4 0c             	add    $0xc,%esp
   113c1:	e8 1a 24 00 00       	call   137e0 <@ObfDereferenceObject@4>

  for(i = 0; i < gNumberOfControllers; i++)
   113c6:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
   113cd:	a1 00 50 01 00       	mov    0x15000,%eax
   113d2:	39 45 e4             	cmp    %eax,0xffffffe4(%ebp)
   113d5:	0f 83 06 01 00 00    	jae    114e1 <_Unload@4+0x161>
   113db:	31 f6                	xor    %esi,%esi
   113dd:	eb 17                	jmp    113f6 <_Unload@4+0x76>
   113df:	90                   	nop    
   113e0:	8b 7d e4             	mov    0xffffffe4(%ebp),%edi
   113e3:	81 c6 40 12 00 00    	add    $0x1240,%esi
   113e9:	47                   	inc    %edi
   113ea:	89 7d e4             	mov    %edi,0xffffffe4(%ebp)
   113ed:	39 45 e4             	cmp    %eax,0xffffffe4(%ebp)
   113f0:	0f 83 eb 00 00 00    	jae    114e1 <_Unload@4+0x161>
    {
      if(!gControllerInfo[i].Initialized)
   113f6:	80 be 11 50 01 00 00 	cmpb   $0x0,0x15011(%esi)
   113fd:	74 e1                	je     113e0 <_Unload@4+0x60>
	continue;

      for(j = 0; j < gControllerInfo[i].NumberOfDrives; j++)
   113ff:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
   11406:	80 be 80 50 01 00 00 	cmpb   $0x0,0x15080(%esi)
   1140d:	0f 84 95 00 00 00    	je     114a8 <_Unload@4+0x128>
   11413:	31 ff                	xor    %edi,%edi
   11415:	eb 1a                	jmp    11431 <_Unload@4+0xb1>
   11417:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   1141a:	81 c7 58 04 00 00    	add    $0x458,%edi
   11420:	40                   	inc    %eax
   11421:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   11424:	31 c0                	xor    %eax,%eax
   11426:	8a 86 80 50 01 00    	mov    0x15080(%esi),%al
   1142c:	3b 45 e0             	cmp    0xffffffe0(%ebp),%eax
   1142f:	76 77                	jbe    114a8 <_Unload@4+0x128>
	{
	  if(!gControllerInfo[i].DriveInfo[j].Initialized)
   11431:	8d 1c 3e             	lea    (%esi,%edi,1),%ebx
   11434:	80 bb dc 54 01 00 00 	cmpb   $0x0,0x154dc(%ebx)
   1143b:	74 da                	je     11417 <_Unload@4+0x97>
	    continue;

          if(gControllerInfo[i].DriveInfo[j].DeviceObject)
   1143d:	8b 93 98 50 01 00    	mov    0x15098(%ebx),%edx
   11443:	85 d2                	test   %edx,%edx
   11445:	74 d0                	je     11417 <_Unload@4+0x97>
            {
	      UNICODE_STRING Link;

	      RtlInitUnicodeString(&Link, gControllerInfo[i].DriveInfo[j].SymLinkBuffer);
   11447:	50                   	push   %eax
   11448:	50                   	push   %eax
   11449:	8d 83 da 50 01 00    	lea    0x150da(%ebx),%eax
   1144f:	50                   	push   %eax
   11450:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   11453:	50                   	push   %eax
   11454:	e8 97 23 00 00       	call   137f0 <_RtlInitUnicodeString@8>
   11459:	81 c7 58 04 00 00    	add    $0x458,%edi
	      IoDeleteSymbolicLink(&Link);
   1145f:	50                   	push   %eax
   11460:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   11463:	50                   	push   %eax
   11464:	e8 97 23 00 00       	call   13800 <_IoDeleteSymbolicLink@4>

	      RtlInitUnicodeString(&Link, gControllerInfo[i].DriveInfo[j].ArcPathBuffer);
   11469:	8d 83 d8 52 01 00    	lea    0x152d8(%ebx),%eax
   1146f:	89 04 24             	mov    %eax,(%esp)
   11472:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   11475:	50                   	push   %eax
   11476:	e8 75 23 00 00       	call   137f0 <_RtlInitUnicodeString@8>
	      IoDeassignArcName(&Link);
   1147b:	50                   	push   %eax
   1147c:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   1147f:	50                   	push   %eax
   11480:	e8 7b 23 00 00       	call   13800 <_IoDeleteSymbolicLink@4>

              IoDeleteDevice(gControllerInfo[i].DriveInfo[j].DeviceObject);
   11485:	8b 83 98 50 01 00    	mov    0x15098(%ebx),%eax
   1148b:	50                   	push   %eax
   1148c:	e8 7f 23 00 00       	call   13810 <_IoDeleteDevice@4>
   11491:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   11494:	83 c4 0c             	add    $0xc,%esp
   11497:	40                   	inc    %eax
   11498:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   1149b:	31 c0                	xor    %eax,%eax
   1149d:	8a 86 80 50 01 00    	mov    0x15080(%esi),%al
   114a3:	3b 45 e0             	cmp    0xffffffe0(%ebp),%eax
   114a6:	77 89                	ja     11431 <_Unload@4+0xb1>
            }
	}

      IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
   114a8:	83 ec 0c             	sub    $0xc,%esp
   114ab:	8b 86 78 50 01 00    	mov    0x15078(%esi),%eax
   114b1:	50                   	push   %eax
   114b2:	e8 69 23 00 00       	call   13820 <_IoDisconnectInterrupt@4>

      /* Power down the controller */
      if(HwPowerOff(&gControllerInfo[i]) != STATUS_SUCCESS)
   114b7:	8d 86 10 50 01 00    	lea    0x15010(%esi),%eax
   114bd:	81 c6 40 12 00 00    	add    $0x1240,%esi
   114c3:	50                   	push   %eax
   114c4:	e8 17 16 00 00       	call   12ae0 <_HwPowerOff@4>
   114c9:	8b 7d e4             	mov    0xffffffe4(%ebp),%edi
   114cc:	a1 00 50 01 00       	mov    0x15000,%eax
   114d1:	47                   	inc    %edi
   114d2:	83 c4 0c             	add    $0xc,%esp
   114d5:	89 7d e4             	mov    %edi,0xffffffe4(%ebp)
   114d8:	39 45 e4             	cmp    %eax,0xffffffe4(%ebp)
   114db:	0f 82 15 ff ff ff    	jb     113f6 <_Unload@4+0x76>
   114e1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   114e4:	5b                   	pop    %ebx
   114e5:	5e                   	pop    %esi
   114e6:	5f                   	pop    %edi
   114e7:	5d                   	pop    %ebp
   114e8:	c2 04 00             	ret    $0x4
   114eb:	90                   	nop    
   114ec:	8d 74 26 00          	lea    0x0(%esi),%esi

000114f0 <_ConfigCallback@44>:
	KdPrint(("floppy: unload: warning: HwPowerOff failed\n"));
    }
}


static NTSTATUS NTAPI ConfigCallback(PVOID Context,
                                     PUNICODE_STRING PathName,
                                     INTERFACE_TYPE BusType,
                                     ULONG BusNumber,
                                     PKEY_VALUE_FULL_INFORMATION *BusInformation,
                                     CONFIGURATION_TYPE ControllerType,
                                     ULONG ControllerNumber,
                                     PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
                                     CONFIGURATION_TYPE PeripheralType,
                                     ULONG PeripheralNumber,
                                     PKEY_VALUE_FULL_INFORMATION *PeripheralInformation)
/*
 * FUNCTION: Callback to IoQueryDeviceDescription, which tells us about our controllers
 * ARGUMENTS:
 *     Context: Unused
 *     PathName: Unused
 *     BusType: Type of the bus that our controller is on
 *     BusNumber: Number of the bus that our controller is on
 *     BusInformation: Unused
 *     ControllerType: Unused
 *     ControllerNumber: Number of the controller that we're adding
 *     ControllerInformation: Full configuration information for our controller
 *     PeripheralType: Unused
 *     PeripheralNumber: Unused
 *     PeripheralInformation: Full configuration information for each drive on our controller
 * RETURNS:
 *     STATUS_SUCCESS in all cases
 * NOTES:
 *     - The only documentation I've found about the contents of these structures is
 *       from the various Microsoft floppy samples and from the DDK headers.  They're
 *       very vague, though, so I'm only mostly sure that this stuff is correct, as
 *       the MS samples do things completely differently than I have done them.  Seems
 *       to work in my VMWare, though.
 *     - Basically, the function gets all of the information (port, dma, irq) about the
 *       controller, and then loops through all of the drives presented in PeripheralInformation.
 *     - Each controller has a CONTROLLER_INFO created for it, and each drive has a DRIVE_INFO.
 *     - Device objects are created for each drive (not controller), as that's the targeted
 *       device in the eyes of the rest of the OS.  Each DRIVE_INFO points to a single CONTROLLER_INFO.
 *     - We only support up to four controllers in the whole system, each of which supports up to four
 *       drives.
 */
{
   114f0:	55                   	push   %ebp
   114f1:	89 e5                	mov    %esp,%ebp
   114f3:	57                   	push   %edi
   114f4:	56                   	push   %esi
   114f5:	53                   	push   %ebx
   114f6:	83 ec 2c             	sub    $0x2c,%esp
  PKEY_VALUE_FULL_INFORMATION ControllerFullDescriptor = ControllerInformation[IoQueryDeviceConfigurationData];
   114f9:	8b 45 24             	mov    0x24(%ebp),%eax
   114fc:	8b 70 04             	mov    0x4(%eax),%esi
  PCM_FULL_RESOURCE_DESCRIPTOR ControllerResourceDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR)((PCHAR)ControllerFullDescriptor + 
                                                               ControllerFullDescriptor->DataOffset);

  PKEY_VALUE_FULL_INFORMATION PeripheralFullDescriptor = PeripheralInformation[IoQueryDeviceConfigurationData];
   114ff:	8b 45 30             	mov    0x30(%ebp),%eax
   11502:	8b 40 04             	mov    0x4(%eax),%eax
   11505:	8b 7e 08             	mov    0x8(%esi),%edi
   11508:	01 fe                	add    %edi,%esi
  PCM_FULL_RESOURCE_DESCRIPTOR PeripheralResourceDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR)((PCHAR)PeripheralFullDescriptor + 
   1150a:	8b 50 08             	mov    0x8(%eax),%edx
   1150d:	01 d0                	add    %edx,%eax
   1150f:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
                                                               PeripheralFullDescriptor->DataOffset);

  PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
  PCM_FLOPPY_DEVICE_DATA FloppyDeviceData;
  UCHAR i;

  PAGED_CODE();
   11512:	e8 b9 24 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   11517:	3c 01                	cmp    $0x1,%al
   11519:	76 01                	jbe    1151c <_ConfigCallback@44+0x2c>
   1151b:	cc                   	int3   
  UNREFERENCED_PARAMETER(PeripheralType);
  UNREFERENCED_PARAMETER(PeripheralNumber);
  UNREFERENCED_PARAMETER(BusInformation);
  UNREFERENCED_PARAMETER(Context);
  UNREFERENCED_PARAMETER(ControllerType);
  UNREFERENCED_PARAMETER(PathName);


  KdPrint(("floppy: ConfigCallback called with ControllerNumber %d\n", ControllerNumber));

  gControllerInfo[gNumberOfControllers].ControllerNumber = ControllerNumber;
   1151c:	8b 3d 00 50 01 00    	mov    0x15000,%edi
   11522:	8b 55 20             	mov    0x20(%ebp),%edx
  gControllerInfo[gNumberOfControllers].InterfaceType = BusType;
  gControllerInfo[gNumberOfControllers].BusNumber = BusNumber;

  /* Get controller interrupt level/vector, dma channel, and port base */
  for(i = 0; i < ControllerResourceDescriptor->PartialResourceList.Count; i++)
   11525:	c6 45 df 00          	movb   $0x0,0xffffffdf(%ebp)
   11529:	8d 04 ff             	lea    (%edi,%edi,8),%eax
   1152c:	8d 04 c7             	lea    (%edi,%eax,8),%eax
   1152f:	c1 e0 06             	shl    $0x6,%eax
   11532:	89 90 14 50 01 00    	mov    %edx,0x15014(%eax)
   11538:	8b 55 10             	mov    0x10(%ebp),%edx
   1153b:	89 90 18 50 01 00    	mov    %edx,0x15018(%eax)
   11541:	8b 55 14             	mov    0x14(%ebp),%edx
   11544:	89 90 1c 50 01 00    	mov    %edx,0x1501c(%eax)
   1154a:	8b 5e 0c             	mov    0xc(%esi),%ebx
   1154d:	85 db                	test   %ebx,%ebx
   1154f:	75 28                	jne    11579 <_ConfigCallback@44+0x89>
   11551:	e9 91 00 00 00       	jmp    115e7 <_ConfigCallback@44+0xf7>
    {
      KeInitializeEvent(&gControllerInfo[gNumberOfControllers].SynchEvent, NotificationEvent, FALSE);

      PartialDescriptor = &ControllerResourceDescriptor->PartialResourceList.PartialDescriptors[i];

      if(PartialDescriptor->Type == CmResourceTypeInterrupt)
        {
          gControllerInfo[gNumberOfControllers].Level = PartialDescriptor->u.Interrupt.Level;
          gControllerInfo[gNumberOfControllers].Vector = PartialDescriptor->u.Interrupt.Vector;

          if(PartialDescriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED)
            gControllerInfo[gNumberOfControllers].InterruptMode = Latched;
          else
            gControllerInfo[gNumberOfControllers].InterruptMode = LevelSensitive;
        }

      else if(PartialDescriptor->Type == CmResourceTypePort)
   11556:	3c 01                	cmp    $0x1,%al
   11558:	0f 84 c3 01 00 00    	je     11721 <_ConfigCallback@44+0x231>
        {
          PHYSICAL_ADDRESS TranslatedAddress;
          ULONG AddressSpace = 0x1; /* I/O Port Range */

          if(!HalTranslateBusAddress(BusType, BusNumber, PartialDescriptor->u.Port.Start, &AddressSpace, &TranslatedAddress))
	    {
	      KdPrint(("floppy: HalTranslateBusAddress failed; returning\n"));
	      return STATUS_IO_DEVICE_ERROR;
	    }

          if(AddressSpace == 0)
              gControllerInfo[gNumberOfControllers].BaseAddress = MmMapIoSpace(TranslatedAddress, FDC_PORT_BYTES, MmNonCached);
          else
              gControllerInfo[gNumberOfControllers].BaseAddress = (PUCHAR)TranslatedAddress.u.LowPart;
        }

      else if(PartialDescriptor->Type == CmResourceTypeDma)
   1155e:	3c 04                	cmp    $0x4,%al
   11560:	0f 84 9e 01 00 00    	je     11704 <_ConfigCallback@44+0x214>
   11566:	8b 3d 00 50 01 00    	mov    0x15000,%edi
   1156c:	fe 45 df             	incb   0xffffffdf(%ebp)
   1156f:	31 c0                	xor    %eax,%eax
   11571:	8a 45 df             	mov    0xffffffdf(%ebp),%al
   11574:	3b 46 0c             	cmp    0xc(%esi),%eax
   11577:	73 6e                	jae    115e7 <_ConfigCallback@44+0xf7>
   11579:	8d 04 ff             	lea    (%edi,%edi,8),%eax
   1157c:	51                   	push   %ecx
   1157d:	6a 00                	push   $0x0
   1157f:	8d 04 c7             	lea    (%edi,%eax,8),%eax
   11582:	6a 00                	push   $0x0
   11584:	c1 e0 06             	shl    $0x6,%eax
   11587:	05 45 50 01 00       	add    $0x15045,%eax
   1158c:	50                   	push   %eax
   1158d:	e8 9e 22 00 00       	call   13830 <_KeInitializeEvent@12>
   11592:	31 c0                	xor    %eax,%eax
   11594:	5a                   	pop    %edx
   11595:	8a 45 df             	mov    0xffffffdf(%ebp),%al
   11598:	c1 e0 04             	shl    $0x4,%eax
   1159b:	01 f0                	add    %esi,%eax
   1159d:	8d 48 10             	lea    0x10(%eax),%ecx
   115a0:	8a 40 10             	mov    0x10(%eax),%al
   115a3:	3c 02                	cmp    $0x2,%al
   115a5:	75 af                	jne    11556 <_ConfigCallback@44+0x66>
   115a7:	8b 3d 00 50 01 00    	mov    0x15000,%edi
   115ad:	8b 41 04             	mov    0x4(%ecx),%eax
   115b0:	8d 14 ff             	lea    (%edi,%edi,8),%edx
   115b3:	8d 14 d7             	lea    (%edi,%edx,8),%edx
   115b6:	c1 e2 06             	shl    $0x6,%edx
   115b9:	f6 41 02 01          	testb  $0x1,0x2(%ecx)
   115bd:	89 82 20 50 01 00    	mov    %eax,0x15020(%edx)
   115c3:	8b 41 08             	mov    0x8(%ecx),%eax
   115c6:	89 82 28 50 01 00    	mov    %eax,0x15028(%edx)
   115cc:	0f 95 c0             	setne  %al
   115cf:	fe 45 df             	incb   0xffffffdf(%ebp)
   115d2:	25 ff 00 00 00       	and    $0xff,%eax
   115d7:	89 82 30 50 01 00    	mov    %eax,0x15030(%edx)
   115dd:	31 c0                	xor    %eax,%eax
   115df:	8a 45 df             	mov    0xffffffdf(%ebp),%al
   115e2:	3b 46 0c             	cmp    0xc(%esi),%eax
   115e5:	72 92                	jb     11579 <_ConfigCallback@44+0x89>
        gControllerInfo[gNumberOfControllers].Dma = PartialDescriptor->u.Dma.Channel;
    }

  /* Start with 0 drives, then go looking */
  gControllerInfo[gNumberOfControllers].NumberOfDrives = 0;
   115e7:	8d 04 ff             	lea    (%edi,%edi,8),%eax

  /* learn about drives attached to controller */
  for(i = 0; i < PeripheralResourceDescriptor->PartialResourceList.Count; i++)
   115ea:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
   115ed:	c6 45 df 00          	movb   $0x0,0xffffffdf(%ebp)
   115f1:	8d 04 c7             	lea    (%edi,%eax,8),%eax
   115f4:	c1 e0 06             	shl    $0x6,%eax
   115f7:	c6 80 80 50 01 00 00 	movb   $0x0,0x15080(%eax)
   115fe:	8b 52 0c             	mov    0xc(%edx),%edx
   11601:	89 55 d4             	mov    %edx,0xffffffd4(%ebp)
   11604:	85 d2                	test   %edx,%edx
   11606:	0f 84 d4 00 00 00    	je     116e0 <_ConfigCallback@44+0x1f0>
   1160c:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   1160f:	eb 11                	jmp    11622 <_ConfigCallback@44+0x132>
   11611:	fe 45 df             	incb   0xffffffdf(%ebp)
   11614:	31 c0                	xor    %eax,%eax
   11616:	8a 45 df             	mov    0xffffffdf(%ebp),%al
   11619:	3b 45 d4             	cmp    0xffffffd4(%ebp),%eax
   1161c:	0f 83 be 00 00 00    	jae    116e0 <_ConfigCallback@44+0x1f0>
    {
      PDRIVE_INFO DriveInfo = &gControllerInfo[gNumberOfControllers].DriveInfo[i];
   11622:	31 c0                	xor    %eax,%eax
   11624:	8a 45 df             	mov    0xffffffdf(%ebp),%al
   11627:	89 c1                	mov    %eax,%ecx
   11629:	c1 e1 04             	shl    $0x4,%ecx
   1162c:	8d 14 01             	lea    (%ecx,%eax,1),%edx
   1162f:	8d 14 90             	lea    (%eax,%edx,4),%edx
   11632:	8d 14 50             	lea    (%eax,%edx,2),%edx
   11635:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   11638:	8d 34 d0             	lea    (%eax,%edx,8),%esi

      PartialDescriptor = &PeripheralResourceDescriptor->PartialResourceList.PartialDescriptors[i];
   1163b:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
   1163e:	8d 04 11             	lea    (%ecx,%edx,1),%eax
   11641:	8d 9e 88 50 01 00    	lea    0x15088(%esi),%ebx

      if(PartialDescriptor->Type != CmResourceTypeDeviceSpecific)
   11647:	80 78 10 05          	cmpb   $0x5,0x10(%eax)
   1164b:	75 c4                	jne    11611 <_ConfigCallback@44+0x121>
        continue;

      FloppyDeviceData = (PCM_FLOPPY_DEVICE_DATA)(PartialDescriptor + 1);
   1164d:	8d 50 20             	lea    0x20(%eax),%edx

      DriveInfo->ControllerInfo = &gControllerInfo[gNumberOfControllers];
   11650:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   11653:	05 10 50 01 00       	add    $0x15010,%eax
   11658:	89 86 88 50 01 00    	mov    %eax,0x15088(%esi)
      DriveInfo->UnitNumber = i;
   1165e:	8a 45 df             	mov    0xffffffdf(%ebp),%al
   11661:	88 43 04             	mov    %al,0x4(%ebx)

      DriveInfo->FloppyDeviceData.MaxDensity = FloppyDeviceData->MaxDensity;
   11664:	8b 42 0c             	mov    0xc(%edx),%eax
   11667:	89 43 20             	mov    %eax,0x20(%ebx)
      DriveInfo->FloppyDeviceData.MountDensity = FloppyDeviceData->MountDensity;
   1166a:	8b 42 10             	mov    0x10(%edx),%eax
   1166d:	89 43 24             	mov    %eax,0x24(%ebx)
      DriveInfo->FloppyDeviceData.StepRateHeadUnloadTime = FloppyDeviceData->StepRateHeadUnloadTime;
   11670:	8a 42 14             	mov    0x14(%edx),%al
   11673:	88 43 28             	mov    %al,0x28(%ebx)
      DriveInfo->FloppyDeviceData.HeadLoadTime = FloppyDeviceData->HeadLoadTime;
   11676:	8a 42 15             	mov    0x15(%edx),%al
   11679:	88 43 29             	mov    %al,0x29(%ebx)
      DriveInfo->FloppyDeviceData.MotorOffTime = FloppyDeviceData->MotorOffTime;
   1167c:	8a 42 16             	mov    0x16(%edx),%al
   1167f:	88 43 2a             	mov    %al,0x2a(%ebx)
      DriveInfo->FloppyDeviceData.SectorLengthCode = FloppyDeviceData->SectorLengthCode;
   11682:	8a 42 17             	mov    0x17(%edx),%al
   11685:	88 43 2b             	mov    %al,0x2b(%ebx)
      DriveInfo->FloppyDeviceData.SectorPerTrack = FloppyDeviceData->SectorPerTrack;
   11688:	8a 42 18             	mov    0x18(%edx),%al
   1168b:	88 43 2c             	mov    %al,0x2c(%ebx)
      DriveInfo->FloppyDeviceData.ReadWriteGapLength = FloppyDeviceData->ReadWriteGapLength;
   1168e:	8a 42 19             	mov    0x19(%edx),%al
   11691:	88 43 2d             	mov    %al,0x2d(%ebx)
      DriveInfo->FloppyDeviceData.FormatGapLength = FloppyDeviceData->FormatGapLength;
   11694:	8a 42 1b             	mov    0x1b(%edx),%al
   11697:	88 43 2f             	mov    %al,0x2f(%ebx)
      DriveInfo->FloppyDeviceData.FormatFillCharacter = FloppyDeviceData->FormatFillCharacter;
   1169a:	8a 42 1c             	mov    0x1c(%edx),%al
   1169d:	88 43 30             	mov    %al,0x30(%ebx)
      DriveInfo->FloppyDeviceData.HeadSettleTime = FloppyDeviceData->HeadSettleTime;
   116a0:	8a 42 1d             	mov    0x1d(%edx),%al
   116a3:	88 43 31             	mov    %al,0x31(%ebx)
      DriveInfo->FloppyDeviceData.MotorSettleTime = FloppyDeviceData->MotorSettleTime;
   116a6:	8a 42 1e             	mov    0x1e(%edx),%al
   116a9:	88 43 32             	mov    %al,0x32(%ebx)
      DriveInfo->FloppyDeviceData.MaximumTrackValue = FloppyDeviceData->MaximumTrackValue;
   116ac:	8a 42 1f             	mov    0x1f(%edx),%al
   116af:	88 43 33             	mov    %al,0x33(%ebx)
      DriveInfo->FloppyDeviceData.DataTransferLength = FloppyDeviceData->DataTransferLength;
   116b2:	8a 42 1a             	mov    0x1a(%edx),%al
   116b5:	88 43 2e             	mov    %al,0x2e(%ebx)

      /* Once it's all set up, acknowledge its existance in the controller info object */
      gControllerInfo[gNumberOfControllers].NumberOfDrives++;
   116b8:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   116bb:	fe 82 80 50 01 00    	incb   0x15080(%edx)
   116c1:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   116c4:	fe 45 df             	incb   0xffffffdf(%ebp)
   116c7:	8b 40 0c             	mov    0xc(%eax),%eax
   116ca:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   116cd:	31 c0                	xor    %eax,%eax
   116cf:	8a 45 df             	mov    0xffffffdf(%ebp),%al
   116d2:	3b 45 d4             	cmp    0xffffffd4(%ebp),%eax
   116d5:	0f 82 47 ff ff ff    	jb     11622 <_ConfigCallback@44+0x132>
   116db:	90                   	nop    
   116dc:	8d 74 26 00          	lea    0x0(%esi),%esi
    }

  gControllerInfo[gNumberOfControllers].Populated = TRUE;
   116e0:	8d 04 ff             	lea    (%edi,%edi,8),%eax
   116e3:	8d 04 c7             	lea    (%edi,%eax,8),%eax
   116e6:	c1 e0 06             	shl    $0x6,%eax
   116e9:	c6 80 10 50 01 00 01 	movb   $0x1,0x15010(%eax)
  gNumberOfControllers++;
   116f0:	8d 47 01             	lea    0x1(%edi),%eax
   116f3:	a3 00 50 01 00       	mov    %eax,0x15000

  return STATUS_SUCCESS;
   116f8:	31 c0                	xor    %eax,%eax
}
   116fa:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   116fd:	5b                   	pop    %ebx
   116fe:	5e                   	pop    %esi
   116ff:	5f                   	pop    %edi
   11700:	5d                   	pop    %ebp
   11701:	c2 2c 00             	ret    $0x2c
   11704:	8b 3d 00 50 01 00    	mov    0x15000,%edi
   1170a:	8b 51 04             	mov    0x4(%ecx),%edx
   1170d:	8d 04 ff             	lea    (%edi,%edi,8),%eax
   11710:	8d 04 c7             	lea    (%edi,%eax,8),%eax
   11713:	c1 e0 06             	shl    $0x6,%eax
   11716:	89 90 38 50 01 00    	mov    %edx,0x15038(%eax)
   1171c:	e9 4b fe ff ff       	jmp    1156c <_ConfigCallback@44+0x7c>
   11721:	50                   	push   %eax
   11722:	50                   	push   %eax
   11723:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   11726:	50                   	push   %eax
   11727:	8d 45 e4             	lea    0xffffffe4(%ebp),%eax
   1172a:	50                   	push   %eax
   1172b:	8b 7d 14             	mov    0x14(%ebp),%edi
   1172e:	8b 41 08             	mov    0x8(%ecx),%eax
   11731:	8b 5d 10             	mov    0x10(%ebp),%ebx
   11734:	50                   	push   %eax
   11735:	c7 45 e4 01 00 00 00 	movl   $0x1,0xffffffe4(%ebp)
   1173c:	8b 41 04             	mov    0x4(%ecx),%eax
   1173f:	50                   	push   %eax
   11740:	57                   	push   %edi
   11741:	53                   	push   %ebx
   11742:	e8 99 22 00 00       	call   139e0 <_HalTranslateBusAddress@24>
   11747:	5a                   	pop    %edx
   11748:	84 c0                	test   %al,%al
   1174a:	59                   	pop    %ecx
   1174b:	74 4e                	je     1179b <_ConfigCallback@44+0x2ab>
   1174d:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11750:	85 c0                	test   %eax,%eax
   11752:	74 1d                	je     11771 <_ConfigCallback@44+0x281>
   11754:	8b 3d 00 50 01 00    	mov    0x15000,%edi
   1175a:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   1175d:	8d 04 ff             	lea    (%edi,%edi,8),%eax
   11760:	8d 04 c7             	lea    (%edi,%eax,8),%eax
   11763:	c1 e0 06             	shl    $0x6,%eax
   11766:	89 90 34 50 01 00    	mov    %edx,0x15034(%eax)
   1176c:	e9 fb fd ff ff       	jmp    1156c <_ConfigCallback@44+0x7c>
   11771:	a1 00 50 01 00       	mov    0x15000,%eax
   11776:	8b 7d e8             	mov    0xffffffe8(%ebp),%edi
   11779:	6a 00                	push   $0x0
   1177b:	6a 08                	push   $0x8
   1177d:	8d 1c c0             	lea    (%eax,%eax,8),%ebx
   11780:	8d 1c d8             	lea    (%eax,%ebx,8),%ebx
   11783:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11786:	c1 e3 06             	shl    $0x6,%ebx
   11789:	50                   	push   %eax
   1178a:	57                   	push   %edi
   1178b:	e8 b0 20 00 00       	call   13840 <_MmMapIoSpace@16>
   11790:	89 83 34 50 01 00    	mov    %eax,0x15034(%ebx)
   11796:	e9 cb fd ff ff       	jmp    11566 <_ConfigCallback@44+0x76>
   1179b:	b8 85 01 00 c0       	mov    $0xc0000185,%eax
   117a0:	e9 55 ff ff ff       	jmp    116fa <_ConfigCallback@44+0x20a>
   117a5:	8d 74 26 00          	lea    0x0(%esi),%esi
   117a9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000117b0 <_Isr@8>:


static BOOLEAN NTAPI Isr(PKINTERRUPT Interrupt,
                         PVOID ServiceContext)
/*
 * FUNCTION: Interrupt service routine for the controllers
 * ARGUMENTS:
 *     Interrupt: Interrupt object representing the interrupt that occured
 *     ServiceContext: Pointer to the ControllerInfo object that caused the interrupt
 * RETURNS:
 *     TRUE in all cases (see notes)
 * NOTES:
 *     - We should always be the target of the interrupt, being an edge-triggered ISA interrupt, but
 *       this won't be the case with a level-sensitive system like PCI
 *     - Note that it probably doesn't matter if the interrupt isn't dismissed, as it's edge-triggered.
 *       It probably won't keep re-interrupting.
 *     - There are two different ways to dismiss a floppy interrupt.  If the command has a result phase
 *       (see intel datasheet), you dismiss the interrupt by reading the first data byte.  If it does
 *       not, you dismiss the interrupt by doing a Sense Interrupt command.  Again, because it's edge-
 *       triggered, this is safe to not do here, as we can just wait for the DPC.
 *     - Either way, we don't want to do this here.  The controller shouldn't interrupt again, so we'll
 *       schedule a DPC to take care of it.
 *     - This driver really cannot shrare interrupts, as I don't know how to conclusively say 
 *       whether it was our controller that interrupted or not.  I just have to assume that any time
 *       my ISR gets called, it was my board that called it.  Dumb design, yes, but it goes back to 
 *       the semantics of ISA buses.  That, and I don't know much about ISA drivers. :-)
 *       UPDATE: The high bit of Status Register A seems to work on non-AT controllers.
 *     - Called at DIRQL
 */
{
   117b0:	55                   	push   %ebp
   117b1:	89 e5                	mov    %esp,%ebp
   117b3:	51                   	push   %ecx
   117b4:	51                   	push   %ecx
   117b5:	8b 45 0c             	mov    0xc(%ebp),%eax
  PCONTROLLER_INFO ControllerInfo = (PCONTROLLER_INFO)ServiceContext;

  UNREFERENCED_PARAMETER(Interrupt);

  ASSERT(ControllerInfo);
   117b8:	85 c0                	test   %eax,%eax
   117ba:	74 17                	je     117d3 <_Isr@8+0x23>

  KdPrint(("floppy: ISR called\n"));

  /*
   * Due to the stupidity of the drive/controller relationship on the floppy drive, only one device object
   * can have an active interrupt pending.  Due to the nature of these IRPs, though, there will only ever
   * be one thread expecting an interrupt at a time, and furthermore, Interrupts (outside of spurious ones)
   * won't ever happen unless a thread is expecting them.  Therefore, all we have to do is signal an event
   * and we're done.  Queue a DPC and leave.
   */
  KeInsertQueueDpc(&ControllerInfo->Dpc, NULL, NULL);
   117bc:	83 c0 45             	add    $0x45,%eax
   117bf:	52                   	push   %edx
   117c0:	6a 00                	push   $0x0
   117c2:	6a 00                	push   $0x0
   117c4:	50                   	push   %eax
   117c5:	e8 86 20 00 00       	call   13850 <_KeInsertQueueDpc@12>

  return TRUE;
}
   117ca:	b8 01 00 00 00       	mov    $0x1,%eax
   117cf:	c9                   	leave  
   117d0:	c2 08 00             	ret    $0x8
   117d3:	cc                   	int3   
   117d4:	83 c0 45             	add    $0x45,%eax
   117d7:	52                   	push   %edx
   117d8:	6a 00                	push   $0x0
   117da:	6a 00                	push   $0x0
   117dc:	50                   	push   %eax
   117dd:	e8 6e 20 00 00       	call   13850 <_KeInsertQueueDpc@12>
   117e2:	b8 01 00 00 00       	mov    $0x1,%eax
   117e7:	c9                   	leave  
   117e8:	c2 08 00             	ret    $0x8
   117eb:	90                   	nop    
   117ec:	8d 74 26 00          	lea    0x0(%esi),%esi

000117f0 <_DpcForIsr@16>:


VOID NTAPI DpcForIsr(PKDPC UnusedDpc,
                     PVOID Context,
                     PVOID SystemArgument1,
                     PVOID SystemArgument2)
/*
 * FUNCTION: This DPC gets queued by every ISR.  Does the real per-interrupt work.
 * ARGUMENTS:
 *     UnusedDpc: Pointer to the DPC object that represents our function
 *     DeviceObject: Device that this DPC is running for
 *     Irp: Unused
 *     Context: Pointer to our ControllerInfo struct 
 * NOTES:
 *     - This function just kicks off whatever the SynchEvent is and returns.  We depend on
 *       the thing that caused the drive to interrupt to handle the work of clearing the interrupt.
 *       This enables us to get back to PASSIVE_LEVEL and not hog system time on a really stupid,
 *       slow, screwed-up piece of hardare.
 *     - If nothing is waiting for us to set the event, the interrupt is effectively lost and will
 *       never be dismissed.  I wonder if this will become a problem.
 *     - Called at DISPATCH_LEVEL
 */
{
   117f0:	55                   	push   %ebp
   117f1:	89 e5                	mov    %esp,%ebp
   117f3:	51                   	push   %ecx
   117f4:	51                   	push   %ecx
   117f5:	8b 45 0c             	mov    0xc(%ebp),%eax
  PCONTROLLER_INFO ControllerInfo = (PCONTROLLER_INFO)Context;

  UNREFERENCED_PARAMETER(UnusedDpc);
  UNREFERENCED_PARAMETER(SystemArgument1);
  UNREFERENCED_PARAMETER(SystemArgument2);

  ASSERT(ControllerInfo);
   117f8:	85 c0                	test   %eax,%eax
   117fa:	74 14                	je     11810 <_DpcForIsr@16+0x20>

  KdPrint(("floppy: DpcForIsr called\n"));

  KeSetEvent(&ControllerInfo->SynchEvent, EVENT_INCREMENT, FALSE);
   117fc:	83 c0 35             	add    $0x35,%eax
   117ff:	52                   	push   %edx
   11800:	6a 00                	push   $0x0
   11802:	6a 01                	push   $0x1
   11804:	50                   	push   %eax
   11805:	e8 76 1f 00 00       	call   13780 <_KeSetEvent@12>
   1180a:	c9                   	leave  
   1180b:	c2 10 00             	ret    $0x10
   1180e:	89 f6                	mov    %esi,%esi
   11810:	cc                   	int3   
   11811:	83 c0 35             	add    $0x35,%eax
   11814:	52                   	push   %edx
   11815:	6a 00                	push   $0x0
   11817:	6a 01                	push   $0x1
   11819:	50                   	push   %eax
   1181a:	e8 61 1f 00 00       	call   13780 <_KeSetEvent@12>
   1181f:	c9                   	leave  
   11820:	c2 10 00             	ret    $0x10
   11823:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11829:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011830 <_SignalMediaChanged@8>:
}


static NTSTATUS NTAPI InitController(PCONTROLLER_INFO ControllerInfo)
/*
 * FUNCTION:  Initialize a newly-found controller
 * ARGUMENTS:
 *     ControllerInfo: pointer to the controller to be initialized
 * RETURNS:
 *     STATUS_SUCCESS if the controller is successfully initialized
 *     STATUS_IO_DEVICE_ERROR otherwise
 */
{
  int i;
  UCHAR HeadLoadTime;
  UCHAR HeadUnloadTime;
  UCHAR StepRateTime;

  PAGED_CODE();
  ASSERT(ControllerInfo);

  KdPrint(("floppy: InitController called with Controller 0x%x\n", ControllerInfo));

  KeClearEvent(&ControllerInfo->SynchEvent);

  KdPrint(("floppy: InitController: resetting the controller\n"));

  /* Reset the controller */
  if(HwReset(ControllerInfo) != STATUS_SUCCESS)
    {
      KdPrint(("floppy: InitController: unable to reset controller\n"));
      return STATUS_IO_DEVICE_ERROR;
    }

  KdPrint(("floppy: InitController: setting data rate\n"));

  /* Set data rate */
  if(HwSetDataRate(ControllerInfo, DRSR_DSEL_500KBPS) != STATUS_SUCCESS)
    {
      KdPrint(("floppy: InitController: unable to set data rate\n"));
      return STATUS_IO_DEVICE_ERROR;
    }

  KdPrint(("floppy: InitController: waiting for initial interrupt\n"));

  /* Wait for an interrupt */
  WaitForControllerInterrupt(ControllerInfo);

  /* Reset means you have to clear each of the four interrupts (one per drive) */
  for(i = 0; i < MAX_DRIVES_PER_CONTROLLER; i++)
    {
      KdPrint(("floppy: InitController: Sensing interrupt %d\n", i));

      if(HwSenseInterruptStatus(ControllerInfo) != STATUS_SUCCESS)
	{
	  KdPrint(("floppy: InitController: Unable to clear interrupt 0x%x\n", i));
	  return STATUS_IO_DEVICE_ERROR;
	}
    }

  KdPrint(("floppy: InitController: done sensing interrupts\n"));

  /* Next, see if we have the right version to do implied seek */
  if(HwGetVersion(ControllerInfo) == VERSION_ENHANCED)
    {
      /* If so, set that up -- all defaults below except first TRUE for EIS */
      if(HwConfigure(ControllerInfo, TRUE, TRUE, FALSE, 0, 0) != STATUS_SUCCESS)
	{
	  KdPrint(("floppy: InitController: unable to set up implied seek\n"));
          ControllerInfo->ImpliedSeeks = FALSE;
	}
      else 
	{
	  KdPrint(("floppy: InitController: implied seeks set!\n"));
          ControllerInfo->ImpliedSeeks = TRUE;
	}

      /* 
       * FIXME: Figure out the answer to the below
       *
       * I must admit that I'm really confused about the Model 30 issue.  At least one
       * important bit (the disk change bit in the DIR) is flipped if this is a Model 30
       * controller.  However, at least one other floppy driver believes that there are only
       * two computers that are guaranteed to have a Model 30 controller:
       *  - IBM Thinkpad 750
       *  - IBM PS2e
       *
       * ...and another driver only lists a config option for "thinkpad", that flips
       * the change line.  A third driver doesn't mention the Model 30 issue at all.
       *
       * What I can't tell is whether or not the average, run-of-the-mill computer now has
       * a Model 30 controller.  For the time being, I'm going to wire this to FALSE,
       * and just not support the computers mentioned above, while I try to figure out
       * how ubiquitous these newfangled 30 thingies are.
       */
      //ControllerInfo->Model30 = TRUE;
      ControllerInfo->Model30 = FALSE;
    }
  else
    {
      KdPrint(("floppy: InitController: enhanced version not supported; disabling implied seeks\n"));
      ControllerInfo->ImpliedSeeks = FALSE;
      ControllerInfo->Model30 = FALSE;
    }
  
  /* Specify */
  KdPrint(("FLOPPY: FIXME: Figure out speed\n"));
  HeadLoadTime = SPECIFY_HLT_500K;
  HeadUnloadTime = SPECIFY_HUT_500K;
  StepRateTime = SPECIFY_SRT_500K;

  KdPrint(("floppy: InitController: issuing specify command to controller\n"));
      
  /* Don't disable DMA --> enable dma (dumb & confusing) */
  if(HwSpecify(ControllerInfo, HeadLoadTime, HeadUnloadTime, StepRateTime, FALSE) != STATUS_SUCCESS)
    {
      KdPrint(("floppy: InitController: unable to specify options\n"));
      return STATUS_IO_DEVICE_ERROR;
    }

  /* Init the stop stuff */
  KeInitializeDpc(&ControllerInfo->MotorStopDpc, MotorStopDpcFunc, ControllerInfo);
  KeInitializeTimer(&ControllerInfo->MotorTimer);
  KeInitializeEvent(&ControllerInfo->MotorStoppedEvent, NotificationEvent, FALSE);
  ControllerInfo->StopDpcQueued = FALSE;

  /* 
   * Recalibrate each drive on the controller (depends on StartMotor, which depends on the timer stuff above) 
   * We don't even know if there is a disk in the drive, so this may not work, but that's OK.
   */
  for(i = 0; i < ControllerInfo->NumberOfDrives; i++)
    {
      KdPrint(("floppy: InitController: recalibrating drive 0x%x on controller 0x%x\n", i, ControllerInfo));
      Recalibrate(&ControllerInfo->DriveInfo[i]);
    }

  KdPrint(("floppy: InitController: done initializing; returning STATUS_SUCCESS\n"));

  return STATUS_SUCCESS;
}


static BOOLEAN NTAPI AddControllers(PDRIVER_OBJECT DriverObject)
/*
 * FUNCTION: Called on initialization to find our controllers and build device and controller objects for them
 * ARGUMENTS:
 *     DriverObject: Our driver's DriverObject (so we can create devices against it)
 * RETURNS:
 *     FALSE if we can't allocate a device, adapter, or interrupt object, or if we fail to find any controllers
 *     TRUE otherwise (i.e. we have at least one fully-configured controller)
 * NOTES:
 *     - Currently we only support ISA buses.  
 *     - BUG: Windows 2000 seems to clobber the response from the IoQueryDeviceDescription callback, so now we
 *       just test a boolean value in the first object to see if it was completely populated.  The same value
 *       is tested for each controller before we build device objects for it.
 * TODO:
 *     - Report resource usage to the HAL
 */
{
  INTERFACE_TYPE InterfaceType = Isa;
  CONFIGURATION_TYPE ControllerType = DiskController;
  CONFIGURATION_TYPE PeripheralType = FloppyDiskPeripheral;
  KAFFINITY Affinity;
  DEVICE_DESCRIPTION DeviceDescription;
  UCHAR i;
  UCHAR j;

  PAGED_CODE();

  /* Find our controllers on all ISA buses */
  IoQueryDeviceDescription(&InterfaceType, 0, &ControllerType, 0, &PeripheralType, 0, ConfigCallback, 0);

  /* 
   * w2k breaks the return val from ConfigCallback, so we have to hack around it, rather than just
   * looking for a return value from ConfigCallback.  We expect at least one controller.
   */ 
  if(!gControllerInfo[0].Populated)
    {
      KdPrint(("floppy: AddControllers: failed to get controller info from registry\n"));
      return FALSE;
    }

  /* Now that we have a controller, set it up with the system */
  for(i = 0; i < gNumberOfControllers; i++)
    {
      /* 0: Report resource usage to the kernel, to make sure they aren't assigned to anyone else */
      /* FIXME: Implement me. */

      /* 1: Set up interrupt */
      gControllerInfo[i].MappedVector = HalGetInterruptVector(gControllerInfo[i].InterfaceType, gControllerInfo[i].BusNumber,
                                                              gControllerInfo[i].Level, gControllerInfo[i].Vector,
                                                              &gControllerInfo[i].MappedLevel, &Affinity);

      /* Must set up the DPC before we connect the interrupt */
      KeInitializeDpc(&gControllerInfo[i].Dpc, DpcForIsr, &gControllerInfo[i]);

      KdPrint(("floppy: Connecting interrupt %d to controller%d (object 0x%x)\n", gControllerInfo[i].MappedVector,
	       i, &gControllerInfo[i]));

      /* NOTE: We cannot share our interrupt, even on level-triggered buses.  See Isr() for details. */
      if(IoConnectInterrupt(&gControllerInfo[i].InterruptObject, Isr, &gControllerInfo[i], 0, gControllerInfo[i].MappedVector,
         gControllerInfo[i].MappedLevel, gControllerInfo[i].MappedLevel, gControllerInfo[i].InterruptMode,
         FALSE, Affinity, 0) != STATUS_SUCCESS)
        {
          KdPrint(("floppy: AddControllers: unable to connect interrupt\n"));
          continue;
        }

      /* 2: Set up DMA */
      memset(&DeviceDescription, 0, sizeof(DeviceDescription));
      DeviceDescription.Version = DEVICE_DESCRIPTION_VERSION;
      DeviceDescription.DmaChannel = gControllerInfo[i].Dma;
      DeviceDescription.InterfaceType = gControllerInfo[i].InterfaceType;
      DeviceDescription.BusNumber = gControllerInfo[i].BusNumber;

      /* DMA 0,1,2,3 are 8-bit; 4,5,6,7 are 16-bit (4 is chain i think) */
      DeviceDescription.DmaWidth = gControllerInfo[i].Dma > 3 ? Width16Bits: Width8Bits;

      gControllerInfo[i].AdapterObject = HalGetAdapter(&DeviceDescription, &gControllerInfo[i].MapRegisters);

      if(!gControllerInfo[i].AdapterObject)
        {
          KdPrint(("floppy: AddControllers: unable to allocate an adapter object\n"));
          IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
          continue;
        }

      /* 2b: Initialize the new controller */
      if(InitController(&gControllerInfo[i]) != STATUS_SUCCESS)
	{
	  KdPrint(("floppy: AddControllers():Unable to set up controller %d - initialization failed\n", i));
          IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
	  continue;
	}

      /* 2c: Set the controller's initlized flag so we know to release stuff in Unload */
      gControllerInfo[i].Initialized = TRUE;

      /* 3: per-drive setup */
      for(j = 0; j < gControllerInfo[i].NumberOfDrives; j++)
        {
          WCHAR DeviceNameBuf[MAX_DEVICE_NAME];
          UNICODE_STRING DeviceName;
          UNICODE_STRING LinkName;
	  UNICODE_STRING ArcPath;
	  UCHAR DriveNumber;

	  KdPrint(("floppy: AddControllers(): Configuring drive %d on controller %d\n", i, j));

	  /* 
	   * 3a: create a device object for the drive
	   * Controllers and drives are 0-based, so the combos are:
	   * 0: 0,0
	   * 1: 0,1
	   * 2: 0,2
	   * 3: 0,3
	   * 4: 1,0
	   * 5: 1,1
	   * ...
	   * 14: 3,2
	   * 15: 3,3 
	   */ 
	  DriveNumber = (UCHAR)(i*4 + j); /* loss of precision is OK; there are only 16 of 'em */

          swprintf(DeviceNameBuf, L"\\Device\\Floppy%d", DriveNumber);
          RtlInitUnicodeString(&DeviceName, DeviceNameBuf);

          if(IoCreateDevice(DriverObject, sizeof(PVOID), &DeviceName, 
			    FILE_DEVICE_DISK, FILE_REMOVABLE_MEDIA | FILE_FLOPPY_DISKETTE, FALSE,
                            &gControllerInfo[i].DriveInfo[j].DeviceObject) != STATUS_SUCCESS)
            {
              KdPrint(("floppy: AddControllers: unable to register a Device object\n"));
              IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
              continue; /* continue on to next drive */
            }

	  KdPrint(("floppy: AddControllers: New device: %S (0x%x)\n", DeviceNameBuf, gControllerInfo[i].DriveInfo[j].DeviceObject));

	  /* 3b.5: Create an ARC path in case we're booting from this drive */
	  swprintf(gControllerInfo[i].DriveInfo[j].ArcPathBuffer,
		   L"\\ArcName\\multi(%d)disk(%d)fdisk(%d)", gControllerInfo[i].BusNumber, i, DriveNumber);

	  RtlInitUnicodeString(&ArcPath, gControllerInfo[i].DriveInfo[j].ArcPathBuffer);
	  IoAssignArcName(&ArcPath, &DeviceName);

	  /* 3c: Set flags up */
	  gControllerInfo[i].DriveInfo[j].DeviceObject->Flags |= DO_DIRECT_IO;

	  /* 3d: Create a symlink */
	  swprintf(gControllerInfo[i].DriveInfo[j].SymLinkBuffer, L"\\DosDevices\\%c:", DriveNumber + 'A');
	  RtlInitUnicodeString(&LinkName, gControllerInfo[i].DriveInfo[j].SymLinkBuffer);
	  if(IoCreateSymbolicLink(&LinkName, &DeviceName) != STATUS_SUCCESS)
	    {
	      KdPrint(("floppy: AddControllers: Unable to create a symlink for drive %d\n", DriveNumber));
	      IoDisconnectInterrupt(gControllerInfo[i].InterruptObject);
	      IoDeassignArcName(&ArcPath);
	      continue; /* continue to next drive */
	    }

	  /* 3e: Set up the DPC */
	  IoInitializeDpcRequest(gControllerInfo[i].DriveInfo[j].DeviceObject, DpcForIsr);

	  /* 3f: Point the device extension at our DriveInfo struct */
	  gControllerInfo[i].DriveInfo[j].DeviceObject->DeviceExtension = &gControllerInfo[i].DriveInfo[j];

	  /* 3g: neat comic strip */

	  /* 3h: set the initial media type to unknown */
	  memset(&gControllerInfo[i].DriveInfo[j].DiskGeometry, 0, sizeof(DISK_GEOMETRY));
	  gControllerInfo[i].DriveInfo[j].DiskGeometry.MediaType = Unknown;

	  /* 3i: Now that we're done, set the Initialized flag so we know to free this in Unload */
	  gControllerInfo[i].DriveInfo[j].Initialized = TRUE;
        }
    }

  KdPrint(("floppy: AddControllers: --------------------------------------------> finished adding controllers\n"));

  return TRUE;
}


VOID NTAPI SignalMediaChanged(PDEVICE_OBJECT DeviceObject,
                              PIRP Irp)
/*
 * FUNCTION: Process an IRP when the media has changed, and possibly notify the user
 * ARGUMENTS:
 *     DeviceObject: DeviceObject associated with the IRP
 *     Irp: IRP that we're failing due to change
 * NOTES:
 *     - This procedure is documented in the DDK by "Notifying the File System of Possible Media Changes",
 *       "IoSetHardErrorOrVerifyDevice", and by "Responding to Check-Verify Requests from the File System".
 *     - Callable at <= DISPATCH_LEVEL
 */
{
   11830:	55                   	push   %ebp
   11831:	89 e5                	mov    %esp,%ebp
   11833:	8b 55 08             	mov    0x8(%ebp),%edx
   11836:	8b 4d 0c             	mov    0xc(%ebp),%ecx
  PDRIVE_INFO DriveInfo = DeviceObject->DeviceExtension;
   11839:	8b 42 28             	mov    0x28(%edx),%eax

  KdPrint(("floppy: SignalMediaChanged called\n"));

  DriveInfo->DiskChangeCount++;
   1183c:	ff 80 50 04 00 00    	incl   0x450(%eax)

  /* If volume is not mounted, do NOT set verify and return STATUS_IO_DEVICE_ERROR */
  if(!(DeviceObject->Vpb->Flags & VPB_MOUNTED))
   11842:	8b 42 24             	mov    0x24(%edx),%eax
   11845:	f6 40 04 01          	testb  $0x1,0x4(%eax)
   11849:	75 15                	jne    11860 <_SignalMediaChanged@8+0x30>
    {
      Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
   1184b:	c7 41 18 85 01 00 c0 	movl   $0xc0000185,0x18(%ecx)
      Irp->IoStatus.Information = 0;
   11852:	c7 41 1c 00 00 00 00 	movl   $0x0,0x1c(%ecx)
      return;
    }

  /* Notify the filesystem that it will need to verify the volume */
  DeviceObject->Flags |= DO_VERIFY_VOLUME;
  Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;
  Irp->IoStatus.Information = 0;

  /* 
   * If this is a user-based, threaded request, let the IO manager know to pop up a box asking
   * the user to supply the correct media, but only if the error (which we just picked out above)
   * is deemed by the IO manager to be "user induced".  The reason we don't just unconditionally
   * call IoSetHardError... is because MS might change the definition of "user induced" some day,
   * and we don't want to have to remember to re-code this.
   */
  if(Irp->Tail.Overlay.Thread && IoIsErrorUserInduced(Irp->IoStatus.Status))
    IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
}
   11859:	c9                   	leave  
   1185a:	c2 08 00             	ret    $0x8
   1185d:	8d 76 00             	lea    0x0(%esi),%esi
   11860:	8b 42 1c             	mov    0x1c(%edx),%eax
   11863:	83 c8 02             	or     $0x2,%eax
   11866:	89 42 1c             	mov    %eax,0x1c(%edx)
   11869:	c7 41 18 16 00 00 80 	movl   $0x80000016,0x18(%ecx)
   11870:	8b 41 50             	mov    0x50(%ecx),%eax
   11873:	c7 41 1c 00 00 00 00 	movl   $0x0,0x1c(%ecx)
   1187a:	85 c0                	test   %eax,%eax
   1187c:	74 db                	je     11859 <_SignalMediaChanged@8+0x29>
   1187e:	89 55 0c             	mov    %edx,0xc(%ebp)
   11881:	89 4d 08             	mov    %ecx,0x8(%ebp)
   11884:	c9                   	leave  
   11885:	e9 d6 1f 00 00       	jmp    13860 <_IoSetHardErrorOrVerifyDevice@8>
   1188a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011890 <_QueueThread@4>:


static VOID NTAPI QueueThread(PVOID Context)
/*
 * FUNCTION: Thread that manages the queue and dispatches any queued requests
 * ARGUMENTS:
 *     Context: unused
 */
{
   11890:	55                   	push   %ebp
   11891:	89 e5                	mov    %esp,%ebp
   11893:	53                   	push   %ebx
   11894:	83 ec 14             	sub    $0x14,%esp
  PIRP Irp;
  PIO_STACK_LOCATION Stack;
  PDEVICE_OBJECT DeviceObject;
  PVOID Objects[2];

  PAGED_CODE();
   11897:	e8 34 21 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   1189c:	3c 01                	cmp    $0x1,%al
   1189e:	76 01                	jbe    118a1 <_QueueThread@4+0x11>
   118a0:	cc                   	int3   
  UNREFERENCED_PARAMETER(Context);

  Objects[0] = &QueueSemaphore;
   118a1:	c7 45 f0 50 99 01 00 	movl   $0x19950,0xfffffff0(%ebp)
  Objects[1] = &QueueThreadTerminate;
   118a8:	8d 5d f0             	lea    0xfffffff0(%ebp),%ebx
   118ab:	c7 45 f4 10 99 01 00 	movl   $0x19910,0xfffffff4(%ebp)

  for(;;)
    {
      KeWaitForMultipleObjects(2, Objects, WaitAny, Executive, KernelMode, FALSE, NULL, NULL);
   118b2:	6a 00                	push   $0x0
   118b4:	6a 00                	push   $0x0
   118b6:	6a 00                	push   $0x0
   118b8:	6a 00                	push   $0x0
   118ba:	6a 00                	push   $0x0
   118bc:	6a 01                	push   $0x1
   118be:	53                   	push   %ebx
   118bf:	6a 02                	push   $0x2
   118c1:	e8 aa 1f 00 00       	call   13870 <_KeWaitForMultipleObjects@32>

      if(KeReadStateEvent(&QueueThreadTerminate))
   118c6:	83 ec 0c             	sub    $0xc,%esp
   118c9:	68 10 99 01 00       	push   $0x19910
   118ce:	e8 ad 1f 00 00       	call   13880 <_KeReadStateEvent@4>
   118d3:	83 c4 0c             	add    $0xc,%esp
   118d6:	85 c0                	test   %eax,%eax
   118d8:	75 6c                	jne    11946 <_QueueThread@4+0xb6>
	{
	  KdPrint(("floppy: QueueThread terminating\n"));
          return;
	}

      KdPrint(("floppy: QueueThread: servicing an IRP\n"));

      Irp = IoCsqRemoveNextIrp(&Csq, 0);
   118da:	50                   	push   %eax
   118db:	50                   	push   %eax
   118dc:	6a 00                	push   $0x0
   118de:	68 80 99 01 00       	push   $0x19980
   118e3:	e8 08 1e 00 00       	call   136f0 <_IoCsqRemoveNextIrp@8>
   118e8:	89 c2                	mov    %eax,%edx

      /* we won't get an irp if it was canceled */
      if(!Irp)
   118ea:	58                   	pop    %eax
   118eb:	85 d2                	test   %edx,%edx
   118ed:	59                   	pop    %ecx
   118ee:	74 c2                	je     118b2 <_QueueThread@4+0x22>
	{
	  KdPrint(("floppy: QueueThread: IRP queue empty\n"));
          continue;
	}

      DeviceObject = (PDEVICE_OBJECT)Irp->Tail.Overlay.DriverContext[0];
   118f0:	8b 4a 40             	mov    0x40(%edx),%ecx

      ASSERT(DeviceObject);
   118f3:	85 c9                	test   %ecx,%ecx
   118f5:	74 4c                	je     11943 <_QueueThread@4+0xb3>

      Stack = IoGetCurrentIrpStackLocation(Irp);
   118f7:	8b 42 60             	mov    0x60(%edx),%eax

      /* Decide what to do with the IRP */
      switch(Stack->MajorFunction)
   118fa:	8a 00                	mov    (%eax),%al
   118fc:	25 ff 00 00 00       	and    $0xff,%eax
   11901:	83 f8 03             	cmp    $0x3,%eax
   11904:	7c 0a                	jl     11910 <_QueueThread@4+0x80>
   11906:	83 f8 04             	cmp    $0x4,%eax
   11909:	7e 25                	jle    11930 <_QueueThread@4+0xa0>
   1190b:	83 f8 0e             	cmp    $0xe,%eax
   1190e:	74 3d                	je     1194d <_QueueThread@4+0xbd>
	{
	case IRP_MJ_READ:
	case IRP_MJ_WRITE:
          ReadWritePassive(DeviceObject->DeviceExtension, Irp);
	  break;

	case IRP_MJ_DEVICE_CONTROL:
	  DeviceIoctlPassive(DeviceObject->DeviceExtension, Irp);
	  break;

	default:
	  KdPrint(("floppy: QueueThread(): Unrecognized irp: mj: 0x%x\n", Stack->MajorFunction));
	  Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
   11910:	c7 42 18 bb 00 00 c0 	movl   $0xc00000bb,0x18(%edx)
	  Irp->IoStatus.Information = 0;
   11917:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
	  IoCompleteRequest(Irp, IO_NO_INCREMENT);
   1191e:	51                   	push   %ecx
   1191f:	51                   	push   %ecx
   11920:	6a 00                	push   $0x0
   11922:	52                   	push   %edx
   11923:	e8 a8 1e 00 00       	call   137d0 <_IoCompleteRequest@8>
   11928:	58                   	pop    %eax
   11929:	5a                   	pop    %edx
   1192a:	eb 86                	jmp    118b2 <_QueueThread@4+0x22>
   1192c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11930:	50                   	push   %eax
   11931:	50                   	push   %eax
   11932:	52                   	push   %edx
   11933:	8b 41 28             	mov    0x28(%ecx),%eax
   11936:	50                   	push   %eax
   11937:	e8 94 12 00 00       	call   12bd0 <_ReadWritePassive@8>
   1193c:	58                   	pop    %eax
   1193d:	5a                   	pop    %edx
   1193e:	e9 6f ff ff ff       	jmp    118b2 <_QueueThread@4+0x22>
   11943:	cc                   	int3   
   11944:	eb b1                	jmp    118f7 <_QueueThread@4+0x67>
	}
    }
}
   11946:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11949:	c9                   	leave  
   1194a:	c2 04 00             	ret    $0x4
   1194d:	50                   	push   %eax
   1194e:	50                   	push   %eax
   1194f:	52                   	push   %edx
   11950:	8b 41 28             	mov    0x28(%ecx),%eax
   11953:	50                   	push   %eax
   11954:	e8 97 18 00 00       	call   131f0 <_DeviceIoctlPassive@8>
   11959:	58                   	pop    %eax
   1195a:	5a                   	pop    %edx
   1195b:	e9 52 ff ff ff       	jmp    118b2 <_QueueThread@4+0x22>

00011960 <_DriverEntry@8>:


NTSTATUS NTAPI DriverEntry(PDRIVER_OBJECT DriverObject,
                           PUNICODE_STRING RegistryPath)
/*
 * FUNCTION: Entry-point for the driver
 * ARGUMENTS:
 *     DriverObject: Our driver object
 *     RegistryPath: Unused
 * RETURNS:
 *     STATUS_SUCCESS on successful initialization of at least one drive
 *     STATUS_NO_SUCH_DEVICE if we didn't find even one drive
 *     STATUS_UNSUCCESSFUL otherwise
 */
{
   11960:	55                   	push   %ebp
   11961:	89 e5                	mov    %esp,%ebp
   11963:	57                   	push   %edi
   11964:	56                   	push   %esi
   11965:	53                   	push   %ebx
   11966:	81 ec 80 02 00 00    	sub    $0x280,%esp
  HANDLE ThreadHandle;

  UNREFERENCED_PARAMETER(RegistryPath);

  /*
   * Set up dispatch routines
   */
  DriverObject->MajorFunction[IRP_MJ_CREATE]         = (PDRIVER_DISPATCH)CreateClose;
   1196c:	8b 45 08             	mov    0x8(%ebp),%eax
   1196f:	c7 40 38 b0 11 01 00 	movl   $0x111b0,0x38(%eax)
  DriverObject->MajorFunction[IRP_MJ_CLOSE]          = (PDRIVER_DISPATCH)CreateClose;
   11976:	c7 40 40 b0 11 01 00 	movl   $0x111b0,0x40(%eax)
  DriverObject->MajorFunction[IRP_MJ_READ]           = (PDRIVER_DISPATCH)ReadWrite;
   1197d:	c7 40 44 30 2b 01 00 	movl   $0x12b30,0x44(%eax)
  DriverObject->MajorFunction[IRP_MJ_WRITE]          = (PDRIVER_DISPATCH)ReadWrite;
   11984:	c7 40 48 30 2b 01 00 	movl   $0x12b30,0x48(%eax)
  DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = (PDRIVER_DISPATCH)DeviceIoctl;
   1198b:	c7 40 70 a0 31 01 00 	movl   $0x131a0,0x70(%eax)

  DriverObject->DriverUnload = Unload;
   11992:	c7 40 34 80 13 01 00 	movl   $0x11380,0x34(%eax)

  /*
   * We depend on some zeroes in these structures.  I know this is supposed to be 
   * initialized to 0 by the complier but this makes me feel beter.
   */
  memset(&gControllerInfo, 0, sizeof(gControllerInfo));
   11999:	68 00 49 00 00       	push   $0x4900
   1199e:	6a 00                	push   $0x0
   119a0:	68 10 50 01 00       	push   $0x15010
   119a5:	e8 96 1f 00 00       	call   13940 <_memset>

  /*
   * Set up queue.  This routine cannot fail (trust me, I wrote it).
   */
  IoCsqInitialize(&Csq, CsqInsertIrp, CsqRemoveIrp, CsqPeekNextIrp, 
   119aa:	83 c4 0c             	add    $0xc,%esp
   119ad:	68 00 20 01 00       	push   $0x12000
   119b2:	68 e0 1f 01 00       	push   $0x11fe0
   119b7:	68 d0 1f 01 00       	push   $0x11fd0
   119bc:	68 a0 1f 01 00       	push   $0x11fa0
   119c1:	68 80 1f 01 00       	push   $0x11f80
   119c6:	68 30 20 01 00       	push   $0x12030
   119cb:	68 80 99 01 00       	push   $0x19980
   119d0:	e8 1b 1b 00 00       	call   134f0 <_IoCsqInitialize@28>
                  CsqAcquireLock, CsqReleaseLock, CsqCompleteCanceledIrp);

  /*
   * ...and its lock
   */
  KeInitializeSpinLock(&IrpQueueLock);
   119d5:	56                   	push   %esi
   119d6:	56                   	push   %esi
   119d7:	68 70 99 01 00       	push   $0x19970
   119dc:	e8 af 1e 00 00       	call   13890 <_KeInitializeSpinLock@4>
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   119e1:	59                   	pop    %ecx
   119e2:	5b                   	pop    %ebx
   * The queue is counted by a semaphore.  The queue management thread 
   * blocks on this semaphore, so if requests come in faster than the queue
   * thread can handle them, the semaphore count goes up. 
   */
  KeInitializeSemaphore(&QueueSemaphore, 0, 0x7fffffff);
   119e3:	68 ff ff ff 7f       	push   $0x7fffffff
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   119e8:	c7 05 44 99 01 00 40 	movl   $0x19940,0x19944
   119ef:	99 01 00 
   119f2:	6a 00                	push   $0x0
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   119f4:	c7 05 40 99 01 00 40 	movl   $0x19940,0x19940
   119fb:	99 01 00 
   119fe:	68 50 99 01 00       	push   $0x19950
   11a03:	e8 98 1e 00 00       	call   138a0 <_KeInitializeSemaphore@12>

  /*
   * Event to terminate that thread
   */
  KeInitializeEvent(&QueueThreadTerminate, NotificationEvent, FALSE);
   11a08:	6a 00                	push   $0x0
   11a0a:	6a 00                	push   $0x0
   11a0c:	68 10 99 01 00       	push   $0x19910
   11a11:	e8 1a 1e 00 00       	call   13830 <_KeInitializeEvent@12>

  /*
   * Create the queue processing thread.  Save its handle in the global variable
   * ThreadHandle so we can wait on its termination during Unload.
   */
  if(PsCreateSystemThread(&ThreadHandle, 0, 0, 0, 0, QueueThread, 0) != STATUS_SUCCESS)
   11a16:	8d 85 b4 fd ff ff    	lea    0xfffffdb4(%ebp),%eax
   11a1c:	6a 00                	push   $0x0
   11a1e:	68 90 18 01 00       	push   $0x11890
   11a23:	6a 00                	push   $0x0
   11a25:	6a 00                	push   $0x0
   11a27:	6a 00                	push   $0x0
   11a29:	6a 00                	push   $0x0
   11a2b:	50                   	push   %eax
   11a2c:	e8 7f 1e 00 00       	call   138b0 <_PsCreateSystemThread@28>
   11a31:	5a                   	pop    %edx
   11a32:	85 c0                	test   %eax,%eax
    {
      KdPrint(("floppy: Unable to create system thread; failing init\n"));
      return STATUS_INSUFFICIENT_RESOURCES;
   11a34:	ba 9a 00 00 c0       	mov    $0xc000009a,%edx
   11a39:	0f 85 7b 01 00 00    	jne    11bba <_DriverEntry@8+0x25a>
    }

  if(ObReferenceObjectByHandle(ThreadHandle, STANDARD_RIGHTS_ALL, NULL, KernelMode, &QueueThreadObject, NULL) != STATUS_SUCCESS)
   11a3f:	50                   	push   %eax
   11a40:	50                   	push   %eax
   11a41:	8b 85 b4 fd ff ff    	mov    0xfffffdb4(%ebp),%eax
   11a47:	6a 00                	push   $0x0
   11a49:	68 20 99 01 00       	push   $0x19920
   11a4e:	6a 00                	push   $0x0
   11a50:	6a 00                	push   $0x0
   11a52:	68 00 00 1f 00       	push   $0x1f0000
   11a57:	50                   	push   %eax
   11a58:	e8 63 1e 00 00       	call   138c0 <_ObReferenceObjectByHandle@24>
    {
      KdPrint(("floppy: Unable to reference returned thread handle; failing init\n"));
      return STATUS_UNSUCCESSFUL;
   11a5d:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   11a62:	89 c3                	mov    %eax,%ebx
   11a64:	5f                   	pop    %edi
   11a65:	85 db                	test   %ebx,%ebx
   11a67:	58                   	pop    %eax
   11a68:	0f 85 4c 01 00 00    	jne    11bba <_DriverEntry@8+0x25a>
    }

  /* 
   * Close the handle, now that we have the object pointer and a reference of our own. 
   * The handle will certainly not be valid in the context of the caller next time we
   * need it, as handles are process-specific.
   */
  ZwClose(ThreadHandle);
   11a6e:	83 ec 0c             	sub    $0xc,%esp
   11a71:	8b b5 b4 fd ff ff    	mov    0xfffffdb4(%ebp),%esi
   11a77:	56                   	push   %esi
   11a78:	e8 53 1e 00 00       	call   138d0 <_ZwClose@4>
   11a7d:	83 c4 0c             	add    $0xc,%esp
   11a80:	c7 85 a8 fd ff ff 01 	movl   $0x1,0xfffffda8(%ebp)
   11a87:	00 00 00 
   11a8a:	c7 85 ac fd ff ff 0d 	movl   $0xd,0xfffffdac(%ebp)
   11a91:	00 00 00 
   11a94:	c7 85 b0 fd ff ff 1a 	movl   $0x1a,0xfffffdb0(%ebp)
   11a9b:	00 00 00 
   11a9e:	e8 2d 1f 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   11aa3:	3c 01                	cmp    $0x1,%al
   11aa5:	0f 87 1b 01 00 00    	ja     11bc6 <_DriverEntry@8+0x266>
   11aab:	8d 85 b0 fd ff ff    	lea    0xfffffdb0(%ebp),%eax
   11ab1:	6a 00                	push   $0x0
   11ab3:	68 f0 14 01 00       	push   $0x114f0
   11ab8:	6a 00                	push   $0x0
   11aba:	50                   	push   %eax
   11abb:	8d 85 ac fd ff ff    	lea    0xfffffdac(%ebp),%eax
   11ac1:	6a 00                	push   $0x0
   11ac3:	50                   	push   %eax
   11ac4:	8d 85 a8 fd ff ff    	lea    0xfffffda8(%ebp),%eax
   11aca:	6a 00                	push   $0x0
   11acc:	50                   	push   %eax
   11acd:	e8 0e 1e 00 00       	call   138e0 <_IoQueryDeviceDescription@32>
   11ad2:	31 c0                	xor    %eax,%eax
   11ad4:	80 3d 10 50 01 00 00 	cmpb   $0x0,0x15010
   11adb:	0f 84 cf 00 00 00    	je     11bb0 <_DriverEntry@8+0x250>
   11ae1:	3b 1d 00 50 01 00    	cmp    0x15000,%ebx
   11ae7:	c6 85 87 fd ff ff 00 	movb   $0x0,0xfffffd87(%ebp)
   11aee:	e9 b2 00 00 00       	jmp    11ba5 <_DriverEntry@8+0x245>
   11af3:	31 c0                	xor    %eax,%eax
   11af5:	8a 85 87 fd ff ff    	mov    0xfffffd87(%ebp),%al
   11afb:	51                   	push   %ecx
   11afc:	51                   	push   %ecx
   11afd:	8d 14 c0             	lea    (%eax,%eax,8),%edx
   11b00:	8d 1c d0             	lea    (%eax,%edx,8),%ebx
   11b03:	8d 95 a4 fd ff ff    	lea    0xfffffda4(%ebp),%edx
   11b09:	c1 e3 06             	shl    $0x6,%ebx
   11b0c:	52                   	push   %edx
   11b0d:	8d 83 24 50 01 00    	lea    0x15024(%ebx),%eax
   11b13:	8b 93 28 50 01 00    	mov    0x15028(%ebx),%edx
   11b19:	50                   	push   %eax
   11b1a:	8b 83 20 50 01 00    	mov    0x15020(%ebx),%eax
   11b20:	52                   	push   %edx
   11b21:	50                   	push   %eax
   11b22:	8b 83 1c 50 01 00    	mov    0x1501c(%ebx),%eax
   11b28:	8d b3 10 50 01 00    	lea    0x15010(%ebx),%esi
   11b2e:	50                   	push   %eax
   11b2f:	8b 83 18 50 01 00    	mov    0x15018(%ebx),%eax
   11b35:	50                   	push   %eax
   11b36:	e8 b5 1e 00 00       	call   139f0 <_HalGetInterruptVector@24>
   11b3b:	89 83 2c 50 01 00    	mov    %eax,0x1502c(%ebx)
   11b41:	8d 83 55 50 01 00    	lea    0x15055(%ebx),%eax
   11b47:	89 34 24             	mov    %esi,(%esp)
   11b4a:	68 f0 17 01 00       	push   $0x117f0
   11b4f:	50                   	push   %eax
   11b50:	e8 9b 1d 00 00       	call   138f0 <_KeInitializeDpc@12>
   11b55:	8b 85 a4 fd ff ff    	mov    0xfffffda4(%ebp),%eax
   11b5b:	6a 00                	push   $0x0
   11b5d:	50                   	push   %eax
   11b5e:	8b 83 30 50 01 00    	mov    0x15030(%ebx),%eax
   11b64:	6a 00                	push   $0x0
   11b66:	50                   	push   %eax
   11b67:	31 c0                	xor    %eax,%eax
   11b69:	8a 83 24 50 01 00    	mov    0x15024(%ebx),%al
   11b6f:	50                   	push   %eax
   11b70:	50                   	push   %eax
   11b71:	8b 83 2c 50 01 00    	mov    0x1502c(%ebx),%eax
   11b77:	50                   	push   %eax
   11b78:	8d 83 78 50 01 00    	lea    0x15078(%ebx),%eax
   11b7e:	6a 00                	push   $0x0
   11b80:	56                   	push   %esi
   11b81:	68 b0 17 01 00       	push   $0x117b0
   11b86:	50                   	push   %eax
   11b87:	e8 74 1d 00 00       	call   13900 <_IoConnectInterrupt@44>
   11b8c:	5f                   	pop    %edi
   11b8d:	85 c0                	test   %eax,%eax
   11b8f:	74 3f                	je     11bd0 <_DriverEntry@8+0x270>
   11b91:	fe 85 87 fd ff ff    	incb   0xfffffd87(%ebp)
   11b97:	31 c0                	xor    %eax,%eax
   11b99:	8a 85 87 fd ff ff    	mov    0xfffffd87(%ebp),%al
   11b9f:	3b 05 00 50 01 00    	cmp    0x15000,%eax
   11ba5:	0f 82 48 ff ff ff    	jb     11af3 <_DriverEntry@8+0x193>
   11bab:	b8 01 00 00 00       	mov    $0x1,%eax

  /*
   * Start the device discovery proces.  Returns STATUS_SUCCESS if
   * it finds even one drive attached to one controller. 
   */
  if(!AddControllers(DriverObject))
    return STATUS_NO_SUCH_DEVICE;
   11bb0:	3c 01                	cmp    $0x1,%al
   11bb2:	19 d2                	sbb    %edx,%edx
   11bb4:	81 e2 0e 00 00 c0    	and    $0xc000000e,%edx

  return STATUS_SUCCESS;
}
   11bba:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11bbd:	89 d0                	mov    %edx,%eax
   11bbf:	5b                   	pop    %ebx
   11bc0:	5e                   	pop    %esi
   11bc1:	5f                   	pop    %edi
   11bc2:	5d                   	pop    %ebp
   11bc3:	c2 08 00             	ret    $0x8
   11bc6:	cc                   	int3   
   11bc7:	e9 df fe ff ff       	jmp    11aab <_DriverEntry@8+0x14b>
   11bcc:	8d 74 26 00          	lea    0x0(%esi),%esi
   11bd0:	fc                   	cld    
   11bd1:	8d 7d b8             	lea    0xffffffb8(%ebp),%edi
   11bd4:	b9 0a 00 00 00       	mov    $0xa,%ecx
   11bd9:	f3 ab                	repz stos %eax,%es:(%edi)
   11bdb:	8b 83 18 50 01 00    	mov    0x15018(%ebx),%eax
   11be1:	8b 93 38 50 01 00    	mov    0x15038(%ebx),%edx
   11be7:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   11bea:	8b 83 1c 50 01 00    	mov    0x1501c(%ebx),%eax
   11bf0:	83 fa 03             	cmp    $0x3,%edx
   11bf3:	89 45 c4             	mov    %eax,0xffffffc4(%ebp)
   11bf6:	0f 97 c0             	seta   %al
   11bf9:	25 ff 00 00 00       	and    $0xff,%eax
   11bfe:	51                   	push   %ecx
   11bff:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   11c02:	8d 83 3c 50 01 00    	lea    0x1503c(%ebx),%eax
   11c08:	51                   	push   %ecx
   11c09:	50                   	push   %eax
   11c0a:	8d 45 b8             	lea    0xffffffb8(%ebp),%eax
   11c0d:	89 55 c8             	mov    %edx,0xffffffc8(%ebp)
   11c10:	c7 45 b8 00 00 00 00 	movl   $0x0,0xffffffb8(%ebp)
   11c17:	50                   	push   %eax
   11c18:	e8 e3 1d 00 00       	call   13a00 <_HalGetAdapter@8>
   11c1d:	5f                   	pop    %edi
   11c1e:	85 c0                	test   %eax,%eax
   11c20:	5a                   	pop    %edx
   11c21:	89 83 7c 50 01 00    	mov    %eax,0x1507c(%ebx)
   11c27:	75 17                	jne    11c40 <_DriverEntry@8+0x2e0>
   11c29:	83 ec 0c             	sub    $0xc,%esp
   11c2c:	8b 9b 78 50 01 00    	mov    0x15078(%ebx),%ebx
   11c32:	53                   	push   %ebx
   11c33:	e8 e8 1b 00 00       	call   13820 <_IoDisconnectInterrupt@4>
   11c38:	83 c4 0c             	add    $0xc,%esp
   11c3b:	e9 51 ff ff ff       	jmp    11b91 <_DriverEntry@8+0x231>
   11c40:	e8 8b 1d 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   11c45:	3c 01                	cmp    $0x1,%al
   11c47:	77 3e                	ja     11c87 <_DriverEntry@8+0x327>
   11c49:	85 f6                	test   %esi,%esi
   11c4b:	0f 84 ff 01 00 00    	je     11e50 <_DriverEntry@8+0x4f0>
   11c51:	83 ec 0c             	sub    $0xc,%esp
   11c54:	8d 46 35             	lea    0x35(%esi),%eax
   11c57:	50                   	push   %eax
   11c58:	e8 53 1b 00 00       	call   137b0 <_KeClearEvent@4>
   11c5d:	56                   	push   %esi
   11c5e:	e8 0d 0e 00 00       	call   12a70 <_HwReset@4>
   11c63:	83 c4 0c             	add    $0xc,%esp
   11c66:	85 c0                	test   %eax,%eax
   11c68:	74 20                	je     11c8a <_DriverEntry@8+0x32a>
   11c6a:	31 c0                	xor    %eax,%eax
   11c6c:	83 ec 0c             	sub    $0xc,%esp
   11c6f:	8a 85 87 fd ff ff    	mov    0xfffffd87(%ebp),%al
   11c75:	8d 14 c0             	lea    (%eax,%eax,8),%edx
   11c78:	8d 14 d0             	lea    (%eax,%edx,8),%edx
   11c7b:	c1 e2 06             	shl    $0x6,%edx
   11c7e:	8b 8a 78 50 01 00    	mov    0x15078(%edx),%ecx
   11c84:	51                   	push   %ecx
   11c85:	eb ac                	jmp    11c33 <_DriverEntry@8+0x2d3>
   11c87:	cc                   	int3   
   11c88:	eb bf                	jmp    11c49 <_DriverEntry@8+0x2e9>
   11c8a:	51                   	push   %ecx
   11c8b:	51                   	push   %ecx
   11c8c:	6a 00                	push   $0x0
   11c8e:	56                   	push   %esi
   11c8f:	e8 6c 06 00 00       	call   12300 <_HwSetDataRate@8>
   11c94:	5f                   	pop    %edi
   11c95:	85 c0                	test   %eax,%eax
   11c97:	5a                   	pop    %edx
   11c98:	75 d0                	jne    11c6a <_DriverEntry@8+0x30a>
   11c9a:	83 ec 0c             	sub    $0xc,%esp
   11c9d:	31 ff                	xor    %edi,%edi
   11c9f:	56                   	push   %esi
   11ca0:	e8 9b f4 ff ff       	call   11140 <_WaitForControllerInterrupt@4>
   11ca5:	83 c4 0c             	add    $0xc,%esp
   11ca8:	83 ec 0c             	sub    $0xc,%esp
   11cab:	56                   	push   %esi
   11cac:	e8 7f 09 00 00       	call   12630 <_HwSenseInterruptStatus@4>
   11cb1:	83 c4 0c             	add    $0xc,%esp
   11cb4:	85 c0                	test   %eax,%eax
   11cb6:	75 b2                	jne    11c6a <_DriverEntry@8+0x30a>
   11cb8:	47                   	inc    %edi
   11cb9:	83 ff 03             	cmp    $0x3,%edi
   11cbc:	7e ea                	jle    11ca8 <_DriverEntry@8+0x348>
   11cbe:	83 ec 0c             	sub    $0xc,%esp
   11cc1:	56                   	push   %esi
   11cc2:	e8 09 0c 00 00       	call   128d0 <_HwGetVersion@4>
   11cc7:	83 c4 0c             	add    $0xc,%esp
   11cca:	3d 90 00 00 00       	cmp    $0x90,%eax
   11ccf:	0f 84 89 02 00 00    	je     11f5e <_DriverEntry@8+0x5fe>
   11cd5:	c6 46 71 00          	movb   $0x0,0x71(%esi)
   11cd9:	83 ec 0c             	sub    $0xc,%esp
   11cdc:	c6 86 dc 11 00 00 00 	movb   $0x0,0x11dc(%esi)
   11ce3:	6a 00                	push   $0x0
   11ce5:	6a 00                	push   $0x0
   11ce7:	6a 00                	push   $0x0
   11ce9:	6a 08                	push   $0x8
   11ceb:	56                   	push   %esi
   11cec:	e8 2f 0d 00 00       	call   12a20 <_HwSpecify@20>
   11cf1:	83 c4 0c             	add    $0xc,%esp
   11cf4:	85 c0                	test   %eax,%eax
   11cf6:	0f 85 6e ff ff ff    	jne    11c6a <_DriverEntry@8+0x30a>
   11cfc:	50                   	push   %eax
   11cfd:	8d 86 18 12 00 00    	lea    0x1218(%esi),%eax
   11d03:	56                   	push   %esi
   11d04:	68 00 10 01 00       	push   $0x11000
   11d09:	50                   	push   %eax
   11d0a:	e8 e1 1b 00 00       	call   138f0 <_KeInitializeDpc@12>
   11d0f:	50                   	push   %eax
   11d10:	50                   	push   %eax
   11d11:	8d 86 f0 11 00 00    	lea    0x11f0(%esi),%eax
   11d17:	50                   	push   %eax
   11d18:	e8 f3 1b 00 00       	call   13910 <_KeInitializeTimer@4>
   11d1d:	5f                   	pop    %edi
   11d1e:	58                   	pop    %eax
   11d1f:	8d 86 dd 11 00 00    	lea    0x11dd(%esi),%eax
   11d25:	6a 00                	push   $0x0
   11d27:	6a 00                	push   $0x0
   11d29:	50                   	push   %eax
   11d2a:	e8 01 1b 00 00       	call   13830 <_KeInitializeEvent@12>
   11d2f:	31 ff                	xor    %edi,%edi
   11d31:	5b                   	pop    %ebx
   11d32:	c6 86 38 12 00 00 00 	movb   $0x0,0x1238(%esi)
   11d39:	80 7e 70 00          	cmpb   $0x0,0x70(%esi)
   11d3d:	74 1a                	je     11d59 <_DriverEntry@8+0x3f9>
   11d3f:	8d 5e 78             	lea    0x78(%esi),%ebx
   11d42:	89 d8                	mov    %ebx,%eax
   11d44:	47                   	inc    %edi
   11d45:	e8 96 f4 ff ff       	call   111e0 <_Recalibrate@4>
   11d4a:	31 c0                	xor    %eax,%eax
   11d4c:	8a 46 70             	mov    0x70(%esi),%al
   11d4f:	81 c3 58 04 00 00    	add    $0x458,%ebx
   11d55:	39 f8                	cmp    %edi,%eax
   11d57:	7f e9                	jg     11d42 <_DriverEntry@8+0x3e2>
   11d59:	31 db                	xor    %ebx,%ebx
   11d5b:	c6 85 86 fd ff ff 00 	movb   $0x0,0xfffffd86(%ebp)
   11d62:	8a 9d 87 fd ff ff    	mov    0xfffffd87(%ebp),%bl
   11d68:	8d 04 db             	lea    (%ebx,%ebx,8),%eax
   11d6b:	8d 04 c3             	lea    (%ebx,%eax,8),%eax
   11d6e:	c1 e0 06             	shl    $0x6,%eax
   11d71:	c6 80 11 50 01 00 01 	movb   $0x1,0x15011(%eax)
   11d78:	80 b8 80 50 01 00 00 	cmpb   $0x0,0x15080(%eax)
   11d7f:	0f 84 0c fe ff ff    	je     11b91 <_DriverEntry@8+0x231>
   11d85:	89 9d 7c fd ff ff    	mov    %ebx,0xfffffd7c(%ebp)
   11d8b:	8a 95 86 fd ff ff    	mov    0xfffffd86(%ebp),%dl
   11d91:	8d 04 9a             	lea    (%edx,%ebx,4),%eax
   11d94:	25 ff 00 00 00       	and    $0xff,%eax
   11d99:	52                   	push   %edx
   11d9a:	89 85 80 fd ff ff    	mov    %eax,0xfffffd80(%ebp)
   11da0:	50                   	push   %eax
   11da1:	8d 85 b8 fd ff ff    	lea    0xfffffdb8(%ebp),%eax
   11da7:	68 00 40 01 00       	push   $0x14000
   11dac:	50                   	push   %eax
   11dad:	e8 9e 1b 00 00       	call   13950 <_swprintf>
   11db2:	5e                   	pop    %esi
   11db3:	8d 95 b8 fd ff ff    	lea    0xfffffdb8(%ebp),%edx
   11db9:	5f                   	pop    %edi
   11dba:	8d 85 98 fd ff ff    	lea    0xfffffd98(%ebp),%eax
   11dc0:	52                   	push   %edx
   11dc1:	50                   	push   %eax
   11dc2:	e8 29 1a 00 00       	call   137f0 <_RtlInitUnicodeString@8>
   11dc7:	8d 04 db             	lea    (%ebx,%ebx,8),%eax
   11dca:	31 d2                	xor    %edx,%edx
   11dcc:	8d 3c c3             	lea    (%ebx,%eax,8),%edi
   11dcf:	8a 95 86 fd ff ff    	mov    0xfffffd86(%ebp),%dl
   11dd5:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11dd8:	c1 e7 06             	shl    $0x6,%edi
   11ddb:	89 d0                	mov    %edx,%eax
   11ddd:	c1 e0 04             	shl    $0x4,%eax
   11de0:	01 d0                	add    %edx,%eax
   11de2:	8d 04 82             	lea    (%edx,%eax,4),%eax
   11de5:	8d 04 42             	lea    (%edx,%eax,2),%eax
   11de8:	8d 95 98 fd ff ff    	lea    0xfffffd98(%ebp),%edx
   11dee:	8d 34 c7             	lea    (%edi,%eax,8),%esi
   11df1:	8d 86 98 50 01 00    	lea    0x15098(%esi),%eax
   11df7:	89 04 24             	mov    %eax,(%esp)
   11dfa:	6a 00                	push   $0x0
   11dfc:	6a 05                	push   $0x5
   11dfe:	6a 07                	push   $0x7
   11e00:	52                   	push   %edx
   11e01:	6a 04                	push   $0x4
   11e03:	51                   	push   %ecx
   11e04:	e8 17 1b 00 00       	call   13920 <_IoCreateDevice@28>
   11e09:	5a                   	pop    %edx
   11e0a:	85 c0                	test   %eax,%eax
   11e0c:	74 48                	je     11e56 <_DriverEntry@8+0x4f6>
   11e0e:	83 ec 0c             	sub    $0xc,%esp
   11e11:	8b 87 78 50 01 00    	mov    0x15078(%edi),%eax
   11e17:	50                   	push   %eax
   11e18:	e8 03 1a 00 00       	call   13820 <_IoDisconnectInterrupt@4>
   11e1d:	83 c4 0c             	add    $0xc,%esp
   11e20:	8b 9d 7c fd ff ff    	mov    0xfffffd7c(%ebp),%ebx
   11e26:	fe 85 86 fd ff ff    	incb   0xfffffd86(%ebp)
   11e2c:	8d 04 db             	lea    (%ebx,%ebx,8),%eax
   11e2f:	8a 95 86 fd ff ff    	mov    0xfffffd86(%ebp),%dl
   11e35:	8d 04 c3             	lea    (%ebx,%eax,8),%eax
   11e38:	c1 e0 06             	shl    $0x6,%eax
   11e3b:	38 90 80 50 01 00    	cmp    %dl,0x15080(%eax)
   11e41:	0f 87 44 ff ff ff    	ja     11d8b <_DriverEntry@8+0x42b>
   11e47:	e9 45 fd ff ff       	jmp    11b91 <_DriverEntry@8+0x231>
   11e4c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11e50:	cc                   	int3   
   11e51:	e9 fb fd ff ff       	jmp    11c51 <_DriverEntry@8+0x2f1>
   11e56:	83 ec 0c             	sub    $0xc,%esp
   11e59:	8b 85 80 fd ff ff    	mov    0xfffffd80(%ebp),%eax
   11e5f:	50                   	push   %eax
   11e60:	53                   	push   %ebx
   11e61:	8b 9f 1c 50 01 00    	mov    0x1501c(%edi),%ebx
   11e67:	53                   	push   %ebx
   11e68:	8d 9e d8 52 01 00    	lea    0x152d8(%esi),%ebx
   11e6e:	68 24 40 01 00       	push   $0x14024
   11e73:	53                   	push   %ebx
   11e74:	e8 d7 1a 00 00       	call   13950 <_swprintf>
   11e79:	83 c4 18             	add    $0x18,%esp
   11e7c:	8d 85 90 fd ff ff    	lea    0xfffffd90(%ebp),%eax
   11e82:	53                   	push   %ebx
   11e83:	50                   	push   %eax
   11e84:	e8 67 19 00 00       	call   137f0 <_RtlInitUnicodeString@8>
   11e89:	8d 95 98 fd ff ff    	lea    0xfffffd98(%ebp),%edx
   11e8f:	8d 85 90 fd ff ff    	lea    0xfffffd90(%ebp),%eax
   11e95:	52                   	push   %edx
   11e96:	50                   	push   %eax
   11e97:	e8 94 1a 00 00       	call   13930 <_IoCreateSymbolicLink@8>
   11e9c:	8b 86 98 50 01 00    	mov    0x15098(%esi),%eax
   11ea2:	8b 48 1c             	mov    0x1c(%eax),%ecx
   11ea5:	8d 9e da 50 01 00    	lea    0x150da(%esi),%ebx
   11eab:	83 c9 10             	or     $0x10,%ecx
   11eae:	89 48 1c             	mov    %ecx,0x1c(%eax)
   11eb1:	8b 85 80 fd ff ff    	mov    0xfffffd80(%ebp),%eax
   11eb7:	83 c0 41             	add    $0x41,%eax
   11eba:	89 04 24             	mov    %eax,(%esp)
   11ebd:	68 6c 40 01 00       	push   $0x1406c
   11ec2:	53                   	push   %ebx
   11ec3:	e8 88 1a 00 00       	call   13950 <_swprintf>
   11ec8:	58                   	pop    %eax
   11ec9:	5a                   	pop    %edx
   11eca:	53                   	push   %ebx
   11ecb:	8d 9d 88 fd ff ff    	lea    0xfffffd88(%ebp),%ebx
   11ed1:	53                   	push   %ebx
   11ed2:	e8 19 19 00 00       	call   137f0 <_RtlInitUnicodeString@8>
   11ed7:	8d 95 98 fd ff ff    	lea    0xfffffd98(%ebp),%edx
   11edd:	52                   	push   %edx
   11ede:	53                   	push   %ebx
   11edf:	e8 4c 1a 00 00       	call   13930 <_IoCreateSymbolicLink@8>
   11ee4:	5a                   	pop    %edx
   11ee5:	89 c3                	mov    %eax,%ebx
   11ee7:	59                   	pop    %ecx
   11ee8:	85 c0                	test   %eax,%eax
   11eea:	74 20                	je     11f0c <_DriverEntry@8+0x5ac>
   11eec:	83 ec 0c             	sub    $0xc,%esp
   11eef:	8b 87 78 50 01 00    	mov    0x15078(%edi),%eax
   11ef5:	50                   	push   %eax
   11ef6:	e8 25 19 00 00       	call   13820 <_IoDisconnectInterrupt@4>
   11efb:	8d 85 90 fd ff ff    	lea    0xfffffd90(%ebp),%eax
   11f01:	50                   	push   %eax
   11f02:	e8 f9 18 00 00       	call   13800 <_IoDeleteSymbolicLink@4>
   11f07:	e9 11 ff ff ff       	jmp    11e1d <_DriverEntry@8+0x4bd>
   11f0c:	50                   	push   %eax
   11f0d:	8b 86 98 50 01 00    	mov    0x15098(%esi),%eax
   11f13:	8d be c0 50 01 00    	lea    0x150c0(%esi),%edi
   11f19:	50                   	push   %eax
   11f1a:	8b 86 98 50 01 00    	mov    0x15098(%esi),%eax
   11f20:	83 c0 74             	add    $0x74,%eax
   11f23:	68 f0 17 01 00       	push   $0x117f0
   11f28:	50                   	push   %eax
   11f29:	e8 c2 19 00 00       	call   138f0 <_KeInitializeDpc@12>
   11f2e:	8b 96 98 50 01 00    	mov    0x15098(%esi),%edx
   11f34:	58                   	pop    %eax
   11f35:	fc                   	cld    
   11f36:	8d 86 88 50 01 00    	lea    0x15088(%esi),%eax
   11f3c:	b9 06 00 00 00       	mov    $0x6,%ecx
   11f41:	89 42 28             	mov    %eax,0x28(%edx)
   11f44:	89 d8                	mov    %ebx,%eax
   11f46:	f3 ab                	repz stos %eax,%es:(%edi)
   11f48:	c7 86 c8 50 01 00 00 	movl   $0x0,0x150c8(%esi)
   11f4f:	00 00 00 
   11f52:	c6 86 dc 54 01 00 01 	movb   $0x1,0x154dc(%esi)
   11f59:	e9 c2 fe ff ff       	jmp    11e20 <_DriverEntry@8+0x4c0>
   11f5e:	53                   	push   %ebx
   11f5f:	53                   	push   %ebx
   11f60:	6a 00                	push   $0x0
   11f62:	6a 00                	push   $0x0
   11f64:	6a 00                	push   $0x0
   11f66:	6a 01                	push   $0x1
   11f68:	6a 01                	push   $0x1
   11f6a:	56                   	push   %esi
   11f6b:	e8 c0 08 00 00       	call   12830 <_HwConfigure@24>
   11f70:	5a                   	pop    %edx
   11f71:	85 c0                	test   %eax,%eax
   11f73:	59                   	pop    %ecx
   11f74:	0f 94 46 71          	sete   0x71(%esi)
   11f78:	e9 5c fd ff ff       	jmp    11cd9 <_DriverEntry@8+0x379>
   11f7d:	90                   	nop    
   11f7e:	90                   	nop    
   11f7f:	90                   	nop    

00011f80 <_CsqRemoveIrp@8>:
   11f80:	55                   	push   %ebp
   11f81:	89 e5                	mov    %esp,%ebp
   11f83:	8b 45 0c             	mov    0xc(%ebp),%eax
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   11f86:	8b 50 58             	mov    0x58(%eax),%edx
  OldBlink = Entry->Blink;
   11f89:	8b 40 5c             	mov    0x5c(%eax),%eax
  OldFlink->Blink = OldBlink;
   11f8c:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   11f8f:	89 10                	mov    %edx,(%eax)
   11f91:	5d                   	pop    %ebp
   11f92:	c2 08 00             	ret    $0x8
   11f95:	8d 74 26 00          	lea    0x0(%esi),%esi
   11f99:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011fa0 <_CsqPeekNextIrp@12>:
   11fa0:	55                   	push   %ebp
   11fa1:	89 e5                	mov    %esp,%ebp
   11fa3:	8b 45 0c             	mov    0xc(%ebp),%eax
   11fa6:	85 c0                	test   %eax,%eax
   11fa8:	74 06                	je     11fb0 <_CsqPeekNextIrp@12+0x10>
   11faa:	5d                   	pop    %ebp
   11fab:	c2 0c 00             	ret    $0xc
   11fae:	89 f6                	mov    %esi,%esi
   11fb0:	8b 15 40 99 01 00    	mov    0x19940,%edx
   11fb6:	81 fa 40 99 01 00    	cmp    $0x19940,%edx
   11fbc:	74 ec                	je     11faa <_CsqPeekNextIrp@12+0xa>
   11fbe:	8d 42 a8             	lea    0xffffffa8(%edx),%eax
   11fc1:	5d                   	pop    %ebp
   11fc2:	c2 0c 00             	ret    $0xc
   11fc5:	8d 74 26 00          	lea    0x0(%esi),%esi
   11fc9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011fd0 <_CsqAcquireLock@8>:
   11fd0:	55                   	push   %ebp
   11fd1:	89 e5                	mov    %esp,%ebp
   11fd3:	c7 45 08 70 99 01 00 	movl   $0x19970,0x8(%ebp)
   11fda:	c9                   	leave  
   11fdb:	e9 30 1a 00 00       	jmp    13a10 <_KeAcquireSpinLock@8>

00011fe0 <_CsqReleaseLock@8>:
   11fe0:	55                   	push   %ebp
   11fe1:	31 c0                	xor    %eax,%eax
   11fe3:	89 e5                	mov    %esp,%ebp
   11fe5:	8a 45 0c             	mov    0xc(%ebp),%al
   11fe8:	c7 45 08 70 99 01 00 	movl   $0x19970,0x8(%ebp)
   11fef:	89 45 0c             	mov    %eax,0xc(%ebp)
   11ff2:	c9                   	leave  
   11ff3:	e9 28 1a 00 00       	jmp    13a20 <_KeReleaseSpinLock@8>
   11ff8:	90                   	nop    
   11ff9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00012000 <_CsqCompleteCanceledIrp@8>:
   12000:	55                   	push   %ebp
   12001:	89 e5                	mov    %esp,%ebp
   12003:	8b 45 0c             	mov    0xc(%ebp),%eax
   12006:	c7 40 18 20 01 00 c0 	movl   $0xc0000120,0x18(%eax)
   1200d:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   12014:	c7 45 0c 00 00 00 00 	movl   $0x0,0xc(%ebp)
   1201b:	89 45 08             	mov    %eax,0x8(%ebp)
   1201e:	c9                   	leave  
   1201f:	e9 ac 17 00 00       	jmp    137d0 <_IoCompleteRequest@8>
   12024:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1202a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00012030 <_CsqInsertIrp@8>:
   12030:	55                   	push   %ebp
   12031:	89 e5                	mov    %esp,%ebp
   12033:	50                   	push   %eax
   12034:	50                   	push   %eax
   12035:	8b 45 0c             	mov    0xc(%ebp),%eax
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   12038:	8b 0d 44 99 01 00    	mov    0x19944,%ecx
   1203e:	8d 50 58             	lea    0x58(%eax),%edx
	Entry->Flink = ListHead;
   12041:	c7 40 58 40 99 01 00 	movl   $0x19940,0x58(%eax)
	Entry->Blink = OldBlink;
	OldBlink->Flink = Entry;
   12048:	89 11                	mov    %edx,(%ecx)
   1204a:	89 4a 04             	mov    %ecx,0x4(%edx)
   1204d:	6a 00                	push   $0x0
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
	Entry->Blink = OldBlink;
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   1204f:	89 15 44 99 01 00    	mov    %edx,0x19944
   12055:	6a 01                	push   $0x1
   12057:	6a 00                	push   $0x0
   12059:	68 50 99 01 00       	push   $0x19950
   1205e:	e8 fd 18 00 00       	call   13960 <_KeReleaseSemaphore@16>
   12063:	c9                   	leave  
   12064:	c2 08 00             	ret    $0x8
   12067:	90                   	nop    
   12068:	90                   	nop    
   12069:	90                   	nop    
   1206a:	90                   	nop    
   1206b:	90                   	nop    
   1206c:	90                   	nop    
   1206d:	90                   	nop    
   1206e:	90                   	nop    
   1206f:	90                   	nop    

00012070 <_HwDumpRegisters@4>:
   12070:	55                   	push   %ebp
   12071:	89 e5                	mov    %esp,%ebp
   12073:	5d                   	pop    %ebp
   12074:	c2 04 00             	ret    $0x4
   12077:	89 f6                	mov    %esi,%esi
   12079:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012080 <_Send_Byte@8>:
   12080:	55                   	push   %ebp
   12081:	89 e5                	mov    %esp,%ebp
   12083:	57                   	push   %edi
   12084:	56                   	push   %esi
   12085:	53                   	push   %ebx
   12086:	83 ec 3c             	sub    $0x3c,%esp
   12089:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   1208c:	88 55 db             	mov    %dl,0xffffffdb(%ebp)
   1208f:	e8 3c 19 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12094:	3c 01                	cmp    $0x1,%al
   12096:	76 01                	jbe    12099 <_Send_Byte@8+0x19>
   12098:	cc                   	int3   
   12099:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   1209c:	8b 42 24             	mov    0x24(%edx),%eax
   1209f:	8d 48 05             	lea    0x5(%eax),%ecx
   120a2:	89 4d d4             	mov    %ecx,0xffffffd4(%ebp)
   120a5:	8b 0d 30 99 01 00    	mov    0x19930,%ecx
   120ab:	85 c9                	test   %ecx,%ecx
   120ad:	0f 84 f4 00 00 00    	je     121a7 <_Send_Byte@8+0x127>
   120b3:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   120ba:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   120c1:	83 ec 0c             	sub    $0xc,%esp
   120c4:	83 c0 04             	add    $0x4,%eax
   120c7:	50                   	push   %eax
   120c8:	e8 63 19 00 00       	call   13a30 <_READ_PORT_UCHAR@4>
   120cd:	31 d2                	xor    %edx,%edx
   120cf:	83 c4 0c             	add    $0xc,%esp
   120d2:	a8 40                	test   $0x40,%al
   120d4:	75 06                	jne    120dc <_Send_Byte@8+0x5c>
   120d6:	0f be d0             	movsbl %al,%edx
   120d9:	c1 ea 1f             	shr    $0x1f,%edx
   120dc:	85 d2                	test   %edx,%edx
   120de:	75 3a                	jne    1211a <_Send_Byte@8+0x9a>
   120e0:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   120e3:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   120e6:	89 d1                	mov    %edx,%ecx
   120e8:	09 c1                	or     %eax,%ecx
   120ea:	75 49                	jne    12135 <_Send_Byte@8+0xb5>
   120ec:	83 ec 0c             	sub    $0xc,%esp
   120ef:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   120f2:	50                   	push   %eax
   120f3:	e8 78 18 00 00       	call   13970 <_KeQueryTickCount@4>
   120f8:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   120fb:	83 c4 0c             	add    $0xc,%esp
   120fe:	83 ec 0c             	sub    $0xc,%esp
   12101:	8b 42 24             	mov    0x24(%edx),%eax
   12104:	83 c0 04             	add    $0x4,%eax
   12107:	50                   	push   %eax
   12108:	e8 23 19 00 00       	call   13a30 <_READ_PORT_UCHAR@4>
   1210d:	31 d2                	xor    %edx,%edx
   1210f:	83 c4 0c             	add    $0xc,%esp
   12112:	a8 40                	test   $0x40,%al
   12114:	74 c0                	je     120d6 <_Send_Byte@8+0x56>
   12116:	85 d2                	test   %edx,%edx
   12118:	74 c6                	je     120e0 <_Send_Byte@8+0x60>
   1211a:	31 c0                	xor    %eax,%eax
   1211c:	52                   	push   %edx
   1211d:	52                   	push   %edx
   1211e:	8a 45 db             	mov    0xffffffdb(%ebp),%al
   12121:	50                   	push   %eax
   12122:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   12125:	50                   	push   %eax
   12126:	e8 15 19 00 00       	call   13a40 <_WRITE_PORT_UCHAR@8>
   1212b:	31 c0                	xor    %eax,%eax
   1212d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12130:	5b                   	pop    %ebx
   12131:	5e                   	pop    %esi
   12132:	5f                   	pop    %edi
   12133:	5d                   	pop    %ebp
   12134:	c3                   	ret    
   12135:	83 ec 0c             	sub    $0xc,%esp
   12138:	8d 45 e0             	lea    0xffffffe0(%ebp),%eax
   1213b:	50                   	push   %eax
   1213c:	e8 2f 18 00 00       	call   13970 <_KeQueryTickCount@4>
   12141:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   12144:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   12147:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
   1214a:	89 55 c4             	mov    %edx,0xffffffc4(%ebp)
   1214d:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   12150:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   12153:	29 55 c0             	sub    %edx,0xffffffc0(%ebp)
   12156:	19 4d c4             	sbb    %ecx,0xffffffc4(%ebp)
   12159:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
   1215c:	8b 0d 30 99 01 00    	mov    0x19930,%ecx
   12162:	8b 7d c4             	mov    0xffffffc4(%ebp),%edi
   12165:	f7 e1                	mul    %ecx
   12167:	31 db                	xor    %ebx,%ebx
   12169:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
   1216c:	0f af f9             	imul   %ecx,%edi
   1216f:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
   12172:	89 d6                	mov    %edx,%esi
   12174:	0f af c3             	imul   %ebx,%eax
   12177:	01 fe                	add    %edi,%esi
   12179:	83 c4 0c             	add    $0xc,%esp
   1217c:	01 c6                	add    %eax,%esi
   1217e:	89 75 cc             	mov    %esi,0xffffffcc(%ebp)
   12181:	83 fe 00             	cmp    $0x0,%esi
   12184:	77 14                	ja     1219a <_Send_Byte@8+0x11a>
   12186:	81 7d c8 40 78 7d 01 	cmpl   $0x17d7840,0xffffffc8(%ebp)
   1218d:	77 0b                	ja     1219a <_Send_Byte@8+0x11a>
   1218f:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx
   12192:	8b 41 24             	mov    0x24(%ecx),%eax
   12195:	e9 27 ff ff ff       	jmp    120c1 <_Send_Byte@8+0x41>
   1219a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1219d:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   121a2:	5b                   	pop    %ebx
   121a3:	5e                   	pop    %esi
   121a4:	5f                   	pop    %edi
   121a5:	5d                   	pop    %ebp
   121a6:	c3                   	ret    
   121a7:	e8 d4 17 00 00       	call   13980 <_KeQueryTimeIncrement@0>
   121ac:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   121af:	a3 30 99 01 00       	mov    %eax,0x19930
   121b4:	8b 42 24             	mov    0x24(%edx),%eax
   121b7:	e9 f7 fe ff ff       	jmp    120b3 <_Send_Byte@8+0x33>
   121bc:	8d 74 26 00          	lea    0x0(%esi),%esi

000121c0 <_Get_Byte@8>:
   121c0:	55                   	push   %ebp
   121c1:	89 e5                	mov    %esp,%ebp
   121c3:	57                   	push   %edi
   121c4:	56                   	push   %esi
   121c5:	53                   	push   %ebx
   121c6:	83 ec 3c             	sub    $0x3c,%esp
   121c9:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   121cc:	89 55 d8             	mov    %edx,0xffffffd8(%ebp)
   121cf:	e8 fc 17 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   121d4:	3c 01                	cmp    $0x1,%al
   121d6:	76 01                	jbe    121d9 <_Get_Byte@8+0x19>
   121d8:	cc                   	int3   
   121d9:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   121dc:	8b 35 30 99 01 00    	mov    0x19930,%esi
   121e2:	85 f6                	test   %esi,%esi
   121e4:	8b 42 24             	mov    0x24(%edx),%eax
   121e7:	8d 48 05             	lea    0x5(%eax),%ecx
   121ea:	89 4d d4             	mov    %ecx,0xffffffd4(%ebp)
   121ed:	0f 84 f4 00 00 00    	je     122e7 <_Get_Byte@8+0x127>
   121f3:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   121fa:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   12201:	83 ec 0c             	sub    $0xc,%esp
   12204:	83 c0 04             	add    $0x4,%eax
   12207:	50                   	push   %eax
   12208:	e8 23 18 00 00       	call   13a30 <_READ_PORT_UCHAR@4>
   1220d:	31 d2                	xor    %edx,%edx
   1220f:	83 c4 0c             	add    $0xc,%esp
   12212:	a8 40                	test   $0x40,%al
   12214:	74 06                	je     1221c <_Get_Byte@8+0x5c>
   12216:	0f be d0             	movsbl %al,%edx
   12219:	c1 ea 1f             	shr    $0x1f,%edx
   1221c:	85 d2                	test   %edx,%edx
   1221e:	75 3a                	jne    1225a <_Get_Byte@8+0x9a>
   12220:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   12223:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   12226:	89 d1                	mov    %edx,%ecx
   12228:	09 c1                	or     %eax,%ecx
   1222a:	75 49                	jne    12275 <_Get_Byte@8+0xb5>
   1222c:	83 ec 0c             	sub    $0xc,%esp
   1222f:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   12232:	50                   	push   %eax
   12233:	e8 38 17 00 00       	call   13970 <_KeQueryTickCount@4>
   12238:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   1223b:	83 c4 0c             	add    $0xc,%esp
   1223e:	83 ec 0c             	sub    $0xc,%esp
   12241:	8b 42 24             	mov    0x24(%edx),%eax
   12244:	83 c0 04             	add    $0x4,%eax
   12247:	50                   	push   %eax
   12248:	e8 e3 17 00 00       	call   13a30 <_READ_PORT_UCHAR@4>
   1224d:	31 d2                	xor    %edx,%edx
   1224f:	83 c4 0c             	add    $0xc,%esp
   12252:	a8 40                	test   $0x40,%al
   12254:	75 c0                	jne    12216 <_Get_Byte@8+0x56>
   12256:	85 d2                	test   %edx,%edx
   12258:	74 c6                	je     12220 <_Get_Byte@8+0x60>
   1225a:	83 ec 0c             	sub    $0xc,%esp
   1225d:	8b 5d d4             	mov    0xffffffd4(%ebp),%ebx
   12260:	53                   	push   %ebx
   12261:	e8 ca 17 00 00       	call   13a30 <_READ_PORT_UCHAR@4>
   12266:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   12269:	88 02                	mov    %al,(%edx)
   1226b:	31 c0                	xor    %eax,%eax
   1226d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12270:	5b                   	pop    %ebx
   12271:	5e                   	pop    %esi
   12272:	5f                   	pop    %edi
   12273:	5d                   	pop    %ebp
   12274:	c3                   	ret    
   12275:	83 ec 0c             	sub    $0xc,%esp
   12278:	8d 45 e0             	lea    0xffffffe0(%ebp),%eax
   1227b:	50                   	push   %eax
   1227c:	e8 ef 16 00 00       	call   13970 <_KeQueryTickCount@4>
   12281:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   12284:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   12287:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
   1228a:	89 55 c4             	mov    %edx,0xffffffc4(%ebp)
   1228d:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   12290:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   12293:	29 55 c0             	sub    %edx,0xffffffc0(%ebp)
   12296:	19 4d c4             	sbb    %ecx,0xffffffc4(%ebp)
   12299:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
   1229c:	8b 0d 30 99 01 00    	mov    0x19930,%ecx
   122a2:	8b 7d c4             	mov    0xffffffc4(%ebp),%edi
   122a5:	f7 e1                	mul    %ecx
   122a7:	31 db                	xor    %ebx,%ebx
   122a9:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
   122ac:	0f af f9             	imul   %ecx,%edi
   122af:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
   122b2:	89 d6                	mov    %edx,%esi
   122b4:	0f af c3             	imul   %ebx,%eax
   122b7:	01 fe                	add    %edi,%esi
   122b9:	83 c4 0c             	add    $0xc,%esp
   122bc:	01 c6                	add    %eax,%esi
   122be:	89 75 cc             	mov    %esi,0xffffffcc(%ebp)
   122c1:	83 fe 00             	cmp    $0x0,%esi
   122c4:	77 14                	ja     122da <_Get_Byte@8+0x11a>
   122c6:	81 7d c8 40 78 7d 01 	cmpl   $0x17d7840,0xffffffc8(%ebp)
   122cd:	77 0b                	ja     122da <_Get_Byte@8+0x11a>
   122cf:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx
   122d2:	8b 41 24             	mov    0x24(%ecx),%eax
   122d5:	e9 27 ff ff ff       	jmp    12201 <_Get_Byte@8+0x41>
   122da:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   122dd:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   122e2:	5b                   	pop    %ebx
   122e3:	5e                   	pop    %esi
   122e4:	5f                   	pop    %edi
   122e5:	5d                   	pop    %ebp
   122e6:	c3                   	ret    
   122e7:	e8 94 16 00 00       	call   13980 <_KeQueryTimeIncrement@0>
   122ec:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   122ef:	a3 30 99 01 00       	mov    %eax,0x19930
   122f4:	8b 42 24             	mov    0x24(%edx),%eax
   122f7:	e9 f7 fe ff ff       	jmp    121f3 <_Get_Byte@8+0x33>
   122fc:	8d 74 26 00          	lea    0x0(%esi),%esi

00012300 <_HwSetDataRate@8>:
   12300:	55                   	push   %ebp
   12301:	31 c0                	xor    %eax,%eax
   12303:	89 e5                	mov    %esp,%ebp
   12305:	83 ec 10             	sub    $0x10,%esp
   12308:	8a 45 0c             	mov    0xc(%ebp),%al
   1230b:	50                   	push   %eax
   1230c:	8b 45 08             	mov    0x8(%ebp),%eax
   1230f:	8b 40 24             	mov    0x24(%eax),%eax
   12312:	83 c0 04             	add    $0x4,%eax
   12315:	50                   	push   %eax
   12316:	e8 25 17 00 00       	call   13a40 <_WRITE_PORT_UCHAR@8>
   1231b:	31 c0                	xor    %eax,%eax
   1231d:	c9                   	leave  
   1231e:	c2 08 00             	ret    $0x8
   12321:	eb 0d                	jmp    12330 <_HwTurnOffMotor@4>
   12323:	90                   	nop    
   12324:	90                   	nop    
   12325:	90                   	nop    
   12326:	90                   	nop    
   12327:	90                   	nop    
   12328:	90                   	nop    
   12329:	90                   	nop    
   1232a:	90                   	nop    
   1232b:	90                   	nop    
   1232c:	90                   	nop    
   1232d:	90                   	nop    
   1232e:	90                   	nop    
   1232f:	90                   	nop    

00012330 <_HwTurnOffMotor@4>:
   12330:	55                   	push   %ebp
   12331:	89 e5                	mov    %esp,%ebp
   12333:	83 ec 10             	sub    $0x10,%esp
   12336:	8b 45 08             	mov    0x8(%ebp),%eax
   12339:	6a 0c                	push   $0xc
   1233b:	8b 40 24             	mov    0x24(%eax),%eax
   1233e:	83 c0 02             	add    $0x2,%eax
   12341:	50                   	push   %eax
   12342:	e8 f9 16 00 00       	call   13a40 <_WRITE_PORT_UCHAR@8>
   12347:	31 c0                	xor    %eax,%eax
   12349:	c9                   	leave  
   1234a:	c2 04 00             	ret    $0x4
   1234d:	8d 76 00             	lea    0x0(%esi),%esi

00012350 <_HwTurnOnMotor@4>:
   12350:	55                   	push   %ebp
   12351:	89 e5                	mov    %esp,%ebp
   12353:	56                   	push   %esi
   12354:	53                   	push   %ebx
   12355:	8b 45 08             	mov    0x8(%ebp),%eax
   12358:	8b 30                	mov    (%eax),%esi
   1235a:	8a 58 04             	mov    0x4(%eax),%bl
   1235d:	e8 6e 16 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12362:	3c 01                	cmp    $0x1,%al
   12364:	76 01                	jbe    12367 <_HwTurnOnMotor@4+0x17>
   12366:	cc                   	int3   
   12367:	88 d8                	mov    %bl,%al
   12369:	83 c8 0c             	or     $0xc,%eax
   1236c:	84 db                	test   %bl,%bl
   1236e:	75 22                	jne    12392 <_HwTurnOnMotor@4+0x42>
   12370:	83 c8 10             	or     $0x10,%eax
   12373:	25 ff 00 00 00       	and    $0xff,%eax
   12378:	52                   	push   %edx
   12379:	52                   	push   %edx
   1237a:	50                   	push   %eax
   1237b:	8b 46 24             	mov    0x24(%esi),%eax
   1237e:	83 c0 02             	add    $0x2,%eax
   12381:	50                   	push   %eax
   12382:	e8 b9 16 00 00       	call   13a40 <_WRITE_PORT_UCHAR@8>
   12387:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1238a:	31 c0                	xor    %eax,%eax
   1238c:	5b                   	pop    %ebx
   1238d:	5e                   	pop    %esi
   1238e:	5d                   	pop    %ebp
   1238f:	c2 04 00             	ret    $0x4
   12392:	80 fb 01             	cmp    $0x1,%bl
   12395:	74 0f                	je     123a6 <_HwTurnOnMotor@4+0x56>
   12397:	80 fb 02             	cmp    $0x2,%bl
   1239a:	74 2c                	je     123c8 <_HwTurnOnMotor@4+0x78>
   1239c:	80 fb 03             	cmp    $0x3,%bl
   1239f:	75 d2                	jne    12373 <_HwTurnOnMotor@4+0x23>
   123a1:	83 c8 80             	or     $0xffffff80,%eax
   123a4:	eb cd                	jmp    12373 <_HwTurnOnMotor@4+0x23>
   123a6:	83 c8 20             	or     $0x20,%eax
   123a9:	25 ff 00 00 00       	and    $0xff,%eax
   123ae:	52                   	push   %edx
   123af:	52                   	push   %edx
   123b0:	50                   	push   %eax
   123b1:	8b 46 24             	mov    0x24(%esi),%eax
   123b4:	83 c0 02             	add    $0x2,%eax
   123b7:	50                   	push   %eax
   123b8:	e8 83 16 00 00       	call   13a40 <_WRITE_PORT_UCHAR@8>
   123bd:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   123c0:	31 c0                	xor    %eax,%eax
   123c2:	5b                   	pop    %ebx
   123c3:	5e                   	pop    %esi
   123c4:	5d                   	pop    %ebp
   123c5:	c2 04 00             	ret    $0x4
   123c8:	83 c8 40             	or     $0x40,%eax
   123cb:	25 ff 00 00 00       	and    $0xff,%eax
   123d0:	52                   	push   %edx
   123d1:	52                   	push   %edx
   123d2:	50                   	push   %eax
   123d3:	8b 46 24             	mov    0x24(%esi),%eax
   123d6:	83 c0 02             	add    $0x2,%eax
   123d9:	50                   	push   %eax
   123da:	e8 61 16 00 00       	call   13a40 <_WRITE_PORT_UCHAR@8>
   123df:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   123e2:	31 c0                	xor    %eax,%eax
   123e4:	5b                   	pop    %ebx
   123e5:	5e                   	pop    %esi
   123e6:	5d                   	pop    %ebp
   123e7:	c2 04 00             	ret    $0x4
   123ea:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

000123f0 <_HwSenseDriveStatus@4>:
   123f0:	55                   	push   %ebp
   123f1:	89 e5                	mov    %esp,%ebp
   123f3:	57                   	push   %edi
   123f4:	56                   	push   %esi
   123f5:	53                   	push   %ebx
   123f6:	83 ec 0c             	sub    $0xc,%esp
   123f9:	8b 7d 08             	mov    0x8(%ebp),%edi
   123fc:	e8 cf 15 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12401:	3c 01                	cmp    $0x1,%al
   12403:	76 01                	jbe    12406 <_HwSenseDriveStatus@4+0x16>
   12405:	cc                   	int3   
   12406:	c6 45 f2 04          	movb   $0x4,0xfffffff2(%ebp)
   1240a:	8d 75 f2             	lea    0xfffffff2(%ebp),%esi
   1240d:	8a 47 04             	mov    0x4(%edi),%al
   12410:	31 db                	xor    %ebx,%ebx
   12412:	88 45 f3             	mov    %al,0xfffffff3(%ebp)
   12415:	31 d2                	xor    %edx,%edx
   12417:	8b 07                	mov    (%edi),%eax
   12419:	8a 14 33             	mov    (%ebx,%esi,1),%dl
   1241c:	e8 5f fc ff ff       	call   12080 <_Send_Byte@8>
   12421:	85 c0                	test   %eax,%eax
   12423:	75 12                	jne    12437 <_HwSenseDriveStatus@4+0x47>
   12425:	43                   	inc    %ebx
   12426:	83 fb 01             	cmp    $0x1,%ebx
   12429:	7e ea                	jle    12415 <_HwSenseDriveStatus@4+0x25>
   1242b:	31 c0                	xor    %eax,%eax
   1242d:	83 c4 0c             	add    $0xc,%esp
   12430:	5b                   	pop    %ebx
   12431:	5e                   	pop    %esi
   12432:	5f                   	pop    %edi
   12433:	5d                   	pop    %ebp
   12434:	c2 04 00             	ret    $0x4
   12437:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   1243c:	eb ef                	jmp    1242d <_HwSenseDriveStatus@4+0x3d>
   1243e:	89 f6                	mov    %esi,%esi

00012440 <_HwReadWriteData@40>:
   12440:	55                   	push   %ebp
   12441:	89 e5                	mov    %esp,%ebp
   12443:	57                   	push   %edi
   12444:	56                   	push   %esi
   12445:	53                   	push   %ebx
   12446:	83 ec 2c             	sub    $0x2c,%esp
   12449:	8a 45 0c             	mov    0xc(%ebp),%al
   1244c:	8b 7d 08             	mov    0x8(%ebp),%edi
   1244f:	88 45 d7             	mov    %al,0xffffffd7(%ebp)
   12452:	8a 45 14             	mov    0x14(%ebp),%al
   12455:	88 45 d6             	mov    %al,0xffffffd6(%ebp)
   12458:	8a 45 1c             	mov    0x1c(%ebp),%al
   1245b:	88 45 d5             	mov    %al,0xffffffd5(%ebp)
   1245e:	8a 45 20             	mov    0x20(%ebp),%al
   12461:	88 45 d4             	mov    %al,0xffffffd4(%ebp)
   12464:	8a 45 24             	mov    0x24(%ebp),%al
   12467:	88 45 d3             	mov    %al,0xffffffd3(%ebp)
   1246a:	8a 45 28             	mov    0x28(%ebp),%al
   1246d:	88 45 d2             	mov    %al,0xffffffd2(%ebp)
   12470:	8a 45 2c             	mov    0x2c(%ebp),%al
   12473:	88 45 d1             	mov    %al,0xffffffd1(%ebp)
   12476:	8a 5d 10             	mov    0x10(%ebp),%bl
   12479:	0f b6 75 18          	movzbl 0x18(%ebp),%esi
   1247d:	e8 4e 15 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12482:	3c 01                	cmp    $0x1,%al
   12484:	76 01                	jbe    12487 <_HwReadWriteData@40+0x47>
   12486:	cc                   	int3   
   12487:	80 7d d1 ff          	cmpb   $0xff,0xffffffd1(%ebp)
   1248b:	74 01                	je     1248e <_HwReadWriteData@40+0x4e>
   1248d:	cc                   	int3   
   1248e:	80 7d d7 00          	cmpb   $0x0,0xffffffd7(%ebp)
   12492:	74 63                	je     124f7 <_HwReadWriteData@40+0xb7>
   12494:	c6 45 d8 06          	movb   $0x6,0xffffffd8(%ebp)
   12498:	89 f0                	mov    %esi,%eax
   1249a:	25 ff 00 00 00       	and    $0xff,%eax
   1249f:	c1 e0 02             	shl    $0x2,%eax
   124a2:	09 c3                	or     %eax,%ebx
   124a4:	8a 45 d6             	mov    0xffffffd6(%ebp),%al
   124a7:	88 45 da             	mov    %al,0xffffffda(%ebp)
   124aa:	89 f0                	mov    %esi,%eax
   124ac:	88 45 db             	mov    %al,0xffffffdb(%ebp)
   124af:	8a 45 d5             	mov    0xffffffd5(%ebp),%al
   124b2:	88 45 dc             	mov    %al,0xffffffdc(%ebp)
   124b5:	8a 45 d4             	mov    0xffffffd4(%ebp),%al
   124b8:	88 45 dd             	mov    %al,0xffffffdd(%ebp)
   124bb:	8a 45 d3             	mov    0xffffffd3(%ebp),%al
   124be:	88 45 de             	mov    %al,0xffffffde(%ebp)
   124c1:	8a 45 d2             	mov    0xffffffd2(%ebp),%al
   124c4:	80 4d d8 c0          	orb    $0xc0,0xffffffd8(%ebp)
   124c8:	88 45 df             	mov    %al,0xffffffdf(%ebp)
   124cb:	8a 45 d1             	mov    0xffffffd1(%ebp),%al
   124ce:	88 5d d9             	mov    %bl,0xffffffd9(%ebp)
   124d1:	88 45 e0             	mov    %al,0xffffffe0(%ebp)
   124d4:	31 db                	xor    %ebx,%ebx
   124d6:	31 d2                	xor    %edx,%edx
   124d8:	89 f8                	mov    %edi,%eax
   124da:	8a 54 2b d8          	mov    0xffffffd8(%ebx,%ebp,1),%dl
   124de:	e8 9d fb ff ff       	call   12080 <_Send_Byte@8>
   124e3:	85 c0                	test   %eax,%eax
   124e5:	75 16                	jne    124fd <_HwReadWriteData@40+0xbd>
   124e7:	43                   	inc    %ebx
   124e8:	83 fb 08             	cmp    $0x8,%ebx
   124eb:	7e e9                	jle    124d6 <_HwReadWriteData@40+0x96>
   124ed:	83 c4 2c             	add    $0x2c,%esp
   124f0:	5b                   	pop    %ebx
   124f1:	5e                   	pop    %esi
   124f2:	5f                   	pop    %edi
   124f3:	5d                   	pop    %ebp
   124f4:	c2 28 00             	ret    $0x28
   124f7:	c6 45 d8 05          	movb   $0x5,0xffffffd8(%ebp)
   124fb:	eb 9b                	jmp    12498 <_HwReadWriteData@40+0x58>
   124fd:	83 c4 2c             	add    $0x2c,%esp
   12500:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   12505:	5b                   	pop    %ebx
   12506:	5e                   	pop    %esi
   12507:	5f                   	pop    %edi
   12508:	5d                   	pop    %ebp
   12509:	c2 28 00             	ret    $0x28
   1250c:	8d 74 26 00          	lea    0x0(%esi),%esi

00012510 <_HwRecalibrateResult@4>:
   12510:	55                   	push   %ebp
   12511:	89 e5                	mov    %esp,%ebp
   12513:	57                   	push   %edi
   12514:	56                   	push   %esi
   12515:	53                   	push   %ebx
   12516:	83 ec 0c             	sub    $0xc,%esp
   12519:	8b 7d 08             	mov    0x8(%ebp),%edi
   1251c:	e8 af 14 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12521:	3c 01                	cmp    $0x1,%al
   12523:	76 01                	jbe    12526 <_HwRecalibrateResult@4+0x16>
   12525:	cc                   	int3   
   12526:	ba 08 00 00 00       	mov    $0x8,%edx
   1252b:	89 f8                	mov    %edi,%eax
   1252d:	e8 4e fb ff ff       	call   12080 <_Send_Byte@8>
   12532:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   12537:	85 c0                	test   %eax,%eax
   12539:	75 2c                	jne    12567 <_HwRecalibrateResult@4+0x57>
   1253b:	31 db                	xor    %ebx,%ebx
   1253d:	8d 75 f2             	lea    0xfffffff2(%ebp),%esi
   12540:	8d 14 33             	lea    (%ebx,%esi,1),%edx
   12543:	89 f8                	mov    %edi,%eax
   12545:	e8 76 fc ff ff       	call   121c0 <_Get_Byte@8>
   1254a:	85 c0                	test   %eax,%eax
   1254c:	75 25                	jne    12573 <_HwRecalibrateResult@4+0x63>
   1254e:	43                   	inc    %ebx
   1254f:	83 fb 01             	cmp    $0x1,%ebx
   12552:	7e ec                	jle    12540 <_HwRecalibrateResult@4+0x30>
   12554:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   12559:	80 7e 01 00          	cmpb   $0x0,0x1(%esi)
   1255d:	75 08                	jne    12567 <_HwRecalibrateResult@4+0x57>
   1255f:	f6 45 f2 20          	testb  $0x20,0xfffffff2(%ebp)
   12563:	74 02                	je     12567 <_HwRecalibrateResult@4+0x57>
   12565:	31 d2                	xor    %edx,%edx
   12567:	83 c4 0c             	add    $0xc,%esp
   1256a:	89 d0                	mov    %edx,%eax
   1256c:	5b                   	pop    %ebx
   1256d:	5e                   	pop    %esi
   1256e:	5f                   	pop    %edi
   1256f:	5d                   	pop    %ebp
   12570:	c2 04 00             	ret    $0x4
   12573:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   12578:	eb ed                	jmp    12567 <_HwRecalibrateResult@4+0x57>
   1257a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00012580 <_HwReadWriteResult@4>:
   12580:	55                   	push   %ebp
   12581:	89 e5                	mov    %esp,%ebp
   12583:	57                   	push   %edi
   12584:	56                   	push   %esi
   12585:	53                   	push   %ebx
   12586:	83 ec 1c             	sub    $0x1c,%esp
   12589:	8b 7d 08             	mov    0x8(%ebp),%edi
   1258c:	e8 3f 14 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12591:	3c 01                	cmp    $0x1,%al
   12593:	76 01                	jbe    12596 <_HwReadWriteResult@4+0x16>
   12595:	cc                   	int3   
   12596:	31 db                	xor    %ebx,%ebx
   12598:	8d 75 d8             	lea    0xffffffd8(%ebp),%esi
   1259b:	90                   	nop    
   1259c:	8d 74 26 00          	lea    0x0(%esi),%esi
   125a0:	8d 14 1e             	lea    (%esi,%ebx,1),%edx
   125a3:	89 f8                	mov    %edi,%eax
   125a5:	e8 16 fc ff ff       	call   121c0 <_Get_Byte@8>
   125aa:	85 c0                	test   %eax,%eax
   125ac:	75 1d                	jne    125cb <_HwReadWriteResult@4+0x4b>
   125ae:	43                   	inc    %ebx
   125af:	83 fb 06             	cmp    $0x6,%ebx
   125b2:	7e ec                	jle    125a0 <_HwReadWriteResult@4+0x20>
   125b4:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   125b9:	f6 45 d8 c0          	testb  $0xc0,0xffffffd8(%ebp)
   125bd:	75 02                	jne    125c1 <_HwReadWriteResult@4+0x41>
   125bf:	31 c0                	xor    %eax,%eax
   125c1:	83 c4 1c             	add    $0x1c,%esp
   125c4:	5b                   	pop    %ebx
   125c5:	5e                   	pop    %esi
   125c6:	5f                   	pop    %edi
   125c7:	5d                   	pop    %ebp
   125c8:	c2 04 00             	ret    $0x4
   125cb:	83 c4 1c             	add    $0x1c,%esp
   125ce:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   125d3:	5b                   	pop    %ebx
   125d4:	5e                   	pop    %esi
   125d5:	5f                   	pop    %edi
   125d6:	5d                   	pop    %ebp
   125d7:	c2 04 00             	ret    $0x4
   125da:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

000125e0 <_HwRecalibrate@4>:
   125e0:	55                   	push   %ebp
   125e1:	89 e5                	mov    %esp,%ebp
   125e3:	57                   	push   %edi
   125e4:	56                   	push   %esi
   125e5:	53                   	push   %ebx
   125e6:	83 ec 0c             	sub    $0xc,%esp
   125e9:	8b 45 08             	mov    0x8(%ebp),%eax
   125ec:	8b 30                	mov    (%eax),%esi
   125ee:	8a 58 04             	mov    0x4(%eax),%bl
   125f1:	e8 da 13 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   125f6:	3c 01                	cmp    $0x1,%al
   125f8:	76 01                	jbe    125fb <_HwRecalibrate@4+0x1b>
   125fa:	cc                   	int3   
   125fb:	88 5d f3             	mov    %bl,0xfffffff3(%ebp)
   125fe:	c6 45 f2 07          	movb   $0x7,0xfffffff2(%ebp)
   12602:	8d 7d f2             	lea    0xfffffff2(%ebp),%edi
   12605:	31 db                	xor    %ebx,%ebx
   12607:	31 d2                	xor    %edx,%edx
   12609:	89 f0                	mov    %esi,%eax
   1260b:	8a 14 3b             	mov    (%ebx,%edi,1),%dl
   1260e:	e8 6d fa ff ff       	call   12080 <_Send_Byte@8>
   12613:	85 c0                	test   %eax,%eax
   12615:	75 12                	jne    12629 <_HwRecalibrate@4+0x49>
   12617:	43                   	inc    %ebx
   12618:	83 fb 01             	cmp    $0x1,%ebx
   1261b:	7e ea                	jle    12607 <_HwRecalibrate@4+0x27>
   1261d:	31 c0                	xor    %eax,%eax
   1261f:	83 c4 0c             	add    $0xc,%esp
   12622:	5b                   	pop    %ebx
   12623:	5e                   	pop    %esi
   12624:	5f                   	pop    %edi
   12625:	5d                   	pop    %ebp
   12626:	c2 04 00             	ret    $0x4
   12629:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   1262e:	eb ef                	jmp    1261f <_HwRecalibrate@4+0x3f>

00012630 <_HwSenseInterruptStatus@4>:
   12630:	55                   	push   %ebp
   12631:	89 e5                	mov    %esp,%ebp
   12633:	57                   	push   %edi
   12634:	56                   	push   %esi
   12635:	53                   	push   %ebx
   12636:	83 ec 0c             	sub    $0xc,%esp
   12639:	8b 7d 08             	mov    0x8(%ebp),%edi
   1263c:	e8 8f 13 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12641:	3c 01                	cmp    $0x1,%al
   12643:	76 01                	jbe    12646 <_HwSenseInterruptStatus@4+0x16>
   12645:	cc                   	int3   
   12646:	ba 08 00 00 00       	mov    $0x8,%edx
   1264b:	89 f8                	mov    %edi,%eax
   1264d:	e8 2e fa ff ff       	call   12080 <_Send_Byte@8>
   12652:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   12657:	85 c0                	test   %eax,%eax
   12659:	75 1b                	jne    12676 <_HwSenseInterruptStatus@4+0x46>
   1265b:	31 db                	xor    %ebx,%ebx
   1265d:	8d 75 f2             	lea    0xfffffff2(%ebp),%esi
   12660:	8d 14 33             	lea    (%ebx,%esi,1),%edx
   12663:	89 f8                	mov    %edi,%eax
   12665:	e8 56 fb ff ff       	call   121c0 <_Get_Byte@8>
   1266a:	85 c0                	test   %eax,%eax
   1266c:	75 14                	jne    12682 <_HwSenseInterruptStatus@4+0x52>
   1266e:	43                   	inc    %ebx
   1266f:	83 fb 01             	cmp    $0x1,%ebx
   12672:	7e ec                	jle    12660 <_HwSenseInterruptStatus@4+0x30>
   12674:	31 d2                	xor    %edx,%edx
   12676:	83 c4 0c             	add    $0xc,%esp
   12679:	89 d0                	mov    %edx,%eax
   1267b:	5b                   	pop    %ebx
   1267c:	5e                   	pop    %esi
   1267d:	5f                   	pop    %edi
   1267e:	5d                   	pop    %ebp
   1267f:	c2 04 00             	ret    $0x4
   12682:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   12687:	eb ed                	jmp    12676 <_HwSenseInterruptStatus@4+0x46>
   12689:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00012690 <_HwReadId@8>:
   12690:	55                   	push   %ebp
   12691:	89 e5                	mov    %esp,%ebp
   12693:	57                   	push   %edi
   12694:	56                   	push   %esi
   12695:	53                   	push   %ebx
   12696:	83 ec 0c             	sub    $0xc,%esp
   12699:	8b 7d 08             	mov    0x8(%ebp),%edi
   1269c:	8a 5d 0c             	mov    0xc(%ebp),%bl
   1269f:	e8 2c 13 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   126a4:	3c 01                	cmp    $0x1,%al
   126a6:	76 01                	jbe    126a9 <_HwReadId@8+0x19>
   126a8:	cc                   	int3   
   126a9:	31 c0                	xor    %eax,%eax
   126ab:	c6 45 f2 4a          	movb   $0x4a,0xfffffff2(%ebp)
   126af:	88 d8                	mov    %bl,%al
   126b1:	8d 75 f2             	lea    0xfffffff2(%ebp),%esi
   126b4:	c1 e0 02             	shl    $0x2,%eax
   126b7:	31 db                	xor    %ebx,%ebx
   126b9:	0a 47 04             	or     0x4(%edi),%al
   126bc:	88 45 f3             	mov    %al,0xfffffff3(%ebp)
   126bf:	31 d2                	xor    %edx,%edx
   126c1:	8b 07                	mov    (%edi),%eax
   126c3:	8a 14 33             	mov    (%ebx,%esi,1),%dl
   126c6:	e8 b5 f9 ff ff       	call   12080 <_Send_Byte@8>
   126cb:	85 c0                	test   %eax,%eax
   126cd:	75 12                	jne    126e1 <_HwReadId@8+0x51>
   126cf:	43                   	inc    %ebx
   126d0:	83 fb 01             	cmp    $0x1,%ebx
   126d3:	7e ea                	jle    126bf <_HwReadId@8+0x2f>
   126d5:	31 c0                	xor    %eax,%eax
   126d7:	83 c4 0c             	add    $0xc,%esp
   126da:	5b                   	pop    %ebx
   126db:	5e                   	pop    %esi
   126dc:	5f                   	pop    %edi
   126dd:	5d                   	pop    %ebp
   126de:	c2 08 00             	ret    $0x8
   126e1:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   126e6:	eb ef                	jmp    126d7 <_HwReadId@8+0x47>
   126e8:	90                   	nop    
   126e9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000126f0 <_HwFormatTrack@28>:
   126f0:	55                   	push   %ebp
   126f1:	89 e5                	mov    %esp,%ebp
   126f3:	57                   	push   %edi
   126f4:	56                   	push   %esi
   126f5:	53                   	push   %ebx
   126f6:	83 ec 2c             	sub    $0x2c,%esp
   126f9:	8b 45 18             	mov    0x18(%ebp),%eax
   126fc:	8b 7d 14             	mov    0x14(%ebp),%edi
   126ff:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   12702:	8b 45 1c             	mov    0x1c(%ebp),%eax
   12705:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   12708:	8b 45 20             	mov    0x20(%ebp),%eax
   1270b:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   1270e:	8a 5d 0c             	mov    0xc(%ebp),%bl
   12711:	0f b6 75 10          	movzbl 0x10(%ebp),%esi
   12715:	e8 b6 12 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   1271a:	3c 01                	cmp    $0x1,%al
   1271c:	76 01                	jbe    1271f <_HwFormatTrack@28+0x2f>
   1271e:	cc                   	int3   
   1271f:	89 f0                	mov    %esi,%eax
   12721:	c6 45 d8 0d          	movb   $0xd,0xffffffd8(%ebp)
   12725:	25 ff 00 00 00       	and    $0xff,%eax
   1272a:	c1 e0 02             	shl    $0x2,%eax
   1272d:	09 c3                	or     %eax,%ebx
   1272f:	89 f8                	mov    %edi,%eax
   12731:	88 45 da             	mov    %al,0xffffffda(%ebp)
   12734:	8a 45 d4             	mov    0xffffffd4(%ebp),%al
   12737:	88 45 db             	mov    %al,0xffffffdb(%ebp)
   1273a:	8a 45 d0             	mov    0xffffffd0(%ebp),%al
   1273d:	88 45 dc             	mov    %al,0xffffffdc(%ebp)
   12740:	8a 45 cc             	mov    0xffffffcc(%ebp),%al
   12743:	88 5d d9             	mov    %bl,0xffffffd9(%ebp)
   12746:	88 45 dd             	mov    %al,0xffffffdd(%ebp)
   12749:	31 db                	xor    %ebx,%ebx
   1274b:	90                   	nop    
   1274c:	8d 74 26 00          	lea    0x0(%esi),%esi
   12750:	31 d2                	xor    %edx,%edx
   12752:	8b 45 08             	mov    0x8(%ebp),%eax
   12755:	8a 54 2b d8          	mov    0xffffffd8(%ebx,%ebp,1),%dl
   12759:	e8 22 f9 ff ff       	call   12080 <_Send_Byte@8>
   1275e:	85 c0                	test   %eax,%eax
   12760:	75 12                	jne    12774 <_HwFormatTrack@28+0x84>
   12762:	43                   	inc    %ebx
   12763:	83 fb 05             	cmp    $0x5,%ebx
   12766:	7e e8                	jle    12750 <_HwFormatTrack@28+0x60>
   12768:	83 c4 2c             	add    $0x2c,%esp
   1276b:	31 c0                	xor    %eax,%eax
   1276d:	5b                   	pop    %ebx
   1276e:	5e                   	pop    %esi
   1276f:	5f                   	pop    %edi
   12770:	5d                   	pop    %ebp
   12771:	c2 1c 00             	ret    $0x1c
   12774:	83 c4 2c             	add    $0x2c,%esp
   12777:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   1277c:	5b                   	pop    %ebx
   1277d:	5e                   	pop    %esi
   1277e:	5f                   	pop    %edi
   1277f:	5d                   	pop    %ebp
   12780:	c2 1c 00             	ret    $0x1c
   12783:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12789:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012790 <_HwSeek@8>:
   12790:	55                   	push   %ebp
   12791:	89 e5                	mov    %esp,%ebp
   12793:	57                   	push   %edi
   12794:	56                   	push   %esi
   12795:	53                   	push   %ebx
   12796:	83 ec 3c             	sub    $0x3c,%esp
   12799:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1279c:	8b 75 0c             	mov    0xc(%ebp),%esi
   1279f:	e8 2c 12 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   127a4:	3c 01                	cmp    $0x1,%al
   127a6:	76 01                	jbe    127a9 <_HwSeek@8+0x19>
   127a8:	cc                   	int3   
   127a9:	c6 45 d8 0f          	movb   $0xf,0xffffffd8(%ebp)
   127ad:	8a 43 04             	mov    0x4(%ebx),%al
   127b0:	88 45 d9             	mov    %al,0xffffffd9(%ebp)
   127b3:	89 f0                	mov    %esi,%eax
   127b5:	88 45 da             	mov    %al,0xffffffda(%ebp)
   127b8:	31 f6                	xor    %esi,%esi
   127ba:	31 d2                	xor    %edx,%edx
   127bc:	8b 03                	mov    (%ebx),%eax
   127be:	8a 54 2e d8          	mov    0xffffffd8(%esi,%ebp,1),%dl
   127c2:	e8 b9 f8 ff ff       	call   12080 <_Send_Byte@8>
   127c7:	85 c0                	test   %eax,%eax
   127c9:	75 52                	jne    1281d <_HwSeek@8+0x8d>
   127cb:	46                   	inc    %esi
   127cc:	83 fe 02             	cmp    $0x2,%esi
   127cf:	7e e9                	jle    127ba <_HwSeek@8+0x2a>
   127d1:	31 d2                	xor    %edx,%edx
   127d3:	be f0 d8 ff ff       	mov    $0xffffd8f0,%esi
   127d8:	8a 53 31             	mov    0x31(%ebx),%dl
   127db:	c7 45 c4 00 00 00 00 	movl   $0x0,0xffffffc4(%ebp)
   127e2:	89 d0                	mov    %edx,%eax
   127e4:	8b 7d c4             	mov    0xffffffc4(%ebp),%edi
   127e7:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
   127ea:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
   127ed:	f7 e6                	mul    %esi
   127ef:	0f af fe             	imul   %esi,%edi
   127f2:	89 d6                	mov    %edx,%esi
   127f4:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   127f7:	01 fe                	add    %edi,%esi
   127f9:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
   127fc:	89 f3                	mov    %esi,%ebx
   127fe:	8b 75 c0             	mov    0xffffffc0(%ebp),%esi
   12801:	29 f3                	sub    %esi,%ebx
   12803:	89 5d d4             	mov    %ebx,0xffffffd4(%ebp)
   12806:	51                   	push   %ecx
   12807:	50                   	push   %eax
   12808:	6a 00                	push   $0x0
   1280a:	6a 00                	push   $0x0
   1280c:	e8 7f 11 00 00       	call   13990 <_KeDelayExecutionThread@12>
   12811:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12814:	31 c0                	xor    %eax,%eax
   12816:	5b                   	pop    %ebx
   12817:	5e                   	pop    %esi
   12818:	5f                   	pop    %edi
   12819:	5d                   	pop    %ebp
   1281a:	c2 08 00             	ret    $0x8
   1281d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12820:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   12825:	5b                   	pop    %ebx
   12826:	5e                   	pop    %esi
   12827:	5f                   	pop    %edi
   12828:	5d                   	pop    %ebp
   12829:	c2 08 00             	ret    $0x8
   1282c:	8d 74 26 00          	lea    0x0(%esi),%esi

00012830 <_HwConfigure@24>:
   12830:	55                   	push   %ebp
   12831:	89 e5                	mov    %esp,%ebp
   12833:	57                   	push   %edi
   12834:	56                   	push   %esi
   12835:	53                   	push   %ebx
   12836:	83 ec 0c             	sub    $0xc,%esp
   12839:	8b 45 1c             	mov    0x1c(%ebp),%eax
   1283c:	8a 5d 0c             	mov    0xc(%ebp),%bl
   1283f:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   12842:	8a 45 18             	mov    0x18(%ebp),%al
   12845:	88 45 ef             	mov    %al,0xffffffef(%ebp)
   12848:	0f b6 75 10          	movzbl 0x10(%ebp),%esi
   1284c:	0f b6 7d 14          	movzbl 0x14(%ebp),%edi
   12850:	e8 7b 11 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12855:	3c 01                	cmp    $0x1,%al
   12857:	76 01                	jbe    1285a <_HwConfigure@24+0x2a>
   12859:	cc                   	int3   
   1285a:	31 c0                	xor    %eax,%eax
   1285c:	89 f2                	mov    %esi,%edx
   1285e:	88 d8                	mov    %bl,%al
   12860:	81 e2 ff 00 00 00    	and    $0xff,%edx
   12866:	c6 45 f0 13          	movb   $0x13,0xfffffff0(%ebp)
   1286a:	c6 45 f1 00          	movb   $0x0,0xfffffff1(%ebp)
   1286e:	8d 04 42             	lea    (%edx,%eax,2),%eax
   12871:	89 fa                	mov    %edi,%edx
   12873:	81 e2 ff 00 00 00    	and    $0xff,%edx
   12879:	31 db                	xor    %ebx,%ebx
   1287b:	8d 04 42             	lea    (%edx,%eax,2),%eax
   1287e:	c1 e0 04             	shl    $0x4,%eax
   12881:	02 45 ef             	add    0xffffffef(%ebp),%al
   12884:	88 45 f2             	mov    %al,0xfffffff2(%ebp)
   12887:	8a 45 e8             	mov    0xffffffe8(%ebp),%al
   1288a:	88 45 f3             	mov    %al,0xfffffff3(%ebp)
   1288d:	8d 76 00             	lea    0x0(%esi),%esi
   12890:	31 d2                	xor    %edx,%edx
   12892:	8b 45 08             	mov    0x8(%ebp),%eax
   12895:	8a 54 2b f0          	mov    0xfffffff0(%ebx,%ebp,1),%dl
   12899:	e8 e2 f7 ff ff       	call   12080 <_Send_Byte@8>
   1289e:	85 c0                	test   %eax,%eax
   128a0:	75 12                	jne    128b4 <_HwConfigure@24+0x84>
   128a2:	43                   	inc    %ebx
   128a3:	83 fb 03             	cmp    $0x3,%ebx
   128a6:	7e e8                	jle    12890 <_HwConfigure@24+0x60>
   128a8:	83 c4 0c             	add    $0xc,%esp
   128ab:	31 c0                	xor    %eax,%eax
   128ad:	5b                   	pop    %ebx
   128ae:	5e                   	pop    %esi
   128af:	5f                   	pop    %edi
   128b0:	5d                   	pop    %ebp
   128b1:	c2 18 00             	ret    $0x18
   128b4:	83 c4 0c             	add    $0xc,%esp
   128b7:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   128bc:	5b                   	pop    %ebx
   128bd:	5e                   	pop    %esi
   128be:	5f                   	pop    %edi
   128bf:	5d                   	pop    %ebp
   128c0:	c2 18 00             	ret    $0x18
   128c3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   128c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000128d0 <_HwGetVersion@4>:
   128d0:	55                   	push   %ebp
   128d1:	89 e5                	mov    %esp,%ebp
   128d3:	50                   	push   %eax
   128d4:	50                   	push   %eax
   128d5:	e8 f6 10 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   128da:	3c 01                	cmp    $0x1,%al
   128dc:	76 01                	jbe    128df <_HwGetVersion@4+0xf>
   128de:	cc                   	int3   
   128df:	ba 10 00 00 00       	mov    $0x10,%edx
   128e4:	8b 45 08             	mov    0x8(%ebp),%eax
   128e7:	e8 94 f7 ff ff       	call   12080 <_Send_Byte@8>
   128ec:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   128f1:	85 c0                	test   %eax,%eax
   128f3:	75 19                	jne    1290e <_HwGetVersion@4+0x3e>
   128f5:	8d 55 ff             	lea    0xffffffff(%ebp),%edx
   128f8:	8b 45 08             	mov    0x8(%ebp),%eax
   128fb:	e8 c0 f8 ff ff       	call   121c0 <_Get_Byte@8>
   12900:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   12905:	85 c0                	test   %eax,%eax
   12907:	75 05                	jne    1290e <_HwGetVersion@4+0x3e>
   12909:	31 d2                	xor    %edx,%edx
   1290b:	8a 55 ff             	mov    0xffffffff(%ebp),%dl
   1290e:	89 d0                	mov    %edx,%eax
   12910:	c9                   	leave  
   12911:	c2 04 00             	ret    $0x4
   12914:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1291a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00012920 <_HwDiskChanged@8>:
   12920:	55                   	push   %ebp
   12921:	89 e5                	mov    %esp,%ebp
   12923:	56                   	push   %esi
   12924:	53                   	push   %ebx
   12925:	8b 45 08             	mov    0x8(%ebp),%eax
   12928:	83 ec 0c             	sub    $0xc,%esp
   1292b:	8b 75 0c             	mov    0xc(%ebp),%esi
   1292e:	8b 18                	mov    (%eax),%ebx
   12930:	8b 43 24             	mov    0x24(%ebx),%eax
   12933:	83 c0 07             	add    $0x7,%eax
   12936:	50                   	push   %eax
   12937:	e8 f4 10 00 00       	call   13a30 <_READ_PORT_UCHAR@4>
   1293c:	83 c4 0c             	add    $0xc,%esp
   1293f:	80 bb dc 11 00 00 00 	cmpb   $0x0,0x11dc(%ebx)
   12946:	74 03                	je     1294b <_HwDiskChanged@8+0x2b>
   12948:	83 f0 ff             	xor    $0xffffffff,%eax
   1294b:	c0 e8 07             	shr    $0x7,%al
   1294e:	88 06                	mov    %al,(%esi)
   12950:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   12953:	31 c0                	xor    %eax,%eax
   12955:	5b                   	pop    %ebx
   12956:	5e                   	pop    %esi
   12957:	5d                   	pop    %ebp
   12958:	c2 08 00             	ret    $0x8
   1295b:	90                   	nop    
   1295c:	8d 74 26 00          	lea    0x0(%esi),%esi

00012960 <_HwSenseDriveStatusResult@8>:
   12960:	55                   	push   %ebp
   12961:	89 e5                	mov    %esp,%ebp
   12963:	50                   	push   %eax
   12964:	50                   	push   %eax
   12965:	e8 66 10 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   1296a:	3c 01                	cmp    $0x1,%al
   1296c:	76 01                	jbe    1296f <_HwSenseDriveStatusResult@8+0xf>
   1296e:	cc                   	int3   
   1296f:	8b 55 0c             	mov    0xc(%ebp),%edx
   12972:	8b 45 08             	mov    0x8(%ebp),%eax
   12975:	e8 46 f8 ff ff       	call   121c0 <_Get_Byte@8>
   1297a:	c9                   	leave  
   1297b:	83 f8 01             	cmp    $0x1,%eax
   1297e:	19 c0                	sbb    %eax,%eax
   12980:	83 f0 ff             	xor    $0xffffffff,%eax
   12983:	25 01 00 00 c0       	and    $0xc0000001,%eax
   12988:	c2 08 00             	ret    $0x8
   1298b:	90                   	nop    
   1298c:	8d 74 26 00          	lea    0x0(%esi),%esi

00012990 <_HwReadIdResult@12>:
   12990:	55                   	push   %ebp
   12991:	31 c0                	xor    %eax,%eax
   12993:	89 e5                	mov    %esp,%ebp
   12995:	57                   	push   %edi
   12996:	fc                   	cld    
   12997:	56                   	push   %esi
   12998:	53                   	push   %ebx
   12999:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
   1299c:	b9 01 00 00 00       	mov    $0x1,%ecx
   129a1:	89 df                	mov    %ebx,%edi
   129a3:	83 ec 1c             	sub    $0x1c,%esp
   129a6:	f3 ab                	repz stos %eax,%es:(%edi)
   129a8:	8b 75 08             	mov    0x8(%ebp),%esi
   129ab:	66 c7 07 00 00       	movw   $0x0,(%edi)
   129b0:	c6 47 02 00          	movb   $0x0,0x2(%edi)
   129b4:	e8 17 10 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   129b9:	3c 01                	cmp    $0x1,%al
   129bb:	76 01                	jbe    129be <_HwReadIdResult@12+0x2e>
   129bd:	cc                   	int3   
   129be:	31 ff                	xor    %edi,%edi
   129c0:	8d 14 3b             	lea    (%ebx,%edi,1),%edx
   129c3:	89 f0                	mov    %esi,%eax
   129c5:	e8 f6 f7 ff ff       	call   121c0 <_Get_Byte@8>
   129ca:	85 c0                	test   %eax,%eax
   129cc:	75 41                	jne    12a0f <_HwReadIdResult@12+0x7f>
   129ce:	47                   	inc    %edi
   129cf:	83 ff 06             	cmp    $0x6,%edi
   129d2:	7e ec                	jle    129c0 <_HwReadIdResult@12+0x30>
   129d4:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   129d9:	f6 45 d8 c0          	testb  $0xc0,0xffffffd8(%ebp)
   129dd:	75 35                	jne    12a14 <_HwReadIdResult@12+0x84>
   129df:	f6 45 d9 01          	testb  $0x1,0xffffffd9(%ebp)
   129e3:	75 2f                	jne    12a14 <_HwReadIdResult@12+0x84>
   129e5:	8b 45 0c             	mov    0xc(%ebp),%eax
   129e8:	85 c0                	test   %eax,%eax
   129ea:	74 08                	je     129f4 <_HwReadIdResult@12+0x64>
   129ec:	8b 55 0c             	mov    0xc(%ebp),%edx
   129ef:	8a 45 db             	mov    0xffffffdb(%ebp),%al
   129f2:	88 02                	mov    %al,(%edx)
   129f4:	8b 45 10             	mov    0x10(%ebp),%eax
   129f7:	85 c0                	test   %eax,%eax
   129f9:	74 08                	je     12a03 <_HwReadIdResult@12+0x73>
   129fb:	8b 55 10             	mov    0x10(%ebp),%edx
   129fe:	8a 45 dc             	mov    0xffffffdc(%ebp),%al
   12a01:	88 02                	mov    %al,(%edx)
   12a03:	83 c4 1c             	add    $0x1c,%esp
   12a06:	31 c0                	xor    %eax,%eax
   12a08:	5b                   	pop    %ebx
   12a09:	5e                   	pop    %esi
   12a0a:	5f                   	pop    %edi
   12a0b:	5d                   	pop    %ebp
   12a0c:	c2 0c 00             	ret    $0xc
   12a0f:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   12a14:	83 c4 1c             	add    $0x1c,%esp
   12a17:	5b                   	pop    %ebx
   12a18:	5e                   	pop    %esi
   12a19:	5f                   	pop    %edi
   12a1a:	5d                   	pop    %ebp
   12a1b:	c2 0c 00             	ret    $0xc
   12a1e:	89 f6                	mov    %esi,%esi

00012a20 <_HwSpecify@20>:
   12a20:	55                   	push   %ebp
   12a21:	89 e5                	mov    %esp,%ebp
   12a23:	56                   	push   %esi
   12a24:	53                   	push   %ebx
   12a25:	31 db                	xor    %ebx,%ebx
   12a27:	83 ec 10             	sub    $0x10,%esp
   12a2a:	c6 45 e8 03          	movb   $0x3,0xffffffe8(%ebp)
   12a2e:	8b 75 08             	mov    0x8(%ebp),%esi
   12a31:	c6 45 e9 d1          	movb   $0xd1,0xffffffe9(%ebp)
   12a35:	c6 45 ea 02          	movb   $0x2,0xffffffea(%ebp)
   12a39:	31 d2                	xor    %edx,%edx
   12a3b:	89 f0                	mov    %esi,%eax
   12a3d:	8a 54 2b e8          	mov    0xffffffe8(%ebx,%ebp,1),%dl
   12a41:	e8 3a f6 ff ff       	call   12080 <_Send_Byte@8>
   12a46:	85 c0                	test   %eax,%eax
   12a48:	75 11                	jne    12a5b <_HwSpecify@20+0x3b>
   12a4a:	43                   	inc    %ebx
   12a4b:	83 fb 02             	cmp    $0x2,%ebx
   12a4e:	7e e9                	jle    12a39 <_HwSpecify@20+0x19>
   12a50:	83 c4 10             	add    $0x10,%esp
   12a53:	31 c0                	xor    %eax,%eax
   12a55:	5b                   	pop    %ebx
   12a56:	5e                   	pop    %esi
   12a57:	5d                   	pop    %ebp
   12a58:	c2 14 00             	ret    $0x14
   12a5b:	83 c4 10             	add    $0x10,%esp
   12a5e:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   12a63:	5b                   	pop    %ebx
   12a64:	5e                   	pop    %esi
   12a65:	5d                   	pop    %ebp
   12a66:	c2 14 00             	ret    $0x14
   12a69:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00012a70 <_HwReset@4>:
   12a70:	55                   	push   %ebp
   12a71:	89 e5                	mov    %esp,%ebp
   12a73:	53                   	push   %ebx
   12a74:	83 ec 0c             	sub    $0xc,%esp
   12a77:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12a7a:	68 80 00 00 00       	push   $0x80
   12a7f:	8b 43 24             	mov    0x24(%ebx),%eax
   12a82:	83 c0 04             	add    $0x4,%eax
   12a85:	50                   	push   %eax
   12a86:	e8 b5 0f 00 00       	call   13a40 <_WRITE_PORT_UCHAR@8>
   12a8b:	52                   	push   %edx
   12a8c:	8b 43 24             	mov    0x24(%ebx),%eax
   12a8f:	83 c0 02             	add    $0x2,%eax
   12a92:	50                   	push   %eax
   12a93:	e8 98 0f 00 00       	call   13a30 <_READ_PORT_UCHAR@4>
   12a98:	83 c4 0c             	add    $0xc,%esp
   12a9b:	a8 04                	test   $0x4,%al
   12a9d:	74 11                	je     12ab0 <_HwReset@4+0x40>
   12a9f:	31 d2                	xor    %edx,%edx
   12aa1:	89 d0                	mov    %edx,%eax
   12aa3:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   12aa6:	c9                   	leave  
   12aa7:	c2 04 00             	ret    $0x4
   12aaa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12ab0:	50                   	push   %eax
   12ab1:	50                   	push   %eax
   12ab2:	6a 0c                	push   $0xc
   12ab4:	8b 43 24             	mov    0x24(%ebx),%eax
   12ab7:	83 c0 02             	add    $0x2,%eax
   12aba:	50                   	push   %eax
   12abb:	e8 80 0f 00 00       	call   13a40 <_WRITE_PORT_UCHAR@8>
   12ac0:	50                   	push   %eax
   12ac1:	8b 43 24             	mov    0x24(%ebx),%eax
   12ac4:	83 c0 02             	add    $0x2,%eax
   12ac7:	50                   	push   %eax
   12ac8:	e8 63 0f 00 00       	call   13a30 <_READ_PORT_UCHAR@4>
   12acd:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   12ad2:	83 c4 0c             	add    $0xc,%esp
   12ad5:	a8 04                	test   $0x4,%al
   12ad7:	75 c6                	jne    12a9f <_HwReset@4+0x2f>
   12ad9:	eb c6                	jmp    12aa1 <_HwReset@4+0x31>
   12adb:	90                   	nop    
   12adc:	8d 74 26 00          	lea    0x0(%esi),%esi

00012ae0 <_HwPowerOff@4>:
   12ae0:	55                   	push   %ebp
   12ae1:	89 e5                	mov    %esp,%ebp
   12ae3:	83 ec 10             	sub    $0x10,%esp
   12ae6:	8b 45 08             	mov    0x8(%ebp),%eax
   12ae9:	6a 40                	push   $0x40
   12aeb:	8b 40 24             	mov    0x24(%eax),%eax
   12aee:	83 c0 04             	add    $0x4,%eax
   12af1:	50                   	push   %eax
   12af2:	e8 49 0f 00 00       	call   13a40 <_WRITE_PORT_UCHAR@8>
   12af7:	31 c0                	xor    %eax,%eax
   12af9:	c9                   	leave  
   12afa:	c2 04 00             	ret    $0x4
   12afd:	90                   	nop    
   12afe:	90                   	nop    
   12aff:	90                   	nop    

00012b00 <_MapRegisterCallback@16>:
   12b00:	55                   	push   %ebp
   12b01:	89 e5                	mov    %esp,%ebp
   12b03:	83 ec 0c             	sub    $0xc,%esp
   12b06:	8b 55 14             	mov    0x14(%ebp),%edx
   12b09:	8b 45 10             	mov    0x10(%ebp),%eax
   12b0c:	89 42 30             	mov    %eax,0x30(%edx)
   12b0f:	83 c2 35             	add    $0x35,%edx
   12b12:	6a 00                	push   $0x0
   12b14:	6a 00                	push   $0x0
   12b16:	52                   	push   %edx
   12b17:	e8 64 0c 00 00       	call   13780 <_KeSetEvent@12>
   12b1c:	b8 01 00 00 00       	mov    $0x1,%eax
   12b21:	c9                   	leave  
   12b22:	c2 10 00             	ret    $0x10
   12b25:	8d 74 26 00          	lea    0x0(%esi),%esi
   12b29:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012b30 <_ReadWrite@8>:
   12b30:	55                   	push   %ebp
   12b31:	89 e5                	mov    %esp,%ebp
   12b33:	50                   	push   %eax
   12b34:	50                   	push   %eax
   12b35:	8b 55 08             	mov    0x8(%ebp),%edx
   12b38:	8b 45 0c             	mov    0xc(%ebp),%eax
   12b3b:	85 d2                	test   %edx,%edx
   12b3d:	74 49                	je     12b88 <_ReadWrite@8+0x58>
   12b3f:	85 c0                	test   %eax,%eax
   12b41:	74 42                	je     12b85 <_ReadWrite@8+0x55>
   12b43:	8b 48 04             	mov    0x4(%eax),%ecx
   12b46:	85 c9                	test   %ecx,%ecx
   12b48:	74 1a                	je     12b64 <_ReadWrite@8+0x34>
   12b4a:	89 50 40             	mov    %edx,0x40(%eax)
   12b4d:	52                   	push   %edx
   12b4e:	6a 00                	push   $0x0
   12b50:	50                   	push   %eax
   12b51:	68 80 99 01 00       	push   $0x19980
   12b56:	e8 05 0b 00 00       	call   13660 <_IoCsqInsertIrp@12>
   12b5b:	b8 03 01 00 00       	mov    $0x103,%eax
   12b60:	c9                   	leave  
   12b61:	c2 08 00             	ret    $0x8
   12b64:	c7 40 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%eax)
   12b6b:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   12b72:	51                   	push   %ecx
   12b73:	51                   	push   %ecx
   12b74:	6a 00                	push   $0x0
   12b76:	50                   	push   %eax
   12b77:	e8 54 0c 00 00       	call   137d0 <_IoCompleteRequest@8>
   12b7c:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
   12b81:	c9                   	leave  
   12b82:	c2 08 00             	ret    $0x8
   12b85:	cc                   	int3   
   12b86:	eb bb                	jmp    12b43 <_ReadWrite@8+0x13>
   12b88:	cc                   	int3   
   12b89:	eb b4                	jmp    12b3f <_ReadWrite@8+0xf>
   12b8b:	90                   	nop    
   12b8c:	8d 74 26 00          	lea    0x0(%esi),%esi

00012b90 <_RWFreeAdapterChannel@4>:
   12b90:	55                   	push   %ebp
   12b91:	89 e5                	mov    %esp,%ebp
   12b93:	53                   	push   %ebx
   12b94:	89 c3                	mov    %eax,%ebx
   12b96:	52                   	push   %edx
   12b97:	e8 34 0e 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12b9c:	3c 02                	cmp    $0x2,%al
   12b9e:	76 01                	jbe    12ba1 <_RWFreeAdapterChannel@4+0x11>
   12ba0:	cc                   	int3   
   12ba1:	50                   	push   %eax
   12ba2:	50                   	push   %eax
   12ba3:	8d 45 fb             	lea    0xfffffffb(%ebp),%eax
   12ba6:	50                   	push   %eax
   12ba7:	6a 02                	push   $0x2
   12ba9:	e8 a2 0e 00 00       	call   13a50 <_KeRaiseIrql@8>
   12bae:	50                   	push   %eax
   12baf:	53                   	push   %ebx
   12bb0:	e8 ab 0e 00 00       	call   13a60 <_IoFreeAdapterChannel@4>
   12bb5:	31 c0                	xor    %eax,%eax
   12bb7:	8a 45 fb             	mov    0xfffffffb(%ebp),%al
   12bba:	50                   	push   %eax
   12bbb:	e8 b0 0e 00 00       	call   13a70 <_KeLowerIrql@4>
   12bc0:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   12bc3:	c9                   	leave  
   12bc4:	c3                   	ret    
   12bc5:	8d 74 26 00          	lea    0x0(%esi),%esi
   12bc9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012bd0 <_ReadWritePassive@8>:
   12bd0:	55                   	push   %ebp
   12bd1:	89 e5                	mov    %esp,%ebp
   12bd3:	57                   	push   %edi
   12bd4:	56                   	push   %esi
   12bd5:	53                   	push   %ebx
   12bd6:	83 ec 4c             	sub    $0x4c,%esp
   12bd9:	8b 45 08             	mov    0x8(%ebp),%eax
   12bdc:	8b 55 0c             	mov    0xc(%ebp),%edx
   12bdf:	8b 58 10             	mov    0x10(%eax),%ebx
   12be2:	8b 72 60             	mov    0x60(%edx),%esi
   12be5:	e8 e6 0d 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12bea:	3c 01                	cmp    $0x1,%al
   12bec:	76 01                	jbe    12bef <_ReadWritePassive@8+0x1f>
   12bee:	cc                   	int3   
   12bef:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   12bf2:	83 ec 0c             	sub    $0xc,%esp
   12bf5:	8b 45 08             	mov    0x8(%ebp),%eax
   12bf8:	c7 41 18 01 00 00 c0 	movl   $0xc0000001,0x18(%ecx)
   12bff:	c7 41 1c 00 00 00 00 	movl   $0x0,0x1c(%ecx)
   12c06:	50                   	push   %eax
   12c07:	e8 44 e4 ff ff       	call   11050 <_StartMotor@4>
   12c0c:	8d 45 ef             	lea    0xffffffef(%ebp),%eax
   12c0f:	89 04 24             	mov    %eax,(%esp)
   12c12:	8b 7b 28             	mov    0x28(%ebx),%edi
   12c15:	57                   	push   %edi
   12c16:	e8 05 fd ff ff       	call   12920 <_HwDiskChanged@8>
   12c1b:	5a                   	pop    %edx
   12c1c:	85 c0                	test   %eax,%eax
   12c1e:	59                   	pop    %ecx
   12c1f:	0f 85 9e 03 00 00    	jne    12fc3 <_ReadWritePassive@8+0x3f3>
   12c25:	80 7d ef 00          	cmpb   $0x0,0xffffffef(%ebp)
   12c29:	0f 85 51 03 00 00    	jne    12f80 <_ReadWritePassive@8+0x3b0>
   12c2f:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12c32:	8b 41 40             	mov    0x40(%ecx),%eax
   12c35:	85 c0                	test   %eax,%eax
   12c37:	0f 84 fb 03 00 00    	je     13038 <_ReadWritePassive@8+0x468>
   12c3d:	80 3e 03             	cmpb   $0x3,(%esi)
   12c40:	0f 84 0f 05 00 00    	je     13155 <_ReadWritePassive@8+0x585>
   12c46:	8b 4e 04             	mov    0x4(%esi),%ecx
   12c49:	89 4d dc             	mov    %ecx,0xffffffdc(%ebp)
   12c4c:	8b 76 0c             	mov    0xc(%esi),%esi
   12c4f:	c6 45 e3 01          	movb   $0x1,0xffffffe3(%ebp)
   12c53:	89 75 d8             	mov    %esi,0xffffffd8(%ebp)
   12c56:	50                   	push   %eax
   12c57:	50                   	push   %eax
   12c58:	8d 45 ee             	lea    0xffffffee(%ebp),%eax
   12c5b:	50                   	push   %eax
   12c5c:	6a 02                	push   $0x2
   12c5e:	e8 ed 0d 00 00       	call   13a50 <_KeRaiseIrql@8>
   12c63:	50                   	push   %eax
   12c64:	8b 45 08             	mov    0x8(%ebp),%eax
   12c67:	8b 38                	mov    (%eax),%edi
   12c69:	57                   	push   %edi
   12c6a:	68 00 2b 01 00       	push   $0x12b00
   12c6f:	8b 00                	mov    (%eax),%eax
   12c71:	8b 70 2c             	mov    0x2c(%eax),%esi
   12c74:	56                   	push   %esi
   12c75:	53                   	push   %ebx
   12c76:	8b 58 6c             	mov    0x6c(%eax),%ebx
   12c79:	53                   	push   %ebx
   12c7a:	e8 21 0d 00 00       	call   139a0 <_IoAllocateAdapterChannel@20>
   12c7f:	89 c3                	mov    %eax,%ebx
   12c81:	31 c0                	xor    %eax,%eax
   12c83:	8a 45 ee             	mov    0xffffffee(%ebp),%al
   12c86:	50                   	push   %eax
   12c87:	e8 e4 0d 00 00       	call   13a70 <_KeLowerIrql@4>
   12c8c:	83 c4 0c             	add    $0xc,%esp
   12c8f:	85 db                	test   %ebx,%ebx
   12c91:	0f 85 8c 03 00 00    	jne    13023 <_ReadWritePassive@8+0x453>
   12c97:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
   12c9e:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   12ca1:	39 45 d4             	cmp    %eax,0xffffffd4(%ebp)
   12ca4:	0f 83 48 03 00 00    	jae    12ff2 <_ReadWritePassive@8+0x422>
   12caa:	8a 55 e3             	mov    0xffffffe3(%ebp),%dl
   12cad:	81 e2 ff 00 00 00    	and    $0xff,%edx
   12cb3:	89 55 bc             	mov    %edx,0xffffffbc(%ebp)
   12cb6:	e9 60 01 00 00       	jmp    12e1b <_ReadWritePassive@8+0x24b>
   12cbb:	90                   	nop    
   12cbc:	8d 74 26 00          	lea    0x0(%esi),%esi
   12cc0:	31 c0                	xor    %eax,%eax
   12cc2:	89 f2                	mov    %esi,%edx
   12cc4:	8a 45 c3             	mov    0xffffffc3(%ebp),%al
   12cc7:	29 c2                	sub    %eax,%edx
   12cc9:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   12ccc:	8d 4a 01             	lea    0x1(%edx),%ecx
   12ccf:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
   12cd2:	29 d0                	sub    %edx,%eax
   12cd4:	31 d2                	xor    %edx,%edx
   12cd6:	f7 f7                	div    %edi
   12cd8:	88 45 d2             	mov    %al,0xffffffd2(%ebp)
   12cdb:	39 c1                	cmp    %eax,%ecx
   12cdd:	73 0b                	jae    12cea <_ReadWritePassive@8+0x11a>
   12cdf:	89 f0                	mov    %esi,%eax
   12ce1:	2a 45 c3             	sub    0xffffffc3(%ebp),%al
   12ce4:	8d 50 01             	lea    0x1(%eax),%edx
   12ce7:	88 55 d2             	mov    %dl,0xffffffd2(%ebp)
   12cea:	31 d2                	xor    %edx,%edx
   12cec:	8a 55 d2             	mov    0xffffffd2(%ebp),%dl
   12cef:	0f af d7             	imul   %edi,%edx
   12cf2:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   12cf5:	85 d2                	test   %edx,%edx
   12cf7:	75 01                	jne    12cfa <_ReadWritePassive@8+0x12a>
   12cf9:	cc                   	int3   
   12cfa:	89 d0                	mov    %edx,%eax
   12cfc:	8b 4b 2c             	mov    0x2c(%ebx),%ecx
   12cff:	c1 e8 0c             	shr    $0xc,%eax
   12d02:	81 e2 ff 0f 00 00    	and    $0xfff,%edx
   12d08:	74 01                	je     12d0b <_ReadWritePassive@8+0x13b>
   12d0a:	40                   	inc    %eax
   12d0b:	39 c8                	cmp    %ecx,%eax
   12d0d:	76 18                	jbe    12d27 <_ReadWritePassive@8+0x157>
   12d0f:	8b 43 2c             	mov    0x2c(%ebx),%eax
   12d12:	31 d2                	xor    %edx,%edx
   12d14:	c1 e0 0c             	shl    $0xc,%eax
   12d17:	f7 f7                	div    %edi
   12d19:	88 45 d2             	mov    %al,0xffffffd2(%ebp)
   12d1c:	31 c0                	xor    %eax,%eax
   12d1e:	8a 45 d2             	mov    0xffffffd2(%ebp),%al
   12d21:	0f af c7             	imul   %edi,%eax
   12d24:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   12d27:	50                   	push   %eax
   12d28:	50                   	push   %eax
   12d29:	8d 45 e4             	lea    0xffffffe4(%ebp),%eax
   12d2c:	8b 7d bc             	mov    0xffffffbc(%ebp),%edi
   12d2f:	57                   	push   %edi
   12d30:	50                   	push   %eax
   12d31:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   12d34:	8b 51 04             	mov    0x4(%ecx),%edx
   12d37:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
   12d3a:	8b 72 10             	mov    0x10(%edx),%esi
   12d3d:	8b 42 18             	mov    0x18(%edx),%eax
   12d40:	01 f0                	add    %esi,%eax
   12d42:	01 c8                	add    %ecx,%eax
   12d44:	50                   	push   %eax
   12d45:	8b 43 30             	mov    0x30(%ebx),%eax
   12d48:	50                   	push   %eax
   12d49:	52                   	push   %edx
   12d4a:	8b 43 6c             	mov    0x6c(%ebx),%eax
   12d4d:	50                   	push   %eax
   12d4e:	e8 2d 0d 00 00       	call   13a80 <_IoMapTransfer@24>
   12d53:	57                   	push   %edi
   12d54:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12d57:	8b 03                	mov    (%ebx),%eax
   12d59:	83 c0 35             	add    $0x35,%eax
   12d5c:	50                   	push   %eax
   12d5d:	e8 4e 0a 00 00       	call   137b0 <_KeClearEvent@4>
   12d62:	c7 04 24 ff 00 00 00 	movl   $0xff,(%esp)
   12d69:	6a 00                	push   $0x0
   12d6b:	8a 55 ec             	mov    0xffffffec(%ebp),%dl
   12d6e:	8a 4d d2             	mov    0xffffffd2(%ebp),%cl
   12d71:	8d 04 0a             	lea    (%edx,%ecx,1),%eax
   12d74:	81 e2 ff 00 00 00    	and    $0xff,%edx
   12d7a:	25 ff 00 00 00       	and    $0xff,%eax
   12d7f:	50                   	push   %eax
   12d80:	31 c0                	xor    %eax,%eax
   12d82:	8a 43 50             	mov    0x50(%ebx),%al
   12d85:	50                   	push   %eax
   12d86:	31 c0                	xor    %eax,%eax
   12d88:	52                   	push   %edx
   12d89:	8a 45 ed             	mov    0xffffffed(%ebp),%al
   12d8c:	50                   	push   %eax
   12d8d:	31 c0                	xor    %eax,%eax
   12d8f:	8a 45 d3             	mov    0xffffffd3(%ebp),%al
   12d92:	50                   	push   %eax
   12d93:	31 c0                	xor    %eax,%eax
   12d95:	8a 43 04             	mov    0x4(%ebx),%al
   12d98:	50                   	push   %eax
   12d99:	8a 45 e3             	mov    0xffffffe3(%ebp),%al
   12d9c:	83 f0 01             	xor    $0x1,%eax
   12d9f:	25 ff 00 00 00       	and    $0xff,%eax
   12da4:	50                   	push   %eax
   12da5:	8b 33                	mov    (%ebx),%esi
   12da7:	56                   	push   %esi
   12da8:	e8 93 f6 ff ff       	call   12440 <_HwReadWriteData@40>
   12dad:	5a                   	pop    %edx
   12dae:	85 c0                	test   %eax,%eax
   12db0:	59                   	pop    %ecx
   12db1:	0f 85 5f 02 00 00    	jne    13016 <_ReadWritePassive@8+0x446>
   12db7:	83 ec 0c             	sub    $0xc,%esp
   12dba:	8b 03                	mov    (%ebx),%eax
   12dbc:	50                   	push   %eax
   12dbd:	e8 7e e3 ff ff       	call   11140 <_WaitForControllerInterrupt@4>
   12dc2:	8b 7d bc             	mov    0xffffffbc(%ebp),%edi
   12dc5:	58                   	pop    %eax
   12dc6:	57                   	push   %edi
   12dc7:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
   12dca:	56                   	push   %esi
   12dcb:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   12dce:	8b 53 04             	mov    0x4(%ebx),%edx
   12dd1:	8b 5a 10             	mov    0x10(%edx),%ebx
   12dd4:	8b 42 18             	mov    0x18(%edx),%eax
   12dd7:	01 d8                	add    %ebx,%eax
   12dd9:	50                   	push   %eax
   12dda:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12ddd:	8b 01                	mov    (%ecx),%eax
   12ddf:	8b 48 30             	mov    0x30(%eax),%ecx
   12de2:	51                   	push   %ecx
   12de3:	52                   	push   %edx
   12de4:	8b 40 6c             	mov    0x6c(%eax),%eax
   12de7:	50                   	push   %eax
   12de8:	e8 a3 0c 00 00       	call   13a90 <_IoFlushAdapterBuffers@24>
   12ded:	50                   	push   %eax
   12dee:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12df1:	8b 03                	mov    (%ebx),%eax
   12df3:	50                   	push   %eax
   12df4:	e8 87 f7 ff ff       	call   12580 <_HwReadWriteResult@4>
   12df9:	83 c4 0c             	add    $0xc,%esp
   12dfc:	85 c0                	test   %eax,%eax
   12dfe:	0f 85 88 03 00 00    	jne    1318c <_ReadWritePassive@8+0x5bc>
   12e04:	8b 7d d4             	mov    0xffffffd4(%ebp),%edi
   12e07:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   12e0a:	01 c7                	add    %eax,%edi
   12e0c:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   12e0f:	89 7d d4             	mov    %edi,0xffffffd4(%ebp)
   12e12:	39 55 d4             	cmp    %edx,0xffffffd4(%ebp)
   12e15:	0f 83 d7 01 00 00    	jae    12ff2 <_ReadWritePassive@8+0x422>
   12e1b:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12e1e:	83 ec 0c             	sub    $0xc,%esp
   12e21:	8b 01                	mov    (%ecx),%eax
   12e23:	83 c0 35             	add    $0x35,%eax
   12e26:	50                   	push   %eax
   12e27:	e8 84 09 00 00       	call   137b0 <_KeClearEvent@4>
   12e2c:	8b 45 08             	mov    0x8(%ebp),%eax
   12e2f:	8b 75 d4             	mov    0xffffffd4(%ebp),%esi
   12e32:	8b 5d d8             	mov    0xffffffd8(%ebp),%ebx
   12e35:	83 c4 0c             	add    $0xc,%esp
   12e38:	01 f3                	add    %esi,%ebx
   12e3a:	8b 70 48             	mov    0x48(%eax),%esi
   12e3d:	8b 50 44             	mov    0x44(%eax),%edx
   12e40:	89 f0                	mov    %esi,%eax
   12e42:	0f af c2             	imul   %edx,%eax
   12e45:	89 55 c4             	mov    %edx,0xffffffc4(%ebp)
   12e48:	8b 55 08             	mov    0x8(%ebp),%edx
   12e4b:	88 c1                	mov    %al,%cl
   12e4d:	89 d8                	mov    %ebx,%eax
   12e4f:	8b 7a 4c             	mov    0x4c(%edx),%edi
   12e52:	31 d2                	xor    %edx,%edx
   12e54:	f7 f7                	div    %edi
   12e56:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   12e59:	85 d2                	test   %edx,%edx
   12e5b:	74 01                	je     12e5e <_ReadWritePassive@8+0x28e>
   12e5d:	cc                   	int3   
   12e5e:	31 d2                	xor    %edx,%edx
   12e60:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
   12e63:	88 ca                	mov    %cl,%dl
   12e65:	89 f1                	mov    %esi,%ecx
   12e67:	89 d3                	mov    %edx,%ebx
   12e69:	31 d2                	xor    %edx,%edx
   12e6b:	f7 f3                	div    %ebx
   12e6d:	39 f2                	cmp    %esi,%edx
   12e6f:	88 45 d3             	mov    %al,0xffffffd3(%ebp)
   12e72:	0f 93 c0             	setae  %al
   12e75:	88 45 ed             	mov    %al,0xffffffed(%ebp)
   12e78:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12e7b:	0f af c1             	imul   %ecx,%eax
   12e7e:	28 c2                	sub    %al,%dl
   12e80:	31 c0                	xor    %eax,%eax
   12e82:	42                   	inc    %edx
   12e83:	8a 45 d3             	mov    0xffffffd3(%ebp),%al
   12e86:	88 55 c3             	mov    %dl,0xffffffc3(%ebp)
   12e89:	88 55 ec             	mov    %dl,0xffffffec(%ebp)
   12e8c:	8b 4b 38             	mov    0x38(%ebx),%ecx
   12e8f:	31 d2                	xor    %edx,%edx
   12e91:	8b 5b 3c             	mov    0x3c(%ebx),%ebx
   12e94:	89 4d b0             	mov    %ecx,0xffffffb0(%ebp)
   12e97:	89 5d b4             	mov    %ebx,0xffffffb4(%ebp)
   12e9a:	39 da                	cmp    %ebx,%edx
   12e9c:	7c 07                	jl     12ea5 <_ReadWritePassive@8+0x2d5>
   12e9e:	7f 04                	jg     12ea4 <_ReadWritePassive@8+0x2d4>
   12ea0:	39 c8                	cmp    %ecx,%eax
   12ea2:	76 01                	jbe    12ea5 <_ReadWritePassive@8+0x2d5>
   12ea4:	cc                   	int3   
   12ea5:	31 c0                	xor    %eax,%eax
   12ea7:	8a 45 ed             	mov    0xffffffed(%ebp),%al
   12eaa:	3b 45 c4             	cmp    0xffffffc4(%ebp),%eax
   12ead:	76 01                	jbe    12eb0 <_ReadWritePassive@8+0x2e0>
   12eaf:	cc                   	int3   
   12eb0:	31 c0                	xor    %eax,%eax
   12eb2:	8a 45 ec             	mov    0xffffffec(%ebp),%al
   12eb5:	39 f0                	cmp    %esi,%eax
   12eb7:	76 01                	jbe    12eba <_ReadWritePassive@8+0x2ea>
   12eb9:	cc                   	int3   
   12eba:	8b 45 08             	mov    0x8(%ebp),%eax
   12ebd:	8b 18                	mov    (%eax),%ebx
   12ebf:	80 7b 71 00          	cmpb   $0x0,0x71(%ebx)
   12ec3:	0f 85 f7 fd ff ff    	jne    12cc0 <_ReadWritePassive@8+0xf0>
   12ec9:	e8 02 0b 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   12ece:	3c 01                	cmp    $0x1,%al
   12ed0:	76 01                	jbe    12ed3 <_ReadWritePassive@8+0x303>
   12ed2:	cc                   	int3   
   12ed3:	8b 55 08             	mov    0x8(%ebp),%edx
   12ed6:	83 ec 0c             	sub    $0xc,%esp
   12ed9:	8b 02                	mov    (%edx),%eax
   12edb:	83 c0 35             	add    $0x35,%eax
   12ede:	50                   	push   %eax
   12edf:	e8 cc 08 00 00       	call   137b0 <_KeClearEvent@4>
   12ee4:	31 c0                	xor    %eax,%eax
   12ee6:	8a 45 d3             	mov    0xffffffd3(%ebp),%al
   12ee9:	89 04 24             	mov    %eax,(%esp)
   12eec:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12eef:	53                   	push   %ebx
   12ef0:	e8 9b f8 ff ff       	call   12790 <_HwSeek@8>
   12ef5:	5a                   	pop    %edx
   12ef6:	85 c0                	test   %eax,%eax
   12ef8:	59                   	pop    %ecx
   12ef9:	0f 85 6b 02 00 00    	jne    1316a <_ReadWritePassive@8+0x59a>
   12eff:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12f02:	83 ec 0c             	sub    $0xc,%esp
   12f05:	8b 01                	mov    (%ecx),%eax
   12f07:	50                   	push   %eax
   12f08:	e8 33 e2 ff ff       	call   11140 <_WaitForControllerInterrupt@4>
   12f0d:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12f10:	8b 3b                	mov    (%ebx),%edi
   12f12:	57                   	push   %edi
   12f13:	e8 18 f7 ff ff       	call   12630 <_HwSenseInterruptStatus@4>
   12f18:	83 c4 0c             	add    $0xc,%esp
   12f1b:	85 c0                	test   %eax,%eax
   12f1d:	0f 85 47 02 00 00    	jne    1316a <_ReadWritePassive@8+0x59a>
   12f23:	56                   	push   %esi
   12f24:	56                   	push   %esi
   12f25:	6a 00                	push   $0x0
   12f27:	53                   	push   %ebx
   12f28:	e8 63 f7 ff ff       	call   12690 <_HwReadId@8>
   12f2d:	5a                   	pop    %edx
   12f2e:	85 c0                	test   %eax,%eax
   12f30:	59                   	pop    %ecx
   12f31:	0f 85 33 02 00 00    	jne    1316a <_ReadWritePassive@8+0x59a>
   12f37:	83 ec 0c             	sub    $0xc,%esp
   12f3a:	8b 03                	mov    (%ebx),%eax
   12f3c:	50                   	push   %eax
   12f3d:	e8 fe e1 ff ff       	call   11140 <_WaitForControllerInterrupt@4>
   12f42:	8d 45 eb             	lea    0xffffffeb(%ebp),%eax
   12f45:	5e                   	pop    %esi
   12f46:	5f                   	pop    %edi
   12f47:	6a 00                	push   $0x0
   12f49:	50                   	push   %eax
   12f4a:	8b 1b                	mov    (%ebx),%ebx
   12f4c:	53                   	push   %ebx
   12f4d:	e8 3e fa ff ff       	call   12990 <_HwReadIdResult@12>
   12f52:	59                   	pop    %ecx
   12f53:	85 c0                	test   %eax,%eax
   12f55:	0f 85 0f 02 00 00    	jne    1316a <_ReadWritePassive@8+0x59a>
   12f5b:	8a 45 d3             	mov    0xffffffd3(%ebp),%al
   12f5e:	38 45 eb             	cmp    %al,0xffffffeb(%ebp)
   12f61:	0f 85 03 02 00 00    	jne    1316a <_ReadWritePassive@8+0x59a>
   12f67:	8b 55 08             	mov    0x8(%ebp),%edx
   12f6a:	8a 4d ec             	mov    0xffffffec(%ebp),%cl
   12f6d:	88 4d c3             	mov    %cl,0xffffffc3(%ebp)
   12f70:	8b 1a                	mov    (%edx),%ebx
   12f72:	8b 72 48             	mov    0x48(%edx),%esi
   12f75:	8b 7a 4c             	mov    0x4c(%edx),%edi
   12f78:	e9 43 fd ff ff       	jmp    12cc0 <_ReadWritePassive@8+0xf0>
   12f7d:	8d 76 00             	lea    0x0(%esi),%esi
   12f80:	51                   	push   %ecx
   12f81:	51                   	push   %ecx
   12f82:	8b 55 0c             	mov    0xc(%ebp),%edx
   12f85:	52                   	push   %edx
   12f86:	53                   	push   %ebx
   12f87:	e8 a4 e8 ff ff       	call   11830 <_SignalMediaChanged@8>
   12f8c:	50                   	push   %eax
   12f8d:	8b 45 08             	mov    0x8(%ebp),%eax
   12f90:	50                   	push   %eax
   12f91:	e8 0a e3 ff ff       	call   112a0 <_ResetChangeFlag@4>
   12f96:	83 c4 0c             	add    $0xc,%esp
   12f99:	3d 13 00 00 c0       	cmp    $0xc0000013,%eax
   12f9e:	74 46                	je     12fe6 <_ReadWritePassive@8+0x416>
   12fa0:	50                   	push   %eax
   12fa1:	50                   	push   %eax
   12fa2:	6a 00                	push   $0x0
   12fa4:	8b 45 0c             	mov    0xc(%ebp),%eax
   12fa7:	50                   	push   %eax
   12fa8:	e8 23 08 00 00       	call   137d0 <_IoCompleteRequest@8>
   12fad:	53                   	push   %ebx
   12fae:	8b 55 08             	mov    0x8(%ebp),%edx
   12fb1:	8b 0a                	mov    (%edx),%ecx
   12fb3:	51                   	push   %ecx
   12fb4:	e8 37 e1 ff ff       	call   110f0 <_StopMotor@4>
   12fb9:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12fbc:	5b                   	pop    %ebx
   12fbd:	5e                   	pop    %esi
   12fbe:	5f                   	pop    %edi
   12fbf:	5d                   	pop    %ebp
   12fc0:	c2 08 00             	ret    $0x8
   12fc3:	57                   	push   %edi
   12fc4:	57                   	push   %edi
   12fc5:	6a 00                	push   $0x0
   12fc7:	8b 75 0c             	mov    0xc(%ebp),%esi
   12fca:	56                   	push   %esi
   12fcb:	e8 00 08 00 00       	call   137d0 <_IoCompleteRequest@8>
   12fd0:	53                   	push   %ebx
   12fd1:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12fd4:	8b 03                	mov    (%ebx),%eax
   12fd6:	50                   	push   %eax
   12fd7:	e8 14 e1 ff ff       	call   110f0 <_StopMotor@4>
   12fdc:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12fdf:	5b                   	pop    %ebx
   12fe0:	5e                   	pop    %esi
   12fe1:	5f                   	pop    %edi
   12fe2:	5d                   	pop    %ebp
   12fe3:	c2 08 00             	ret    $0x8
   12fe6:	8b 45 0c             	mov    0xc(%ebp),%eax
   12fe9:	c7 40 18 13 00 00 c0 	movl   $0xc0000013,0x18(%eax)
   12ff0:	eb ae                	jmp    12fa0 <_ReadWritePassive@8+0x3d0>
   12ff2:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12ff5:	8b 01                	mov    (%ecx),%eax
   12ff7:	8b 40 6c             	mov    0x6c(%eax),%eax
   12ffa:	e8 91 fb ff ff       	call   12b90 <_RWFreeAdapterChannel@4>
   12fff:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   13002:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   13005:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
   1300c:	89 43 1c             	mov    %eax,0x1c(%ebx)
   1300f:	56                   	push   %esi
   13010:	56                   	push   %esi
   13011:	6a 00                	push   $0x0
   13013:	53                   	push   %ebx
   13014:	eb 92                	jmp    12fa8 <_ReadWritePassive@8+0x3d8>
   13016:	8b 55 08             	mov    0x8(%ebp),%edx
   13019:	8b 02                	mov    (%edx),%eax
   1301b:	8b 40 6c             	mov    0x6c(%eax),%eax
   1301e:	e8 6d fb ff ff       	call   12b90 <_RWFreeAdapterChannel@4>
   13023:	50                   	push   %eax
   13024:	50                   	push   %eax
   13025:	6a 00                	push   $0x0
   13027:	8b 45 0c             	mov    0xc(%ebp),%eax
   1302a:	50                   	push   %eax
   1302b:	e8 a0 07 00 00       	call   137d0 <_IoCompleteRequest@8>
   13030:	50                   	push   %eax
   13031:	8b 4d 08             	mov    0x8(%ebp),%ecx
   13034:	8b 01                	mov    (%ecx),%eax
   13036:	eb 9e                	jmp    12fd6 <_ReadWritePassive@8+0x406>
   13038:	e8 93 09 00 00       	call   139d0 <_KeGetCurrentIrql@0>
   1303d:	3c 01                	cmp    $0x1,%al
   1303f:	76 01                	jbe    13042 <_ReadWritePassive@8+0x472>
   13041:	cc                   	int3   
   13042:	50                   	push   %eax
   13043:	50                   	push   %eax
   13044:	6a 00                	push   $0x0
   13046:	8b 45 08             	mov    0x8(%ebp),%eax
   13049:	8b 38                	mov    (%eax),%edi
   1304b:	57                   	push   %edi
   1304c:	e8 af f2 ff ff       	call   12300 <_HwSetDataRate@8>
   13051:	5a                   	pop    %edx
   13052:	85 c0                	test   %eax,%eax
   13054:	59                   	pop    %ecx
   13055:	75 cc                	jne    13023 <_ReadWritePassive@8+0x453>
   13057:	83 ec 0c             	sub    $0xc,%esp
   1305a:	6a 00                	push   $0x0
   1305c:	6a 00                	push   $0x0
   1305e:	6a 00                	push   $0x0
   13060:	6a 08                	push   $0x8
   13062:	8b 55 08             	mov    0x8(%ebp),%edx
   13065:	8b 02                	mov    (%edx),%eax
   13067:	50                   	push   %eax
   13068:	e8 b3 f9 ff ff       	call   12a20 <_HwSpecify@20>
   1306d:	83 c4 0c             	add    $0xc,%esp
   13070:	85 c0                	test   %eax,%eax
   13072:	75 af                	jne    13023 <_ReadWritePassive@8+0x453>
   13074:	8b 4d 08             	mov    0x8(%ebp),%ecx
   13077:	83 ec 0c             	sub    $0xc,%esp
   1307a:	31 ff                	xor    %edi,%edi
   1307c:	8b 01                	mov    (%ecx),%eax
   1307e:	83 c0 35             	add    $0x35,%eax
   13081:	50                   	push   %eax
   13082:	e8 29 07 00 00       	call   137b0 <_KeClearEvent@4>
   13087:	83 c4 0c             	add    $0xc,%esp
   1308a:	83 ec 0c             	sub    $0xc,%esp
   1308d:	8b 45 08             	mov    0x8(%ebp),%eax
   13090:	50                   	push   %eax
   13091:	e8 4a f5 ff ff       	call   125e0 <_HwRecalibrate@4>
   13096:	83 c4 0c             	add    $0xc,%esp
   13099:	85 c0                	test   %eax,%eax
   1309b:	75 86                	jne    13023 <_ReadWritePassive@8+0x453>
   1309d:	8b 45 08             	mov    0x8(%ebp),%eax
   130a0:	83 ec 0c             	sub    $0xc,%esp
   130a3:	8b 00                	mov    (%eax),%eax
   130a5:	50                   	push   %eax
   130a6:	e8 95 e0 ff ff       	call   11140 <_WaitForControllerInterrupt@4>
   130ab:	8b 55 08             	mov    0x8(%ebp),%edx
   130ae:	8b 02                	mov    (%edx),%eax
   130b0:	50                   	push   %eax
   130b1:	e8 5a f4 ff ff       	call   12510 <_HwRecalibrateResult@4>
   130b6:	83 c4 0c             	add    $0xc,%esp
   130b9:	85 c0                	test   %eax,%eax
   130bb:	74 0f                	je     130cc <_ReadWritePassive@8+0x4fc>
   130bd:	83 ff 01             	cmp    $0x1,%edi
   130c0:	0f 84 5d ff ff ff    	je     13023 <_ReadWritePassive@8+0x453>
   130c6:	47                   	inc    %edi
   130c7:	83 ff 01             	cmp    $0x1,%edi
   130ca:	7e be                	jle    1308a <_ReadWritePassive@8+0x4ba>
   130cc:	8b 4d 08             	mov    0x8(%ebp),%ecx
   130cf:	83 ec 0c             	sub    $0xc,%esp
   130d2:	8b 01                	mov    (%ecx),%eax
   130d4:	83 c0 35             	add    $0x35,%eax
   130d7:	50                   	push   %eax
   130d8:	e8 d3 06 00 00       	call   137b0 <_KeClearEvent@4>
   130dd:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   130e4:	8b 7d 08             	mov    0x8(%ebp),%edi
   130e7:	57                   	push   %edi
   130e8:	e8 a3 f5 ff ff       	call   12690 <_HwReadId@8>
   130ed:	5a                   	pop    %edx
   130ee:	85 c0                	test   %eax,%eax
   130f0:	59                   	pop    %ecx
   130f1:	0f 85 2c ff ff ff    	jne    13023 <_ReadWritePassive@8+0x453>
   130f7:	8b 45 08             	mov    0x8(%ebp),%eax
   130fa:	83 ec 0c             	sub    $0xc,%esp
   130fd:	8b 00                	mov    (%eax),%eax
   130ff:	50                   	push   %eax
   13100:	e8 3b e0 ff ff       	call   11140 <_WaitForControllerInterrupt@4>
   13105:	5f                   	pop    %edi
   13106:	58                   	pop    %eax
   13107:	6a 00                	push   $0x0
   13109:	6a 00                	push   $0x0
   1310b:	8b 55 08             	mov    0x8(%ebp),%edx
   1310e:	8b 0a                	mov    (%edx),%ecx
   13110:	51                   	push   %ecx
   13111:	e8 7a f8 ff ff       	call   12990 <_HwReadIdResult@12>
   13116:	5a                   	pop    %edx
   13117:	85 c0                	test   %eax,%eax
   13119:	0f 85 04 ff ff ff    	jne    13023 <_ReadWritePassive@8+0x453>
   1311f:	8b 45 08             	mov    0x8(%ebp),%eax
   13122:	c7 40 40 02 00 00 00 	movl   $0x2,0x40(%eax)
   13129:	c7 40 38 50 00 00 00 	movl   $0x50,0x38(%eax)
   13130:	c7 40 3c 00 00 00 00 	movl   $0x0,0x3c(%eax)
   13137:	c7 40 44 02 00 00 00 	movl   $0x2,0x44(%eax)
   1313e:	c7 40 48 12 00 00 00 	movl   $0x12,0x48(%eax)
   13145:	c7 40 4c 00 02 00 00 	movl   $0x200,0x4c(%eax)
   1314c:	c6 40 50 02          	movb   $0x2,0x50(%eax)
   13150:	e9 e8 fa ff ff       	jmp    12c3d <_ReadWritePassive@8+0x6d>
   13155:	8b 56 04             	mov    0x4(%esi),%edx
   13158:	89 55 dc             	mov    %edx,0xffffffdc(%ebp)
   1315b:	8b 76 0c             	mov    0xc(%esi),%esi
   1315e:	c6 45 e3 00          	movb   $0x0,0xffffffe3(%ebp)
   13162:	89 75 d8             	mov    %esi,0xffffffd8(%ebp)
   13165:	e9 ec fa ff ff       	jmp    12c56 <_ReadWritePassive@8+0x86>
   1316a:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1316d:	8b 03                	mov    (%ebx),%eax
   1316f:	8b 40 6c             	mov    0x6c(%eax),%eax
   13172:	e8 19 fa ff ff       	call   12b90 <_RWFreeAdapterChannel@4>
   13177:	51                   	push   %ecx
   13178:	51                   	push   %ecx
   13179:	6a 00                	push   $0x0
   1317b:	8b 55 0c             	mov    0xc(%ebp),%edx
   1317e:	52                   	push   %edx
   1317f:	e8 4c 06 00 00       	call   137d0 <_IoCompleteRequest@8>
   13184:	50                   	push   %eax
   13185:	8b 03                	mov    (%ebx),%eax
   13187:	e9 4a fe ff ff       	jmp    12fd6 <_ReadWritePassive@8+0x406>
   1318c:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1318f:	83 ec 0c             	sub    $0xc,%esp
   13192:	8b 3b                	mov    (%ebx),%edi
   13194:	57                   	push   %edi
   13195:	e8 d6 ee ff ff       	call   12070 <_HwDumpRegisters@4>
   1319a:	83 c4 0c             	add    $0xc,%esp
   1319d:	eb ce                	jmp    1316d <_ReadWritePassive@8+0x59d>
   1319f:	90                   	nop    

000131a0 <_DeviceIoctl@8>:
   131a0:	55                   	push   %ebp
   131a1:	89 e5                	mov    %esp,%ebp
   131a3:	51                   	push   %ecx
   131a4:	51                   	push   %ecx
   131a5:	8b 55 08             	mov    0x8(%ebp),%edx
   131a8:	8b 45 0c             	mov    0xc(%ebp),%eax
   131ab:	85 d2                	test   %edx,%edx
   131ad:	74 21                	je     131d0 <_DeviceIoctl@8+0x30>
   131af:	85 c0                	test   %eax,%eax
   131b1:	74 22                	je     131d5 <_DeviceIoctl@8+0x35>
   131b3:	89 50 40             	mov    %edx,0x40(%eax)
   131b6:	52                   	push   %edx
   131b7:	6a 00                	push   $0x0
   131b9:	50                   	push   %eax
   131ba:	68 80 99 01 00       	push   $0x19980
   131bf:	e8 9c 04 00 00       	call   13660 <_IoCsqInsertIrp@12>
   131c4:	b8 03 01 00 00       	mov    $0x103,%eax
   131c9:	c9                   	leave  
   131ca:	c2 08 00             	ret    $0x8
   131cd:	8d 76 00             	lea    0x0(%esi),%esi
   131d0:	cc                   	int3   
   131d1:	85 c0                	test   %eax,%eax
   131d3:	75 de                	jne    131b3 <_DeviceIoctl@8+0x13>
   131d5:	cc                   	int3   
   131d6:	89 50 40             	mov    %edx,0x40(%eax)
   131d9:	52                   	push   %edx
   131da:	6a 00                	push   $0x0
   131dc:	50                   	push   %eax
   131dd:	68 80 99 01 00       	push   $0x19980
   131e2:	e8 79 04 00 00       	call   13660 <_IoCsqInsertIrp@12>
   131e7:	b8 03 01 00 00       	mov    $0x103,%eax
   131ec:	c9                   	leave  
   131ed:	c2 08 00             	ret    $0x8

000131f0 <_DeviceIoctlPassive@8>:
   131f0:	55                   	push   %ebp
   131f1:	89 e5                	mov    %esp,%ebp
   131f3:	57                   	push   %edi
   131f4:	56                   	push   %esi
   131f5:	53                   	push   %ebx
   131f6:	83 ec 0c             	sub    $0xc,%esp
   131f9:	8b 7d 0c             	mov    0xc(%ebp),%edi
   131fc:	8b 47 60             	mov    0x60(%edi),%eax
   131ff:	8b 50 04             	mov    0x4(%eax),%edx
   13202:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   13205:	8b 58 0c             	mov    0xc(%eax),%ebx
   13208:	8b 77 0c             	mov    0xc(%edi),%esi
   1320b:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
   13212:	81 fb 00 0c 07 00    	cmp    $0x70c00,%ebx
   13218:	0f 84 92 00 00 00    	je     132b0 <_DeviceIoctlPassive@8+0xc0>
   1321e:	83 ec 0c             	sub    $0xc,%esp
   13221:	8b 45 08             	mov    0x8(%ebp),%eax
   13224:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
   1322b:	50                   	push   %eax
   1322c:	e8 1f de ff ff       	call   11050 <_StartMotor@4>
   13231:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13234:	89 04 24             	mov    %eax,(%esp)
   13237:	8b 45 08             	mov    0x8(%ebp),%eax
   1323a:	50                   	push   %eax
   1323b:	e8 e0 f6 ff ff       	call   12920 <_HwDiskChanged@8>
   13240:	5a                   	pop    %edx
   13241:	85 c0                	test   %eax,%eax
   13243:	59                   	pop    %ecx
   13244:	0f 85 c6 00 00 00    	jne    13310 <_DeviceIoctlPassive@8+0x120>
   1324a:	80 7d f3 00          	cmpb   $0x0,0xfffffff3(%ebp)
   1324e:	0f 85 cc 00 00 00    	jne    13320 <_DeviceIoctlPassive@8+0x130>
   13254:	81 fb 04 40 07 00    	cmp    $0x74004,%ebx
   1325a:	74 24                	je     13280 <_DeviceIoctlPassive@8+0x90>
   1325c:	0f 87 f1 00 00 00    	ja     13353 <_DeviceIoctlPassive@8+0x163>
   13262:	81 fb 00 00 07 00    	cmp    $0x70000,%ebx
   13268:	0f 84 33 01 00 00    	je     133a1 <_DeviceIoctlPassive@8+0x1b1>
   1326e:	81 fb 24 00 07 00    	cmp    $0x70024,%ebx
   13274:	0f 84 6b 01 00 00    	je     133e5 <_DeviceIoctlPassive@8+0x1f5>
   1327a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   13280:	c7 47 18 bb 00 00 c0 	movl   $0xc00000bb,0x18(%edi)
   13287:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
   1328e:	50                   	push   %eax
   1328f:	50                   	push   %eax
   13290:	6a 00                	push   $0x0
   13292:	57                   	push   %edi
   13293:	e8 38 05 00 00       	call   137d0 <_IoCompleteRequest@8>
   13298:	56                   	push   %esi
   13299:	8b 45 08             	mov    0x8(%ebp),%eax
   1329c:	8b 18                	mov    (%eax),%ebx
   1329e:	53                   	push   %ebx
   1329f:	e8 4c de ff ff       	call   110f0 <_StopMotor@4>
   132a4:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   132a7:	5b                   	pop    %ebx
   132a8:	5e                   	pop    %esi
   132a9:	5f                   	pop    %edi
   132aa:	5d                   	pop    %ebp
   132ab:	c2 08 00             	ret    $0x8
   132ae:	89 f6                	mov    %esi,%esi
   132b0:	83 fa 17             	cmp    $0x17,%edx
   132b3:	77 1b                	ja     132d0 <_DeviceIoctlPassive@8+0xe0>
   132b5:	c7 47 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%edi)
   132bc:	50                   	push   %eax
   132bd:	50                   	push   %eax
   132be:	6a 00                	push   $0x0
   132c0:	57                   	push   %edi
   132c1:	e8 0a 05 00 00       	call   137d0 <_IoCompleteRequest@8>
   132c6:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   132c9:	5b                   	pop    %ebx
   132ca:	5e                   	pop    %esi
   132cb:	5f                   	pop    %edi
   132cc:	5d                   	pop    %ebp
   132cd:	c2 08 00             	ret    $0x8
   132d0:	c7 06 50 00 00 00    	movl   $0x50,(%esi)
   132d6:	c7 46 04 00 00 00 00 	movl   $0x0,0x4(%esi)
   132dd:	c7 46 0c 24 00 00 00 	movl   $0x24,0xc(%esi)
   132e4:	c7 46 10 12 00 00 00 	movl   $0x12,0x10(%esi)
   132eb:	c7 46 14 00 02 00 00 	movl   $0x200,0x14(%esi)
   132f2:	c7 46 08 02 00 00 00 	movl   $0x2,0x8(%esi)
   132f9:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
   13300:	c7 47 1c 18 00 00 00 	movl   $0x18,0x1c(%edi)
   13307:	eb b3                	jmp    132bc <_DeviceIoctlPassive@8+0xcc>
   13309:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   13310:	c7 47 18 01 00 00 c0 	movl   $0xc0000001,0x18(%edi)
   13317:	e9 6b ff ff ff       	jmp    13287 <_DeviceIoctlPassive@8+0x97>
   1331c:	8d 74 26 00          	lea    0x0(%esi),%esi
   13320:	50                   	push   %eax
   13321:	50                   	push   %eax
   13322:	57                   	push   %edi
   13323:	8b 55 08             	mov    0x8(%ebp),%edx
   13326:	8b 42 10             	mov    0x10(%edx),%eax
   13329:	50                   	push   %eax
   1332a:	e8 01 e5 ff ff       	call   11830 <_SignalMediaChanged@8>
   1332f:	50                   	push   %eax
   13330:	8b 45 08             	mov    0x8(%ebp),%eax
   13333:	50                   	push   %eax
   13334:	e8 67 df ff ff       	call   112a0 <_ResetChangeFlag@4>
   13339:	83 c4 0c             	add    $0xc,%esp
   1333c:	3d 13 00 00 c0       	cmp    $0xc0000013,%eax
   13341:	0f 85 47 ff ff ff    	jne    1328e <_DeviceIoctlPassive@8+0x9e>
   13347:	c7 47 18 13 00 00 c0 	movl   $0xc0000013,0x18(%edi)
   1334e:	e9 3b ff ff ff       	jmp    1328e <_DeviceIoctlPassive@8+0x9e>
   13353:	81 fb 18 c0 07 00    	cmp    $0x7c018,%ebx
   13359:	0f 84 2f ff ff ff    	je     1328e <_DeviceIoctlPassive@8+0x9e>
   1335f:	77 2f                	ja     13390 <_DeviceIoctlPassive@8+0x1a0>
   13361:	81 fb 00 48 07 00    	cmp    $0x74800,%ebx
   13367:	0f 85 13 ff ff ff    	jne    13280 <_DeviceIoctlPassive@8+0x90>
   1336d:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   13370:	85 c0                	test   %eax,%eax
   13372:	0f 84 93 00 00 00    	je     1340b <_DeviceIoctlPassive@8+0x21b>
   13378:	83 7d ec 03          	cmpl   $0x3,0xffffffec(%ebp)
   1337c:	0f 87 cc 00 00 00    	ja     1344e <_DeviceIoctlPassive@8+0x25e>
   13382:	c7 47 18 23 00 00 c0 	movl   $0xc0000023,0x18(%edi)
   13389:	e9 f9 fe ff ff       	jmp    13287 <_DeviceIoctlPassive@8+0x97>
   1338e:	89 f6                	mov    %esi,%esi
   13390:	81 fb 2c c0 07 00    	cmp    $0x7c02c,%ebx
   13396:	0f 85 e4 fe ff ff    	jne    13280 <_DeviceIoctlPassive@8+0x90>
   1339c:	e9 ed fe ff ff       	jmp    1328e <_DeviceIoctlPassive@8+0x9e>
   133a1:	83 7d ec 17          	cmpl   $0x17,0xffffffec(%ebp)
   133a5:	77 0c                	ja     133b3 <_DeviceIoctlPassive@8+0x1c3>
   133a7:	c7 47 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%edi)
   133ae:	e9 db fe ff ff       	jmp    1328e <_DeviceIoctlPassive@8+0x9e>
   133b3:	8b 55 08             	mov    0x8(%ebp),%edx
   133b6:	8b 42 38             	mov    0x38(%edx),%eax
   133b9:	89 06                	mov    %eax,(%esi)
   133bb:	8b 42 3c             	mov    0x3c(%edx),%eax
   133be:	89 46 04             	mov    %eax,0x4(%esi)
   133c1:	8b 42 40             	mov    0x40(%edx),%eax
   133c4:	89 46 08             	mov    %eax,0x8(%esi)
   133c7:	8b 42 44             	mov    0x44(%edx),%eax
   133ca:	89 46 0c             	mov    %eax,0xc(%esi)
   133cd:	8b 42 48             	mov    0x48(%edx),%eax
   133d0:	89 46 10             	mov    %eax,0x10(%esi)
   133d3:	8b 42 4c             	mov    0x4c(%edx),%eax
   133d6:	89 46 14             	mov    %eax,0x14(%esi)
   133d9:	c7 47 1c 18 00 00 00 	movl   $0x18,0x1c(%edi)
   133e0:	e9 a9 fe ff ff       	jmp    1328e <_DeviceIoctlPassive@8+0x9e>
   133e5:	83 ec 0c             	sub    $0xc,%esp
   133e8:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
   133ef:	8b 45 08             	mov    0x8(%ebp),%eax
   133f2:	50                   	push   %eax
   133f3:	e8 f8 ef ff ff       	call   123f0 <_HwSenseDriveStatus@4>
   133f8:	83 c4 0c             	add    $0xc,%esp
   133fb:	85 c0                	test   %eax,%eax
   133fd:	74 18                	je     13417 <_DeviceIoctlPassive@8+0x227>
   133ff:	c7 47 18 85 01 00 c0 	movl   $0xc0000185,0x18(%edi)
   13406:	e9 83 fe ff ff       	jmp    1328e <_DeviceIoctlPassive@8+0x9e>
   1340b:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
   13412:	e9 70 fe ff ff       	jmp    13287 <_DeviceIoctlPassive@8+0x97>
   13417:	8d 45 f2             	lea    0xfffffff2(%ebp),%eax
   1341a:	56                   	push   %esi
   1341b:	56                   	push   %esi
   1341c:	50                   	push   %eax
   1341d:	8b 55 08             	mov    0x8(%ebp),%edx
   13420:	8b 1a                	mov    (%edx),%ebx
   13422:	53                   	push   %ebx
   13423:	e8 38 f5 ff ff       	call   12960 <_HwSenseDriveStatusResult@8>
   13428:	5a                   	pop    %edx
   13429:	85 c0                	test   %eax,%eax
   1342b:	59                   	pop    %ecx
   1342c:	75 d1                	jne    133ff <_DeviceIoctlPassive@8+0x20f>
   1342e:	31 c0                	xor    %eax,%eax
   13430:	8a 45 f2             	mov    0xfffffff2(%ebp),%al
   13433:	c1 e8 06             	shr    $0x6,%eax
   13436:	83 e0 01             	and    $0x1,%eax
   13439:	83 f8 01             	cmp    $0x1,%eax
   1343c:	19 c0                	sbb    %eax,%eax
   1343e:	83 f0 ff             	xor    $0xffffffff,%eax
   13441:	25 a2 00 00 c0       	and    $0xc00000a2,%eax
   13446:	89 47 18             	mov    %eax,0x18(%edi)
   13449:	e9 40 fe ff ff       	jmp    1328e <_DeviceIoctlPassive@8+0x9e>
   1344e:	8b 55 08             	mov    0x8(%ebp),%edx
   13451:	8b 82 50 04 00 00    	mov    0x450(%edx),%eax
   13457:	89 06                	mov    %eax,(%esi)
   13459:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
   13460:	c7 47 1c 04 00 00 00 	movl   $0x4,0x1c(%edi)
   13467:	e9 22 fe ff ff       	jmp    1328e <_DeviceIoctlPassive@8+0x9e>
   1346c:	90                   	nop    
   1346d:	90                   	nop    
   1346e:	90                   	nop    
   1346f:	90                   	nop    

00013470 <_IopCsqCancelRoutine@8>:
   13470:	55                   	push   %ebp
   13471:	31 c0                	xor    %eax,%eax
   13473:	89 e5                	mov    %esp,%ebp
   13475:	56                   	push   %esi
   13476:	53                   	push   %ebx
   13477:	83 ec 1c             	sub    $0x1c,%esp
   1347a:	8b 75 0c             	mov    0xc(%ebp),%esi
   1347d:	8a 46 25             	mov    0x25(%esi),%al
   13480:	50                   	push   %eax
   13481:	e8 2a 05 00 00       	call   139b0 <_IoReleaseCancelSpinLock@4>
   13486:	8b 5e 4c             	mov    0x4c(%esi),%ebx
   13489:	83 c4 0c             	add    $0xc,%esp
   1348c:	83 3b 01             	cmpl   $0x1,(%ebx)
   1348f:	74 27                	je     134b8 <_IopCsqCancelRoutine@8+0x48>
   13491:	50                   	push   %eax
   13492:	50                   	push   %eax
   13493:	8d 45 f7             	lea    0xfffffff7(%ebp),%eax
   13496:	50                   	push   %eax
   13497:	53                   	push   %ebx
   13498:	ff 53 10             	call   *0x10(%ebx)
   1349b:	56                   	push   %esi
   1349c:	53                   	push   %ebx
   1349d:	ff 53 08             	call   *0x8(%ebx)
   134a0:	56                   	push   %esi
   134a1:	53                   	push   %ebx
   134a2:	ff 53 18             	call   *0x18(%ebx)
   134a5:	31 c0                	xor    %eax,%eax
   134a7:	8a 45 f7             	mov    0xfffffff7(%ebp),%al
   134aa:	50                   	push   %eax
   134ab:	53                   	push   %ebx
   134ac:	ff 53 14             	call   *0x14(%ebx)
   134af:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   134b2:	5b                   	pop    %ebx
   134b3:	5e                   	pop    %esi
   134b4:	5d                   	pop    %ebp
   134b5:	c2 08 00             	ret    $0x8
   134b8:	89 d8                	mov    %ebx,%eax
   134ba:	8b 5b 08             	mov    0x8(%ebx),%ebx
   134bd:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)
   134c4:	50                   	push   %eax
   134c5:	50                   	push   %eax
   134c6:	8d 45 f7             	lea    0xfffffff7(%ebp),%eax
   134c9:	50                   	push   %eax
   134ca:	53                   	push   %ebx
   134cb:	ff 53 10             	call   *0x10(%ebx)
   134ce:	56                   	push   %esi
   134cf:	53                   	push   %ebx
   134d0:	ff 53 08             	call   *0x8(%ebx)
   134d3:	56                   	push   %esi
   134d4:	53                   	push   %ebx
   134d5:	ff 53 18             	call   *0x18(%ebx)
   134d8:	31 c0                	xor    %eax,%eax
   134da:	8a 45 f7             	mov    0xfffffff7(%ebp),%al
   134dd:	50                   	push   %eax
   134de:	53                   	push   %ebx
   134df:	ff 53 14             	call   *0x14(%ebx)
   134e2:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   134e5:	5b                   	pop    %ebx
   134e6:	5e                   	pop    %esi
   134e7:	5d                   	pop    %ebp
   134e8:	c2 08 00             	ret    $0x8
   134eb:	90                   	nop    
   134ec:	8d 74 26 00          	lea    0x0(%esi),%esi

000134f0 <_IoCsqInitialize@28>:
   134f0:	55                   	push   %ebp
   134f1:	89 e5                	mov    %esp,%ebp
   134f3:	8b 55 08             	mov    0x8(%ebp),%edx
   134f6:	8b 45 0c             	mov    0xc(%ebp),%eax
   134f9:	89 42 04             	mov    %eax,0x4(%edx)
   134fc:	8b 45 10             	mov    0x10(%ebp),%eax
   134ff:	89 42 08             	mov    %eax,0x8(%edx)
   13502:	8b 45 14             	mov    0x14(%ebp),%eax
   13505:	89 42 0c             	mov    %eax,0xc(%edx)
   13508:	8b 45 18             	mov    0x18(%ebp),%eax
   1350b:	89 42 10             	mov    %eax,0x10(%edx)
   1350e:	8b 45 1c             	mov    0x1c(%ebp),%eax
   13511:	89 42 14             	mov    %eax,0x14(%edx)
   13514:	8b 45 20             	mov    0x20(%ebp),%eax
   13517:	89 42 18             	mov    %eax,0x18(%edx)
   1351a:	c7 02 02 00 00 00    	movl   $0x2,(%edx)
   13520:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   13527:	31 c0                	xor    %eax,%eax
   13529:	5d                   	pop    %ebp
   1352a:	c2 1c 00             	ret    $0x1c
   1352d:	8d 76 00             	lea    0x0(%esi),%esi

00013530 <_IoCsqInitializeEx@28>:
   13530:	55                   	push   %ebp
   13531:	89 e5                	mov    %esp,%ebp
   13533:	8b 55 08             	mov    0x8(%ebp),%edx
   13536:	8b 45 0c             	mov    0xc(%ebp),%eax
   13539:	89 42 04             	mov    %eax,0x4(%edx)
   1353c:	8b 45 10             	mov    0x10(%ebp),%eax
   1353f:	89 42 08             	mov    %eax,0x8(%edx)
   13542:	8b 45 14             	mov    0x14(%ebp),%eax
   13545:	89 42 0c             	mov    %eax,0xc(%edx)
   13548:	8b 45 18             	mov    0x18(%ebp),%eax
   1354b:	89 42 10             	mov    %eax,0x10(%edx)
   1354e:	8b 45 1c             	mov    0x1c(%ebp),%eax
   13551:	89 42 14             	mov    %eax,0x14(%edx)
   13554:	8b 45 20             	mov    0x20(%ebp),%eax
   13557:	89 42 18             	mov    %eax,0x18(%edx)
   1355a:	c7 02 03 00 00 00    	movl   $0x3,(%edx)
   13560:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   13567:	31 c0                	xor    %eax,%eax
   13569:	5d                   	pop    %ebp
   1356a:	c2 1c 00             	ret    $0x1c
   1356d:	8d 76 00             	lea    0x0(%esi),%esi

00013570 <_IoCsqInsertIrpEx@16>:
   13570:	55                   	push   %ebp
   13571:	89 e5                	mov    %esp,%ebp
   13573:	57                   	push   %edi
   13574:	56                   	push   %esi
   13575:	53                   	push   %ebx
   13576:	83 ec 14             	sub    $0x14,%esp
   13579:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   1357c:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1357f:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   13586:	50                   	push   %eax
   13587:	8b 7d 0c             	mov    0xc(%ebp),%edi
   1358a:	53                   	push   %ebx
   1358b:	ff 53 10             	call   *0x10(%ebx)
   1358e:	8b 47 60             	mov    0x60(%edi),%eax
   13591:	80 48 03 01          	orb    $0x1,0x3(%eax)
   13595:	8b 75 10             	mov    0x10(%ebp),%esi
   13598:	58                   	pop    %eax
   13599:	85 f6                	test   %esi,%esi
   1359b:	5a                   	pop    %edx
   1359c:	0f 84 ae 00 00 00    	je     13650 <_IoCsqInsertIrpEx@16+0xe0>
   135a2:	8b 45 10             	mov    0x10(%ebp),%eax
   135a5:	c7 00 01 00 00 00    	movl   $0x1,(%eax)
   135ab:	89 78 04             	mov    %edi,0x4(%eax)
   135ae:	89 58 08             	mov    %ebx,0x8(%eax)
   135b1:	89 47 4c             	mov    %eax,0x4c(%edi)
   135b4:	83 3b 02             	cmpl   $0x2,(%ebx)
   135b7:	74 47                	je     13600 <_IoCsqInsertIrpEx@16+0x90>
   135b9:	8b 4d 14             	mov    0x14(%ebp),%ecx
   135bc:	56                   	push   %esi
   135bd:	51                   	push   %ecx
   135be:	57                   	push   %edi
   135bf:	53                   	push   %ebx
   135c0:	ff 53 04             	call   *0x4(%ebx)
   135c3:	5a                   	pop    %edx
   135c4:	85 c0                	test   %eax,%eax
   135c6:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   135c9:	75 15                	jne    135e0 <_IoCsqInsertIrpEx@16+0x70>
   135cb:	8d 77 38             	lea    0x38(%edi),%esi
   135ce:	ba 70 34 01 00       	mov    $0x13470,%edx
   135d3:	89 f1                	mov    %esi,%ecx
   135d5:	e8 e6 03 00 00       	call   139c0 <@InterlockedExchange@8>
   135da:	80 7f 24 00          	cmpb   $0x0,0x24(%edi)
   135de:	75 3e                	jne    1361e <_IoCsqInsertIrpEx@16+0xae>
   135e0:	31 c0                	xor    %eax,%eax
   135e2:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   135e5:	52                   	push   %edx
   135e6:	52                   	push   %edx
   135e7:	50                   	push   %eax
   135e8:	53                   	push   %ebx
   135e9:	ff 53 14             	call   *0x14(%ebx)
   135ec:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   135ef:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   135f2:	5b                   	pop    %ebx
   135f3:	5e                   	pop    %esi
   135f4:	5f                   	pop    %edi
   135f5:	5d                   	pop    %ebp
   135f6:	c2 10 00             	ret    $0x10
   135f9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   13600:	51                   	push   %ecx
   13601:	51                   	push   %ecx
   13602:	57                   	push   %edi
   13603:	53                   	push   %ebx
   13604:	ff 53 04             	call   *0x4(%ebx)
   13607:	8d 77 38             	lea    0x38(%edi),%esi
   1360a:	58                   	pop    %eax
   1360b:	89 f1                	mov    %esi,%ecx
   1360d:	5a                   	pop    %edx
   1360e:	ba 70 34 01 00       	mov    $0x13470,%edx
   13613:	e8 a8 03 00 00       	call   139c0 <@InterlockedExchange@8>
   13618:	80 7f 24 00          	cmpb   $0x0,0x24(%edi)
   1361c:	74 c2                	je     135e0 <_IoCsqInsertIrpEx@16+0x70>
   1361e:	31 d2                	xor    %edx,%edx
   13620:	89 f1                	mov    %esi,%ecx
   13622:	e8 99 03 00 00       	call   139c0 <@InterlockedExchange@8>
   13627:	85 c0                	test   %eax,%eax
   13629:	74 b5                	je     135e0 <_IoCsqInsertIrpEx@16+0x70>
   1362b:	50                   	push   %eax
   1362c:	50                   	push   %eax
   1362d:	57                   	push   %edi
   1362e:	53                   	push   %ebx
   1362f:	ff 53 08             	call   *0x8(%ebx)
   13632:	57                   	push   %edi
   13633:	53                   	push   %ebx
   13634:	ff 53 18             	call   *0x18(%ebx)
   13637:	8b 4d 10             	mov    0x10(%ebp),%ecx
   1363a:	5e                   	pop    %esi
   1363b:	85 c9                	test   %ecx,%ecx
   1363d:	5f                   	pop    %edi
   1363e:	74 a0                	je     135e0 <_IoCsqInsertIrpEx@16+0x70>
   13640:	8b 45 10             	mov    0x10(%ebp),%eax
   13643:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)
   1364a:	eb 94                	jmp    135e0 <_IoCsqInsertIrpEx@16+0x70>
   1364c:	8d 74 26 00          	lea    0x0(%esi),%esi
   13650:	89 5f 4c             	mov    %ebx,0x4c(%edi)
   13653:	e9 5c ff ff ff       	jmp    135b4 <_IoCsqInsertIrpEx@16+0x44>
   13658:	90                   	nop    
   13659:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00013660 <_IoCsqInsertIrp@12>:
   13660:	55                   	push   %ebp
   13661:	89 e5                	mov    %esp,%ebp
   13663:	50                   	push   %eax
   13664:	50                   	push   %eax
   13665:	6a 00                	push   $0x0
   13667:	8b 45 10             	mov    0x10(%ebp),%eax
   1366a:	8b 4d 08             	mov    0x8(%ebp),%ecx
   1366d:	50                   	push   %eax
   1366e:	8b 45 0c             	mov    0xc(%ebp),%eax
   13671:	50                   	push   %eax
   13672:	51                   	push   %ecx
   13673:	e8 f8 fe ff ff       	call   13570 <_IoCsqInsertIrpEx@16>
   13678:	c9                   	leave  
   13679:	c2 0c 00             	ret    $0xc
   1367c:	8d 74 26 00          	lea    0x0(%esi),%esi

00013680 <_IoCsqRemoveIrp@8>:
   13680:	55                   	push   %ebp
   13681:	89 e5                	mov    %esp,%ebp
   13683:	57                   	push   %edi
   13684:	56                   	push   %esi
   13685:	53                   	push   %ebx
   13686:	83 ec 14             	sub    $0x14,%esp
   13689:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   1368c:	8b 7d 08             	mov    0x8(%ebp),%edi
   1368f:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   13692:	50                   	push   %eax
   13693:	57                   	push   %edi
   13694:	ff 57 10             	call   *0x10(%edi)
   13697:	8b 73 04             	mov    0x4(%ebx),%esi
   1369a:	85 f6                	test   %esi,%esi
   1369c:	5b                   	pop    %ebx
   1369d:	58                   	pop    %eax
   1369e:	74 10                	je     136b0 <_IoCsqRemoveIrp@8+0x30>
   136a0:	31 d2                	xor    %edx,%edx
   136a2:	8d 4e 38             	lea    0x38(%esi),%ecx
   136a5:	e8 16 03 00 00       	call   139c0 <@InterlockedExchange@8>
   136aa:	85 c0                	test   %eax,%eax
   136ac:	75 1a                	jne    136c8 <_IoCsqRemoveIrp@8+0x48>
   136ae:	31 f6                	xor    %esi,%esi
   136b0:	50                   	push   %eax
   136b1:	50                   	push   %eax
   136b2:	31 c0                	xor    %eax,%eax
   136b4:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   136b7:	50                   	push   %eax
   136b8:	57                   	push   %edi
   136b9:	ff 57 14             	call   *0x14(%edi)
   136bc:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   136bf:	89 f0                	mov    %esi,%eax
   136c1:	5b                   	pop    %ebx
   136c2:	5e                   	pop    %esi
   136c3:	5f                   	pop    %edi
   136c4:	5d                   	pop    %ebp
   136c5:	c2 08 00             	ret    $0x8
   136c8:	51                   	push   %ecx
   136c9:	51                   	push   %ecx
   136ca:	56                   	push   %esi
   136cb:	57                   	push   %edi
   136cc:	ff 57 08             	call   *0x8(%edi)
   136cf:	8d 4e 4c             	lea    0x4c(%esi),%ecx
   136d2:	58                   	pop    %eax
   136d3:	5a                   	pop    %edx
   136d4:	31 d2                	xor    %edx,%edx
   136d6:	e8 e5 02 00 00       	call   139c0 <@InterlockedExchange@8>
   136db:	85 c0                	test   %eax,%eax
   136dd:	74 d1                	je     136b0 <_IoCsqRemoveIrp@8+0x30>
   136df:	83 38 01             	cmpl   $0x1,(%eax)
   136e2:	75 cc                	jne    136b0 <_IoCsqRemoveIrp@8+0x30>
   136e4:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)
   136eb:	eb c3                	jmp    136b0 <_IoCsqRemoveIrp@8+0x30>
   136ed:	8d 76 00             	lea    0x0(%esi),%esi

000136f0 <_IoCsqRemoveNextIrp@8>:
   136f0:	55                   	push   %ebp
   136f1:	89 e5                	mov    %esp,%ebp
   136f3:	57                   	push   %edi
   136f4:	56                   	push   %esi
   136f5:	53                   	push   %ebx
   136f6:	83 ec 14             	sub    $0x14,%esp
   136f9:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   136fc:	8b 75 08             	mov    0x8(%ebp),%esi
   136ff:	8b 7d 0c             	mov    0xc(%ebp),%edi
   13702:	50                   	push   %eax
   13703:	56                   	push   %esi
   13704:	ff 56 10             	call   *0x10(%esi)
   13707:	31 db                	xor    %ebx,%ebx
   13709:	58                   	pop    %eax
   1370a:	5a                   	pop    %edx
   1370b:	90                   	nop    
   1370c:	8d 74 26 00          	lea    0x0(%esi),%esi
   13710:	50                   	push   %eax
   13711:	57                   	push   %edi
   13712:	53                   	push   %ebx
   13713:	56                   	push   %esi
   13714:	ff 56 0c             	call   *0xc(%esi)
   13717:	89 c3                	mov    %eax,%ebx
   13719:	58                   	pop    %eax
   1371a:	85 db                	test   %ebx,%ebx
   1371c:	74 2a                	je     13748 <_IoCsqRemoveNextIrp@8+0x58>
   1371e:	31 d2                	xor    %edx,%edx
   13720:	8d 4b 38             	lea    0x38(%ebx),%ecx
   13723:	e8 98 02 00 00       	call   139c0 <@InterlockedExchange@8>
   13728:	85 c0                	test   %eax,%eax
   1372a:	74 e4                	je     13710 <_IoCsqRemoveNextIrp@8+0x20>
   1372c:	51                   	push   %ecx
   1372d:	51                   	push   %ecx
   1372e:	53                   	push   %ebx
   1372f:	56                   	push   %esi
   13730:	ff 56 08             	call   *0x8(%esi)
   13733:	8d 4b 4c             	lea    0x4c(%ebx),%ecx
   13736:	58                   	pop    %eax
   13737:	5a                   	pop    %edx
   13738:	31 d2                	xor    %edx,%edx
   1373a:	e8 81 02 00 00       	call   139c0 <@InterlockedExchange@8>
   1373f:	85 c0                	test   %eax,%eax
   13741:	74 05                	je     13748 <_IoCsqRemoveNextIrp@8+0x58>
   13743:	83 38 01             	cmpl   $0x1,(%eax)
   13746:	74 18                	je     13760 <_IoCsqRemoveNextIrp@8+0x70>
   13748:	50                   	push   %eax
   13749:	50                   	push   %eax
   1374a:	31 c0                	xor    %eax,%eax
   1374c:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   1374f:	50                   	push   %eax
   13750:	56                   	push   %esi
   13751:	ff 56 14             	call   *0x14(%esi)
   13754:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13757:	89 d8                	mov    %ebx,%eax
   13759:	5b                   	pop    %ebx
   1375a:	5e                   	pop    %esi
   1375b:	5f                   	pop    %edi
   1375c:	5d                   	pop    %ebp
   1375d:	c2 08 00             	ret    $0x8
   13760:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)
   13767:	50                   	push   %eax
   13768:	50                   	push   %eax
   13769:	31 c0                	xor    %eax,%eax
   1376b:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   1376e:	50                   	push   %eax
   1376f:	56                   	push   %esi
   13770:	ff 56 14             	call   *0x14(%esi)
   13773:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13776:	89 d8                	mov    %ebx,%eax
   13778:	5b                   	pop    %ebx
   13779:	5e                   	pop    %esi
   1377a:	5f                   	pop    %edi
   1377b:	5d                   	pop    %ebp
   1377c:	c2 08 00             	ret    $0x8
   1377f:	90                   	nop    

00013780 <_KeSetEvent@12>:
   13780:	ff 25 bc a1 01 00    	jmp    *0x1a1bc
   13786:	90                   	nop    
   13787:	90                   	nop    
	...

00013790 <_KeCancelTimer@4>:
   13790:	ff 25 88 a1 01 00    	jmp    *0x1a188
   13796:	90                   	nop    
   13797:	90                   	nop    
	...

000137a0 <_KeWaitForSingleObject@20>:
   137a0:	ff 25 c8 a1 01 00    	jmp    *0x1a1c8
   137a6:	90                   	nop    
   137a7:	90                   	nop    
	...

000137b0 <_KeClearEvent@4>:
   137b0:	ff 25 8c a1 01 00    	jmp    *0x1a18c
   137b6:	90                   	nop    
   137b7:	90                   	nop    
	...

000137c0 <_KeSetTimer@16>:
   137c0:	ff 25 c0 a1 01 00    	jmp    *0x1a1c0
   137c6:	90                   	nop    
   137c7:	90                   	nop    
	...

000137d0 <_IoCompleteRequest@8>:
   137d0:	ff 25 60 a1 01 00    	jmp    *0x1a160
   137d6:	90                   	nop    
   137d7:	90                   	nop    
	...

000137e0 <@ObfDereferenceObject@4>:
   137e0:	ff 25 58 a1 01 00    	jmp    *0x1a158
   137e6:	90                   	nop    
   137e7:	90                   	nop    
	...

000137f0 <_RtlInitUnicodeString@8>:
   137f0:	ff 25 d8 a1 01 00    	jmp    *0x1a1d8
   137f6:	90                   	nop    
   137f7:	90                   	nop    
	...

00013800 <_IoDeleteSymbolicLink@4>:
   13800:	ff 25 74 a1 01 00    	jmp    *0x1a174
   13806:	90                   	nop    
   13807:	90                   	nop    
	...

00013810 <_IoDeleteDevice@4>:
   13810:	ff 25 70 a1 01 00    	jmp    *0x1a170
   13816:	90                   	nop    
   13817:	90                   	nop    
	...

00013820 <_IoDisconnectInterrupt@4>:
   13820:	ff 25 78 a1 01 00    	jmp    *0x1a178
   13826:	90                   	nop    
   13827:	90                   	nop    
	...

00013830 <_KeInitializeEvent@12>:
   13830:	ff 25 98 a1 01 00    	jmp    *0x1a198
   13836:	90                   	nop    
   13837:	90                   	nop    
	...

00013840 <_MmMapIoSpace@16>:
   13840:	ff 25 cc a1 01 00    	jmp    *0x1a1cc
   13846:	90                   	nop    
   13847:	90                   	nop    
	...

00013850 <_KeInsertQueueDpc@12>:
   13850:	ff 25 a8 a1 01 00    	jmp    *0x1a1a8
   13856:	90                   	nop    
   13857:	90                   	nop    
	...

00013860 <_IoSetHardErrorOrVerifyDevice@8>:
   13860:	ff 25 84 a1 01 00    	jmp    *0x1a184
   13866:	90                   	nop    
   13867:	90                   	nop    
	...

00013870 <_KeWaitForMultipleObjects@32>:
   13870:	ff 25 c4 a1 01 00    	jmp    *0x1a1c4
   13876:	90                   	nop    
   13877:	90                   	nop    
	...

00013880 <_KeReadStateEvent@4>:
   13880:	ff 25 b4 a1 01 00    	jmp    *0x1a1b4
   13886:	90                   	nop    
   13887:	90                   	nop    
	...

00013890 <_KeInitializeSpinLock@4>:
   13890:	ff 25 a0 a1 01 00    	jmp    *0x1a1a0
   13896:	90                   	nop    
   13897:	90                   	nop    
	...

000138a0 <_KeInitializeSemaphore@12>:
   138a0:	ff 25 9c a1 01 00    	jmp    *0x1a19c
   138a6:	90                   	nop    
   138a7:	90                   	nop    
	...

000138b0 <_PsCreateSystemThread@28>:
   138b0:	ff 25 d4 a1 01 00    	jmp    *0x1a1d4
   138b6:	90                   	nop    
   138b7:	90                   	nop    
	...

000138c0 <_ObReferenceObjectByHandle@24>:
   138c0:	ff 25 d0 a1 01 00    	jmp    *0x1a1d0
   138c6:	90                   	nop    
   138c7:	90                   	nop    
	...

000138d0 <_ZwClose@4>:
   138d0:	ff 25 dc a1 01 00    	jmp    *0x1a1dc
   138d6:	90                   	nop    
   138d7:	90                   	nop    
	...

000138e0 <_IoQueryDeviceDescription@32>:
   138e0:	ff 25 7c a1 01 00    	jmp    *0x1a17c
   138e6:	90                   	nop    
   138e7:	90                   	nop    
	...

000138f0 <_KeInitializeDpc@12>:
   138f0:	ff 25 94 a1 01 00    	jmp    *0x1a194
   138f6:	90                   	nop    
   138f7:	90                   	nop    
	...

00013900 <_IoConnectInterrupt@44>:
   13900:	ff 25 64 a1 01 00    	jmp    *0x1a164
   13906:	90                   	nop    
   13907:	90                   	nop    
	...

00013910 <_KeInitializeTimer@4>:
   13910:	ff 25 a4 a1 01 00    	jmp    *0x1a1a4
   13916:	90                   	nop    
   13917:	90                   	nop    
	...

00013920 <_IoCreateDevice@28>:
   13920:	ff 25 68 a1 01 00    	jmp    *0x1a168
   13926:	90                   	nop    
   13927:	90                   	nop    
	...

00013930 <_IoCreateSymbolicLink@8>:
   13930:	ff 25 6c a1 01 00    	jmp    *0x1a16c
   13936:	90                   	nop    
   13937:	90                   	nop    
	...

00013940 <_memset>:
   13940:	ff 25 e0 a1 01 00    	jmp    *0x1a1e0
   13946:	90                   	nop    
   13947:	90                   	nop    
	...

00013950 <_swprintf>:
   13950:	ff 25 e4 a1 01 00    	jmp    *0x1a1e4
   13956:	90                   	nop    
   13957:	90                   	nop    
	...

00013960 <_KeReleaseSemaphore@16>:
   13960:	ff 25 b8 a1 01 00    	jmp    *0x1a1b8
   13966:	90                   	nop    
   13967:	90                   	nop    
	...

00013970 <_KeQueryTickCount@4>:
   13970:	ff 25 ac a1 01 00    	jmp    *0x1a1ac
   13976:	90                   	nop    
   13977:	90                   	nop    
	...

00013980 <_KeQueryTimeIncrement@0>:
   13980:	ff 25 b0 a1 01 00    	jmp    *0x1a1b0
   13986:	90                   	nop    
   13987:	90                   	nop    
	...

00013990 <_KeDelayExecutionThread@12>:
   13990:	ff 25 90 a1 01 00    	jmp    *0x1a190
   13996:	90                   	nop    
   13997:	90                   	nop    
	...

000139a0 <_IoAllocateAdapterChannel@20>:
   139a0:	ff 25 5c a1 01 00    	jmp    *0x1a15c
   139a6:	90                   	nop    
   139a7:	90                   	nop    
	...

000139b0 <_IoReleaseCancelSpinLock@4>:
   139b0:	ff 25 80 a1 01 00    	jmp    *0x1a180
   139b6:	90                   	nop    
   139b7:	90                   	nop    
	...

000139c0 <@InterlockedExchange@8>:
   139c0:	ff 25 54 a1 01 00    	jmp    *0x1a154
   139c6:	90                   	nop    
   139c7:	90                   	nop    
	...

000139d0 <_KeGetCurrentIrql@0>:
   139d0:	ff 25 34 a1 01 00    	jmp    *0x1a134
   139d6:	90                   	nop    
   139d7:	90                   	nop    
	...

000139e0 <_HalTranslateBusAddress@24>:
   139e0:	ff 25 20 a1 01 00    	jmp    *0x1a120
   139e6:	90                   	nop    
   139e7:	90                   	nop    
	...

000139f0 <_HalGetInterruptVector@24>:
   139f0:	ff 25 1c a1 01 00    	jmp    *0x1a11c
   139f6:	90                   	nop    
   139f7:	90                   	nop    
	...

00013a00 <_HalGetAdapter@8>:
   13a00:	ff 25 18 a1 01 00    	jmp    *0x1a118
   13a06:	90                   	nop    
   13a07:	90                   	nop    
	...

00013a10 <_KeAcquireSpinLock@8>:
   13a10:	ff 25 30 a1 01 00    	jmp    *0x1a130
   13a16:	90                   	nop    
   13a17:	90                   	nop    
	...

00013a20 <_KeReleaseSpinLock@8>:
   13a20:	ff 25 40 a1 01 00    	jmp    *0x1a140
   13a26:	90                   	nop    
   13a27:	90                   	nop    
	...

00013a30 <_READ_PORT_UCHAR@4>:
   13a30:	ff 25 44 a1 01 00    	jmp    *0x1a144
   13a36:	90                   	nop    
   13a37:	90                   	nop    
	...

00013a40 <_WRITE_PORT_UCHAR@8>:
   13a40:	ff 25 48 a1 01 00    	jmp    *0x1a148
   13a46:	90                   	nop    
   13a47:	90                   	nop    
	...

00013a50 <_KeRaiseIrql@8>:
   13a50:	ff 25 3c a1 01 00    	jmp    *0x1a13c
   13a56:	90                   	nop    
   13a57:	90                   	nop    
	...

00013a60 <_IoFreeAdapterChannel@4>:
   13a60:	ff 25 28 a1 01 00    	jmp    *0x1a128
   13a66:	90                   	nop    
   13a67:	90                   	nop    
	...

00013a70 <_KeLowerIrql@4>:
   13a70:	ff 25 38 a1 01 00    	jmp    *0x1a138
   13a76:	90                   	nop    
   13a77:	90                   	nop    
	...

00013a80 <_IoMapTransfer@24>:
   13a80:	ff 25 2c a1 01 00    	jmp    *0x1a12c
   13a86:	90                   	nop    
   13a87:	90                   	nop    
	...

00013a90 <_IoFlushAdapterBuffers@24>:
   13a90:	ff 25 24 a1 01 00    	jmp    *0x1a124
   13a96:	90                   	nop    
   13a97:	90                   	nop    
	...

00013aa0 <__CTOR_LIST__>:
   13aa0:	ff                   	(bad)  
   13aa1:	ff                   	(bad)  
   13aa2:	ff                   	(bad)  
   13aa3:	ff 00                	incl   (%eax)
   13aa5:	00 00                	add    %al,(%eax)
	...

00013aa8 <__DTOR_LIST__>:
   13aa8:	ff                   	(bad)  
   13aa9:	ff                   	(bad)  
   13aaa:	ff                   	(bad)  
   13aab:	ff 00                	incl   (%eax)
   13aad:	00 00                	add    %al,(%eax)
	...
