
beep.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <___crt_xc_end__>:
BeepDPC(PKDPC Dpc,
	PVOID DeferredContext,
	PVOID SystemArgument1,
	PVOID SystemArgument2)
{
   11000:	55                   	push   %ebp
   11001:	89 e5                	mov    %esp,%ebp
   11003:	53                   	push   %ebx
   11004:	83 ec 10             	sub    $0x10,%esp
   11007:	8b 5d 0c             	mov    0xc(%ebp),%ebx
  PDEVICE_EXTENSION DeviceExtension = DeferredContext;

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

  HalMakeBeep(0);
   1100a:	6a 00                	push   $0x0
   1100c:	e8 6f 03 00 00       	call   11380 <_HalMakeBeep@4>
  DeviceExtension->BeepOn = FALSE;
   11011:	c6 43 58 00          	movb   $0x0,0x58(%ebx)
  KeSetEvent(&DeviceExtension->Event,
   11015:	83 c3 48             	add    $0x48,%ebx
   11018:	58                   	pop    %eax
   11019:	5a                   	pop    %edx
   1101a:	6a 00                	push   $0x0
   1101c:	6a 00                	push   $0x0
   1101e:	53                   	push   %ebx
   1101f:	e8 bc 02 00 00       	call   112e0 <_KeSetEvent@12>
   11024:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11027:	c9                   	leave  
   11028:	c2 10 00             	ret    $0x10
   1102b:	90                   	nop    
   1102c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011030 <_BeepCreate@8>:
	     0,
	     FALSE);

  DPRINT("BeepDPC() finished!\n");
}


static NTSTATUS STDCALL
BeepCreate(
   PDEVICE_OBJECT DeviceObject,
	 PIRP Irp)
/*
 * FUNCTION: Handles user mode requests
 * ARGUMENTS:
 *                       DeviceObject = Device for request
 *                       Irp = I/O request packet describing request
 * RETURNS: Success or failure
 */
{
   11030:	55                   	push   %ebp
   11031:	89 e5                	mov    %esp,%ebp
   11033:	83 ec 10             	sub    $0x10,%esp
   11036:	8b 45 0c             	mov    0xc(%ebp),%eax
  DPRINT("BeepCreate() called!\n");

  Irp->IoStatus.Status = STATUS_SUCCESS;
   11039:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
  Irp->IoStatus.Information = 0;
   11040:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
  IoCompleteRequest(Irp,
   11047:	6a 00                	push   $0x0
   11049:	50                   	push   %eax
   1104a:	e8 a1 02 00 00       	call   112f0 <_IoCompleteRequest@8>
		    IO_NO_INCREMENT);

  return(STATUS_SUCCESS);
}
   1104f:	31 c0                	xor    %eax,%eax
   11051:	c9                   	leave  
   11052:	c2 08 00             	ret    $0x8
   11055:	8d 74 26 00          	lea    0x0(%esi),%esi
   11059:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011060 <_BeepClose@8>:


static NTSTATUS STDCALL
BeepClose(PDEVICE_OBJECT DeviceObject,
	  PIRP Irp)
/*
 * FUNCTION: Handles user mode requests
 * ARGUMENTS:
 *                       DeviceObject = Device for request
 *                       Irp = I/O request packet describing request
 * RETURNS: Success or failure
 */
{
   11060:	55                   	push   %ebp
   11061:	89 e5                	mov    %esp,%ebp
   11063:	56                   	push   %esi
   11064:	53                   	push   %ebx
  PDEVICE_EXTENSION DeviceExtension;
  NTSTATUS Status;

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

  DeviceExtension = DeviceObject->DeviceExtension;
   11065:	8b 45 08             	mov    0x8(%ebp),%eax
   11068:	8b 75 0c             	mov    0xc(%ebp),%esi
   1106b:	8b 58 28             	mov    0x28(%eax),%ebx
  if (DeviceExtension->BeepOn == TRUE)
   1106e:	80 7b 58 01          	cmpb   $0x1,0x58(%ebx)
   11072:	74 23                	je     11097 <_BeepClose@8+0x37>
    {
      HalMakeBeep(0);
      DeviceExtension->BeepOn = FALSE;
      KeCancelTimer(&DeviceExtension->Timer);
    }

  Status = STATUS_SUCCESS;

  Irp->IoStatus.Status = Status;
   11074:	c7 46 18 00 00 00 00 	movl   $0x0,0x18(%esi)
  Irp->IoStatus.Information = 0;
   1107b:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
  IoCompleteRequest(Irp,
   11082:	51                   	push   %ecx
   11083:	51                   	push   %ecx
   11084:	6a 00                	push   $0x0
   11086:	56                   	push   %esi
   11087:	e8 64 02 00 00       	call   112f0 <_IoCompleteRequest@8>
		    IO_NO_INCREMENT);

  return(Status);
}
   1108c:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1108f:	31 c0                	xor    %eax,%eax
   11091:	5b                   	pop    %ebx
   11092:	5e                   	pop    %esi
   11093:	5d                   	pop    %ebp
   11094:	c2 08 00             	ret    $0x8
   11097:	83 ec 0c             	sub    $0xc,%esp
   1109a:	6a 00                	push   $0x0
   1109c:	e8 df 02 00 00       	call   11380 <_HalMakeBeep@4>
   110a1:	c6 43 58 00          	movb   $0x0,0x58(%ebx)
   110a5:	8d 43 20             	lea    0x20(%ebx),%eax
   110a8:	50                   	push   %eax
   110a9:	e8 52 02 00 00       	call   11300 <_KeCancelTimer@4>
   110ae:	83 c4 0c             	add    $0xc,%esp
   110b1:	c7 46 18 00 00 00 00 	movl   $0x0,0x18(%esi)
   110b8:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   110bf:	51                   	push   %ecx
   110c0:	51                   	push   %ecx
   110c1:	6a 00                	push   $0x0
   110c3:	56                   	push   %esi
   110c4:	e8 27 02 00 00       	call   112f0 <_IoCompleteRequest@8>
   110c9:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   110cc:	31 c0                	xor    %eax,%eax
   110ce:	5b                   	pop    %ebx
   110cf:	5e                   	pop    %esi
   110d0:	5d                   	pop    %ebp
   110d1:	c2 08 00             	ret    $0x8
   110d4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   110da:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

000110e0 <_BeepCleanup@8>:


static NTSTATUS STDCALL
BeepCleanup(PDEVICE_OBJECT DeviceObject,
	    PIRP Irp)
/*
 * FUNCTION: Handles user mode requests
 * ARGUMENTS:
 *                       DeviceObject = Device for request
 *                       Irp = I/O request packet describing request
 * RETURNS: Success or failure
 */
{
   110e0:	55                   	push   %ebp
   110e1:	89 e5                	mov    %esp,%ebp
   110e3:	83 ec 10             	sub    $0x10,%esp
   110e6:	8b 45 0c             	mov    0xc(%ebp),%eax
  DPRINT("BeepCleanup() called!\n");

  Irp->IoStatus.Status = STATUS_SUCCESS;
   110e9:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
  Irp->IoStatus.Information = 0;
   110f0:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
  IoCompleteRequest(Irp,
   110f7:	6a 00                	push   $0x0
   110f9:	50                   	push   %eax
   110fa:	e8 f1 01 00 00       	call   112f0 <_IoCompleteRequest@8>
		    IO_NO_INCREMENT);

  return(STATUS_SUCCESS);
}
   110ff:	31 c0                	xor    %eax,%eax
   11101:	c9                   	leave  
   11102:	c2 08 00             	ret    $0x8
   11105:	8d 74 26 00          	lea    0x0(%esi),%esi
   11109:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011110 <_BeepDeviceControl@8>:


static NTSTATUS STDCALL
BeepDeviceControl(PDEVICE_OBJECT DeviceObject,
		  PIRP Irp)
/*
 * FUNCTION: Handles user mode requests
 * ARGUMENTS:
 *                       DeviceObject = Device for request
 *                       Irp = I/O request packet describing request
 * RETURNS: Success or failure
 */
{
   11110:	55                   	push   %ebp
   11111:	89 e5                	mov    %esp,%ebp
   11113:	57                   	push   %edi
   11114:	56                   	push   %esi
   11115:	53                   	push   %ebx
   11116:	83 ec 0c             	sub    $0xc,%esp
  PIO_STACK_LOCATION Stack;
  PDEVICE_EXTENSION DeviceExtension;
  PBEEP_SET_PARAMETERS BeepParam;
  LARGE_INTEGER DueTime;

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

  DeviceExtension = DeviceObject->DeviceExtension;
   11119:	8b 45 08             	mov    0x8(%ebp),%eax
   1111c:	8b 7d 0c             	mov    0xc(%ebp),%edi
   1111f:	8b 40 28             	mov    0x28(%eax),%eax
  Stack = IoGetCurrentIrpStackLocation(Irp);
  BeepParam = (PBEEP_SET_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;

  Irp->IoStatus.Information = 0;
   11122:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
   11129:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   1112c:	8b 47 60             	mov    0x60(%edi),%eax
   1112f:	8b 57 0c             	mov    0xc(%edi),%edx
   11132:	89 55 ec             	mov    %edx,0xffffffec(%ebp)

  if (Stack->Parameters.DeviceIoControl.IoControlCode != IOCTL_BEEP_SET)
   11135:	81 78 0c 00 00 01 00 	cmpl   $0x10000,0xc(%eax)
   1113c:	0f 85 ae 00 00 00    	jne    111f0 <_BeepDeviceControl@8+0xe0>
    {
      Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
      IoCompleteRequest(Irp,
			IO_NO_INCREMENT);
      return(STATUS_NOT_IMPLEMENTED);
    }

  if ((Stack->Parameters.DeviceIoControl.InputBufferLength != sizeof(BEEP_SET_PARAMETERS))
   11142:	83 78 08 08          	cmpl   $0x8,0x8(%eax)
   11146:	75 0a                	jne    11152 <_BeepDeviceControl@8+0x42>
   11148:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   1114b:	8b 02                	mov    (%edx),%eax
   1114d:	83 f8 24             	cmp    $0x24,%eax
   11150:	77 20                	ja     11172 <_BeepDeviceControl@8+0x62>
      || (BeepParam->Frequency < BEEP_FREQUENCY_MINIMUM)
      || (BeepParam->Frequency > BEEP_FREQUENCY_MAXIMUM))
    {
      Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
   11152:	c7 47 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%edi)
      IoCompleteRequest(Irp,
   11159:	50                   	push   %eax
   1115a:	50                   	push   %eax
   1115b:	6a 00                	push   $0x0
   1115d:	57                   	push   %edi
   1115e:	e8 8d 01 00 00       	call   112f0 <_IoCompleteRequest@8>
			IO_NO_INCREMENT);
      return(STATUS_INVALID_PARAMETER);
   11163:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
    }

  DueTime.QuadPart = 0;

  /* do the beep!! */
  DPRINT("Beep:\n  Freq: %lu Hz\n  Dur: %lu ms\n",
	 pbsp->Frequency,
	 pbsp->Duration);

  if (BeepParam->Duration >= 0)
    {
      DueTime.QuadPart = (LONGLONG)BeepParam->Duration * -10000;

      KeSetTimer(&DeviceExtension->Timer,
		 DueTime,
		 &DeviceExtension->Dpc);

      HalMakeBeep(BeepParam->Frequency);
      DeviceExtension->BeepOn = TRUE;
      KeWaitForSingleObject(&DeviceExtension->Event,
			    Executive,
			    KernelMode,
			    FALSE,
			    NULL);
    }
  else if (BeepParam->Duration == (DWORD)-1)
    {
      if (DeviceExtension->BeepOn == TRUE)
	{
	  HalMakeBeep(0);
	  DeviceExtension->BeepOn = FALSE;
	}
      else
	{
	  HalMakeBeep(BeepParam->Frequency);
	  DeviceExtension->BeepOn = TRUE;
	}
    }

  DPRINT("Did the beep!\n");

  Irp->IoStatus.Status = STATUS_SUCCESS;
  IoCompleteRequest(Irp,
		    IO_NO_INCREMENT);
  return(STATUS_SUCCESS);
}
   11168:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1116b:	5b                   	pop    %ebx
   1116c:	5e                   	pop    %esi
   1116d:	5f                   	pop    %edi
   1116e:	5d                   	pop    %ebp
   1116f:	c2 08 00             	ret    $0x8
   11172:	3d ff 7f 00 00       	cmp    $0x7fff,%eax
   11177:	77 d9                	ja     11152 <_BeepDeviceControl@8+0x42>
   11179:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1117c:	31 db                	xor    %ebx,%ebx
   1117e:	8b 48 04             	mov    0x4(%eax),%ecx
   11181:	b8 f0 d8 ff ff       	mov    $0xffffd8f0,%eax
   11186:	f7 e1                	mul    %ecx
   11188:	89 d6                	mov    %edx,%esi
   1118a:	29 ce                	sub    %ecx,%esi
   1118c:	69 cb f0 d8 ff ff    	imul   $0xffffd8f0,%ebx,%ecx
   11192:	8d 14 0e             	lea    (%esi,%ecx,1),%edx
   11195:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
   11198:	56                   	push   %esi
   11199:	52                   	push   %edx
   1119a:	50                   	push   %eax
   1119b:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   1119e:	83 c0 20             	add    $0x20,%eax
   111a1:	50                   	push   %eax
   111a2:	e8 69 01 00 00       	call   11310 <_KeSetTimer@16>
   111a7:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   111aa:	83 ec 0c             	sub    $0xc,%esp
   111ad:	8b 1a                	mov    (%edx),%ebx
   111af:	53                   	push   %ebx
   111b0:	e8 cb 01 00 00       	call   11380 <_HalMakeBeep@4>
   111b5:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   111b8:	c6 40 58 01          	movb   $0x1,0x58(%eax)
   111bc:	6a 00                	push   $0x0
   111be:	6a 00                	push   $0x0
   111c0:	6a 00                	push   $0x0
   111c2:	6a 00                	push   $0x0
   111c4:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   111c7:	83 c0 48             	add    $0x48,%eax
   111ca:	50                   	push   %eax
   111cb:	e8 50 01 00 00       	call   11320 <_KeWaitForSingleObject@20>
   111d0:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
   111d7:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   111de:	57                   	push   %edi
   111df:	e8 0c 01 00 00       	call   112f0 <_IoCompleteRequest@8>
   111e4:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   111e7:	31 c0                	xor    %eax,%eax
   111e9:	5b                   	pop    %ebx
   111ea:	5e                   	pop    %esi
   111eb:	5f                   	pop    %edi
   111ec:	5d                   	pop    %ebp
   111ed:	c2 08 00             	ret    $0x8
   111f0:	c7 47 18 02 00 00 c0 	movl   $0xc0000002,0x18(%edi)
   111f7:	50                   	push   %eax
   111f8:	50                   	push   %eax
   111f9:	6a 00                	push   $0x0
   111fb:	57                   	push   %edi
   111fc:	e8 ef 00 00 00       	call   112f0 <_IoCompleteRequest@8>
   11201:	b8 02 00 00 c0       	mov    $0xc0000002,%eax
   11206:	e9 5d ff ff ff       	jmp    11168 <_BeepDeviceControl@8+0x58>
   1120b:	90                   	nop    
   1120c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011210 <_BeepUnload@4>:


static VOID STDCALL
BeepUnload(PDRIVER_OBJECT DriverObject)
{
   11210:	55                   	push   %ebp
   11211:	89 e5                	mov    %esp,%ebp
   11213:	5d                   	pop    %ebp
   11214:	c2 04 00             	ret    $0x4
   11217:	89 f6                	mov    %esi,%esi
   11219:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011220 <_DriverEntry@8>:
  DPRINT("BeepUnload() called!\n");
}


NTSTATUS STDCALL
DriverEntry(PDRIVER_OBJECT DriverObject,
	    PUNICODE_STRING RegistryPath)
/*
 * FUNCTION:  Called by the system to initalize the driver
 * ARGUMENTS:
 *            DriverObject = object describing this driver
 *            RegistryPath = path to our configuration entries
 * RETURNS:   Success or failure
 */
{
   11220:	55                   	push   %ebp
   11221:	89 e5                	mov    %esp,%ebp
   11223:	56                   	push   %esi
   11224:	53                   	push   %ebx
   11225:	83 ec 24             	sub    $0x24,%esp
  PDEVICE_EXTENSION DeviceExtension;
  PDEVICE_OBJECT DeviceObject;
  UNICODE_STRING DeviceName = ROS_STRING_INITIALIZER(L"\\Device\\Beep");
  UNICODE_STRING SymlinkName = ROS_STRING_INITIALIZER(L"\\??\\Beep");
  NTSTATUS Status;

  DPRINT("Beep Device Driver 0.0.3\n");

  DriverObject->Flags = 0;
  DriverObject->MajorFunction[IRP_MJ_CREATE] = BeepCreate;
  DriverObject->MajorFunction[IRP_MJ_CLOSE] = BeepClose;
  DriverObject->MajorFunction[IRP_MJ_CLEANUP] = BeepCleanup;
  DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = BeepDeviceControl;
  DriverObject->DriverUnload = BeepUnload;

  Status = IoCreateDevice(DriverObject,
   11228:	8d 55 e4             	lea    0xffffffe4(%ebp),%edx
   1122b:	8b 45 08             	mov    0x8(%ebp),%eax
   1122e:	8d 75 f0             	lea    0xfffffff0(%ebp),%esi
   11231:	66 c7 45 f0 18 00    	movw   $0x18,0xfffffff0(%ebp)
   11237:	66 c7 45 f2 1a 00    	movw   $0x1a,0xfffffff2(%ebp)
   1123d:	c7 40 08 00 00 00 00 	movl   $0x0,0x8(%eax)
   11244:	c7 40 38 30 10 01 00 	movl   $0x11030,0x38(%eax)
   1124b:	c7 40 40 60 10 01 00 	movl   $0x11060,0x40(%eax)
   11252:	c7 80 80 00 00 00 e0 	movl   $0x110e0,0x80(%eax)
   11259:	10 01 00 
   1125c:	c7 40 70 10 11 01 00 	movl   $0x11110,0x70(%eax)
   11263:	c7 40 34 10 12 01 00 	movl   $0x11210,0x34(%eax)
   1126a:	c7 45 f4 00 20 01 00 	movl   $0x12000,0xfffffff4(%ebp)
   11271:	52                   	push   %edx
   11272:	66 c7 45 e8 10 00    	movw   $0x10,0xffffffe8(%ebp)
   11278:	6a 00                	push   $0x0
   1127a:	66 c7 45 ea 12 00    	movw   $0x12,0xffffffea(%ebp)
   11280:	6a 00                	push   $0x0
   11282:	c7 45 ec 1a 20 01 00 	movl   $0x1201a,0xffffffec(%ebp)
   11289:	6a 01                	push   $0x1
   1128b:	56                   	push   %esi
   1128c:	6a 60                	push   $0x60
   1128e:	50                   	push   %eax
   1128f:	e8 9c 00 00 00       	call   11330 <_IoCreateDevice@28>
			  sizeof(DEVICE_EXTENSION),
			  &DeviceName,
			  FILE_DEVICE_BEEP,
			  0,
			  FALSE,
			  &DeviceObject);
  if (!NT_SUCCESS(Status))
   11294:	5a                   	pop    %edx
   11295:	85 c0                	test   %eax,%eax
   11297:	78 3e                	js     112d7 <_DriverEntry@8+0xb7>
    return Status;

  /* set up device extension */
  DeviceExtension = DeviceObject->DeviceExtension;
   11299:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   1129c:	8b 58 28             	mov    0x28(%eax),%ebx
  DeviceExtension->BeepOn = FALSE;
   1129f:	c6 43 58 00          	movb   $0x0,0x58(%ebx)

  KeInitializeDpc(&DeviceExtension->Dpc,
   112a3:	50                   	push   %eax
   112a4:	53                   	push   %ebx
   112a5:	68 00 10 01 00       	push   $0x11000
   112aa:	53                   	push   %ebx
   112ab:	e8 90 00 00 00       	call   11340 <_KeInitializeDpc@12>
		  BeepDPC,
		  DeviceExtension);
  KeInitializeTimer(&DeviceExtension->Timer);
   112b0:	8d 43 20             	lea    0x20(%ebx),%eax
  KeInitializeEvent(&DeviceExtension->Event,
   112b3:	83 c3 48             	add    $0x48,%ebx
   112b6:	51                   	push   %ecx
   112b7:	51                   	push   %ecx
   112b8:	50                   	push   %eax
   112b9:	e8 92 00 00 00       	call   11350 <_KeInitializeTimer@4>
   112be:	58                   	pop    %eax
   112bf:	5a                   	pop    %edx
   112c0:	6a 00                	push   $0x0
   112c2:	6a 01                	push   $0x1
   112c4:	53                   	push   %ebx
   112c5:	e8 96 00 00 00       	call   11360 <_KeInitializeEvent@12>
		    SynchronizationEvent,
		    FALSE);

  /* Create the dos device link */
  IoCreateSymbolicLink(&SymlinkName,
   112ca:	50                   	push   %eax
   112cb:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   112ce:	56                   	push   %esi
   112cf:	50                   	push   %eax
   112d0:	e8 9b 00 00 00       	call   11370 <_IoCreateSymbolicLink@8>
		       &DeviceName);

  return(STATUS_SUCCESS);
   112d5:	31 c0                	xor    %eax,%eax
}
   112d7:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   112da:	5b                   	pop    %ebx
   112db:	5e                   	pop    %esi
   112dc:	5d                   	pop    %ebp
   112dd:	c2 08 00             	ret    $0x8

000112e0 <_KeSetEvent@12>:
   112e0:	ff 25 a4 30 01 00    	jmp    *0x130a4
   112e6:	90                   	nop    
   112e7:	90                   	nop    
	...

000112f0 <_IoCompleteRequest@8>:
   112f0:	ff 25 88 30 01 00    	jmp    *0x13088
   112f6:	90                   	nop    
   112f7:	90                   	nop    
	...

00011300 <_KeCancelTimer@4>:
   11300:	ff 25 94 30 01 00    	jmp    *0x13094
   11306:	90                   	nop    
   11307:	90                   	nop    
	...

00011310 <_KeSetTimer@16>:
   11310:	ff 25 a8 30 01 00    	jmp    *0x130a8
   11316:	90                   	nop    
   11317:	90                   	nop    
	...

00011320 <_KeWaitForSingleObject@20>:
   11320:	ff 25 ac 30 01 00    	jmp    *0x130ac
   11326:	90                   	nop    
   11327:	90                   	nop    
	...

00011330 <_IoCreateDevice@28>:
   11330:	ff 25 8c 30 01 00    	jmp    *0x1308c
   11336:	90                   	nop    
   11337:	90                   	nop    
	...

00011340 <_KeInitializeDpc@12>:
   11340:	ff 25 98 30 01 00    	jmp    *0x13098
   11346:	90                   	nop    
   11347:	90                   	nop    
	...

00011350 <_KeInitializeTimer@4>:
   11350:	ff 25 a0 30 01 00    	jmp    *0x130a0
   11356:	90                   	nop    
   11357:	90                   	nop    
	...

00011360 <_KeInitializeEvent@12>:
   11360:	ff 25 9c 30 01 00    	jmp    *0x1309c
   11366:	90                   	nop    
   11367:	90                   	nop    
	...

00011370 <_IoCreateSymbolicLink@8>:
   11370:	ff 25 90 30 01 00    	jmp    *0x13090
   11376:	90                   	nop    
   11377:	90                   	nop    
	...

00011380 <_HalMakeBeep@4>:
   11380:	ff 25 7c 30 01 00    	jmp    *0x1307c
   11386:	90                   	nop    
   11387:	90                   	nop    
	...

00011390 <__CTOR_LIST__>:
   11390:	ff                   	(bad)  
   11391:	ff                   	(bad)  
   11392:	ff                   	(bad)  
   11393:	ff 00                	incl   (%eax)
   11395:	00 00                	add    %al,(%eax)
	...

00011398 <__DTOR_LIST__>:
   11398:	ff                   	(bad)  
   11399:	ff                   	(bad)  
   1139a:	ff                   	(bad)  
   1139b:	ff 00                	incl   (%eax)
   1139d:	00 00                	add    %al,(%eax)
	...
