
sermouse.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_ClearMouse>:
/* Waits until the mouse calms down but also quits out after a while
 * in case some destructive user wants to keep moving the mouse
 * before we're done */
VOID ClearMouse(ULONG Port)
{
   11000:	55                   	push   %ebp
   11001:	89 e5                	mov    %esp,%ebp
   11003:	57                   	push   %edi
   11004:	56                   	push   %esi
   11005:	53                   	push   %ebx
   11006:	83 ec 0c             	sub    $0xc,%esp
	ULONG Restarts = 0;
   11009:	31 f6                	xor    %esi,%esi
   1100b:	8b 7d 08             	mov    0x8(%ebp),%edi
	ULONG i;
	UCHAR Temp;

	for (i = 0; i < 60000; i++)
   1100e:	31 db                	xor    %ebx,%ebx
	{
		Temp = READ_PORT_UCHAR((PUCHAR)Port);
   11010:	83 ec 0c             	sub    $0xc,%esp
   11013:	57                   	push   %edi
   11014:	e8 07 11 00 00       	call   12120 <_READ_PORT_UCHAR@4>
		if (Temp != 0)
   11019:	83 c4 0c             	add    $0xc,%esp
   1101c:	84 c0                	test   %al,%al
   1101e:	74 12                	je     11032 <_ClearMouse+0x32>
		{
			Restarts++;
   11020:	46                   	inc    %esi
			if (Restarts < 300000)
				i = 0;
   11021:	81 fe e0 93 04 00    	cmp    $0x493e0,%esi
   11027:	19 db                	sbb    %ebx,%ebx
   11029:	83 f3 ff             	xor    $0xffffffff,%ebx
   1102c:	81 e3 60 ea 00 00    	and    $0xea60,%ebx
   11032:	43                   	inc    %ebx
   11033:	81 fb 5f ea 00 00    	cmp    $0xea5f,%ebx
   11039:	76 d5                	jbe    11010 <_ClearMouse+0x10>
   1103b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1103e:	5b                   	pop    %ebx
   1103f:	5e                   	pop    %esi
   11040:	5f                   	pop    %edi
   11041:	5d                   	pop    %ebp
   11042:	c3                   	ret    
   11043:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11049:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011050 <_SerialMouseInterruptService@8>:
			else
				i = 60000;
		}
	}
}

BOOLEAN STDCALL
SerialMouseInterruptService(IN PKINTERRUPT Interrupt, PVOID ServiceContext)
{
   11050:	55                   	push   %ebp
   11051:	89 e5                	mov    %esp,%ebp
   11053:	57                   	push   %edi
   11054:	56                   	push   %esi
   11055:	53                   	push   %ebx
   11056:	83 ec 18             	sub    $0x18,%esp
	PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT)ServiceContext;
	PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
   11059:	8b 45 0c             	mov    0xc(%ebp),%eax
   1105c:	8b 58 28             	mov    0x28(%eax),%ebx
	UCHAR *PacketBuffer = DeviceExtension->PacketBuffer;
	ULONG MousePort = DeviceExtension->MousePort;
   1105f:	8b 8b 3c 06 00 00    	mov    0x63c(%ebx),%ecx
   11065:	8d 93 44 06 00 00    	lea    0x644(%ebx),%edx
	UCHAR InterruptId = READ_PORT_UCHAR((PUCHAR)MousePort + 2);
   1106b:	89 c8                	mov    %ecx,%eax
   1106d:	89 55 f0             	mov    %edx,0xfffffff0(%ebp)
   11070:	83 c0 02             	add    $0x2,%eax
   11073:	89 4d ec             	mov    %ecx,0xffffffec(%ebp)
   11076:	50                   	push   %eax
   11077:	e8 a4 10 00 00       	call   12120 <_READ_PORT_UCHAR@4>
	UCHAR RecievedByte;
	ULONG Queue;
	PMOUSE_INPUT_DATA Input;
	ULONG ButtonsDifference;

	/* Is the interrupt for us? */
	if ((InterruptId & 0x01) == 0x01)
   1107c:	25 ff 00 00 00       	and    $0xff,%eax
   11081:	83 c4 0c             	add    $0xc,%esp
	{
		return FALSE;
   11084:	31 d2                	xor    %edx,%edx
   11086:	a8 01                	test   $0x1,%al
   11088:	0f 85 32 01 00 00    	jne    111c0 <_SerialMouseInterruptService@8+0x170>
	}

	/* Not a Receive Data Available interrupt? */
	if ((InterruptId & 0x04) == 0)
	{
		return TRUE;
   1108e:	b2 01                	mov    $0x1,%dl
   11090:	a8 04                	test   $0x4,%al
   11092:	0f 84 28 01 00 00    	je     111c0 <_SerialMouseInterruptService@8+0x170>
   11098:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1109b:	83 c0 05             	add    $0x5,%eax
   1109e:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
	}

	/* Read all available data and process */
	while ((READ_PORT_UCHAR((PUCHAR)MousePort + 5) & 0x01) != 0)
	{
		RecievedByte = READ_PORT_UCHAR((PUCHAR)MousePort);

		/* Synchronize */
		if ((RecievedByte & 0x40) == 0x40)
			DeviceExtension->PacketBufferPosition = 0;

		PacketBuffer[DeviceExtension->PacketBufferPosition] =
			(RecievedByte & 0x7f);
		++DeviceExtension->PacketBufferPosition;

		/* Process packet if complete */
		if (DeviceExtension->PacketBufferPosition >= 3)
		{
			Queue = DeviceExtension->ActiveQueue % 2;
	
			/* Prevent buffer overflow */
			if (DeviceExtension->InputDataCount[Queue] == MOUSE_BUFFER_SIZE)
				continue;

			Input = &DeviceExtension->MouseInputData[Queue][DeviceExtension->InputDataCount[Queue]];

			if (DeviceExtension->PacketBufferPosition == 3)
			{
				/* Retrieve change in x and y from packet */
				Input->LastX = (signed char)(PacketBuffer[1] | ((PacketBuffer[0] & 0x03) << 6));
				Input->LastY = (signed char)(PacketBuffer[2] | ((PacketBuffer[0] & 0x0c) << 4));
	
				/* Determine the current state of the buttons */
				Input->RawButtons = (DeviceExtension->PreviousButtons & MOUSE_BUTTON_MIDDLE) |
					((UCHAR)(PacketBuffer[0] & LEFT_BUTTON_MASK) >> LEFT_BUTTON_SHIFT) |
					((UCHAR)(PacketBuffer[0] & RIGHT_BUTTON_MASK) >> RIGHT_BUTTON_SHIFT);
			}
			else if (DeviceExtension->PacketBufferPosition == 4)
			{
				DeviceExtension->PacketBufferPosition = 0;
				/* If middle button state changed than report event */
				if (((UCHAR)(PacketBuffer[3] & MIDDLE_BUTTON_MASK) >> MIDDLE_BUTTON_SHIFT) ^
					(DeviceExtension->PreviousButtons & MOUSE_BUTTON_MIDDLE))
				{
					Input->RawButtons ^= MOUSE_BUTTON_MIDDLE;
					Input->LastX = 0;
					Input->LastY = 0;
				}
				else
				{
					continue;
				}
			}

			/* Determine ButtonFlags */
			Input->ButtonFlags = 0;
			ButtonsDifference = DeviceExtension->PreviousButtons ^ Input->RawButtons;

			if (ButtonsDifference != 0)
			{
				if (ButtonsDifference & MOUSE_BUTTON_LEFT)
				{
					if (Input->RawButtons & MOUSE_BUTTON_LEFT)
						Input->ButtonFlags |= MOUSE_LEFT_BUTTON_DOWN;
					else
						Input->ButtonFlags |= MOUSE_LEFT_BUTTON_UP;
				}

				if (ButtonsDifference & MOUSE_BUTTON_RIGHT)
				{
					if (Input->RawButtons & MOUSE_BUTTON_RIGHT)
						Input->ButtonFlags |= MOUSE_RIGHT_BUTTON_DOWN;
					else
						Input->ButtonFlags |= MOUSE_RIGHT_BUTTON_UP;
				}

				if (ButtonsDifference & MOUSE_BUTTON_MIDDLE)
				{
					if (Input->RawButtons & MOUSE_BUTTON_MIDDLE)
						Input->ButtonFlags |= MOUSE_MIDDLE_BUTTON_DOWN;
					else
						Input->ButtonFlags |= MOUSE_MIDDLE_BUTTON_UP;
				}
			}

			/* Send the Input data to the Mouse Class driver */
			DeviceExtension->InputDataCount[Queue]++;
			KeInsertQueueDpc(&DeviceExtension->IsrDpc, DeviceObject->CurrentIrp, NULL);

			/* Copy RawButtons to Previous Buttons for Input */
			DeviceExtension->PreviousButtons = Input->RawButtons;
   110a1:	83 ec 0c             	sub    $0xc,%esp
   110a4:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   110a7:	50                   	push   %eax
   110a8:	e8 73 10 00 00       	call   12120 <_READ_PORT_UCHAR@4>
   110ad:	83 c4 0c             	add    $0xc,%esp
   110b0:	a8 01                	test   $0x1,%al
   110b2:	0f 84 fc 00 00 00    	je     111b4 <_SerialMouseInterruptService@8+0x164>
   110b8:	83 ec 0c             	sub    $0xc,%esp
   110bb:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   110be:	50                   	push   %eax
   110bf:	e8 5c 10 00 00       	call   12120 <_READ_PORT_UCHAR@4>
   110c4:	83 c4 0c             	add    $0xc,%esp
   110c7:	88 c2                	mov    %al,%dl
   110c9:	a8 40                	test   $0x40,%al
   110cb:	74 0a                	je     110d7 <_SerialMouseInterruptService@8+0x87>
   110cd:	c7 83 48 06 00 00 00 	movl   $0x0,0x648(%ebx)
   110d4:	00 00 00 
   110d7:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   110da:	8b 83 48 06 00 00    	mov    0x648(%ebx),%eax
   110e0:	83 e2 7f             	and    $0x7f,%edx
   110e3:	88 14 01             	mov    %dl,(%ecx,%eax,1)
   110e6:	8b 8b 48 06 00 00    	mov    0x648(%ebx),%ecx
   110ec:	41                   	inc    %ecx
   110ed:	83 f9 02             	cmp    $0x2,%ecx
   110f0:	0f 86 da 00 00 00    	jbe    111d0 <_SerialMouseInterruptService@8+0x180>
   110f6:	8b 7b 04             	mov    0x4(%ebx),%edi
   110f9:	83 e7 01             	and    $0x1,%edi
   110fc:	8b 54 bb 08          	mov    0x8(%ebx,%edi,4),%edx
   11100:	83 fa 20             	cmp    $0x20,%edx
   11103:	0f 84 c7 00 00 00    	je     111d0 <_SerialMouseInterruptService@8+0x180>
   11109:	8d 04 3f             	lea    (%edi,%edi,1),%eax
   1110c:	8d 14 52             	lea    (%edx,%edx,2),%edx
   1110f:	01 f8                	add    %edi,%eax
   11111:	c1 e0 08             	shl    $0x8,%eax
   11114:	01 d8                	add    %ebx,%eax
   11116:	83 f9 03             	cmp    $0x3,%ecx
   11119:	8d 74 d0 10          	lea    0x10(%eax,%edx,8),%esi
   1111d:	0f 84 b8 00 00 00    	je     111db <_SerialMouseInterruptService@8+0x18b>
   11123:	83 f9 04             	cmp    $0x4,%ecx
   11126:	0f 84 22 01 00 00    	je     1124e <_SerialMouseInterruptService@8+0x1fe>
   1112c:	89 8b 48 06 00 00    	mov    %ecx,0x648(%ebx)
   11132:	8b 56 08             	mov    0x8(%esi),%edx
   11135:	66 c7 46 04 00 00    	movw   $0x0,0x4(%esi)
   1113b:	8b 8b 4c 06 00 00    	mov    0x64c(%ebx),%ecx
   11141:	31 d1                	xor    %edx,%ecx
   11143:	74 2f                	je     11174 <_SerialMouseInterruptService@8+0x124>
   11145:	f6 c1 01             	test   $0x1,%cl
   11148:	0f 85 eb 00 00 00    	jne    11239 <_SerialMouseInterruptService@8+0x1e9>
   1114e:	f6 c1 02             	test   $0x2,%cl
   11151:	74 0e                	je     11161 <_SerialMouseInterruptService@8+0x111>
   11153:	f6 c2 02             	test   $0x2,%dl
   11156:	0f 84 39 01 00 00    	je     11295 <_SerialMouseInterruptService@8+0x245>
   1115c:	66 83 4e 04 04       	orw    $0x4,0x4(%esi)
   11161:	83 e1 04             	and    $0x4,%ecx
   11164:	74 0e                	je     11174 <_SerialMouseInterruptService@8+0x124>
   11166:	83 e2 04             	and    $0x4,%edx
   11169:	0f 84 30 01 00 00    	je     1129f <_SerialMouseInterruptService@8+0x24f>
   1116f:	66 83 4e 04 10       	orw    $0x10,0x4(%esi)
   11174:	8b 44 bb 08          	mov    0x8(%ebx,%edi,4),%eax
   11178:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   1117b:	40                   	inc    %eax
   1117c:	89 44 bb 08          	mov    %eax,0x8(%ebx,%edi,4)
   11180:	57                   	push   %edi
   11181:	6a 00                	push   $0x0
   11183:	8b 49 14             	mov    0x14(%ecx),%ecx
   11186:	8d 83 1c 06 00 00    	lea    0x61c(%ebx),%eax
   1118c:	51                   	push   %ecx
   1118d:	50                   	push   %eax
   1118e:	e8 4d 0e 00 00       	call   11fe0 <_KeInsertQueueDpc@12>
   11193:	8b 46 08             	mov    0x8(%esi),%eax
   11196:	89 83 4c 06 00 00    	mov    %eax,0x64c(%ebx)
   1119c:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   1119f:	5a                   	pop    %edx
   111a0:	83 ec 0c             	sub    $0xc,%esp
   111a3:	50                   	push   %eax
   111a4:	e8 77 0f 00 00       	call   12120 <_READ_PORT_UCHAR@4>
   111a9:	83 c4 0c             	add    $0xc,%esp
   111ac:	a8 01                	test   $0x1,%al
   111ae:	0f 85 04 ff ff ff    	jne    110b8 <_SerialMouseInterruptService@8+0x68>
		}
	}

	return TRUE;
   111b4:	ba 01 00 00 00       	mov    $0x1,%edx
   111b9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
}
   111c0:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   111c3:	89 d0                	mov    %edx,%eax
   111c5:	5b                   	pop    %ebx
   111c6:	5e                   	pop    %esi
   111c7:	5f                   	pop    %edi
   111c8:	5d                   	pop    %ebp
   111c9:	c2 08 00             	ret    $0x8
   111cc:	8d 74 26 00          	lea    0x0(%esi),%esi
   111d0:	89 8b 48 06 00 00    	mov    %ecx,0x648(%ebx)
   111d6:	e9 c6 fe ff ff       	jmp    110a1 <_SerialMouseInterruptService@8+0x51>
   111db:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   111de:	c7 83 48 06 00 00 03 	movl   $0x3,0x648(%ebx)
   111e5:	00 00 00 
   111e8:	31 c0                	xor    %eax,%eax
   111ea:	8a 02                	mov    (%edx),%al
   111ec:	83 e0 03             	and    $0x3,%eax
   111ef:	c1 e0 06             	shl    $0x6,%eax
   111f2:	0a 42 01             	or     0x1(%edx),%al
   111f5:	0f be c0             	movsbl %al,%eax
   111f8:	89 46 0c             	mov    %eax,0xc(%esi)
   111fb:	31 c0                	xor    %eax,%eax
   111fd:	8a 02                	mov    (%edx),%al
   111ff:	83 e0 0c             	and    $0xc,%eax
   11202:	c1 e0 04             	shl    $0x4,%eax
   11205:	0a 42 02             	or     0x2(%edx),%al
   11208:	0f be c0             	movsbl %al,%eax
   1120b:	89 46 10             	mov    %eax,0x10(%esi)
   1120e:	89 d0                	mov    %edx,%eax
   11210:	31 d2                	xor    %edx,%edx
   11212:	8b 8b 4c 06 00 00    	mov    0x64c(%ebx),%ecx
   11218:	8a 10                	mov    (%eax),%dl
   1121a:	83 e1 04             	and    $0x4,%ecx
   1121d:	89 d0                	mov    %edx,%eax
   1121f:	83 e2 10             	and    $0x10,%edx
   11222:	c1 fa 03             	sar    $0x3,%edx
   11225:	83 e0 20             	and    $0x20,%eax
   11228:	c1 f8 05             	sar    $0x5,%eax
   1122b:	09 c1                	or     %eax,%ecx
   1122d:	09 d1                	or     %edx,%ecx
   1122f:	89 ca                	mov    %ecx,%edx
   11231:	89 4e 08             	mov    %ecx,0x8(%esi)
   11234:	e9 fc fe ff ff       	jmp    11135 <_SerialMouseInterruptService@8+0xe5>
   11239:	f6 c2 01             	test   $0x1,%dl
   1123c:	0f 94 c0             	sete   %al
   1123f:	25 ff 00 00 00       	and    $0xff,%eax
   11244:	40                   	inc    %eax
   11245:	66 89 46 04          	mov    %ax,0x4(%esi)
   11249:	e9 00 ff ff ff       	jmp    1114e <_SerialMouseInterruptService@8+0xfe>
   1124e:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   11251:	31 c0                	xor    %eax,%eax
   11253:	c7 83 48 06 00 00 00 	movl   $0x0,0x648(%ebx)
   1125a:	00 00 00 
   1125d:	8a 42 03             	mov    0x3(%edx),%al
   11260:	8b 93 4c 06 00 00    	mov    0x64c(%ebx),%edx
   11266:	83 e0 20             	and    $0x20,%eax
   11269:	83 e2 04             	and    $0x4,%edx
   1126c:	c1 f8 03             	sar    $0x3,%eax
   1126f:	39 d0                	cmp    %edx,%eax
   11271:	0f 84 2a fe ff ff    	je     110a1 <_SerialMouseInterruptService@8+0x51>
   11277:	8b 46 08             	mov    0x8(%esi),%eax
   1127a:	c7 46 0c 00 00 00 00 	movl   $0x0,0xc(%esi)
   11281:	83 f0 04             	xor    $0x4,%eax
   11284:	c7 46 10 00 00 00 00 	movl   $0x0,0x10(%esi)
   1128b:	89 c2                	mov    %eax,%edx
   1128d:	89 46 08             	mov    %eax,0x8(%esi)
   11290:	e9 a0 fe ff ff       	jmp    11135 <_SerialMouseInterruptService@8+0xe5>
   11295:	66 83 4e 04 08       	orw    $0x8,0x4(%esi)
   1129a:	e9 c2 fe ff ff       	jmp    11161 <_SerialMouseInterruptService@8+0x111>
   1129f:	66 83 4e 04 20       	orw    $0x20,0x4(%esi)
   112a4:	e9 cb fe ff ff       	jmp    11174 <_SerialMouseInterruptService@8+0x124>
   112a9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000112b0 <_SerialMouseInitializeDataQueue>:

VOID
SerialMouseInitializeDataQueue(PVOID Context)
{
   112b0:	55                   	push   %ebp
   112b1:	89 e5                	mov    %esp,%ebp
   112b3:	5d                   	pop    %ebp
   112b4:	c3                   	ret    
   112b5:	8d 74 26 00          	lea    0x0(%esi),%esi
   112b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000112c0 <_MouseSynchronizeRoutine@4>:
}

BOOLEAN STDCALL
MouseSynchronizeRoutine(PVOID Context)
{
   112c0:	55                   	push   %ebp
	return TRUE;
}
   112c1:	b8 01 00 00 00       	mov    $0x1,%eax
   112c6:	89 e5                	mov    %esp,%ebp
   112c8:	5d                   	pop    %ebp
   112c9:	c2 04 00             	ret    $0x4
   112cc:	8d 74 26 00          	lea    0x0(%esi),%esi

000112d0 <_SerialMouseStartIo@8>:

VOID STDCALL
SerialMouseStartIo(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
   112d0:	55                   	push   %ebp
   112d1:	89 e5                	mov    %esp,%ebp
   112d3:	56                   	push   %esi
   112d4:	53                   	push   %ebx
   112d5:	83 ec 14             	sub    $0x14,%esp
   112d8:	8b 75 08             	mov    0x8(%ebp),%esi
   112db:	8b 5d 0c             	mov    0xc(%ebp),%ebx
	PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
   112de:	8b 46 28             	mov    0x28(%esi),%eax

	if (KeSynchronizeExecution(DeviceExtension->MouseInterrupt, MouseSynchronizeRoutine, Irp))
   112e1:	53                   	push   %ebx
   112e2:	68 c0 12 01 00       	push   $0x112c0
   112e7:	8b 88 18 06 00 00    	mov    0x618(%eax),%ecx
   112ed:	51                   	push   %ecx
   112ee:	e8 fd 0c 00 00       	call   11ff0 <_KeSynchronizeExecution@12>
   112f3:	5a                   	pop    %edx
   112f4:	84 c0                	test   %al,%al
   112f6:	75 09                	jne    11301 <_SerialMouseStartIo@8+0x31>
	{
		KIRQL oldIrql;
		Irp->IoStatus.Status = STATUS_SUCCESS;
		Irp->IoStatus.Information = 0;
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		oldIrql = KeGetCurrentIrql();
		if (oldIrql < DISPATCH_LEVEL)
		{
			KeRaiseIrql(DISPATCH_LEVEL, &oldIrql);
			IoStartNextPacket(DeviceObject, FALSE);
			KeLowerIrql(oldIrql);
		}
		else
		{
			IoStartNextPacket (DeviceObject, FALSE);
		}
	}
}
   112f8:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   112fb:	5b                   	pop    %ebx
   112fc:	5e                   	pop    %esi
   112fd:	5d                   	pop    %ebp
   112fe:	c2 08 00             	ret    $0x8
   11301:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
   11308:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   1130f:	51                   	push   %ecx
   11310:	51                   	push   %ecx
   11311:	6a 00                	push   $0x0
   11313:	53                   	push   %ebx
   11314:	e8 e7 0c 00 00       	call   12000 <_IoCompleteRequest@8>
   11319:	58                   	pop    %eax
   1131a:	5a                   	pop    %edx
   1131b:	e8 10 0e 00 00       	call   12130 <_KeGetCurrentIrql@0>
   11320:	3c 01                	cmp    $0x1,%al
   11322:	88 45 f7             	mov    %al,0xfffffff7(%ebp)
   11325:	77 2d                	ja     11354 <_SerialMouseStartIo@8+0x84>
   11327:	50                   	push   %eax
   11328:	50                   	push   %eax
   11329:	8d 45 f7             	lea    0xfffffff7(%ebp),%eax
   1132c:	50                   	push   %eax
   1132d:	6a 02                	push   $0x2
   1132f:	e8 0c 0e 00 00       	call   12140 <_KeRaiseIrql@8>
   11334:	6a 00                	push   $0x0
   11336:	56                   	push   %esi
   11337:	e8 d4 0c 00 00       	call   12010 <_IoStartNextPacket@8>
   1133c:	31 c0                	xor    %eax,%eax
   1133e:	53                   	push   %ebx
   1133f:	8a 45 f7             	mov    0xfffffff7(%ebp),%al
   11342:	50                   	push   %eax
   11343:	e8 08 0e 00 00       	call   12150 <_KeLowerIrql@4>
   11348:	83 c4 0c             	add    $0xc,%esp
   1134b:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1134e:	5b                   	pop    %ebx
   1134f:	5e                   	pop    %esi
   11350:	5d                   	pop    %ebp
   11351:	c2 08 00             	ret    $0x8
   11354:	51                   	push   %ecx
   11355:	51                   	push   %ecx
   11356:	6a 00                	push   $0x0
   11358:	56                   	push   %esi
   11359:	e8 b2 0c 00 00       	call   12010 <_IoStartNextPacket@8>
   1135e:	58                   	pop    %eax
   1135f:	5a                   	pop    %edx
   11360:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11363:	5b                   	pop    %ebx
   11364:	5e                   	pop    %esi
   11365:	5d                   	pop    %ebp
   11366:	c2 08 00             	ret    $0x8
   11369:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011370 <_SerialMouseInternalDeviceControl@8>:

NTSTATUS STDCALL
SerialMouseInternalDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
   11370:	55                   	push   %ebp
   11371:	89 e5                	mov    %esp,%ebp
   11373:	57                   	push   %edi
   11374:	56                   	push   %esi
   11375:	53                   	push   %ebx
   11376:	83 ec 0c             	sub    $0xc,%esp
   11379:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   1137c:	8b 7d 08             	mov    0x8(%ebp),%edi
	PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
	PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
   1137f:	8b 53 60             	mov    0x60(%ebx),%edx
   11382:	8b 4f 28             	mov    0x28(%edi),%ecx
	NTSTATUS Status;

	switch (Stack->Parameters.DeviceIoControl.IoControlCode)
   11385:	8b 42 0c             	mov    0xc(%edx),%eax
   11388:	3d 00 00 0f 00       	cmp    $0xf0000,%eax
   1138d:	74 33                	je     113c2 <_SerialMouseInternalDeviceControl@8+0x52>
	{
		case IOCTL_INTERNAL_MOUSE_CONNECT:
			DeviceExtension->ClassInformation =
				*((PCLASS_INFORMATION)Stack->Parameters.DeviceIoControl.Type3InputBuffer);

			/* Reinitialize the port input data queue synchronously */
			KeSynchronizeExecution(DeviceExtension->MouseInterrupt,
				(PKSYNCHRONIZE_ROUTINE)SerialMouseInitializeDataQueue,
				DeviceExtension);

			Status = STATUS_SUCCESS;
			break;

#ifdef SERMOUSE_QUERYATTRIBUTES_SUPPORT
		case IOCTL_MOUSE_QUERY_ATTRIBUTES:
			if (Stack->Parameters.DeviceIoControl.OutputBufferLength >= sizeof(MOUSE_ATTRIBUTES))
			{
				*(PMOUSE_ATTRIBUTES)Irp->AssociatedIrp.SystemBuffer =
					DeviceExtension->AttributesInformation;
				Irp->IoStatus.Information = sizeof(MOUSE_ATTRIBUTES);
				Status = STATUS_SUCCESS;				
			} else {
				Status = STATUS_BUFFER_TOO_SMALL;
			}
			break;
#endif

		default:
			Status = STATUS_INVALID_DEVICE_REQUEST;
   1138f:	be 10 00 00 c0       	mov    $0xc0000010,%esi
   11394:	3d 03 02 0f 00       	cmp    $0xf0203,%eax
   11399:	0f 84 81 00 00 00    	je     11420 <_SerialMouseInternalDeviceControl@8+0xb0>
			break;
	}

	Irp->IoStatus.Status = Status;
   1139f:	89 73 18             	mov    %esi,0x18(%ebx)
	if (Status == STATUS_PENDING)
   113a2:	81 fe 03 01 00 00    	cmp    $0x103,%esi
   113a8:	74 56                	je     11400 <_SerialMouseInternalDeviceControl@8+0x90>
	{
		IoMarkIrpPending(Irp);
		IoStartPacket(DeviceObject, Irp, NULL, NULL);
	}
	else
	{
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
   113aa:	50                   	push   %eax
   113ab:	50                   	push   %eax
   113ac:	6a 00                	push   $0x0
   113ae:	53                   	push   %ebx
   113af:	e8 4c 0c 00 00       	call   12000 <_IoCompleteRequest@8>
	}

	return Status;
}
   113b4:	89 f0                	mov    %esi,%eax
   113b6:	5b                   	pop    %ebx
   113b7:	5f                   	pop    %edi
   113b8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   113bb:	5b                   	pop    %ebx
   113bc:	5e                   	pop    %esi
   113bd:	5f                   	pop    %edi
   113be:	5d                   	pop    %ebp
   113bf:	c2 08 00             	ret    $0x8
   113c2:	be 23 00 00 c0       	mov    $0xc0000023,%esi
   113c7:	83 7a 04 0b          	cmpl   $0xb,0x4(%edx)
   113cb:	76 d2                	jbe    1139f <_SerialMouseInternalDeviceControl@8+0x2f>
   113cd:	8b 53 0c             	mov    0xc(%ebx),%edx
   113d0:	8b 81 50 06 00 00    	mov    0x650(%ecx),%eax
   113d6:	31 f6                	xor    %esi,%esi
   113d8:	89 02                	mov    %eax,(%edx)
   113da:	81 fe 03 01 00 00    	cmp    $0x103,%esi
   113e0:	8b 81 54 06 00 00    	mov    0x654(%ecx),%eax
   113e6:	89 42 04             	mov    %eax,0x4(%edx)
   113e9:	8b 81 58 06 00 00    	mov    0x658(%ecx),%eax
   113ef:	89 42 08             	mov    %eax,0x8(%edx)
   113f2:	c7 43 1c 0c 00 00 00 	movl   $0xc,0x1c(%ebx)
   113f9:	89 73 18             	mov    %esi,0x18(%ebx)
   113fc:	75 ac                	jne    113aa <_SerialMouseInternalDeviceControl@8+0x3a>
   113fe:	89 f6                	mov    %esi,%esi
   11400:	8b 43 60             	mov    0x60(%ebx),%eax
   11403:	80 48 03 01          	orb    $0x1,0x3(%eax)
   11407:	6a 00                	push   $0x0
   11409:	6a 00                	push   $0x0
   1140b:	53                   	push   %ebx
   1140c:	57                   	push   %edi
   1140d:	e8 0e 0c 00 00       	call   12020 <_IoStartPacket@16>
   11412:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11415:	89 f0                	mov    %esi,%eax
   11417:	5b                   	pop    %ebx
   11418:	5e                   	pop    %esi
   11419:	5f                   	pop    %edi
   1141a:	5d                   	pop    %ebp
   1141b:	c2 08 00             	ret    $0x8
   1141e:	89 f6                	mov    %esi,%esi
   11420:	8b 42 10             	mov    0x10(%edx),%eax
   11423:	31 f6                	xor    %esi,%esi
   11425:	8b 50 04             	mov    0x4(%eax),%edx
   11428:	8b 00                	mov    (%eax),%eax
   1142a:	89 81 10 06 00 00    	mov    %eax,0x610(%ecx)
   11430:	89 91 14 06 00 00    	mov    %edx,0x614(%ecx)
   11436:	50                   	push   %eax
   11437:	51                   	push   %ecx
   11438:	68 b0 12 01 00       	push   $0x112b0
   1143d:	8b 81 18 06 00 00    	mov    0x618(%ecx),%eax
   11443:	50                   	push   %eax
   11444:	e8 a7 0b 00 00       	call   11ff0 <_KeSynchronizeExecution@12>
   11449:	58                   	pop    %eax
   1144a:	e9 50 ff ff ff       	jmp    1139f <_SerialMouseInternalDeviceControl@8+0x2f>
   1144f:	90                   	nop    

00011450 <_SerialMouseDispatch@8>:

NTSTATUS STDCALL
SerialMouseDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
   11450:	55                   	push   %ebp
   11451:	89 e5                	mov    %esp,%ebp
   11453:	56                   	push   %esi
   11454:	53                   	push   %ebx
   11455:	8b 5d 0c             	mov    0xc(%ebp),%ebx
	PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
   11458:	8b 43 60             	mov    0x60(%ebx),%eax
	NTSTATUS Status;

	switch (Stack->MajorFunction)
   1145b:	8a 00                	mov    (%eax),%al
   1145d:	25 ff 00 00 00       	and    $0xff,%eax
   11462:	85 c0                	test   %eax,%eax
   11464:	74 3b                	je     114a1 <_SerialMouseDispatch@8+0x51>
   11466:	83 f8 02             	cmp    $0x2,%eax
   11469:	74 36                	je     114a1 <_SerialMouseDispatch@8+0x51>
	{
		case IRP_MJ_CREATE:
		case IRP_MJ_CLOSE:
			Status = STATUS_SUCCESS;
			break;

		default:
			DbgPrint("NOT IMPLEMENTED\n");
   1146b:	83 ec 0c             	sub    $0xc,%esp
			Status = STATUS_NOT_IMPLEMENTED;
   1146e:	be 02 00 00 c0       	mov    $0xc0000002,%esi
   11473:	68 00 30 01 00       	push   $0x13000
   11478:	e8 93 0c 00 00       	call   12110 <_DbgPrint>
			break;
   1147d:	83 c4 10             	add    $0x10,%esp
	}

	if (Status == STATUS_PENDING)
	{
		IoMarkIrpPending(Irp);
	}
	else
	{
		Irp->IoStatus.Status = Status;
   11480:	89 73 18             	mov    %esi,0x18(%ebx)
		Irp->IoStatus.Information = 0;
   11483:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
   1148a:	51                   	push   %ecx
   1148b:	51                   	push   %ecx
   1148c:	6a 00                	push   $0x0
   1148e:	53                   	push   %ebx
   1148f:	e8 6c 0b 00 00       	call   12000 <_IoCompleteRequest@8>
   11494:	58                   	pop    %eax
	}

	return Status;
}
   11495:	89 f0                	mov    %esi,%eax
   11497:	5a                   	pop    %edx
   11498:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1149b:	5b                   	pop    %ebx
   1149c:	5e                   	pop    %esi
   1149d:	5d                   	pop    %ebp
   1149e:	c2 08 00             	ret    $0x8
   114a1:	31 f6                	xor    %esi,%esi
   114a3:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   114aa:	89 73 18             	mov    %esi,0x18(%ebx)
   114ad:	51                   	push   %ecx
   114ae:	51                   	push   %ecx
   114af:	6a 00                	push   $0x0
   114b1:	53                   	push   %ebx
   114b2:	e8 49 0b 00 00       	call   12000 <_IoCompleteRequest@8>
   114b7:	58                   	pop    %eax
   114b8:	89 f0                	mov    %esi,%eax
   114ba:	5a                   	pop    %edx
   114bb:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   114be:	5b                   	pop    %ebx
   114bf:	5e                   	pop    %esi
   114c0:	5d                   	pop    %ebp
   114c1:	c2 08 00             	ret    $0x8
   114c4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   114ca:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

000114d0 <_SerialMouseIsrDpc>:

VOID SerialMouseIsrDpc(PKDPC Dpc, PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
{
   114d0:	55                   	push   %ebp
   114d1:	89 e5                	mov    %esp,%ebp
   114d3:	56                   	push   %esi
   114d4:	53                   	push   %ebx
	PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
   114d5:	8b 45 0c             	mov    0xc(%ebp),%eax
   114d8:	8b 58 28             	mov    0x28(%eax),%ebx
	ULONG Queue;

	Queue = DeviceExtension->ActiveQueue % 2;
   114db:	8b 73 04             	mov    0x4(%ebx),%esi
	InterlockedIncrement((PLONG)&DeviceExtension->ActiveQueue);
   114de:	8d 4b 04             	lea    0x4(%ebx),%ecx
   114e1:	83 e6 01             	and    $0x1,%esi
   114e4:	e8 47 0b 00 00       	call   12030 <@InterlockedIncrement@4>
	(*(PSERVICE_CALLBACK_ROUTINE)DeviceExtension->ClassInformation.CallBack)(
   114e9:	8d 44 b3 08          	lea    0x8(%ebx,%esi,4),%eax
   114ed:	50                   	push   %eax
   114ee:	8d 04 36             	lea    (%esi,%esi,1),%eax
   114f1:	01 f0                	add    %esi,%eax
   114f3:	6a 00                	push   $0x0
   114f5:	c1 e0 08             	shl    $0x8,%eax
   114f8:	8d 44 18 10          	lea    0x10(%eax,%ebx,1),%eax
   114fc:	50                   	push   %eax
   114fd:	8b 83 10 06 00 00    	mov    0x610(%ebx),%eax
   11503:	50                   	push   %eax
   11504:	ff 93 14 06 00 00    	call   *0x614(%ebx)
		DeviceExtension->ClassInformation.DeviceObject,
		DeviceExtension->MouseInputData[Queue],
		NULL,
		&DeviceExtension->InputDataCount[Queue]);

	DeviceExtension->InputDataCount[Queue] = 0;
   1150a:	c7 44 b3 08 00 00 00 	movl   $0x0,0x8(%ebx,%esi,4)
   11511:	00 
   11512:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11515:	5b                   	pop    %ebx
   11516:	5e                   	pop    %esi
   11517:	5d                   	pop    %ebp
   11518:	c3                   	ret    
   11519:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011520 <_InitializeSerialPort>:
}

VOID InitializeSerialPort(ULONG Port)
{
   11520:	55                   	push   %ebp
   11521:	89 e5                	mov    %esp,%ebp
   11523:	57                   	push   %edi
   11524:	56                   	push   %esi
   11525:	53                   	push   %ebx
   11526:	83 ec 14             	sub    $0x14,%esp
   11529:	8b 5d 08             	mov    0x8(%ebp),%ebx
	/* DLAB off */
	WRITE_PORT_UCHAR((PUCHAR)Port + 3, 0);
   1152c:	6a 00                	push   $0x0
   1152e:	8d 73 03             	lea    0x3(%ebx),%esi
	WRITE_PORT_UCHAR((PUCHAR)Port + 2, 0);  /* FCR: disable FIFO */
	WRITE_PORT_UCHAR((PUCHAR)Port + 1, 0);  /* IER: disable ints */
   11531:	8d 7b 01             	lea    0x1(%ebx),%edi
   11534:	56                   	push   %esi
   11535:	e8 26 0c 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
   1153a:	8d 43 02             	lea    0x2(%ebx),%eax
   1153d:	6a 00                	push   $0x0
   1153f:	50                   	push   %eax
   11540:	e8 1b 0c 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
   11545:	6a 00                	push   $0x0
   11547:	57                   	push   %edi
   11548:	e8 13 0c 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
	/* Set DLAB on */
	WRITE_PORT_UCHAR((PUCHAR)Port + 3, 0x80);
   1154d:	68 80 00 00 00       	push   $0x80
   11552:	56                   	push   %esi
   11553:	e8 08 0c 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
	/* Set serial port speed */
	WRITE_PORT_UCHAR((PUCHAR)Port, 0x60);
   11558:	6a 60                	push   $0x60
   1155a:	53                   	push   %ebx
   1155b:	e8 00 0c 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
	WRITE_PORT_UCHAR((PUCHAR)Port + 1, 0);
   11560:	6a 00                	push   $0x0
   11562:	57                   	push   %edi
   11563:	e8 f8 0b 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
	/* Set DLAB off and set LCR */
	WRITE_PORT_UCHAR((PUCHAR)Port + 3, 2);
   11568:	6a 02                	push   $0x2
   1156a:	56                   	push   %esi
   1156b:	e8 f0 0b 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
   11570:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11573:	5b                   	pop    %ebx
   11574:	5e                   	pop    %esi
   11575:	5f                   	pop    %edi
   11576:	5d                   	pop    %ebp
   11577:	c3                   	ret    
   11578:	90                   	nop    
   11579:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011580 <_UARTReadChar>:
}

BOOLEAN UARTReadChar(ULONG Port, CHAR *Value, ULONG Timeout)
{
   11580:	55                   	push   %ebp
   11581:	89 e5                	mov    %esp,%ebp
   11583:	57                   	push   %edi
   11584:	56                   	push   %esi
   11585:	53                   	push   %ebx
   11586:	83 ec 0c             	sub    $0xc,%esp
	ULONG i, j;

	for (i = 0; i < Timeout; i++)
   11589:	31 ff                	xor    %edi,%edi
   1158b:	3b 7d 10             	cmp    0x10(%ebp),%edi
   1158e:	73 5a                	jae    115ea <_UARTReadChar+0x6a>
   11590:	8b 45 08             	mov    0x8(%ebp),%eax
   11593:	8d 70 05             	lea    0x5(%eax),%esi
	{
		for (j = 0; j < 1000; j++)
   11596:	31 db                	xor    %ebx,%ebx
   11598:	eb 1c                	jmp    115b6 <_UARTReadChar+0x36>
   1159a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
		{
			/* Is there a character ready? */
			if (READ_PORT_UCHAR((PUCHAR)Port + 5) & 0x01)
			{
				/* Yes, read it and return */
				*Value = READ_PORT_UCHAR((PUCHAR)Port);
				return TRUE;
			}
			else
			{
				/* No, wait */
				KeStallExecutionProcessor(1);
   115a0:	83 ec 0c             	sub    $0xc,%esp
   115a3:	43                   	inc    %ebx
   115a4:	6a 01                	push   $0x1
   115a6:	e8 c5 0b 00 00       	call   12170 <_KeStallExecutionProcessor@4>
   115ab:	83 c4 0c             	add    $0xc,%esp
   115ae:	81 fb e7 03 00 00    	cmp    $0x3e7,%ebx
   115b4:	77 2e                	ja     115e4 <_UARTReadChar+0x64>
   115b6:	83 ec 0c             	sub    $0xc,%esp
   115b9:	56                   	push   %esi
   115ba:	e8 61 0b 00 00       	call   12120 <_READ_PORT_UCHAR@4>
   115bf:	83 c4 0c             	add    $0xc,%esp
   115c2:	a8 01                	test   $0x1,%al
   115c4:	74 da                	je     115a0 <_UARTReadChar+0x20>
   115c6:	83 ec 0c             	sub    $0xc,%esp
   115c9:	8b 45 08             	mov    0x8(%ebp),%eax
   115cc:	50                   	push   %eax
   115cd:	e8 4e 0b 00 00       	call   12120 <_READ_PORT_UCHAR@4>
   115d2:	8b 55 0c             	mov    0xc(%ebp),%edx
   115d5:	88 02                	mov    %al,(%edx)
			}
		}
	}

	return FALSE;
}
   115d7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   115da:	b8 01 00 00 00       	mov    $0x1,%eax
   115df:	5b                   	pop    %ebx
   115e0:	5e                   	pop    %esi
   115e1:	5f                   	pop    %edi
   115e2:	5d                   	pop    %ebp
   115e3:	c3                   	ret    
   115e4:	47                   	inc    %edi
   115e5:	3b 7d 10             	cmp    0x10(%ebp),%edi
   115e8:	72 ac                	jb     11596 <_UARTReadChar+0x16>
   115ea:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   115ed:	31 c0                	xor    %eax,%eax
   115ef:	5b                   	pop    %ebx
   115f0:	5e                   	pop    %esi
   115f1:	5f                   	pop    %edi
   115f2:	5d                   	pop    %ebp
   115f3:	c3                   	ret    
   115f4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   115fa:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011600 <_DetectMicrosoftMouse>:

ULONG DetectMicrosoftMouse(ULONG Port)
{
   11600:	55                   	push   %ebp
   11601:	89 e5                	mov    %esp,%ebp
   11603:	57                   	push   %edi
   11604:	56                   	push   %esi
   11605:	53                   	push   %ebx
   11606:	83 ec 28             	sub    $0x28,%esp
	CHAR Buffer[8];
	ULONG Count, i;
	UCHAR LCR, MCR;

	/* Save original LCR/MCR */
	LCR = READ_PORT_UCHAR((PUCHAR)Port + 3); /* LCR (line ctrl reg) */
	MCR = READ_PORT_UCHAR((PUCHAR)Port + 4); /* MCR (modem ctrl reg) */

	/* Reset UART */
	WRITE_PORT_UCHAR((PUCHAR)Port + 4, 0);  /* MCR: DTR/RTS/OUT2 off */

	/* Set communications parameters */
	InitializeSerialPort(Port);

	/* Flush receive buffer */
	(void) READ_PORT_UCHAR((PUCHAR)Port);
	/* right? -> wait two ticks (approx 1/9 sec) */
	KeStallExecutionProcessor(100000);

	/* Enable DTR/RTS (OUT2 disabled) */
	WRITE_PORT_UCHAR((PUCHAR)Port + 4, 3);

	if (UARTReadChar(Port, &Buffer[0], 500))
	{
		Count = 1;
		while (Count < 8)
		{
			if (UARTReadChar(Port, &Buffer[Count], 100))
				Count++;
			else
				break;
		}
	}
	else
		return MOUSE_TYPE_NONE;
   11609:	31 db                	xor    %ebx,%ebx
   1160b:	8b 75 08             	mov    0x8(%ebp),%esi
   1160e:	8d 46 03             	lea    0x3(%esi),%eax
   11611:	8d 7e 04             	lea    0x4(%esi),%edi
   11614:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   11617:	50                   	push   %eax
   11618:	e8 03 0b 00 00       	call   12120 <_READ_PORT_UCHAR@4>
   1161d:	88 45 e7             	mov    %al,0xffffffe7(%ebp)
   11620:	57                   	push   %edi
   11621:	e8 fa 0a 00 00       	call   12120 <_READ_PORT_UCHAR@4>
   11626:	88 45 e6             	mov    %al,0xffffffe6(%ebp)
   11629:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11630:	57                   	push   %edi
   11631:	e8 2a 0b 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
   11636:	50                   	push   %eax
   11637:	56                   	push   %esi
   11638:	e8 e3 fe ff ff       	call   11520 <_InitializeSerialPort>
   1163d:	89 34 24             	mov    %esi,(%esp)
   11640:	e8 db 0a 00 00       	call   12120 <_READ_PORT_UCHAR@4>
   11645:	68 a0 86 01 00       	push   $0x186a0
   1164a:	e8 21 0b 00 00       	call   12170 <_KeStallExecutionProcessor@4>
   1164f:	c7 04 24 03 00 00 00 	movl   $0x3,(%esp)
   11656:	57                   	push   %edi
   11657:	e8 04 0b 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
   1165c:	8d 55 e8             	lea    0xffffffe8(%ebp),%edx
   1165f:	c7 04 24 f4 01 00 00 	movl   $0x1f4,(%esp)
   11666:	52                   	push   %edx
   11667:	56                   	push   %esi
   11668:	e8 13 ff ff ff       	call   11580 <_UARTReadChar>
   1166d:	83 c4 10             	add    $0x10,%esp
   11670:	84 c0                	test   %al,%al
   11672:	74 5e                	je     116d2 <_DetectMicrosoftMouse+0xd2>
   11674:	b3 01                	mov    $0x1,%bl
   11676:	8d 55 e8             	lea    0xffffffe8(%ebp),%edx
   11679:	50                   	push   %eax
   1167a:	6a 64                	push   $0x64
   1167c:	8d 04 13             	lea    (%ebx,%edx,1),%eax
   1167f:	50                   	push   %eax
   11680:	56                   	push   %esi
   11681:	e8 fa fe ff ff       	call   11580 <_UARTReadChar>
   11686:	83 c4 10             	add    $0x10,%esp
   11689:	84 c0                	test   %al,%al
   1168b:	74 06                	je     11693 <_DetectMicrosoftMouse+0x93>
   1168d:	43                   	inc    %ebx
   1168e:	83 fb 07             	cmp    $0x7,%ebx
   11691:	76 e3                	jbe    11676 <_DetectMicrosoftMouse+0x76>

	/* Restore LCR/MCR */
	WRITE_PORT_UCHAR((PUCHAR)Port + 3, LCR); /* LCR (line ctrl reg) */
   11693:	31 c0                	xor    %eax,%eax
   11695:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   11698:	8a 45 e7             	mov    0xffffffe7(%ebp),%al
   1169b:	56                   	push   %esi
   1169c:	56                   	push   %esi
   1169d:	50                   	push   %eax
   1169e:	51                   	push   %ecx
   1169f:	e8 bc 0a 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
	WRITE_PORT_UCHAR((PUCHAR)Port + 4, MCR); /* MCR (modem ctrl reg) */
   116a4:	31 c0                	xor    %eax,%eax
   116a6:	8a 45 e6             	mov    0xffffffe6(%ebp),%al
   116a9:	50                   	push   %eax
   116aa:	57                   	push   %edi
   116ab:	e8 b0 0a 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>

	for (i = 0; i < Count; ++i)
   116b0:	31 c9                	xor    %ecx,%ecx
   116b2:	58                   	pop    %eax
   116b3:	39 d9                	cmp    %ebx,%ecx
   116b5:	5a                   	pop    %edx
   116b6:	73 18                	jae    116d0 <_DetectMicrosoftMouse+0xd0>
   116b8:	8d 55 e8             	lea    0xffffffe8(%ebp),%edx
   116bb:	90                   	nop    
   116bc:	8d 74 26 00          	lea    0x0(%esi),%esi
	{
		/* Sign for Microsoft Ballpoint */
		if (Buffer[i] == 'B')
   116c0:	8a 02                	mov    (%edx),%al
   116c2:	3c 42                	cmp    $0x42,%al
   116c4:	74 16                	je     116dc <_DetectMicrosoftMouse+0xdc>
		{
			DbgPrint("Microsoft Ballpoint device detected");
			DbgPrint("THIS DEVICE IS NOT SUPPORTED, YET");
			return MOUSE_TYPE_NONE;
		} else
		/* Sign for Microsoft Mouse protocol followed by button specifier */
		if (Buffer[i] == 'M')
   116c6:	3c 4d                	cmp    $0x4d,%al
   116c8:	74 2f                	je     116f9 <_DetectMicrosoftMouse+0xf9>
   116ca:	41                   	inc    %ecx
   116cb:	42                   	inc    %edx
   116cc:	39 d9                	cmp    %ebx,%ecx
   116ce:	72 f0                	jb     116c0 <_DetectMicrosoftMouse+0xc0>
		{
			if (i == 3)
			{
				/* Overflow Error */
				return MOUSE_TYPE_NONE;
			}
			switch (Buffer[i + 1])
			{
				case '3':
					DbgPrint("Microsoft Mouse with 3-buttons detected\n");
					return MOUSE_TYPE_LOGITECH;
				case 'Z':
					DbgPrint("Microsoft Wheel Mouse detected\n");
					return MOUSE_TYPE_WHEELZ;
				/* case '2': */
				default:
					DbgPrint("Microsoft Mouse with 2-buttons detected\n");
					return MOUSE_TYPE_MICROSOFT;
			}
		}
	}

	return MOUSE_TYPE_NONE;
   116d0:	31 db                	xor    %ebx,%ebx
}
   116d2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   116d5:	89 d8                	mov    %ebx,%eax
   116d7:	5b                   	pop    %ebx
   116d8:	5e                   	pop    %esi
   116d9:	5f                   	pop    %edi
   116da:	5d                   	pop    %ebp
   116db:	c3                   	ret    
   116dc:	83 ec 0c             	sub    $0xc,%esp
   116df:	31 db                	xor    %ebx,%ebx
   116e1:	68 14 30 01 00       	push   $0x13014
   116e6:	e8 25 0a 00 00       	call   12110 <_DbgPrint>
   116eb:	c7 04 24 38 30 01 00 	movl   $0x13038,(%esp)
   116f2:	e8 19 0a 00 00       	call   12110 <_DbgPrint>
   116f7:	eb d9                	jmp    116d2 <_DetectMicrosoftMouse+0xd2>
   116f9:	31 db                	xor    %ebx,%ebx
   116fb:	83 f9 03             	cmp    $0x3,%ecx
   116fe:	74 d2                	je     116d2 <_DetectMicrosoftMouse+0xd2>
   11700:	0f be 42 01          	movsbl 0x1(%edx),%eax
   11704:	83 f8 33             	cmp    $0x33,%eax
   11707:	74 19                	je     11722 <_DetectMicrosoftMouse+0x122>
   11709:	83 f8 5a             	cmp    $0x5a,%eax
   1170c:	74 28                	je     11736 <_DetectMicrosoftMouse+0x136>
   1170e:	83 ec 0c             	sub    $0xc,%esp
   11711:	bb 01 00 00 00       	mov    $0x1,%ebx
   11716:	68 5c 30 01 00       	push   $0x1305c
   1171b:	e8 f0 09 00 00       	call   12110 <_DbgPrint>
   11720:	eb b0                	jmp    116d2 <_DetectMicrosoftMouse+0xd2>
   11722:	83 ec 0c             	sub    $0xc,%esp
   11725:	bb 02 00 00 00       	mov    $0x2,%ebx
   1172a:	68 88 30 01 00       	push   $0x13088
   1172f:	e8 dc 09 00 00       	call   12110 <_DbgPrint>
   11734:	eb 9c                	jmp    116d2 <_DetectMicrosoftMouse+0xd2>
   11736:	83 ec 0c             	sub    $0xc,%esp
   11739:	bb 03 00 00 00       	mov    $0x3,%ebx
   1173e:	68 b4 30 01 00       	push   $0x130b4
   11743:	e8 c8 09 00 00       	call   12110 <_DbgPrint>
   11748:	eb 88                	jmp    116d2 <_DetectMicrosoftMouse+0xd2>
   1174a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011750 <_AllocatePointerDevice>:

PDEVICE_OBJECT
AllocatePointerDevice(PDRIVER_OBJECT DriverObject)
{
   11750:	55                   	push   %ebp
   11751:	89 e5                	mov    %esp,%ebp
   11753:	57                   	push   %edi
   11754:	56                   	push   %esi
   11755:	53                   	push   %ebx
   11756:	83 ec 34             	sub    $0x34,%esp
	PDEVICE_OBJECT DeviceObject;
	UNICODE_STRING DeviceName;
	UNICODE_STRING SuffixString;
	PDEVICE_EXTENSION DeviceExtension;
	ULONG Suffix;
	NTSTATUS Status;

	/* Allocate buffer for full device name */
	RtlInitUnicodeString(&DeviceName, NULL);
   11759:	8d 5d e8             	lea    0xffffffe8(%ebp),%ebx
   1175c:	6a 00                	push   $0x0
   1175e:	53                   	push   %ebx
   1175f:	e8 dc 08 00 00       	call   12040 <_RtlInitUnicodeString@8>
	DeviceName.MaximumLength = sizeof(DD_MOUSE_DEVICE_NAME_U) + SUFFIX_MAXIMUM_SIZE + sizeof(UNICODE_NULL);
   11764:	89 5d d4             	mov    %ebx,0xffffffd4(%ebp)
   11767:	66 c7 45 ea 2e 00    	movw   $0x2e,0xffffffea(%ebp)
	DeviceName.Buffer = ExAllocatePool(PagedPool, DeviceName.MaximumLength);
	RtlAppendUnicodeToString(&DeviceName, DD_MOUSE_DEVICE_NAME_U);

	/* Allocate buffer for device name suffix */
	RtlInitUnicodeString(&SuffixString, NULL);
   1176d:	8d 5d e0             	lea    0xffffffe0(%ebp),%ebx
   11770:	6a 2e                	push   $0x2e
   11772:	6a 01                	push   $0x1
   11774:	e8 d7 08 00 00       	call   12050 <_ExAllocatePool@8>
   11779:	8b 75 d4             	mov    0xffffffd4(%ebp),%esi
   1177c:	68 d4 30 01 00       	push   $0x130d4
   11781:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   11784:	56                   	push   %esi
   11785:	e8 d6 08 00 00       	call   12060 <_RtlAppendUnicodeToString@8>
	SuffixString.MaximumLength = SUFFIX_MAXIMUM_SIZE + sizeof(UNICODE_NULL);
	SuffixString.Buffer = ExAllocatePool(PagedPool, SuffixString.MaximumLength);

	/* Generate full qualified name with suffix */
	for (Suffix = 0; Suffix < POINTER_PORTS_MAXIMUM; ++Suffix)
   1178a:	31 f6                	xor    %esi,%esi
   1178c:	6a 00                	push   $0x0
   1178e:	53                   	push   %ebx
   1178f:	e8 ac 08 00 00       	call   12040 <_RtlInitUnicodeString@8>
   11794:	89 5d d8             	mov    %ebx,0xffffffd8(%ebp)
   11797:	66 c7 45 e2 04 00    	movw   $0x4,0xffffffe2(%ebp)
   1179d:	6a 04                	push   $0x4
   1179f:	6a 01                	push   $0x1
   117a1:	e8 aa 08 00 00       	call   12050 <_ExAllocatePool@8>
   117a6:	8b 7d d4             	mov    0xffffffd4(%ebp),%edi
   117a9:	59                   	pop    %ecx
   117aa:	5b                   	pop    %ebx
   117ab:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   117ae:	89 f6                	mov    %esi,%esi
	{
		RtlIntegerToUnicodeString(Suffix, 10, &SuffixString);
   117b0:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   117b3:	52                   	push   %edx
   117b4:	50                   	push   %eax
   117b5:	6a 0a                	push   $0xa
   117b7:	56                   	push   %esi
   117b8:	e8 b3 08 00 00       	call   12070 <_RtlIntegerToUnicodeString@12>
		RtlAppendUnicodeToString(&DeviceName, SuffixString.Buffer);
   117bd:	50                   	push   %eax
   117be:	8d 45 e0             	lea    0xffffffe0(%ebp),%eax
   117c1:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   117c4:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   117c7:	50                   	push   %eax
   117c8:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   117cb:	50                   	push   %eax
   117cc:	e8 8f 08 00 00       	call   12060 <_RtlAppendUnicodeToString@8>
		Status = IoCreateDevice(DriverObject, sizeof(DEVICE_EXTENSION),
   117d1:	8d 45 dc             	lea    0xffffffdc(%ebp),%eax
   117d4:	89 7d d4             	mov    %edi,0xffffffd4(%ebp)
   117d7:	89 04 24             	mov    %eax,(%esp)
   117da:	8b 45 08             	mov    0x8(%ebp),%eax
   117dd:	6a 01                	push   $0x1
   117df:	6a 00                	push   $0x0
   117e1:	6a 1a                	push   $0x1a
   117e3:	57                   	push   %edi
   117e4:	68 5c 06 00 00       	push   $0x65c
   117e9:	50                   	push   %eax
   117ea:	e8 91 08 00 00       	call   12080 <_IoCreateDevice@28>
   117ef:	89 c3                	mov    %eax,%ebx
			&DeviceName, FILE_DEVICE_SERIAL_MOUSE_PORT, 0, TRUE, &DeviceObject);
		/* Device successfully created, leave the cyclus */
		if (NT_SUCCESS(Status))
   117f1:	58                   	pop    %eax
   117f2:	85 db                	test   %ebx,%ebx
   117f4:	79 11                	jns    11807 <_AllocatePointerDevice+0xb7>
			break;
		DeviceName.Length -= SuffixString.Length;
   117f6:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   117f9:	46                   	inc    %esi
   117fa:	66 2b 45 e0          	sub    0xffffffe0(%ebp),%ax
   117fe:	83 fe 07             	cmp    $0x7,%esi
   11801:	66 89 45 e8          	mov    %ax,0xffffffe8(%ebp)
   11805:	76 a9                	jbe    117b0 <_AllocatePointerDevice+0x60>
	}

	ExFreePool(DeviceName.Buffer);
   11807:	83 ec 0c             	sub    $0xc,%esp
   1180a:	8b 7f 04             	mov    0x4(%edi),%edi
   1180d:	57                   	push   %edi
   1180e:	e8 7d 08 00 00       	call   12090 <_ExFreePool@4>
	ExFreePool(SuffixString.Buffer);
   11813:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
   11816:	56                   	push   %esi
   11817:	e8 74 08 00 00       	call   12090 <_ExFreePool@4>

	/* Couldn't create device */
	if (!NT_SUCCESS(Status))
	{
		return NULL;
   1181c:	31 c0                	xor    %eax,%eax
   1181e:	83 c4 0c             	add    $0xc,%esp
   11821:	85 db                	test   %ebx,%ebx
   11823:	78 24                	js     11849 <_AllocatePointerDevice+0xf9>
	}

	DeviceObject->Flags = DeviceObject->Flags | DO_BUFFERED_IO;
   11825:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   11828:	8b 48 1c             	mov    0x1c(%eax),%ecx
   1182b:	83 c9 04             	or     $0x4,%ecx
   1182e:	89 48 1c             	mov    %ecx,0x1c(%eax)

	DeviceExtension = DeviceObject->DeviceExtension;
	KeInitializeDpc(&DeviceExtension->IsrDpc, (PKDEFERRED_ROUTINE)SerialMouseIsrDpc, DeviceObject);
   11831:	52                   	push   %edx
   11832:	50                   	push   %eax
   11833:	68 d0 14 01 00       	push   $0x114d0
   11838:	8b 40 28             	mov    0x28(%eax),%eax
   1183b:	05 1c 06 00 00       	add    $0x61c,%eax
   11840:	50                   	push   %eax
   11841:	e8 5a 08 00 00       	call   120a0 <_KeInitializeDpc@12>

	return DeviceObject;
   11846:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
}
   11849:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1184c:	5b                   	pop    %ebx
   1184d:	5e                   	pop    %esi
   1184e:	5f                   	pop    %edi
   1184f:	5d                   	pop    %ebp
   11850:	c3                   	ret    
   11851:	eb 0d                	jmp    11860 <_InitializeMouse>
   11853:	90                   	nop    
   11854:	90                   	nop    
   11855:	90                   	nop    
   11856:	90                   	nop    
   11857:	90                   	nop    
   11858:	90                   	nop    
   11859:	90                   	nop    
   1185a:	90                   	nop    
   1185b:	90                   	nop    
   1185c:	90                   	nop    
   1185d:	90                   	nop    
   1185e:	90                   	nop    
   1185f:	90                   	nop    

00011860 <_InitializeMouse>:

BOOLEAN
InitializeMouse(ULONG Port, ULONG Irq, PDRIVER_OBJECT DriverObject)
{
   11860:	55                   	push   %ebp
   11861:	89 e5                	mov    %esp,%ebp
   11863:	57                   	push   %edi
   11864:	56                   	push   %esi
   11865:	53                   	push   %ebx
   11866:	83 ec 18             	sub    $0x18,%esp
   11869:	8b 7d 08             	mov    0x8(%ebp),%edi
	PDEVICE_EXTENSION DeviceExtension;
	PDEVICE_OBJECT DeviceObject;
	ULONG MappedIrq;
	KIRQL Dirql;
	KAFFINITY Affinity;
	ULONG MouseType;

	/* Try to detect mouse on specified port */
	MouseType = DetectMicrosoftMouse(Port);
   1186c:	57                   	push   %edi
   1186d:	e8 8e fd ff ff       	call   11600 <_DetectMicrosoftMouse>
   11872:	89 c6                	mov    %eax,%esi

	/* No mouse, no need to continue */
	if (MouseType == MOUSE_TYPE_NONE)
   11874:	83 c4 10             	add    $0x10,%esp
	{
		return FALSE;
   11877:	31 c0                	xor    %eax,%eax
   11879:	85 f6                	test   %esi,%esi
   1187b:	75 08                	jne    11885 <_InitializeMouse+0x25>
	}

	/* Enable interrupts */
	WRITE_PORT_UCHAR((PUCHAR)(Port) + 1, 1);
	
	ClearMouse(Port);

	/* Enable RTS, DTR and OUT2 */
	WRITE_PORT_UCHAR((PUCHAR)Port + 4, 0x0b);

	/* Allocate new device */
	DeviceObject = AllocatePointerDevice(DriverObject);
	if (!DeviceObject)
	{
		DbgPrint("Oops, couldn't creat device object.\n");
		return FALSE;
	}

	DeviceExtension = DeviceObject->DeviceExtension;

	/* Setup device extension structure */
	DeviceExtension->ActiveQueue = 0;
	DeviceExtension->MouseType = MouseType;
	DeviceExtension->MousePort = Port;
	DeviceExtension->PacketBufferPosition = 0;
	DeviceExtension->PreviousButtons = 0;
#ifdef SERMOUSE_QUERYATTRIBUTES_SUPPORT
	switch (MouseType)
	{
		case MOUSE_TYPE_MICROSOFT:
			DeviceExtension->AttributesInformation.MouseIdentifier = MOUSE_SERIAL_HARDWARE;
			DeviceExtension->AttributesInformation.NumberOfButtons = 2;
			break;
		case MOUSE_TYPE_LOGITECH:
			DeviceExtension->AttributesInformation.MouseIdentifier = MOUSE_SERIAL_HARDWARE;
			DeviceExtension->AttributesInformation.NumberOfButtons = 3;
			break;
		case MOUSE_TYPE_WHEELZ:
			DeviceExtension->AttributesInformation.MouseIdentifier = WHEELMOUSE_SERIAL_HARDWARE;
			DeviceExtension->AttributesInformation.NumberOfButtons = 3;
			break;
	};
	DeviceExtension->AttributesInformation.SampleRate = 40;
	DeviceExtension->AttributesInformation.InputDataQueueLength = MOUSE_BUFFER_SIZE;
#endif

	MappedIrq = HalGetInterruptVector(Internal, 0, 0, Irq, &Dirql, &Affinity);

	IoConnectInterrupt(
		&DeviceExtension->MouseInterrupt, SerialMouseInterruptService,
		DeviceObject, NULL, MappedIrq, Dirql, Dirql, 0, FALSE,
		Affinity, FALSE);

	return TRUE;
}
   1187d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11880:	5b                   	pop    %ebx
   11881:	5e                   	pop    %esi
   11882:	5f                   	pop    %edi
   11883:	5d                   	pop    %ebp
   11884:	c3                   	ret    
   11885:	8d 47 01             	lea    0x1(%edi),%eax
   11888:	53                   	push   %ebx
   11889:	53                   	push   %ebx
   1188a:	6a 01                	push   $0x1
   1188c:	50                   	push   %eax
   1188d:	e8 ce 08 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
   11892:	51                   	push   %ecx
   11893:	57                   	push   %edi
   11894:	e8 67 f7 ff ff       	call   11000 <_ClearMouse>
   11899:	58                   	pop    %eax
   1189a:	8d 47 04             	lea    0x4(%edi),%eax
   1189d:	5a                   	pop    %edx
   1189e:	6a 0b                	push   $0xb
   118a0:	50                   	push   %eax
   118a1:	e8 ba 08 00 00       	call   12160 <_WRITE_PORT_UCHAR@8>
   118a6:	50                   	push   %eax
   118a7:	8b 45 10             	mov    0x10(%ebp),%eax
   118aa:	50                   	push   %eax
   118ab:	e8 a0 fe ff ff       	call   11750 <_AllocatePointerDevice>
   118b0:	83 c4 10             	add    $0x10,%esp
   118b3:	85 c0                	test   %eax,%eax
   118b5:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   118b8:	0f 84 e4 00 00 00    	je     119a2 <_InitializeMouse+0x142>
   118be:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   118c1:	83 fe 02             	cmp    $0x2,%esi
   118c4:	8b 58 28             	mov    0x28(%eax),%ebx
   118c7:	c7 43 04 00 00 00 00 	movl   $0x0,0x4(%ebx)
   118ce:	89 b3 40 06 00 00    	mov    %esi,0x640(%ebx)
   118d4:	89 bb 3c 06 00 00    	mov    %edi,0x63c(%ebx)
   118da:	c7 83 48 06 00 00 00 	movl   $0x0,0x648(%ebx)
   118e1:	00 00 00 
   118e4:	c7 83 4c 06 00 00 00 	movl   $0x0,0x64c(%ebx)
   118eb:	00 00 00 
   118ee:	74 77                	je     11967 <_InitializeMouse+0x107>
   118f0:	0f 87 85 00 00 00    	ja     1197b <_InitializeMouse+0x11b>
   118f6:	4e                   	dec    %esi
   118f7:	0f 84 8e 00 00 00    	je     1198b <_InitializeMouse+0x12b>
   118fd:	8d 76 00             	lea    0x0(%esi),%esi
   11900:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11903:	66 c7 83 54 06 00 00 	movw   $0x28,0x654(%ebx)
   1190a:	28 00 
   1190c:	c7 83 58 06 00 00 20 	movl   $0x20,0x658(%ebx)
   11913:	00 00 00 
   11916:	56                   	push   %esi
   11917:	56                   	push   %esi
   11918:	50                   	push   %eax
   11919:	8d 45 ef             	lea    0xffffffef(%ebp),%eax
   1191c:	50                   	push   %eax
   1191d:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   11920:	51                   	push   %ecx
   11921:	6a 00                	push   $0x0
   11923:	6a 00                	push   $0x0
   11925:	6a 00                	push   $0x0
   11927:	e8 54 08 00 00       	call   12180 <_HalGetInterruptVector@24>
   1192c:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11933:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   11936:	52                   	push   %edx
   11937:	31 d2                	xor    %edx,%edx
   11939:	6a 00                	push   $0x0
   1193b:	6a 00                	push   $0x0
   1193d:	8a 55 ef             	mov    0xffffffef(%ebp),%dl
   11940:	52                   	push   %edx
   11941:	52                   	push   %edx
   11942:	50                   	push   %eax
   11943:	6a 00                	push   $0x0
   11945:	8b 7d e8             	mov    0xffffffe8(%ebp),%edi
   11948:	8d 83 18 06 00 00    	lea    0x618(%ebx),%eax
   1194e:	57                   	push   %edi
   1194f:	68 50 10 01 00       	push   $0x11050
   11954:	50                   	push   %eax
   11955:	e8 56 07 00 00       	call   120b0 <_IoConnectInterrupt@44>
   1195a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1195d:	b8 01 00 00 00       	mov    $0x1,%eax
   11962:	5b                   	pop    %ebx
   11963:	5e                   	pop    %esi
   11964:	5f                   	pop    %edi
   11965:	5d                   	pop    %ebp
   11966:	c3                   	ret    
   11967:	66 c7 83 50 06 00 00 	movw   $0x4,0x650(%ebx)
   1196e:	04 00 
   11970:	66 c7 83 52 06 00 00 	movw   $0x3,0x652(%ebx)
   11977:	03 00 
   11979:	eb 85                	jmp    11900 <_InitializeMouse+0xa0>
   1197b:	83 fe 03             	cmp    $0x3,%esi
   1197e:	75 80                	jne    11900 <_InitializeMouse+0xa0>
   11980:	66 c7 83 50 06 00 00 	movw   $0x40,0x650(%ebx)
   11987:	40 00 
   11989:	eb e5                	jmp    11970 <_InitializeMouse+0x110>
   1198b:	66 c7 83 50 06 00 00 	movw   $0x4,0x650(%ebx)
   11992:	04 00 
   11994:	66 c7 83 52 06 00 00 	movw   $0x2,0x652(%ebx)
   1199b:	02 00 
   1199d:	e9 5e ff ff ff       	jmp    11900 <_InitializeMouse+0xa0>
   119a2:	83 ec 0c             	sub    $0xc,%esp
   119a5:	68 00 31 01 00       	push   $0x13100
   119aa:	e8 61 07 00 00       	call   12110 <_DbgPrint>
   119af:	31 c0                	xor    %eax,%eax
   119b1:	e9 c7 fe ff ff       	jmp    1187d <_InitializeMouse+0x1d>
   119b6:	8d 76 00             	lea    0x0(%esi),%esi
   119b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000119c0 <_DriverEntry@8>:


static VOID
GetMouseResourceData(PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor,
		     PULONG Port,
		     PULONG Interrupt)
{
  PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
  ULONG i;

  for (i = 0; i < FullDescriptor->PartialResourceList.Count; i++)
    {
      PartialDescriptor = &FullDescriptor->PartialResourceList.PartialDescriptors[i];

      switch (PartialDescriptor->Type)
	{
	  case CmResourceTypePort:
	    *Port = (ULONG)PartialDescriptor->u.Port.Start.u.LowPart;
	    break;

	  case CmResourceTypeInterrupt:
	    *Interrupt = (ULONG)PartialDescriptor->u.Interrupt.Level;
	    break;
	}
    }
}


static BOOLEAN
GetMouseResources(PULONG Port,
		  PULONG Interrupt)
{
  OBJECT_ATTRIBUTES ObjectAttributes;
  UNICODE_STRING KeyName;
  WCHAR Buffer[32];
  HANDLE BusKey;
  HANDLE BusInstanceKey;
  HANDLE ControllerKey;
  HANDLE ControllerInstanceKey;
  HANDLE PeripheralKey;
  HANDLE PeripheralInstanceKey;
  ULONG BusInstance;
  ULONG ControllerInstance;
  ULONG PeripheralInstance;
  ULONG BufferLength;
  ULONG ReturnedLength;
  PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
  NTSTATUS Status;

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

  /* Open the bus key */
  RtlInitUnicodeString(&KeyName,
		       L"\\Registry\\Machine\\HARDWARE\\Description\\System\\MultifunctionAdapter");
  InitializeObjectAttributes(&ObjectAttributes,
			     &KeyName,
			     OBJ_CASE_INSENSITIVE,
			     NULL,
			     NULL);
  Status = ZwOpenKey(&BusKey,
		     KEY_ALL_ACCESS,
		     &ObjectAttributes);
  if (!NT_SUCCESS(Status))
    {
      DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
      return FALSE;
    }

  BusInstance = 0;
  while (TRUE)
    {
      sprintf((PCHAR)Buffer, "%lu", (ULONG)0);
      swprintf(Buffer, L"%lu", BusInstance);
      RtlInitUnicodeString(&KeyName,
			   Buffer);
      InitializeObjectAttributes(&ObjectAttributes,
				 &KeyName,
				 OBJ_CASE_INSENSITIVE,
				 BusKey,
				 NULL);
      Status = ZwOpenKey(&BusInstanceKey,
			 KEY_ALL_ACCESS,
			 &ObjectAttributes);
      if (!NT_SUCCESS(Status))
	{
	  DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
	  ZwClose(BusKey);
	  return FALSE;
	}

      /* Open the controller type key */
      RtlInitUnicodeString(&KeyName,
			   L"SerialController");
      InitializeObjectAttributes(&ObjectAttributes,
				 &KeyName,
				 OBJ_CASE_INSENSITIVE,
				 BusInstanceKey,
				 NULL);
      Status = ZwOpenKey(&ControllerKey,
			 KEY_ALL_ACCESS,
			 &ObjectAttributes);
      if (NT_SUCCESS(Status))
	{
	  ControllerInstance = 0;
	  while (TRUE)
	    {
	      /* Open the pointer controller instance key */
	      swprintf(Buffer, L"%lu", ControllerInstance);
	      RtlInitUnicodeString(&KeyName,
				   Buffer);
	      InitializeObjectAttributes(&ObjectAttributes,
					 &KeyName,
					 OBJ_CASE_INSENSITIVE,
					 ControllerKey,
					 NULL);
	      Status = ZwOpenKey(&ControllerInstanceKey,
				 KEY_ALL_ACCESS,
				 &ObjectAttributes);
	      if (!NT_SUCCESS(Status))
		{
		  DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
		  ZwClose(ControllerKey);
		  ZwClose(BusInstanceKey);
		  ZwClose(BusKey);
		  return FALSE;
		}

	      /* Open the 'PointerPeripheral' key */
	      RtlInitUnicodeString(&KeyName,
				   L"PointerPeripheral");
	      InitializeObjectAttributes(&ObjectAttributes,
					 &KeyName,
					 OBJ_CASE_INSENSITIVE,
					 ControllerInstanceKey,
					 NULL);
	      Status = ZwOpenKey(&PeripheralKey,
				 KEY_ALL_ACCESS,
				 &ObjectAttributes);
	      if (NT_SUCCESS(Status))
		{
		  PeripheralInstance = 0;
		  while (TRUE)
		    {
		      /* Open the pointer peripheral instance key */
		      swprintf(Buffer, L"%lu", PeripheralInstance);
		      RtlInitUnicodeString(&KeyName,
					   Buffer);
		      InitializeObjectAttributes(&ObjectAttributes,
						 &KeyName,
						 OBJ_CASE_INSENSITIVE,
						 PeripheralKey,
						 NULL);
		      Status = ZwOpenKey(&PeripheralInstanceKey,
					 KEY_ALL_ACCESS,
					 &ObjectAttributes);
		      if (!NT_SUCCESS(Status))
			{
			  DPRINT("ZwOpenKey() failed (Status %lx)\n", Status);
			  ZwClose(PeripheralKey);
			  ZwClose(ControllerInstanceKey);
			  ZwClose(ControllerKey);
			  ZwClose(BusInstanceKey);
			  ZwClose(BusKey);
			  return FALSE;
			}

		      /* Get peripheral identifier */
		      RtlInitUnicodeString(&KeyName,
					   L"Configuration Data");

		      BufferLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION);
		      ReturnedLength = 0;
		      ValueInfo = ExAllocatePool(NonPagedPool,
						 BufferLength);
		      if (ValueInfo == NULL)
			{
			  DPRINT("ExAllocatePool() failed\n");
			  ZwClose(PeripheralInstanceKey);
			  ZwClose(PeripheralKey);
			  ZwClose(ControllerInstanceKey);
			  ZwClose(ControllerKey);
			  ZwClose(BusInstanceKey);
			  ZwClose(BusKey);
			  return FALSE;
			}

		      Status = ZwQueryValueKey(ControllerInstanceKey,
					       &KeyName,
					       KeyValuePartialInformation,
					       ValueInfo,
					       BufferLength,
					       &ReturnedLength);
		      DPRINT("ZwQueryValueKey() called (Status %lx)\n", Status);
		      DPRINT("ReturnedLength %ld\n", ReturnedLength);

		      ExFreePool(ValueInfo);
		      if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL)
			{
			  DPRINT("ZwQueryValueKey() failed (Status %lx)\n", Status);
			  ZwClose(PeripheralInstanceKey);
			  ZwClose(PeripheralKey);
			  ZwClose(ControllerInstanceKey);
			  ZwClose(ControllerKey);
			  ZwClose(BusInstanceKey);
			  ZwClose(BusKey);
			  return FALSE;
			}

		      BufferLength = ReturnedLength;
		      ValueInfo = ExAllocatePool(NonPagedPool,
						 BufferLength);
		      if (ValueInfo == NULL)
			{
			  DPRINT("ExAllocatePool() failed\n");
			  ZwClose(PeripheralInstanceKey);
			  ZwClose(PeripheralKey);
			  ZwClose(ControllerInstanceKey);
			  ZwClose(ControllerKey);
			  ZwClose(BusInstanceKey);
			  ZwClose(BusKey);
			  return FALSE;
			}

		      Status = ZwQueryValueKey(ControllerInstanceKey,
					       &KeyName,
					       KeyValuePartialInformation,
					       ValueInfo,
					       BufferLength,
					       &ReturnedLength);
		      if (NT_SUCCESS(Status))
			{
			  DPRINT("Done\n");
			  GetMouseResourceData((PCM_FULL_RESOURCE_DESCRIPTOR)(ValueInfo->Data),
					       Port,
					       Interrupt);

			  ExFreePool(ValueInfo);
			  ZwClose(PeripheralInstanceKey);
			  ZwClose(PeripheralKey);
			  ZwClose(ControllerInstanceKey);
			  ZwClose(ControllerKey);
			  ZwClose(BusInstanceKey);
			  ZwClose(BusKey);
			  return TRUE;
			}

		      ExFreePool(ValueInfo);

		      ZwClose(PeripheralInstanceKey);

		      PeripheralInstance++;
		    }

		  ZwClose(PeripheralKey);
		}

	      ZwClose(ControllerInstanceKey);

	      ControllerInstance++;
	    }

	  ZwClose(ControllerKey);
	}

      ZwClose(BusInstanceKey);

      BusInstance++;
    }

  ZwClose(BusKey);

  return FALSE;
}



NTSTATUS STDCALL
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
   119c0:	55                   	push   %ebp
   119c1:	89 e5                	mov    %esp,%ebp
   119c3:	57                   	push   %edi
   119c4:	56                   	push   %esi
   119c5:	53                   	push   %ebx
   119c6:	81 ec b0 00 00 00    	sub    $0xb0,%esp
	BOOLEAN MouseFound = FALSE;
	ULONG BaseAddress = (ULONG)-1;
   119cc:	c7 45 84 ff ff ff ff 	movl   $0xffffffff,0xffffff84(%ebp)
	ULONG Interrupt = (ULONG)-1;
   119d3:	c7 45 80 ff ff ff ff 	movl   $0xffffffff,0xffffff80(%ebp)
   119da:	8d 9d 78 ff ff ff    	lea    0xffffff78(%ebp),%ebx

	DPRINT1("Serial Mouse Driver 0.0.9\n");
   119e0:	68 90 03 00 00       	push   $0x390
   119e5:	68 25 31 01 00       	push   $0x13125
   119ea:	68 30 31 01 00       	push   $0x13130
   119ef:	e8 1c 07 00 00       	call   12110 <_DbgPrint>
   119f4:	c7 04 24 39 31 01 00 	movl   $0x13139,(%esp)
   119fb:	e8 10 07 00 00       	call   12110 <_DbgPrint>
   11a00:	5e                   	pop    %esi
   11a01:	5f                   	pop    %edi
   11a02:	68 54 31 01 00       	push   $0x13154
   11a07:	53                   	push   %ebx
   11a08:	e8 33 06 00 00       	call   12040 <_RtlInitUnicodeString@8>
   11a0d:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
   11a10:	89 9d 54 ff ff ff    	mov    %ebx,0xffffff54(%ebp)
   11a16:	89 5d d0             	mov    %ebx,0xffffffd0(%ebp)
   11a19:	c7 45 c8 18 00 00 00 	movl   $0x18,0xffffffc8(%ebp)
   11a20:	c7 45 d4 40 00 00 00 	movl   $0x40,0xffffffd4(%ebp)
   11a27:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
   11a2e:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
   11a35:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   11a3c:	89 04 24             	mov    %eax,(%esp)
   11a3f:	8d 85 74 ff ff ff    	lea    0xffffff74(%ebp),%eax
   11a45:	68 3f 00 0f 00       	push   $0xf003f
   11a4a:	50                   	push   %eax
   11a4b:	e8 70 06 00 00       	call   120c0 <_ZwOpenKey@12>
   11a50:	5b                   	pop    %ebx
   11a51:	89 c3                	mov    %eax,%ebx
   11a53:	31 c0                	xor    %eax,%eax
   11a55:	85 db                	test   %ebx,%ebx
   11a57:	0f 88 0f 01 00 00    	js     11b6c <_DriverEntry@8+0x1ac>
   11a5d:	31 f6                	xor    %esi,%esi
   11a5f:	8d 7d 88             	lea    0xffffff88(%ebp),%edi
   11a62:	eb 74                	jmp    11ad8 <_DriverEntry@8+0x118>
   11a64:	53                   	push   %ebx
   11a65:	53                   	push   %ebx
   11a66:	68 dc 31 01 00       	push   $0x131dc
   11a6b:	8b 8d 54 ff ff ff    	mov    0xffffff54(%ebp),%ecx
   11a71:	51                   	push   %ecx
   11a72:	e8 c9 05 00 00       	call   12040 <_RtlInitUnicodeString@8>
   11a77:	8b 85 54 ff ff ff    	mov    0xffffff54(%ebp),%eax
   11a7d:	c7 45 c8 18 00 00 00 	movl   $0x18,0xffffffc8(%ebp)
   11a84:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   11a87:	8b 85 70 ff ff ff    	mov    0xffffff70(%ebp),%eax
   11a8d:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   11a90:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
   11a93:	c7 45 d4 40 00 00 00 	movl   $0x40,0xffffffd4(%ebp)
   11a9a:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
   11aa1:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   11aa8:	89 04 24             	mov    %eax,(%esp)
   11aab:	8d 85 6c ff ff ff    	lea    0xffffff6c(%ebp),%eax
   11ab1:	68 3f 00 0f 00       	push   $0xf003f
   11ab6:	50                   	push   %eax
   11ab7:	e8 04 06 00 00       	call   120c0 <_ZwOpenKey@12>
   11abc:	5a                   	pop    %edx
   11abd:	85 c0                	test   %eax,%eax
   11abf:	0f 89 5b 01 00 00    	jns    11c20 <_DriverEntry@8+0x260>
   11ac5:	83 ec 0c             	sub    $0xc,%esp
   11ac8:	8b 8d 70 ff ff ff    	mov    0xffffff70(%ebp),%ecx
   11ace:	46                   	inc    %esi
   11acf:	51                   	push   %ecx
   11ad0:	e8 fb 05 00 00       	call   120d0 <_ZwClose@4>
   11ad5:	83 c4 0c             	add    $0xc,%esp
   11ad8:	50                   	push   %eax
   11ad9:	6a 00                	push   $0x0
   11adb:	68 fe 31 01 00       	push   $0x131fe
   11ae0:	57                   	push   %edi
   11ae1:	e8 1a 06 00 00       	call   12100 <_sprintf>
   11ae6:	83 c4 0c             	add    $0xc,%esp
   11ae9:	56                   	push   %esi
   11aea:	68 02 32 01 00       	push   $0x13202
   11aef:	57                   	push   %edi
   11af0:	e8 fb 05 00 00       	call   120f0 <_swprintf>
   11af5:	5b                   	pop    %ebx
   11af6:	58                   	pop    %eax
   11af7:	57                   	push   %edi
   11af8:	8b 8d 54 ff ff ff    	mov    0xffffff54(%ebp),%ecx
   11afe:	51                   	push   %ecx
   11aff:	e8 3c 05 00 00       	call   12040 <_RtlInitUnicodeString@8>
   11b04:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
   11b0a:	c7 45 c8 18 00 00 00 	movl   $0x18,0xffffffc8(%ebp)
   11b11:	89 85 54 ff ff ff    	mov    %eax,0xffffff54(%ebp)
   11b17:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   11b1a:	8b 85 74 ff ff ff    	mov    0xffffff74(%ebp),%eax
   11b20:	c7 45 d4 40 00 00 00 	movl   $0x40,0xffffffd4(%ebp)
   11b27:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   11b2a:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
   11b2d:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
   11b34:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   11b3b:	89 04 24             	mov    %eax,(%esp)
   11b3e:	8d 85 70 ff ff ff    	lea    0xffffff70(%ebp),%eax
   11b44:	68 3f 00 0f 00       	push   $0xf003f
   11b49:	50                   	push   %eax
   11b4a:	e8 71 05 00 00       	call   120c0 <_ZwOpenKey@12>
   11b4f:	5a                   	pop    %edx
   11b50:	85 c0                	test   %eax,%eax
   11b52:	0f 89 0c ff ff ff    	jns    11a64 <_DriverEntry@8+0xa4>
   11b58:	83 ec 0c             	sub    $0xc,%esp
   11b5b:	8b 85 74 ff ff ff    	mov    0xffffff74(%ebp),%eax
   11b61:	50                   	push   %eax
   11b62:	e8 69 05 00 00       	call   120d0 <_ZwClose@4>
   11b67:	31 c0                	xor    %eax,%eax
   11b69:	83 c4 0c             	add    $0xc,%esp
   11b6c:	85 c0                	test   %eax,%eax
   11b6e:	0f 84 b7 01 00 00    	je     11d2b <_DriverEntry@8+0x36b>

	if (GetMouseResources(&BaseAddress, &Interrupt))
	{
		if (BaseAddress != (ULONG)-1 && Interrupt != (ULONG)-1)
   11b74:	83 7d 84 ff          	cmpl   $0xffffffff,0xffffff84(%ebp)
   11b78:	74 76                	je     11bf0 <_DriverEntry@8+0x230>
   11b7a:	83 7d 80 ff          	cmpl   $0xffffffff,0xffffff80(%ebp)
   11b7e:	74 70                	je     11bf0 <_DriverEntry@8+0x230>
		{
			DPRINT1("Found mouse: Port %lx  Interupt %lu\n", BaseAddress, Interrupt);
   11b80:	52                   	push   %edx
   11b81:	68 96 03 00 00       	push   $0x396
   11b86:	68 25 31 01 00       	push   $0x13125
   11b8b:	68 30 31 01 00       	push   $0x13130
   11b90:	e8 7b 05 00 00       	call   12110 <_DbgPrint>
   11b95:	83 c4 0c             	add    $0xc,%esp
   11b98:	8b 45 80             	mov    0xffffff80(%ebp),%eax
   11b9b:	50                   	push   %eax
   11b9c:	8b 45 84             	mov    0xffffff84(%ebp),%eax
   11b9f:	50                   	push   %eax
   11ba0:	68 0c 32 01 00       	push   $0x1320c
   11ba5:	e8 66 05 00 00       	call   12110 <_DbgPrint>
			MouseFound |= InitializeMouse(BaseAddress, Interrupt, DriverObject);
   11baa:	83 c4 0c             	add    $0xc,%esp
   11bad:	8b 45 08             	mov    0x8(%ebp),%eax
   11bb0:	50                   	push   %eax
   11bb1:	8b 45 80             	mov    0xffffff80(%ebp),%eax
   11bb4:	50                   	push   %eax
   11bb5:	8b 45 84             	mov    0xffffff84(%ebp),%eax
   11bb8:	50                   	push   %eax
		}
	}
	else
	{
#ifdef SERMOUSE_COM1_SUPPORT
		DPRINT1("Trying to find mouse on COM1\n");
		MouseFound |= InitializeMouse(MOUSE_PORT_COM1, MOUSE_IRQ_COM1, DriverObject);
   11bb9:	e8 a2 fc ff ff       	call   11860 <_InitializeMouse>
   11bbe:	83 c4 10             	add    $0x10,%esp
#endif
#ifdef SERMOUSE_COM2_SUPPORT
		DPRINT1("Trying to find mouse on COM2\n");
		MouseFound |= InitializeMouse(MOUSE_PORT_COM2, MOUSE_IRQ_COM2, DriverObject);
#endif
	}

	if (!MouseFound)
   11bc1:	84 c0                	test   %al,%al
   11bc3:	74 2b                	je     11bf0 <_DriverEntry@8+0x230>
	{
		DPRINT1("No serial mouse found.\n");
		return STATUS_UNSUCCESSFUL;
	}

	DriverObject->MajorFunction[IRP_MJ_CREATE] = SerialMouseDispatch;
   11bc5:	8b 45 08             	mov    0x8(%ebp),%eax
   11bc8:	c7 40 38 50 14 01 00 	movl   $0x11450,0x38(%eax)
	DriverObject->MajorFunction[IRP_MJ_CLOSE] = SerialMouseDispatch;
   11bcf:	c7 40 40 50 14 01 00 	movl   $0x11450,0x40(%eax)
	DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = SerialMouseInternalDeviceControl;
   11bd6:	c7 40 74 70 13 01 00 	movl   $0x11370,0x74(%eax)
	DriverObject->DriverStartIo = SerialMouseStartIo;
   11bdd:	c7 40 30 d0 12 01 00 	movl   $0x112d0,0x30(%eax)

	return STATUS_SUCCESS;
}
   11be4:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11be7:	31 c0                	xor    %eax,%eax
   11be9:	5b                   	pop    %ebx
   11bea:	5e                   	pop    %esi
   11beb:	5f                   	pop    %edi
   11bec:	5d                   	pop    %ebp
   11bed:	c2 08 00             	ret    $0x8
   11bf0:	56                   	push   %esi
   11bf1:	68 a8 03 00 00       	push   $0x3a8
   11bf6:	68 25 31 01 00       	push   $0x13125
   11bfb:	68 30 31 01 00       	push   $0x13130
   11c00:	e8 0b 05 00 00       	call   12110 <_DbgPrint>
   11c05:	c7 04 24 31 32 01 00 	movl   $0x13231,(%esp)
   11c0c:	e8 ff 04 00 00       	call   12110 <_DbgPrint>
   11c11:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11c14:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   11c19:	5b                   	pop    %ebx
   11c1a:	5e                   	pop    %esi
   11c1b:	5f                   	pop    %edi
   11c1c:	5d                   	pop    %ebp
   11c1d:	c2 08 00             	ret    $0x8
   11c20:	31 f6                	xor    %esi,%esi
   11c22:	eb 74                	jmp    11c98 <_DriverEntry@8+0x2d8>
   11c24:	53                   	push   %ebx
   11c25:	53                   	push   %ebx
   11c26:	68 4c 32 01 00       	push   $0x1324c
   11c2b:	8b 8d 54 ff ff ff    	mov    0xffffff54(%ebp),%ecx
   11c31:	51                   	push   %ecx
   11c32:	e8 09 04 00 00       	call   12040 <_RtlInitUnicodeString@8>
   11c37:	8b 85 54 ff ff ff    	mov    0xffffff54(%ebp),%eax
   11c3d:	c7 45 c8 18 00 00 00 	movl   $0x18,0xffffffc8(%ebp)
   11c44:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   11c47:	8b 85 68 ff ff ff    	mov    0xffffff68(%ebp),%eax
   11c4d:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   11c50:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
   11c53:	c7 45 d4 40 00 00 00 	movl   $0x40,0xffffffd4(%ebp)
   11c5a:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
   11c61:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   11c68:	89 04 24             	mov    %eax,(%esp)
   11c6b:	8d 85 64 ff ff ff    	lea    0xffffff64(%ebp),%eax
   11c71:	68 3f 00 0f 00       	push   $0xf003f
   11c76:	50                   	push   %eax
   11c77:	e8 44 04 00 00       	call   120c0 <_ZwOpenKey@12>
   11c7c:	5a                   	pop    %edx
   11c7d:	85 c0                	test   %eax,%eax
   11c7f:	0f 89 da 00 00 00    	jns    11d5f <_DriverEntry@8+0x39f>
   11c85:	83 ec 0c             	sub    $0xc,%esp
   11c88:	8b 9d 68 ff ff ff    	mov    0xffffff68(%ebp),%ebx
   11c8e:	46                   	inc    %esi
   11c8f:	53                   	push   %ebx
   11c90:	e8 3b 04 00 00       	call   120d0 <_ZwClose@4>
   11c95:	83 c4 0c             	add    $0xc,%esp
   11c98:	50                   	push   %eax
   11c99:	56                   	push   %esi
   11c9a:	68 02 32 01 00       	push   $0x13202
   11c9f:	57                   	push   %edi
   11ca0:	e8 4b 04 00 00       	call   120f0 <_swprintf>
   11ca5:	5b                   	pop    %ebx
   11ca6:	58                   	pop    %eax
   11ca7:	57                   	push   %edi
   11ca8:	8b 8d 54 ff ff ff    	mov    0xffffff54(%ebp),%ecx
   11cae:	51                   	push   %ecx
   11caf:	e8 8c 03 00 00       	call   12040 <_RtlInitUnicodeString@8>
   11cb4:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
   11cba:	c7 45 c8 18 00 00 00 	movl   $0x18,0xffffffc8(%ebp)
   11cc1:	89 85 54 ff ff ff    	mov    %eax,0xffffff54(%ebp)
   11cc7:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   11cca:	8b 85 6c ff ff ff    	mov    0xffffff6c(%ebp),%eax
   11cd0:	c7 45 d4 40 00 00 00 	movl   $0x40,0xffffffd4(%ebp)
   11cd7:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   11cda:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
   11cdd:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
   11ce4:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   11ceb:	89 04 24             	mov    %eax,(%esp)
   11cee:	8d 85 68 ff ff ff    	lea    0xffffff68(%ebp),%eax
   11cf4:	68 3f 00 0f 00       	push   $0xf003f
   11cf9:	50                   	push   %eax
   11cfa:	e8 c1 03 00 00       	call   120c0 <_ZwOpenKey@12>
   11cff:	5a                   	pop    %edx
   11d00:	85 c0                	test   %eax,%eax
   11d02:	0f 89 1c ff ff ff    	jns    11c24 <_DriverEntry@8+0x264>
   11d08:	83 ec 0c             	sub    $0xc,%esp
   11d0b:	8b 85 6c ff ff ff    	mov    0xffffff6c(%ebp),%eax
   11d11:	50                   	push   %eax
   11d12:	e8 b9 03 00 00       	call   120d0 <_ZwClose@4>
   11d17:	8b 85 70 ff ff ff    	mov    0xffffff70(%ebp),%eax
   11d1d:	50                   	push   %eax
   11d1e:	e8 ad 03 00 00       	call   120d0 <_ZwClose@4>
   11d23:	83 c4 0c             	add    $0xc,%esp
   11d26:	e9 2d fe ff ff       	jmp    11b58 <_DriverEntry@8+0x198>
   11d2b:	50                   	push   %eax
   11d2c:	68 9d 03 00 00       	push   $0x39d
   11d31:	68 25 31 01 00       	push   $0x13125
   11d36:	68 30 31 01 00       	push   $0x13130
   11d3b:	e8 d0 03 00 00       	call   12110 <_DbgPrint>
   11d40:	c7 04 24 70 32 01 00 	movl   $0x13270,(%esp)
   11d47:	e8 c4 03 00 00       	call   12110 <_DbgPrint>
   11d4c:	83 c4 0c             	add    $0xc,%esp
   11d4f:	8b 7d 08             	mov    0x8(%ebp),%edi
   11d52:	57                   	push   %edi
   11d53:	6a 04                	push   $0x4
   11d55:	68 f8 03 00 00       	push   $0x3f8
   11d5a:	e9 5a fe ff ff       	jmp    11bb9 <_DriverEntry@8+0x1f9>
   11d5f:	c7 85 58 ff ff ff 00 	movl   $0x0,0xffffff58(%ebp)
   11d66:	00 00 00 
   11d69:	e9 e2 00 00 00       	jmp    11e50 <_DriverEntry@8+0x490>
   11d6e:	89 f6                	mov    %esi,%esi
   11d70:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
   11d76:	51                   	push   %ecx
   11d77:	51                   	push   %ecx
   11d78:	68 90 32 01 00       	push   $0x13290
   11d7d:	50                   	push   %eax
   11d7e:	e8 bd 02 00 00       	call   12040 <_RtlInitUnicodeString@8>
   11d83:	c7 85 5c ff ff ff 00 	movl   $0x0,0xffffff5c(%ebp)
   11d8a:	00 00 00 
   11d8d:	6a 10                	push   $0x10
   11d8f:	6a 00                	push   $0x0
   11d91:	e8 ba 02 00 00       	call   12050 <_ExAllocatePool@8>
   11d96:	5e                   	pop    %esi
   11d97:	85 c0                	test   %eax,%eax
   11d99:	5a                   	pop    %edx
   11d9a:	89 c6                	mov    %eax,%esi
   11d9c:	0f 84 65 01 00 00    	je     11f07 <_DriverEntry@8+0x547>
   11da2:	8d 85 5c ff ff ff    	lea    0xffffff5c(%ebp),%eax
   11da8:	53                   	push   %ebx
   11da9:	53                   	push   %ebx
   11daa:	50                   	push   %eax
   11dab:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
   11db1:	6a 10                	push   $0x10
   11db3:	56                   	push   %esi
   11db4:	6a 02                	push   $0x2
   11db6:	50                   	push   %eax
   11db7:	8b 8d 68 ff ff ff    	mov    0xffffff68(%ebp),%ecx
   11dbd:	51                   	push   %ecx
   11dbe:	e8 1d 03 00 00       	call   120e0 <_ZwQueryValueKey@24>
   11dc3:	89 c3                	mov    %eax,%ebx
   11dc5:	52                   	push   %edx
   11dc6:	56                   	push   %esi
   11dc7:	e8 c4 02 00 00       	call   12090 <_ExFreePool@4>
   11dcc:	89 da                	mov    %ebx,%edx
   11dce:	c1 ea 1f             	shr    $0x1f,%edx
   11dd1:	83 c4 0c             	add    $0xc,%esp
   11dd4:	81 fb 23 00 00 c0    	cmp    $0xc0000023,%ebx
   11dda:	0f 95 c0             	setne  %al
   11ddd:	85 d0                	test   %edx,%eax
   11ddf:	0f 85 22 01 00 00    	jne    11f07 <_DriverEntry@8+0x547>
   11de5:	8b 9d 5c ff ff ff    	mov    0xffffff5c(%ebp),%ebx
   11deb:	56                   	push   %esi
   11dec:	56                   	push   %esi
   11ded:	53                   	push   %ebx
   11dee:	6a 00                	push   $0x0
   11df0:	e8 5b 02 00 00       	call   12050 <_ExAllocatePool@8>
   11df5:	5a                   	pop    %edx
   11df6:	89 c6                	mov    %eax,%esi
   11df8:	59                   	pop    %ecx
   11df9:	85 c0                	test   %eax,%eax
   11dfb:	0f 84 06 01 00 00    	je     11f07 <_DriverEntry@8+0x547>
   11e01:	50                   	push   %eax
   11e02:	50                   	push   %eax
   11e03:	8d 85 5c ff ff ff    	lea    0xffffff5c(%ebp),%eax
   11e09:	50                   	push   %eax
   11e0a:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
   11e10:	53                   	push   %ebx
   11e11:	56                   	push   %esi
   11e12:	6a 02                	push   $0x2
   11e14:	50                   	push   %eax
   11e15:	8b 85 68 ff ff ff    	mov    0xffffff68(%ebp),%eax
   11e1b:	50                   	push   %eax
   11e1c:	e8 bf 02 00 00       	call   120e0 <_ZwQueryValueKey@24>
   11e21:	59                   	pop    %ecx
   11e22:	85 c0                	test   %eax,%eax
   11e24:	5b                   	pop    %ebx
   11e25:	0f 89 0e 01 00 00    	jns    11f39 <_DriverEntry@8+0x579>
   11e2b:	83 ec 0c             	sub    $0xc,%esp
   11e2e:	56                   	push   %esi
   11e2f:	e8 5c 02 00 00       	call   12090 <_ExFreePool@4>
   11e34:	8b 85 60 ff ff ff    	mov    0xffffff60(%ebp),%eax
   11e3a:	50                   	push   %eax
   11e3b:	e8 90 02 00 00       	call   120d0 <_ZwClose@4>
   11e40:	8b b5 58 ff ff ff    	mov    0xffffff58(%ebp),%esi
   11e46:	83 c4 0c             	add    $0xc,%esp
   11e49:	46                   	inc    %esi
   11e4a:	89 b5 58 ff ff ff    	mov    %esi,0xffffff58(%ebp)
   11e50:	53                   	push   %ebx
   11e51:	8b 8d 58 ff ff ff    	mov    0xffffff58(%ebp),%ecx
   11e57:	51                   	push   %ecx
   11e58:	68 02 32 01 00       	push   $0x13202
   11e5d:	57                   	push   %edi
   11e5e:	e8 8d 02 00 00       	call   120f0 <_swprintf>
   11e63:	58                   	pop    %eax
   11e64:	5a                   	pop    %edx
   11e65:	57                   	push   %edi
   11e66:	8b b5 54 ff ff ff    	mov    0xffffff54(%ebp),%esi
   11e6c:	56                   	push   %esi
   11e6d:	e8 ce 01 00 00       	call   12040 <_RtlInitUnicodeString@8>
   11e72:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
   11e78:	c7 45 c8 18 00 00 00 	movl   $0x18,0xffffffc8(%ebp)
   11e7f:	89 85 54 ff ff ff    	mov    %eax,0xffffff54(%ebp)
   11e85:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   11e88:	8b 85 64 ff ff ff    	mov    0xffffff64(%ebp),%eax
   11e8e:	c7 45 d4 40 00 00 00 	movl   $0x40,0xffffffd4(%ebp)
   11e95:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   11e98:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
   11e9b:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
   11ea2:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   11ea9:	89 04 24             	mov    %eax,(%esp)
   11eac:	8d 85 60 ff ff ff    	lea    0xffffff60(%ebp),%eax
   11eb2:	68 3f 00 0f 00       	push   $0xf003f
   11eb7:	50                   	push   %eax
   11eb8:	e8 03 02 00 00       	call   120c0 <_ZwOpenKey@12>
   11ebd:	5b                   	pop    %ebx
   11ebe:	85 c0                	test   %eax,%eax
   11ec0:	0f 89 aa fe ff ff    	jns    11d70 <_DriverEntry@8+0x3b0>
   11ec6:	83 ec 0c             	sub    $0xc,%esp
   11ec9:	8b 95 64 ff ff ff    	mov    0xffffff64(%ebp),%edx
   11ecf:	52                   	push   %edx
   11ed0:	e8 fb 01 00 00       	call   120d0 <_ZwClose@4>
   11ed5:	8b 85 68 ff ff ff    	mov    0xffffff68(%ebp),%eax
   11edb:	50                   	push   %eax
   11edc:	e8 ef 01 00 00       	call   120d0 <_ZwClose@4>
   11ee1:	83 c4 0c             	add    $0xc,%esp
   11ee4:	83 ec 0c             	sub    $0xc,%esp
   11ee7:	8b 85 6c ff ff ff    	mov    0xffffff6c(%ebp),%eax
   11eed:	50                   	push   %eax
   11eee:	e8 dd 01 00 00       	call   120d0 <_ZwClose@4>
   11ef3:	8b 85 70 ff ff ff    	mov    0xffffff70(%ebp),%eax
   11ef9:	50                   	push   %eax
   11efa:	e8 d1 01 00 00       	call   120d0 <_ZwClose@4>
   11eff:	83 c4 0c             	add    $0xc,%esp
   11f02:	e9 51 fc ff ff       	jmp    11b58 <_DriverEntry@8+0x198>
   11f07:	83 ec 0c             	sub    $0xc,%esp
   11f0a:	8b 8d 60 ff ff ff    	mov    0xffffff60(%ebp),%ecx
   11f10:	51                   	push   %ecx
   11f11:	e8 ba 01 00 00       	call   120d0 <_ZwClose@4>
   11f16:	83 c4 0c             	add    $0xc,%esp
   11f19:	8b 95 64 ff ff ff    	mov    0xffffff64(%ebp),%edx
   11f1f:	83 ec 0c             	sub    $0xc,%esp
   11f22:	52                   	push   %edx
   11f23:	e8 a8 01 00 00       	call   120d0 <_ZwClose@4>
   11f28:	8b 85 68 ff ff ff    	mov    0xffffff68(%ebp),%eax
   11f2e:	50                   	push   %eax
   11f2f:	e8 9c 01 00 00       	call   120d0 <_ZwClose@4>
   11f34:	83 c4 0c             	add    $0xc,%esp
   11f37:	eb ab                	jmp    11ee4 <_DriverEntry@8+0x524>
   11f39:	8d 7e 0c             	lea    0xc(%esi),%edi
   11f3c:	31 db                	xor    %ebx,%ebx
   11f3e:	8b 4f 0c             	mov    0xc(%edi),%ecx
   11f41:	83 f9 00             	cmp    $0x0,%ecx
   11f44:	76 31                	jbe    11f77 <_DriverEntry@8+0x5b7>
   11f46:	89 fa                	mov    %edi,%edx
   11f48:	eb 0d                	jmp    11f57 <_DriverEntry@8+0x597>
   11f4a:	83 f8 02             	cmp    $0x2,%eax
   11f4d:	74 1d                	je     11f6c <_DriverEntry@8+0x5ac>
   11f4f:	43                   	inc    %ebx
   11f50:	83 c2 10             	add    $0x10,%edx
   11f53:	39 d9                	cmp    %ebx,%ecx
   11f55:	76 20                	jbe    11f77 <_DriverEntry@8+0x5b7>
   11f57:	31 c0                	xor    %eax,%eax
   11f59:	8a 42 10             	mov    0x10(%edx),%al
   11f5c:	83 f8 01             	cmp    $0x1,%eax
   11f5f:	75 e9                	jne    11f4a <_DriverEntry@8+0x58a>
   11f61:	8b 42 14             	mov    0x14(%edx),%eax
   11f64:	89 45 84             	mov    %eax,0xffffff84(%ebp)
   11f67:	8b 4f 0c             	mov    0xc(%edi),%ecx
   11f6a:	eb e3                	jmp    11f4f <_DriverEntry@8+0x58f>
   11f6c:	8b 42 14             	mov    0x14(%edx),%eax
   11f6f:	89 45 80             	mov    %eax,0xffffff80(%ebp)
   11f72:	8b 4f 0c             	mov    0xc(%edi),%ecx
   11f75:	eb d8                	jmp    11f4f <_DriverEntry@8+0x58f>
   11f77:	83 ec 0c             	sub    $0xc,%esp
   11f7a:	56                   	push   %esi
   11f7b:	e8 10 01 00 00       	call   12090 <_ExFreePool@4>
   11f80:	8b 95 60 ff ff ff    	mov    0xffffff60(%ebp),%edx
   11f86:	52                   	push   %edx
   11f87:	e8 44 01 00 00       	call   120d0 <_ZwClose@4>
   11f8c:	8b 85 64 ff ff ff    	mov    0xffffff64(%ebp),%eax
   11f92:	50                   	push   %eax
   11f93:	e8 38 01 00 00       	call   120d0 <_ZwClose@4>
   11f98:	8b 85 68 ff ff ff    	mov    0xffffff68(%ebp),%eax
   11f9e:	50                   	push   %eax
   11f9f:	e8 2c 01 00 00       	call   120d0 <_ZwClose@4>
   11fa4:	8b 85 6c ff ff ff    	mov    0xffffff6c(%ebp),%eax
   11faa:	50                   	push   %eax
   11fab:	e8 20 01 00 00       	call   120d0 <_ZwClose@4>
   11fb0:	8b 85 70 ff ff ff    	mov    0xffffff70(%ebp),%eax
   11fb6:	50                   	push   %eax
   11fb7:	e8 14 01 00 00       	call   120d0 <_ZwClose@4>
   11fbc:	8b 85 74 ff ff ff    	mov    0xffffff74(%ebp),%eax
   11fc2:	50                   	push   %eax
   11fc3:	e8 08 01 00 00       	call   120d0 <_ZwClose@4>
   11fc8:	b8 01 00 00 00       	mov    $0x1,%eax
   11fcd:	83 c4 0c             	add    $0xc,%esp
   11fd0:	e9 97 fb ff ff       	jmp    11b6c <_DriverEntry@8+0x1ac>
   11fd5:	90                   	nop    
   11fd6:	90                   	nop    
   11fd7:	90                   	nop    
   11fd8:	90                   	nop    
   11fd9:	90                   	nop    
   11fda:	90                   	nop    
   11fdb:	90                   	nop    
   11fdc:	90                   	nop    
   11fdd:	90                   	nop    
   11fde:	90                   	nop    
   11fdf:	90                   	nop    

00011fe0 <_KeInsertQueueDpc@12>:
   11fe0:	ff 25 08 41 01 00    	jmp    *0x14108
   11fe6:	90                   	nop    
   11fe7:	90                   	nop    
	...

00011ff0 <_KeSynchronizeExecution@12>:
   11ff0:	ff 25 0c 41 01 00    	jmp    *0x1410c
   11ff6:	90                   	nop    
   11ff7:	90                   	nop    
	...

00012000 <_IoCompleteRequest@8>:
   12000:	ff 25 f0 40 01 00    	jmp    *0x140f0
   12006:	90                   	nop    
   12007:	90                   	nop    
	...

00012010 <_IoStartNextPacket@8>:
   12010:	ff 25 fc 40 01 00    	jmp    *0x140fc
   12016:	90                   	nop    
   12017:	90                   	nop    
	...

00012020 <_IoStartPacket@16>:
   12020:	ff 25 00 41 01 00    	jmp    *0x14100
   12026:	90                   	nop    
   12027:	90                   	nop    
	...

00012030 <@InterlockedIncrement@4>:
   12030:	ff 25 e0 40 01 00    	jmp    *0x140e0
   12036:	90                   	nop    
   12037:	90                   	nop    
	...

00012040 <_RtlInitUnicodeString@8>:
   12040:	ff 25 14 41 01 00    	jmp    *0x14114
   12046:	90                   	nop    
   12047:	90                   	nop    
	...

00012050 <_ExAllocatePool@8>:
   12050:	ff 25 e8 40 01 00    	jmp    *0x140e8
   12056:	90                   	nop    
   12057:	90                   	nop    
	...

00012060 <_RtlAppendUnicodeToString@8>:
   12060:	ff 25 10 41 01 00    	jmp    *0x14110
   12066:	90                   	nop    
   12067:	90                   	nop    
	...

00012070 <_RtlIntegerToUnicodeString@12>:
   12070:	ff 25 18 41 01 00    	jmp    *0x14118
   12076:	90                   	nop    
   12077:	90                   	nop    
	...

00012080 <_IoCreateDevice@28>:
   12080:	ff 25 f8 40 01 00    	jmp    *0x140f8
   12086:	90                   	nop    
   12087:	90                   	nop    
	...

00012090 <_ExFreePool@4>:
   12090:	ff 25 ec 40 01 00    	jmp    *0x140ec
   12096:	90                   	nop    
   12097:	90                   	nop    
	...

000120a0 <_KeInitializeDpc@12>:
   120a0:	ff 25 04 41 01 00    	jmp    *0x14104
   120a6:	90                   	nop    
   120a7:	90                   	nop    
	...

000120b0 <_IoConnectInterrupt@44>:
   120b0:	ff 25 f4 40 01 00    	jmp    *0x140f4
   120b6:	90                   	nop    
   120b7:	90                   	nop    
	...

000120c0 <_ZwOpenKey@12>:
   120c0:	ff 25 20 41 01 00    	jmp    *0x14120
   120c6:	90                   	nop    
   120c7:	90                   	nop    
	...

000120d0 <_ZwClose@4>:
   120d0:	ff 25 1c 41 01 00    	jmp    *0x1411c
   120d6:	90                   	nop    
   120d7:	90                   	nop    
	...

000120e0 <_ZwQueryValueKey@24>:
   120e0:	ff 25 24 41 01 00    	jmp    *0x14124
   120e6:	90                   	nop    
   120e7:	90                   	nop    
	...

000120f0 <_swprintf>:
   120f0:	ff 25 2c 41 01 00    	jmp    *0x1412c
   120f6:	90                   	nop    
   120f7:	90                   	nop    
	...

00012100 <_sprintf>:
   12100:	ff 25 28 41 01 00    	jmp    *0x14128
   12106:	90                   	nop    
   12107:	90                   	nop    
	...

00012110 <_DbgPrint>:
   12110:	ff 25 e4 40 01 00    	jmp    *0x140e4
   12116:	90                   	nop    
   12117:	90                   	nop    
	...

00012120 <_READ_PORT_UCHAR@4>:
   12120:	ff 25 d0 40 01 00    	jmp    *0x140d0
   12126:	90                   	nop    
   12127:	90                   	nop    
	...

00012130 <_KeGetCurrentIrql@0>:
   12130:	ff 25 c0 40 01 00    	jmp    *0x140c0
   12136:	90                   	nop    
   12137:	90                   	nop    
	...

00012140 <_KeRaiseIrql@8>:
   12140:	ff 25 c8 40 01 00    	jmp    *0x140c8
   12146:	90                   	nop    
   12147:	90                   	nop    
	...

00012150 <_KeLowerIrql@4>:
   12150:	ff 25 c4 40 01 00    	jmp    *0x140c4
   12156:	90                   	nop    
   12157:	90                   	nop    
	...

00012160 <_WRITE_PORT_UCHAR@8>:
   12160:	ff 25 d4 40 01 00    	jmp    *0x140d4
   12166:	90                   	nop    
   12167:	90                   	nop    
	...

00012170 <_KeStallExecutionProcessor@4>:
   12170:	ff 25 cc 40 01 00    	jmp    *0x140cc
   12176:	90                   	nop    
   12177:	90                   	nop    
	...

00012180 <_HalGetInterruptVector@24>:
   12180:	ff 25 bc 40 01 00    	jmp    *0x140bc
   12186:	90                   	nop    
   12187:	90                   	nop    
	...

00012190 <__CTOR_LIST__>:
   12190:	ff                   	(bad)  
   12191:	ff                   	(bad)  
   12192:	ff                   	(bad)  
   12193:	ff 00                	incl   (%eax)
   12195:	00 00                	add    %al,(%eax)
	...

00012198 <__DTOR_LIST__>:
   12198:	ff                   	(bad)  
   12199:	ff                   	(bad)  
   1219a:	ff                   	(bad)  
   1219b:	ff 00                	incl   (%eax)
   1219d:	00 00                	add    %al,(%eax)
	...
