
halmp.nostrip.dll:     file format pei-i386

Disassembly of section .text:

00011000 <_HalpGrowMapBuffers>:
 *     SizeOfMapBuffers: Size of the map buffers to allocate
 * NOTES:
 *     - Needs to be tested...
 */
{
   11000:	55                   	push   %ebp
	//ULONG PagesToAllocate = BYTES_TO_PAGES(SizeOfMapBuffers);
	
	/* TODO: Allocation */

	return TRUE;
}
   11001:	b8 01 00 00 00       	mov    $0x1,%eax
   11006:	89 e5                	mov    %esp,%ebp
   11008:	5d                   	pop    %ebp
   11009:	c3                   	ret    
   1100a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011010 <_HalpAllocateAdapterEx@12>:

PADAPTER_OBJECT STDCALL
HalpAllocateAdapterEx(
  ULONG NumberOfMapRegisters,
  BOOLEAN IsMaster,
  BOOLEAN Dma32BitAddresses)
/*
 * FUNCTION: Allocates an ADAPTER_OBJECT, optionally creates the Master Adapter.
 * ARGUMENTS:
 *     - NumberOfMapRegisters: Number of map registers to allocate
 *     - IsMaster: Wether this is a Master Device or not
 *     - Dma32BitAddresses: Wether 32-bit Addresses are supported
 * RETURNS:
 *     - Pointer to Adapter Object, or NULL if failure.
 * BUGS:
 *     - Some stuff is unhandled/incomplete
 */
{
   11010:	55                   	push   %ebp
   11011:	89 e5                	mov    %esp,%ebp
   11013:	56                   	push   %esi
   11014:	53                   	push   %ebx
   11015:	83 ec 30             	sub    $0x30,%esp
	OBJECT_ATTRIBUTES ObjectAttributes;
	ULONG ObjectSize;
	ULONG BitmapSize;
	NTSTATUS Status;
	ULONG AllowedMapRegisters = 64;
	PADAPTER_OBJECT AdapterObject;
	HANDLE Handle;
	
	/* Allocate the Master Adapter if we haven't already 
	   but make sure we're not asked to do it now, and also check if we need it */
	if ((MasterAdapter == NULL) && (!IsMaster) && (NumberOfMapRegisters)) {
   11018:	a1 30 e5 03 00       	mov    0x3e530,%eax
   1101d:	8a 5d 0c             	mov    0xc(%ebp),%bl
   11020:	85 c0                	test   %eax,%eax
   11022:	8b 75 08             	mov    0x8(%ebp),%esi
   11025:	0f 94 c2             	sete   %dl
   11028:	84 db                	test   %bl,%bl
   1102a:	8a 4d 10             	mov    0x10(%ebp),%cl
   1102d:	0f 94 c0             	sete   %al
   11030:	25 ff 00 00 00       	and    $0xff,%eax
   11035:	85 c2                	test   %eax,%edx
   11037:	74 08                	je     11041 <_HalpAllocateAdapterEx@12+0x31>
   11039:	85 f6                	test   %esi,%esi
   1103b:	0f 85 6f 01 00 00    	jne    111b0 <_HalpAllocateAdapterEx@12+0x1a0>
		
		/* Allocate and Save */
		DPRINT("Allocating the Master Adapter Object\n");
		MasterAdapter = HalpAllocateAdapterEx(NumberOfMapRegisters,
						     TRUE,
						     Dma32BitAddresses);
		
		/* Cancel on Failure */
		DPRINT("Checking if Master Adapter was allocated properly\n");
		if (!MasterAdapter) return NULL;
	}
	
	/* Initialize the Object Attributes for the Adapter Object */
	InitializeObjectAttributes(&ObjectAttributes,
				   NULL,
				   OBJ_PERMANENT,
				   NULL,
				   NULL);
	
	/* Check if this is the Master Adapter, in which case we need to allocate the bitmap */
	if (IsMaster) {
		/* Size due to the Bitmap + Bytes in the Bitmap Buffer (8 bytes, 64 bits)*/
		BitmapSize = sizeof(RTL_BITMAP) + (AllowedMapRegisters + 7) / 8;
		
		/* We will put the Bitmap Buffer after the Adapter Object for simplicity */
		ObjectSize = sizeof(ADAPTER_OBJECT) + BitmapSize;
   11041:	80 fb 01             	cmp    $0x1,%bl
	} else {
		ObjectSize = sizeof(ADAPTER_OBJECT);
	}
	
	/* Create and Allocate the Object */
	DPRINT("Creating the Object\n");
	Status = ObCreateObject(KernelMode,
   11044:	8d 45 d4             	lea    0xffffffd4(%ebp),%eax
   11047:	19 d2                	sbb    %edx,%edx
   11049:	83 ec 0c             	sub    $0xc,%esp
   1104c:	83 e2 f0             	and    $0xfffffff0,%edx
   1104f:	c7 45 d8 18 00 00 00 	movl   $0x18,0xffffffd8(%ebp)
   11056:	50                   	push   %eax
   11057:	83 c2 78             	add    $0x78,%edx
   1105a:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
   1105d:	6a 00                	push   $0x0
   1105f:	6a 00                	push   $0x0
   11061:	52                   	push   %edx
   11062:	6a 00                	push   $0x0
   11064:	6a 00                	push   $0x0
   11066:	50                   	push   %eax
   11067:	a1 14 11 04 00       	mov    0x41114,%eax
   1106c:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
   11073:	c7 45 e4 10 00 00 00 	movl   $0x10,0xffffffe4(%ebp)
   1107a:	8b 00                	mov    (%eax),%eax
   1107c:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   11083:	50                   	push   %eax
   11084:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   1108b:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   11092:	6a 00                	push   $0x0
   11094:	e8 d7 96 00 00       	call   1a770 <_ObCreateObject@36>
				IoAdapterObjectType,
				&ObjectAttributes,
				KernelMode,
				NULL,
				ObjectSize,
				0,
				0,
				(PVOID)&AdapterObject);
	
	if (!NT_SUCCESS(Status)) return NULL;
   11099:	31 d2                	xor    %edx,%edx
   1109b:	83 c4 0c             	add    $0xc,%esp
   1109e:	85 c0                	test   %eax,%eax
   110a0:	0f 88 80 00 00 00    	js     11126 <_HalpAllocateAdapterEx@12+0x116>
	
	/* Add a Reference */
	DPRINT("Referencing the Object\n");
	Status = ObReferenceObjectByPointer(AdapterObject,
   110a6:	a1 14 11 04 00       	mov    0x41114,%eax
   110ab:	6a 00                	push   $0x0
   110ad:	8b 00                	mov    (%eax),%eax
   110af:	50                   	push   %eax
   110b0:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   110b3:	6a 03                	push   $0x3
   110b5:	50                   	push   %eax
   110b6:	e8 c5 96 00 00       	call   1a780 <_ObReferenceObjectByPointer@16>
					    FILE_READ_DATA | FILE_WRITE_DATA,
					    IoAdapterObjectType,
					    KernelMode);
	
	if (!NT_SUCCESS(Status)) return NULL;
   110bb:	31 d2                	xor    %edx,%edx
   110bd:	85 c0                	test   %eax,%eax
   110bf:	78 65                	js     11126 <_HalpAllocateAdapterEx@12+0x116>
	
	/* It's a Valid Object, so now we can play with the memory */
	RtlZeroMemory(AdapterObject, sizeof(ADAPTER_OBJECT));
   110c1:	50                   	push   %eax
   110c2:	50                   	push   %eax
   110c3:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   110c6:	6a 68                	push   $0x68
   110c8:	50                   	push   %eax
   110c9:	e8 c2 96 00 00       	call   1a790 <_RtlZeroMemory@8>
	
	/* Insert it into the Object Table */
	DPRINT("Inserting the Object\n");
	Status = ObInsertObject(AdapterObject,
   110ce:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
   110d1:	50                   	push   %eax
   110d2:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   110d5:	6a 00                	push   $0x0
   110d7:	6a 00                	push   $0x0
   110d9:	6a 03                	push   $0x3
   110db:	6a 00                	push   $0x0
   110dd:	50                   	push   %eax
   110de:	e8 bd 96 00 00       	call   1a7a0 <_ObInsertObject@24>
				NULL,
				FILE_READ_DATA | FILE_WRITE_DATA,
				0,
				NULL,
				&Handle);
	
	if (!NT_SUCCESS(Status)) return NULL;
   110e3:	5a                   	pop    %edx
   110e4:	31 d2                	xor    %edx,%edx
   110e6:	59                   	pop    %ecx
   110e7:	85 c0                	test   %eax,%eax
   110e9:	78 3b                	js     11126 <_HalpAllocateAdapterEx@12+0x116>
	
	/* We don't want the handle */
	NtClose(Handle);	
   110eb:	83 ec 0c             	sub    $0xc,%esp
   110ee:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
   110f1:	51                   	push   %ecx
   110f2:	e8 b9 96 00 00       	call   1a7b0 <_NtClose@4>
	
	/* Set up the Adapter Object fields */
	AdapterObject->MapRegistersPerChannel = 1;
   110f7:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
	
	/* Set the Master if needed (master only needed if we use Map Registers) */
	if (NumberOfMapRegisters) AdapterObject->MasterAdapter = MasterAdapter;
   110fa:	83 c4 0c             	add    $0xc,%esp
   110fd:	85 f6                	test   %esi,%esi
   110ff:	c7 42 0c 01 00 00 00 	movl   $0x1,0xc(%edx)
   11106:	74 08                	je     11110 <_HalpAllocateAdapterEx@12+0x100>
   11108:	a1 30 e5 03 00       	mov    0x3e530,%eax
   1110d:	89 42 08             	mov    %eax,0x8(%edx)
	
	/* Initalize the Channel Wait queue, which every adapter has */
	DPRINT("Initializing the Device Queue of the Object\n");
	KeInitializeDeviceQueue(&AdapterObject->ChannelWaitQueue);
   11110:	83 ec 0c             	sub    $0xc,%esp
   11113:	8d 42 24             	lea    0x24(%edx),%eax
   11116:	50                   	push   %eax
   11117:	e8 a4 96 00 00       	call   1a7c0 <_KeInitializeDeviceQueue@4>
	
	/* Initialize the SpinLock, Queue and Bitmap, which are kept in the Master Adapter only */
	if (IsMaster) {
   1111c:	83 c4 0c             	add    $0xc,%esp
   1111f:	84 db                	test   %bl,%bl
   11121:	75 0e                	jne    11131 <_HalpAllocateAdapterEx@12+0x121>
		
		DPRINT("Initializing the Master Adapter Stuff\n");
		KeInitializeSpinLock(&AdapterObject->SpinLock);
		InitializeListHead(&AdapterObject->AdapterQueue);
		
		/* As said previously, we put them here for simplicity */
		AdapterObject->MapRegisters = (PVOID)(AdapterObject + 1);
		
		/* Set up Bitmap */
		RtlInitializeBitMap(AdapterObject->MapRegisters,
				    (PULONG)(AdapterObject->MapRegisters + 1),
				    AllowedMapRegisters);
				    
		/* Reset the Bitmap */	
		RtlSetAllBits(AdapterObject->MapRegisters);
		AdapterObject->NumberOfMapRegisters = 0;
		AdapterObject->CommittedMapRegisters = 0;
		
		/* Allocate Memory for the Map Registers */
		AdapterObject->MapRegisterBase = ExAllocatePool(NonPagedPool,
								AllowedMapRegisters * sizeof(DWORD));
		
		/* Clear them */
		RtlZeroMemory(AdapterObject->MapRegisterBase, AllowedMapRegisters * sizeof(DWORD));
		
		/* Allocate the contigous memory */
		DPRINT("Allocating Buffers\n");
		HalpGrowMapBuffers(AdapterObject, 0x1000000);
	}
	
	DPRINT("Adapter Object allocated\n");
	return AdapterObject;	
   11123:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
}
   11126:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11129:	89 d0                	mov    %edx,%eax
   1112b:	5b                   	pop    %ebx
   1112c:	5e                   	pop    %esi
   1112d:	5d                   	pop    %ebp
   1112e:	c2 0c 00             	ret    $0xc
   11131:	83 ec 0c             	sub    $0xc,%esp
   11134:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   11137:	83 c0 44             	add    $0x44,%eax
   1113a:	50                   	push   %eax
   1113b:	e8 90 96 00 00       	call   1a7d0 <_KeInitializeSpinLock@4>
   11140:	58                   	pop    %eax
   11141:	5a                   	pop    %edx
   11142:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
   11145:	8d 42 3c             	lea    0x3c(%edx),%eax
   11148:	89 42 3c             	mov    %eax,0x3c(%edx)
   1114b:	89 40 04             	mov    %eax,0x4(%eax)
		KeInitializeSpinLock(&AdapterObject->SpinLock);
		InitializeListHead(&AdapterObject->AdapterQueue);
		
		/* As said previously, we put them here for simplicity */
		AdapterObject->MapRegisters = (PVOID)(AdapterObject + 1);
   1114e:	8d 42 68             	lea    0x68(%edx),%eax
   11151:	89 42 48             	mov    %eax,0x48(%edx)
		
		/* Set up Bitmap */
		RtlInitializeBitMap(AdapterObject->MapRegisters,
   11154:	6a 40                	push   $0x40
   11156:	8b 42 48             	mov    0x48(%edx),%eax
   11159:	83 c0 08             	add    $0x8,%eax
   1115c:	50                   	push   %eax
   1115d:	8b 42 48             	mov    0x48(%edx),%eax
   11160:	50                   	push   %eax
   11161:	e8 7a 96 00 00       	call   1a7e0 <_RtlInitializeBitMap@12>
				    (PULONG)(AdapterObject->MapRegisters + 1),
				    AllowedMapRegisters);
				    
		/* Reset the Bitmap */	
		RtlSetAllBits(AdapterObject->MapRegisters);
   11166:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   11169:	56                   	push   %esi
   1116a:	56                   	push   %esi
   1116b:	8b 58 48             	mov    0x48(%eax),%ebx
   1116e:	53                   	push   %ebx
   1116f:	e8 7c 96 00 00       	call   1a7f0 <_RtlSetAllBits@4>
		AdapterObject->NumberOfMapRegisters = 0;
   11174:	8b 5d d4             	mov    0xffffffd4(%ebp),%ebx
   11177:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
		AdapterObject->CommittedMapRegisters = 0;
   1117e:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
		
		/* Allocate Memory for the Map Registers */
		AdapterObject->MapRegisterBase = ExAllocatePool(NonPagedPool,
   11185:	c7 04 24 00 01 00 00 	movl   $0x100,(%esp)
   1118c:	6a 00                	push   $0x0
   1118e:	e8 6d 96 00 00       	call   1a800 <_ExAllocatePool@8>
   11193:	89 43 14             	mov    %eax,0x14(%ebx)
								AllowedMapRegisters * sizeof(DWORD));
		
		/* Clear them */
		RtlZeroMemory(AdapterObject->MapRegisterBase, AllowedMapRegisters * sizeof(DWORD));
   11196:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   11199:	68 00 01 00 00       	push   $0x100
   1119e:	8b 48 14             	mov    0x14(%eax),%ecx
   111a1:	51                   	push   %ecx
   111a2:	e8 e9 95 00 00       	call   1a790 <_RtlZeroMemory@8>
		
		/* Allocate the contigous memory */
		DPRINT("Allocating Buffers\n");
		HalpGrowMapBuffers(AdapterObject, 0x1000000);
   111a7:	58                   	pop    %eax
   111a8:	5a                   	pop    %edx
   111a9:	e9 75 ff ff ff       	jmp    11123 <_HalpAllocateAdapterEx@12+0x113>
   111ae:	89 f6                	mov    %esi,%esi
   111b0:	50                   	push   %eax
   111b1:	31 c0                	xor    %eax,%eax
   111b3:	88 c8                	mov    %cl,%al
   111b5:	50                   	push   %eax
   111b6:	6a 01                	push   $0x1
   111b8:	56                   	push   %esi
   111b9:	e8 52 fe ff ff       	call   11010 <_HalpAllocateAdapterEx@12>
   111be:	5a                   	pop    %edx
   111bf:	a3 30 e5 03 00       	mov    %eax,0x3e530
   111c4:	31 d2                	xor    %edx,%edx
   111c6:	85 c0                	test   %eax,%eax
   111c8:	0f 85 73 fe ff ff    	jne    11041 <_HalpAllocateAdapterEx@12+0x31>
   111ce:	e9 53 ff ff ff       	jmp    11126 <_HalpAllocateAdapterEx@12+0x116>
   111d3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   111d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000111e0 <_IoFlushAdapterBuffers@24>:
	}
	
	DPRINT("Adapter Object allocated\n");
	return AdapterObject;	
}


BOOLEAN STDCALL
IoFlushAdapterBuffers (
  PADAPTER_OBJECT	AdapterObject,
  PMDL		Mdl,
  PVOID		MapRegisterBase,
  PVOID		CurrentVa,
  ULONG		Length,
  BOOLEAN		WriteToDevice)
/*
 * FUNCTION: flush any data remaining in the dma controller's memory into the host memory
 * ARGUMENTS:
 *     AdapterObject: the adapter object to flush
 *     Mdl: original MDL to flush data into
 *     MapRegisterBase: map register base that was just used by IoMapTransfer, etc
 *     CurrentVa: offset into Mdl to be flushed into, same as was passed to IoMapTransfer
 *     Length: length of the buffer to be flushed into
 *     WriteToDevice: True if it's a write, False if it's a read
 * RETURNS:
 *     TRUE in all cases
 * NOTES:
 *     - This copies data from the map register-backed buffer to the user's target buffer.
 *       Data is not in the user buffer until this is called.
 *     - This is only meaningful on a read operation.  Return immediately for a write.
 */
{
   111e0:	55                   	push   %ebp
   111e1:	89 e5                	mov    %esp,%ebp
   111e3:	57                   	push   %edi
   111e4:	56                   	push   %esi
   111e5:	53                   	push   %ebx
   111e6:	83 ec 0c             	sub    $0xc,%esp
   111e9:	8b 7d 10             	mov    0x10(%ebp),%edi
   111ec:	8b 55 08             	mov    0x8(%ebp),%edx
   111ef:	8b 75 0c             	mov    0xc(%ebp),%esi
   111f2:	8a 5d 1c             	mov    0x1c(%ebp),%bl
  ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
  
  /* this can happen if the card supports scatter/gather */
  if(!MapRegisterBase)
   111f5:	85 ff                	test   %edi,%edi
   111f7:	74 4f                	je     11248 <_IoFlushAdapterBuffers@24+0x68>
    return TRUE;

  /* mask out (disable) the dma channel */
  if (AdapterObject->AdapterNumber == 1) {
   111f9:	80 7a 51 01          	cmpb   $0x1,0x51(%edx)
   111fd:	74 58                	je     11257 <_IoFlushAdapterBuffers@24+0x77>
  
  		/* Set this for Ease */
  		PDMA1_CONTROL DmaControl1 = AdapterObject->AdapterBaseVa;
	
		/* Set Channel */
		WRITE_PORT_UCHAR(&DmaControl1->SingleMask, AdapterObject->ChannelNumber | DMA_SETMASK);
  } else {
  		/* Set this for Ease */
  		PDMA2_CONTROL DmaControl2 = AdapterObject->AdapterBaseVa;
	
		/* Set Channel */
		WRITE_PORT_UCHAR(&DmaControl2->SingleMask, (AdapterObject->ChannelNumber - 4) | DMA_SETMASK);
   111ff:	51                   	push   %ecx
   11200:	51                   	push   %ecx
   11201:	8a 42 50             	mov    0x50(%edx),%al
   11204:	83 e8 04             	sub    $0x4,%eax
   11207:	83 c8 04             	or     $0x4,%eax
   1120a:	25 ff 00 00 00       	and    $0xff,%eax
   1120f:	50                   	push   %eax
   11210:	8b 42 10             	mov    0x10(%edx),%eax
   11213:	83 c0 14             	add    $0x14,%eax
   11216:	50                   	push   %eax
   11217:	e8 74 39 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
  }
  
  if(WriteToDevice)
   1121c:	84 db                	test   %bl,%bl
   1121e:	58                   	pop    %eax
   1121f:	5a                   	pop    %edx
   11220:	75 26                	jne    11248 <_IoFlushAdapterBuffers@24+0x68>
    return TRUE;
    
  memcpy( 
   11222:	8b 5e 18             	mov    0x18(%esi),%ebx
   11225:	8b 4e 10             	mov    0x10(%esi),%ecx
   11228:	66 8b 46 06          	mov    0x6(%esi),%ax
   1122c:	01 cb                	add    %ecx,%ebx
   1122e:	a8 05                	test   $0x5,%al
   11230:	74 3e                	je     11270 <_IoFlushAdapterBuffers@24+0x90>
   11232:	8b 45 14             	mov    0x14(%ebp),%eax
   11235:	8b 56 0c             	mov    0xc(%esi),%edx
   11238:	01 d0                	add    %edx,%eax
   1123a:	29 d8                	sub    %ebx,%eax
   1123c:	8b 55 18             	mov    0x18(%ebp),%edx
   1123f:	51                   	push   %ecx
   11240:	52                   	push   %edx
   11241:	57                   	push   %edi
   11242:	50                   	push   %eax
   11243:	e8 38 96 00 00       	call   1a880 <_memcpy>
        (PVOID)((DWORD)MmGetSystemAddressForMdl( Mdl ) + (DWORD)CurrentVa - (DWORD)MmGetMdlVirtualAddress( Mdl )), 
      MapRegisterBase, Length );

  return TRUE;
}
   11248:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1124b:	b8 01 00 00 00       	mov    $0x1,%eax
   11250:	5b                   	pop    %ebx
   11251:	5e                   	pop    %esi
   11252:	5f                   	pop    %edi
   11253:	5d                   	pop    %ebp
   11254:	c2 18 00             	ret    $0x18
   11257:	50                   	push   %eax
   11258:	50                   	push   %eax
   11259:	8a 42 50             	mov    0x50(%edx),%al
   1125c:	83 c8 04             	or     $0x4,%eax
   1125f:	25 ff 00 00 00       	and    $0xff,%eax
   11264:	50                   	push   %eax
   11265:	8b 42 10             	mov    0x10(%edx),%eax
   11268:	83 c0 0a             	add    $0xa,%eax
   1126b:	eb a9                	jmp    11216 <_IoFlushAdapterBuffers@24+0x36>
   1126d:	8d 76 00             	lea    0x0(%esi),%esi
   11270:	50                   	push   %eax
   11271:	50                   	push   %eax
   11272:	6a 00                	push   $0x0
   11274:	56                   	push   %esi
   11275:	e8 96 95 00 00       	call   1a810 <_MmMapLockedPages@8>
   1127a:	8b 75 14             	mov    0x14(%ebp),%esi
   1127d:	5a                   	pop    %edx
   1127e:	01 f0                	add    %esi,%eax
   11280:	59                   	pop    %ecx
   11281:	eb b7                	jmp    1123a <_IoFlushAdapterBuffers@24+0x5a>
   11283:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11289:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011290 <_IoFreeMapRegisters@12>:


VOID STDCALL
IoFreeAdapterChannel (PADAPTER_OBJECT	AdapterObject)
/*
 * FUNCTION: frees DMA resources allocated by IoAllocateAdapterChannel
 * ARGUMENTS:
 *     AdapterObject: Adapter object with resources to free
 * NOTES:
 *     - This function releases the DMA adapter and optionally the map registers
 *     - After releasing the adapter, it checks the adapter's queue and runs
 *       each queued device object in series until the queue is empty
 *     - This is the only way the device queue is emptied.
 */
{
  LARGE_INTEGER MaxAddress;
  LARGE_INTEGER MinAddress;
  LARGE_INTEGER BoundryAddressMultiple;
  PWAIT_CONTEXT_BLOCK WaitContextBlock;
  IO_ALLOCATION_ACTION Retval;

  while(1)
    {
      /* To keep map registers, call here with the following set to 0 */
      if(AdapterObject->CommittedMapRegisters)
        IoFreeMapRegisters(AdapterObject, AdapterObject->MapRegisterBase, AdapterObject->CommittedMapRegisters);

      if(!(WaitContextBlock = (PWAIT_CONTEXT_BLOCK)KeRemoveDeviceQueue(&AdapterObject->ChannelWaitQueue)))
        break;

      /*
       * the following should really be done elsewhere since this
       * function really can't return an error code.  FIXME.
       */

      /* 24-bit max address due to 16-bit dma controllers */
      MinAddress.QuadPart = 0x0000000;
      MaxAddress.QuadPart = 0x1000000;
      BoundryAddressMultiple.QuadPart = 0;

      AdapterObject->MapRegisterBase = MmAllocateContiguousAlignedMemory( 
          WaitContextBlock->NumberOfMapRegisters * PAGE_SIZE,
          MinAddress,
          MaxAddress,
          BoundryAddressMultiple,
          MmCached,
          0x10000 );

      if(!AdapterObject->MapRegisterBase)
        return;

      /* call the adapter control routine */
      Retval = ((PDRIVER_CONTROL)WaitContextBlock->DeviceRoutine)(WaitContextBlock->DeviceObject, WaitContextBlock->CurrentIrp,
          AdapterObject->MapRegisterBase, WaitContextBlock->DeviceContext);

      if(Retval == KeepObject)
        {
          /* we're done until the caller manually calls IoFreeAdapterChannel */
          break;
        }
      else if(Retval == DeallocateObjectKeepRegisters)
        {
          /* hide the map registers so they aren't deallocated next time around */
          AdapterObject->CommittedMapRegisters = 0;
        }
    }
}


VOID STDCALL
IoFreeMapRegisters (
  IN PADAPTER_OBJECT	AdapterObject,
  IN PVOID		MapRegisterBase,
  IN ULONG		NumberOfMapRegisters)
/*
 * FUNCTION: free map registers reserved by the system for a DMA
 * ARGUMENTS:
 *     AdapterObject: dma adapter to free map registers on
 *     MapRegisterBase: hadle to map registers to free
 *     NumberOfRegisters: number of map registers to be freed
 * NOTES:
 *     - XXX real windows has a funky interdependence between IoFreeMapRegisters 
 *       and IoFreeAdapterChannel 
 * BUGS:
 *     - needs to be improved to use a real map register implementation
 */
{
   11290:	55                   	push   %ebp
   11291:	89 e5                	mov    %esp,%ebp
   11293:	53                   	push   %ebx
   11294:	50                   	push   %eax
   11295:	8b 5d 08             	mov    0x8(%ebp),%ebx
  if( AdapterObject->CommittedMapRegisters )
   11298:	8b 43 1c             	mov    0x1c(%ebx),%eax
   1129b:	85 c0                	test   %eax,%eax
   1129d:	75 07                	jne    112a6 <_IoFreeMapRegisters@12+0x16>
    {
      MmFreeContiguousMemory(AdapterObject->MapRegisterBase);
      AdapterObject->MapRegisterBase = 0;
    }
}
   1129f:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   112a2:	c9                   	leave  
   112a3:	c2 0c 00             	ret    $0xc
   112a6:	83 ec 0c             	sub    $0xc,%esp
   112a9:	8b 43 14             	mov    0x14(%ebx),%eax
   112ac:	50                   	push   %eax
   112ad:	e8 6e 95 00 00       	call   1a820 <_MmFreeContiguousMemory@4>
   112b2:	c7 43 14 00 00 00 00 	movl   $0x0,0x14(%ebx)
   112b9:	83 c4 0c             	add    $0xc,%esp
   112bc:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   112bf:	c9                   	leave  
   112c0:	c2 0c 00             	ret    $0xc
   112c3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   112c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000112d0 <_IoFreeAdapterChannel@4>:
   112d0:	55                   	push   %ebp
   112d1:	89 e5                	mov    %esp,%ebp
   112d3:	57                   	push   %edi
   112d4:	56                   	push   %esi
   112d5:	53                   	push   %ebx
   112d6:	83 ec 0c             	sub    $0xc,%esp
   112d9:	8b 75 08             	mov    0x8(%ebp),%esi
   112dc:	8d 7e 24             	lea    0x24(%esi),%edi
   112df:	90                   	nop    
   112e0:	8b 46 1c             	mov    0x1c(%esi),%eax
   112e3:	85 c0                	test   %eax,%eax
   112e5:	75 69                	jne    11350 <_IoFreeAdapterChannel@4+0x80>
   112e7:	83 ec 0c             	sub    $0xc,%esp
   112ea:	57                   	push   %edi
   112eb:	e8 40 95 00 00       	call   1a830 <_KeRemoveDeviceQueue@4>
   112f0:	83 c4 0c             	add    $0xc,%esp
   112f3:	89 c3                	mov    %eax,%ebx
   112f5:	85 c0                	test   %eax,%eax
   112f7:	74 76                	je     1136f <_IoFreeAdapterChannel@4+0x9f>
   112f9:	83 ec 0c             	sub    $0xc,%esp
   112fc:	68 00 00 01 00       	push   $0x10000
   11301:	6a 01                	push   $0x1
   11303:	6a 00                	push   $0x0
   11305:	6a 00                	push   $0x0
   11307:	6a 00                	push   $0x0
   11309:	68 00 00 00 01       	push   $0x1000000
   1130e:	6a 00                	push   $0x0
   11310:	6a 00                	push   $0x0
   11312:	8b 40 18             	mov    0x18(%eax),%eax
   11315:	c1 e0 0c             	shl    $0xc,%eax
   11318:	50                   	push   %eax
   11319:	e8 22 95 00 00       	call   1a840 <_MmAllocateContiguousAlignedMemory@36>
   1131e:	83 c4 0c             	add    $0xc,%esp
   11321:	85 c0                	test   %eax,%eax
   11323:	89 46 14             	mov    %eax,0x14(%esi)
   11326:	74 47                	je     1136f <_IoFreeAdapterChannel@4+0x9f>
   11328:	8b 53 14             	mov    0x14(%ebx),%edx
   1132b:	52                   	push   %edx
   1132c:	50                   	push   %eax
   1132d:	8b 43 20             	mov    0x20(%ebx),%eax
   11330:	50                   	push   %eax
   11331:	8b 43 1c             	mov    0x1c(%ebx),%eax
   11334:	50                   	push   %eax
   11335:	ff 53 10             	call   *0x10(%ebx)
   11338:	83 f8 01             	cmp    $0x1,%eax
   1133b:	74 32                	je     1136f <_IoFreeAdapterChannel@4+0x9f>
   1133d:	83 f8 03             	cmp    $0x3,%eax
   11340:	75 9e                	jne    112e0 <_IoFreeAdapterChannel@4+0x10>
   11342:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   11349:	8b 46 1c             	mov    0x1c(%esi),%eax
   1134c:	85 c0                	test   %eax,%eax
   1134e:	74 97                	je     112e7 <_IoFreeAdapterChannel@4+0x17>
   11350:	52                   	push   %edx
   11351:	50                   	push   %eax
   11352:	8b 5e 14             	mov    0x14(%esi),%ebx
   11355:	53                   	push   %ebx
   11356:	56                   	push   %esi
   11357:	e8 34 ff ff ff       	call   11290 <_IoFreeMapRegisters@12>
   1135c:	59                   	pop    %ecx
   1135d:	83 ec 0c             	sub    $0xc,%esp
   11360:	57                   	push   %edi
   11361:	e8 ca 94 00 00       	call   1a830 <_KeRemoveDeviceQueue@4>
   11366:	83 c4 0c             	add    $0xc,%esp
   11369:	89 c3                	mov    %eax,%ebx
   1136b:	85 c0                	test   %eax,%eax
   1136d:	75 8a                	jne    112f9 <_IoFreeAdapterChannel@4+0x29>
   1136f:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11372:	5b                   	pop    %ebx
   11373:	5e                   	pop    %esi
   11374:	5f                   	pop    %edi
   11375:	5d                   	pop    %ebp
   11376:	c2 04 00             	ret    $0x4
   11379:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011380 <_HalAllocateAdapterChannel@16>:
   11380:	55                   	push   %ebp
   11381:	89 e5                	mov    %esp,%ebp
   11383:	57                   	push   %edi
   11384:	56                   	push   %esi
   11385:	53                   	push   %ebx
   11386:	83 ec 14             	sub    $0x14,%esp
   11389:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   1138c:	8b 7d 08             	mov    0x8(%ebp),%edi
   1138f:	8b 45 14             	mov    0x14(%ebp),%eax
   11392:	8b 75 10             	mov    0x10(%ebp),%esi
   11395:	89 43 10             	mov    %eax,0x10(%ebx)
   11398:	89 73 18             	mov    %esi,0x18(%ebx)
   1139b:	8d 47 24             	lea    0x24(%edi),%eax
   1139e:	53                   	push   %ebx
   1139f:	50                   	push   %eax
   113a0:	e8 ab 94 00 00       	call   1a850 <_KeInsertDeviceQueue@8>
   113a5:	59                   	pop    %ecx
   113a6:	5a                   	pop    %edx
   113a7:	31 d2                	xor    %edx,%edx
   113a9:	84 c0                	test   %al,%al
   113ab:	74 13                	je     113c0 <_HalAllocateAdapterChannel@16+0x40>
   113ad:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   113b0:	89 d0                	mov    %edx,%eax
   113b2:	5b                   	pop    %ebx
   113b3:	5e                   	pop    %esi
   113b4:	5f                   	pop    %edi
   113b5:	5d                   	pop    %ebp
   113b6:	c2 10 00             	ret    $0x10
   113b9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   113c0:	83 ec 0c             	sub    $0xc,%esp
   113c3:	89 f0                	mov    %esi,%eax
   113c5:	c1 e0 0c             	shl    $0xc,%eax
   113c8:	68 00 00 01 00       	push   $0x10000
   113cd:	6a 01                	push   $0x1
   113cf:	6a 00                	push   $0x0
   113d1:	6a 00                	push   $0x0
   113d3:	6a 00                	push   $0x0
   113d5:	68 00 00 00 01       	push   $0x1000000
   113da:	6a 00                	push   $0x0
   113dc:	6a 00                	push   $0x0
   113de:	50                   	push   %eax
   113df:	e8 5c 94 00 00       	call   1a840 <_MmAllocateContiguousAlignedMemory@36>
   113e4:	ba 9a 00 00 c0       	mov    $0xc000009a,%edx
   113e9:	83 c4 0c             	add    $0xc,%esp
   113ec:	89 47 14             	mov    %eax,0x14(%edi)
   113ef:	85 c0                	test   %eax,%eax
   113f1:	74 ba                	je     113ad <_HalAllocateAdapterChannel@16+0x2d>
   113f3:	8b 53 14             	mov    0x14(%ebx),%edx
   113f6:	89 77 1c             	mov    %esi,0x1c(%edi)
   113f9:	52                   	push   %edx
   113fa:	50                   	push   %eax
   113fb:	8b 73 20             	mov    0x20(%ebx),%esi
   113fe:	56                   	push   %esi
   113ff:	8b 4b 1c             	mov    0x1c(%ebx),%ecx
   11402:	51                   	push   %ecx
   11403:	ff 55 14             	call   *0x14(%ebp)
   11406:	83 f8 02             	cmp    $0x2,%eax
   11409:	74 1a                	je     11425 <_HalAllocateAdapterChannel@16+0xa5>
   1140b:	83 f8 03             	cmp    $0x3,%eax
   1140e:	74 0e                	je     1141e <_HalAllocateAdapterChannel@16+0x9e>
   11410:	31 d2                	xor    %edx,%edx
   11412:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11415:	89 d0                	mov    %edx,%eax
   11417:	5b                   	pop    %ebx
   11418:	5e                   	pop    %esi
   11419:	5f                   	pop    %edi
   1141a:	5d                   	pop    %ebp
   1141b:	c2 10 00             	ret    $0x10
   1141e:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
   11425:	83 ec 0c             	sub    $0xc,%esp
   11428:	57                   	push   %edi
   11429:	e8 a2 fe ff ff       	call   112d0 <_IoFreeAdapterChannel@4>
   1142e:	31 d2                	xor    %edx,%edx
   11430:	83 c4 0c             	add    $0xc,%esp
   11433:	eb dd                	jmp    11412 <_HalAllocateAdapterChannel@16+0x92>
   11435:	8d 74 26 00          	lea    0x0(%esi),%esi
   11439:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011440 <_IoMapTransfer@24>:


PHYSICAL_ADDRESS  STDCALL
IoMapTransfer (
  IN PADAPTER_OBJECT	AdapterObject,
  IN PMDL		Mdl,
  IN PVOID		MapRegisterBase,
  IN PVOID		CurrentVa,
  IN OUT PULONG		Length,
  IN BOOLEAN		WriteToDevice)
/*
 * FUNCTION: map a dma for transfer and do the dma if it's a slave
 * ARGUMENTS:
 *     AdapterObject: adapter object to do the dma on. busmaster may pass NULL.
 *     Mdl: locked-down user buffer to DMA in to or out of
 *     MapRegisterBase: handle to map registers to use for this dma. allways NULL
 *      when doing s/g.
 *     CurrentVa: index into Mdl to transfer into/out of
 *     Length: length of transfer in/out. Only modified on out when doing s/g.
 *     WriteToDevice: TRUE if it's an output dma, FALSE otherwise
 * RETURNS: 
 *     If a busmaster: A logical address that can be used to program a dma controller
 *     Otherwise: nothing meaningful
 * NOTES:
 *     - This function does a copyover to contiguous memory <16MB
 *     - If it's a slave transfer, this function actually performs it.
 * BUGS:
 *     - If the controller supports scatter/gather, the copyover should not happen
 */
{
   11440:	55                   	push   %ebp
   11441:	89 e5                	mov    %esp,%ebp
   11443:	57                   	push   %edi
   11444:	56                   	push   %esi
   11445:	53                   	push   %ebx
   11446:	83 ec 2c             	sub    $0x2c,%esp
  PHYSICAL_ADDRESS Address;
  KIRQL OldIrql;
  ULONG LengthShift = 0;
   11449:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   11450:	8a 45 1c             	mov    0x1c(%ebp),%al

  Address.QuadPart = 0;

  /* Isa System (slave) DMA? */
  if (MapRegisterBase && !AdapterObject->MasterDevice)
   11453:	8b 75 10             	mov    0x10(%ebp),%esi
   11456:	8b 7d 08             	mov    0x8(%ebp),%edi
   11459:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   1145c:	88 45 ee             	mov    %al,0xffffffee(%ebp)
   1145f:	85 f6                	test   %esi,%esi
   11461:	74 0a                	je     1146d <_IoMapTransfer@24+0x2d>
   11463:	80 7f 56 00          	cmpb   $0x0,0x56(%edi)
   11467:	0f 84 25 01 00 00    	je     11592 <_IoMapTransfer@24+0x152>
  {
    KeAcquireSpinLock(&AdapterObject->SpinLock, &OldIrql);

    /*
     * FIXME: Handle case when doing common-buffer System DMA. In this case,
     * the buffer described by MDL is already phys. contiguous and below
     * 16 mega. Driver makes a one-shot call to IoMapTransfer during init.
     * to program controller with the common-buffer.
     *
     * UPDATE: Common buffer support is in place, but it's not done in a
     * clean way. We use the buffer passed by the MDL in case that the
     * adapter object is marked as auto initialize. I'm not sure if this
     * is correct and if not, how to do it properly. Note that it's also
     * possible to allocate the common buffer with different adapter object
     * and IoMapTransfer must still work in this case. Eventually this should
     * be cleaned up somehow or at least this comment modified to reflect
     * the reality.
     * -- Filip Navara, 19/07/2004     
     */

    /* if it is a write to the device, copy the caller buffer to the low buffer */
    if (WriteToDevice && !AdapterObject->AdapterMode.AutoInitialize)
    {
      memcpy(MapRegisterBase,
             (char*)MmGetSystemAddressForMdl(Mdl) + ((ULONG)CurrentVa - (ULONG)MmGetMdlVirtualAddress(Mdl)),
	           *Length );
    }

    /* Writer Adapter Mode, transfer type */
    AdapterObject->AdapterMode.TransferType = (WriteToDevice ? WRITE_TRANSFER : READ_TRANSFER);

    /* program up the dma controller, and return */
    if (!AdapterObject->AdapterMode.AutoInitialize) {
      Address = MmGetPhysicalAddress( MapRegisterBase );
    } else {
      Address = MmGetPhysicalAddress( CurrentVa );
    }
    
    /* 16-bit DMA has a shifted length */
    if (AdapterObject->Width16Bits) {
      LengthShift = 1;
    }
     
    /* Make the Transfer */
    if (AdapterObject->AdapterNumber == 1) {
    
    	PDMA1_CONTROL DmaControl1 = AdapterObject->AdapterBaseVa; /* For Writing Less Code */
    	
	/* Mask the Channel */
	WRITE_PORT_UCHAR(&DmaControl1->SingleMask, AdapterObject->ChannelNumber | DMA_SETMASK);

	/* Reset Register */
	WRITE_PORT_UCHAR(&DmaControl1->ClearBytePointer, 0);
	
	/* Set the Mode */
	WRITE_PORT_UCHAR(&DmaControl1->Mode, AdapterObject->AdapterModeByte);
	
	/* Set the Page Register */
	WRITE_PORT_UCHAR(AdapterObject->PagePort, (UCHAR)(Address.u.LowPart >> 16));

	/* Set the Offset Register (apparently always 0 for us if I trust the previous comment) */
	WRITE_PORT_UCHAR(&DmaControl1->DmaAddressCount[AdapterObject->ChannelNumber].DmaBaseAddress, 0);
	WRITE_PORT_UCHAR(&DmaControl1->DmaAddressCount[AdapterObject->ChannelNumber].DmaBaseAddress, 0);
	
	/* Set the Length */
 	WRITE_PORT_UCHAR(&DmaControl1->DmaAddressCount[AdapterObject->ChannelNumber].DmaBaseCount,
			(UCHAR)((*Length >> LengthShift) - 1));
	WRITE_PORT_UCHAR(&DmaControl1->DmaAddressCount[AdapterObject->ChannelNumber].DmaBaseCount,
			(UCHAR)(((*Length >> LengthShift) - 1) >> 8));
			
	/* Unmask the Channel */
	WRITE_PORT_UCHAR(&DmaControl1->SingleMask, AdapterObject->ChannelNumber | DMA_CLEARMASK);
    } else {
        PDMA2_CONTROL DmaControl2 = AdapterObject->AdapterBaseVa; /* For Writing Less Code */
    	
	/* Mask the Channel */
	WRITE_PORT_UCHAR(&DmaControl2->SingleMask, AdapterObject->ChannelNumber | DMA_SETMASK);

	/* Reset Register */
	WRITE_PORT_UCHAR(&DmaControl2->ClearBytePointer, 0);
	
	/* Set the Mode */
	WRITE_PORT_UCHAR(&DmaControl2->Mode, AdapterObject->AdapterModeByte);
	
	/* Set the Page Register */
	WRITE_PORT_UCHAR(AdapterObject->PagePort, (UCHAR)(Address.u.LowPart >> 16));

	/* Set the Offset Register (apparently always 0 for us if I trust the previous comment) */
	WRITE_PORT_UCHAR(&DmaControl2->DmaAddressCount[AdapterObject->ChannelNumber].DmaBaseAddress, 0);
	WRITE_PORT_UCHAR(&DmaControl2->DmaAddressCount[AdapterObject->ChannelNumber].DmaBaseAddress, 0);
	
	/* Set the Length */
 	WRITE_PORT_UCHAR(&DmaControl2->DmaAddressCount[AdapterObject->ChannelNumber].DmaBaseCount,
			(UCHAR)((*Length >> LengthShift) - 1));
	WRITE_PORT_UCHAR(&DmaControl2->DmaAddressCount[AdapterObject->ChannelNumber].DmaBaseCount,
			(UCHAR)(((*Length >> LengthShift) - 1) >> 8));
			
	/* Unmask the Channel */
	WRITE_PORT_UCHAR(&DmaControl2->SingleMask, AdapterObject->ChannelNumber | DMA_CLEARMASK);
    }
	
    /* Release Spinlock */
    KeReleaseSpinLock(&AdapterObject->SpinLock, OldIrql);

    /* 
    NOTE: Return value should be ignored when doing System DMA.
    Maybe return some more obvious invalid address here (thou returning 
    MapRegisterBase is also wrong;-)to catch invalid use?
    */
    Address.QuadPart = (ULONG)MapRegisterBase;
    return Address;
  }
  

  /* 
  Busmaster with s/g support?   
  NOTE: old docs allowed busmasters to pass a NULL Adapter. In this case, MapRegisterBase 
  being NULL is used to detect a s/g busmaster.
  */
  if ((!AdapterObject && !MapRegisterBase) ||
   1146d:	8b 45 10             	mov    0x10(%ebp),%eax
   11470:	85 ff                	test   %edi,%edi
   11472:	0f 94 c2             	sete   %dl
   11475:	85 c0                	test   %eax,%eax
   11477:	0f 94 c0             	sete   %al
   1147a:	25 ff 00 00 00       	and    $0xff,%eax
   1147f:	85 c2                	test   %eax,%edx
   11481:	0f 84 7d 00 00 00    	je     11504 <_IoMapTransfer@24+0xc4>
      (AdapterObject && AdapterObject->MasterDevice && AdapterObject->ScatterGather))
  {
    /* 
    Just return the passed VA's corresponding phys. address. 
    Update length to the number of phys. contiguous bytes found.
    */
  
    PULONG MdlPages;
    ULONG MdlPageIndex, PhysContiguousLen;
    ULONG PhysAddress;
    
    MdlPages = (PULONG)(Mdl + 1);
    
    /* Get VA's corresponding mdl phys. page index */
    MdlPageIndex = ((ULONG)CurrentVa - (ULONG)Mdl->StartVa) / PAGE_SIZE;
   11487:	8b 73 10             	mov    0x10(%ebx),%esi
   1148a:	8b 55 14             	mov    0x14(%ebp),%edx
   1148d:	29 f2                	sub    %esi,%edx
   1148f:	8d 7b 1c             	lea    0x1c(%ebx),%edi
   11492:	c1 ea 0c             	shr    $0xc,%edx
   
    /* Get phys. page containing the VA */
    PhysAddress = MdlPages[MdlPageIndex];
    
    PhysContiguousLen = PAGE_SIZE - BYTE_OFFSET(CurrentVa);
    
    /* VA to map may span several contiguous phys. pages (unlikely) */
    while (PhysContiguousLen < *Length &&
           MdlPages[MdlPageIndex++] + PAGE_SIZE == MdlPages[MdlPageIndex])
    {
      /* 
      Note that allways adding PAGE_SIZE may make PhysContiguousLen greater
      than Length if buffer doesn't end on page boundary. Take this
      into consideration below. 
      */
      PhysContiguousLen += PAGE_SIZE; 
   11495:	8b 4d 18             	mov    0x18(%ebp),%ecx
   11498:	bb 00 10 00 00       	mov    $0x1000,%ebx
   1149d:	8b 04 97             	mov    (%edi,%edx,4),%eax
   114a0:	8b 31                	mov    (%ecx),%esi
   114a2:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   114a5:	8b 45 14             	mov    0x14(%ebp),%eax
   114a8:	25 ff 0f 00 00       	and    $0xfff,%eax
   114ad:	29 c3                	sub    %eax,%ebx
   114af:	39 de                	cmp    %ebx,%esi
   114b1:	76 31                	jbe    114e4 <_IoMapTransfer@24+0xa4>
   114b3:	42                   	inc    %edx
   114b4:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   114b7:	05 00 10 00 00       	add    $0x1000,%eax
   114bc:	8b 0c 97             	mov    (%edi,%edx,4),%ecx
   114bf:	39 c8                	cmp    %ecx,%eax
   114c1:	75 18                	jne    114db <_IoMapTransfer@24+0x9b>
   114c3:	81 c3 00 10 00 00    	add    $0x1000,%ebx
   114c9:	39 de                	cmp    %ebx,%esi
   114cb:	76 17                	jbe    114e4 <_IoMapTransfer@24+0xa4>
   114cd:	8d 81 00 10 00 00    	lea    0x1000(%ecx),%eax
   114d3:	42                   	inc    %edx
   114d4:	8b 0c 97             	mov    (%edi,%edx,4),%ecx
   114d7:	39 c8                	cmp    %ecx,%eax
   114d9:	74 e8                	je     114c3 <_IoMapTransfer@24+0x83>
    }
    
    if (PhysContiguousLen < *Length)
   114db:	39 de                	cmp    %ebx,%esi
   114dd:	76 05                	jbe    114e4 <_IoMapTransfer@24+0xa4>
    {
      *Length = PhysContiguousLen;
   114df:	8b 45 18             	mov    0x18(%ebp),%eax
   114e2:	89 18                	mov    %ebx,(%eax)
    }
    
    //add offset to phys. page address
    Address.QuadPart = PhysAddress + BYTE_OFFSET(CurrentVa);
   114e4:	8b 4d 14             	mov    0x14(%ebp),%ecx
   114e7:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   114ea:	81 e1 ff 0f 00 00    	and    $0xfff,%ecx
   114f0:	89 4d 14             	mov    %ecx,0x14(%ebp)
   114f3:	8b 45 14             	mov    0x14(%ebp),%eax
   114f6:	01 d0                	add    %edx,%eax
    return Address;
  }
  
  
  /* 
  Busmaster without s/g support? 
  NOTE: old docs allowed busmasters to pass a NULL Adapter. In this case, MapRegisterBase 
  not being NULL is used to detect a non s/g busmaster.
  */
  if ((!AdapterObject && MapRegisterBase) ||
      (AdapterObject && AdapterObject->MasterDevice && !AdapterObject->ScatterGather))
  {
    /*
    NOTE: Busmasters doing common-buffer DMA shouldn't call IoMapTransfer, but I don't
    know if it's illegal... Maybe figure out what to do in this case...
    */

    if( WriteToDevice )
    {
      memcpy(MapRegisterBase,
             (char*)MmGetSystemAddressForMdl(Mdl) + ((ULONG)CurrentVa - (ULONG)MmGetMdlVirtualAddress(Mdl)),
             *Length );
    }

    return MmGetPhysicalAddress(MapRegisterBase);
  }

  DPRINT("IoMapTransfer: Unsupported operation\n");
  KEBUGCHECK(0);
  return Address;
}
   114f8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   114fb:	31 d2                	xor    %edx,%edx
   114fd:	5b                   	pop    %ebx
   114fe:	5e                   	pop    %esi
   114ff:	5f                   	pop    %edi
   11500:	5d                   	pop    %ebp
   11501:	c2 18 00             	ret    $0x18
   11504:	85 ff                	test   %edi,%edi
   11506:	74 0a                	je     11512 <_IoMapTransfer@24+0xd2>
   11508:	80 7f 56 00          	cmpb   $0x0,0x56(%edi)
   1150c:	0f 85 ee 01 00 00    	jne    11700 <_IoMapTransfer@24+0x2c0>
   11512:	8b 45 10             	mov    0x10(%ebp),%eax
   11515:	85 ff                	test   %edi,%edi
   11517:	0f 94 c2             	sete   %dl
   1151a:	85 c0                	test   %eax,%eax
   1151c:	0f 95 c0             	setne  %al
   1151f:	25 ff 00 00 00       	and    $0xff,%eax
   11524:	85 c2                	test   %eax,%edx
   11526:	75 1c                	jne    11544 <_IoMapTransfer@24+0x104>
   11528:	85 ff                	test   %edi,%edi
   1152a:	0f 84 a0 02 00 00    	je     117d0 <_IoMapTransfer@24+0x390>
   11530:	80 7f 56 00          	cmpb   $0x0,0x56(%edi)
   11534:	0f 84 96 02 00 00    	je     117d0 <_IoMapTransfer@24+0x390>
   1153a:	80 7f 58 00          	cmpb   $0x0,0x58(%edi)
   1153e:	0f 85 8c 02 00 00    	jne    117d0 <_IoMapTransfer@24+0x390>
   11544:	80 7d ee 00          	cmpb   $0x0,0xffffffee(%ebp)
   11548:	74 32                	je     1157c <_IoMapTransfer@24+0x13c>
   1154a:	8b 43 10             	mov    0x10(%ebx),%eax
   1154d:	8b 75 14             	mov    0x14(%ebp),%esi
   11550:	29 c6                	sub    %eax,%esi
   11552:	8b 43 18             	mov    0x18(%ebx),%eax
   11555:	29 c6                	sub    %eax,%esi
   11557:	66 8b 43 06          	mov    0x6(%ebx),%ax
   1155b:	a8 05                	test   $0x5,%al
   1155d:	0f 84 a6 02 00 00    	je     11809 <_IoMapTransfer@24+0x3c9>
   11563:	8b 43 0c             	mov    0xc(%ebx),%eax
   11566:	52                   	push   %edx
   11567:	8b 55 18             	mov    0x18(%ebp),%edx
   1156a:	01 f0                	add    %esi,%eax
   1156c:	8b 3a                	mov    (%edx),%edi
   1156e:	57                   	push   %edi
   1156f:	50                   	push   %eax
   11570:	8b 75 10             	mov    0x10(%ebp),%esi
   11573:	56                   	push   %esi
   11574:	e8 07 93 00 00       	call   1a880 <_memcpy>
   11579:	83 c4 10             	add    $0x10,%esp
   1157c:	83 ec 0c             	sub    $0xc,%esp
   1157f:	8b 5d 10             	mov    0x10(%ebp),%ebx
   11582:	53                   	push   %ebx
   11583:	e8 d8 92 00 00       	call   1a860 <_MmGetPhysicalAddress@4>
   11588:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1158b:	5b                   	pop    %ebx
   1158c:	5e                   	pop    %esi
   1158d:	5f                   	pop    %edi
   1158e:	5d                   	pop    %ebp
   1158f:	c2 18 00             	ret    $0x18
   11592:	8d 57 44             	lea    0x44(%edi),%edx
   11595:	8d 45 ef             	lea    0xffffffef(%ebp),%eax
   11598:	51                   	push   %ecx
   11599:	51                   	push   %ecx
   1159a:	50                   	push   %eax
   1159b:	89 55 d4             	mov    %edx,0xffffffd4(%ebp)
   1159e:	52                   	push   %edx
   1159f:	e8 0c 37 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   115a4:	80 7d ee 00          	cmpb   $0x0,0xffffffee(%ebp)
   115a8:	58                   	pop    %eax
   115a9:	5a                   	pop    %edx
   115aa:	0f 84 60 01 00 00    	je     11710 <_IoMapTransfer@24+0x2d0>
   115b0:	8a 47 54             	mov    0x54(%edi),%al
   115b3:	a8 10                	test   $0x10,%al
   115b5:	75 35                	jne    115ec <_IoMapTransfer@24+0x1ac>
   115b7:	8b 43 10             	mov    0x10(%ebx),%eax
   115ba:	8b 75 14             	mov    0x14(%ebp),%esi
   115bd:	29 c6                	sub    %eax,%esi
   115bf:	8b 43 18             	mov    0x18(%ebx),%eax
   115c2:	29 c6                	sub    %eax,%esi
   115c4:	66 8b 43 06          	mov    0x6(%ebx),%ax
   115c8:	a8 05                	test   $0x5,%al
   115ca:	0f 84 28 02 00 00    	je     117f8 <_IoMapTransfer@24+0x3b8>
   115d0:	8b 43 0c             	mov    0xc(%ebx),%eax
   115d3:	52                   	push   %edx
   115d4:	8b 4d 18             	mov    0x18(%ebp),%ecx
   115d7:	01 f0                	add    %esi,%eax
   115d9:	8b 31                	mov    (%ecx),%esi
   115db:	56                   	push   %esi
   115dc:	50                   	push   %eax
   115dd:	8b 5d 10             	mov    0x10(%ebp),%ebx
   115e0:	53                   	push   %ebx
   115e1:	e8 9a 92 00 00       	call   1a880 <_memcpy>
   115e6:	83 c4 10             	add    $0x10,%esp
   115e9:	8a 47 54             	mov    0x54(%edi),%al
   115ec:	b2 02                	mov    $0x2,%dl
   115ee:	80 7d ee 00          	cmpb   $0x0,0xffffffee(%ebp)
   115f2:	75 02                	jne    115f6 <_IoMapTransfer@24+0x1b6>
   115f4:	b2 01                	mov    $0x1,%dl
   115f6:	c1 e2 02             	shl    $0x2,%edx
   115f9:	83 e0 f3             	and    $0xfffffff3,%eax
   115fc:	09 d0                	or     %edx,%eax
   115fe:	88 47 54             	mov    %al,0x54(%edi)
   11601:	a8 10                	test   $0x10,%al
   11603:	0f 85 0f 01 00 00    	jne    11718 <_IoMapTransfer@24+0x2d8>
   11609:	83 ec 0c             	sub    $0xc,%esp
   1160c:	8b 4d 10             	mov    0x10(%ebp),%ecx
   1160f:	51                   	push   %ecx
   11610:	e8 4b 92 00 00       	call   1a860 <_MmGetPhysicalAddress@4>
   11615:	83 c4 0c             	add    $0xc,%esp
   11618:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   1161b:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   1161e:	80 7f 57 00          	cmpb   $0x0,0x57(%edi)
   11622:	74 07                	je     1162b <_IoMapTransfer@24+0x1eb>
   11624:	c7 45 dc 01 00 00 00 	movl   $0x1,0xffffffdc(%ebp)
   1162b:	80 7f 51 01          	cmpb   $0x1,0x51(%edi)
   1162f:	0f 84 ef 00 00 00    	je     11724 <_IoMapTransfer@24+0x2e4>
   11635:	8b 5f 10             	mov    0x10(%edi),%ebx
   11638:	50                   	push   %eax
   11639:	50                   	push   %eax
   1163a:	8a 47 50             	mov    0x50(%edi),%al
   1163d:	8d 73 14             	lea    0x14(%ebx),%esi
   11640:	83 c8 04             	or     $0x4,%eax
   11643:	25 ff 00 00 00       	and    $0xff,%eax
   11648:	50                   	push   %eax
   11649:	56                   	push   %esi
   1164a:	e8 41 35 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1164f:	8d 43 18             	lea    0x18(%ebx),%eax
   11652:	6a 00                	push   $0x0
   11654:	50                   	push   %eax
   11655:	e8 36 35 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1165a:	31 c0                	xor    %eax,%eax
   1165c:	8a 47 54             	mov    0x54(%edi),%al
   1165f:	50                   	push   %eax
   11660:	8d 43 16             	lea    0x16(%ebx),%eax
   11663:	50                   	push   %eax
   11664:	e8 27 35 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   11669:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   1166c:	c1 e8 10             	shr    $0x10,%eax
   1166f:	25 ff 00 00 00       	and    $0xff,%eax
   11674:	50                   	push   %eax
   11675:	8b 47 4c             	mov    0x4c(%edi),%eax
   11678:	50                   	push   %eax
   11679:	e8 12 35 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1167e:	31 c0                	xor    %eax,%eax
   11680:	6a 00                	push   $0x0
   11682:	8a 47 50             	mov    0x50(%edi),%al
   11685:	8d 04 83             	lea    (%ebx,%eax,4),%eax
   11688:	50                   	push   %eax
   11689:	e8 02 35 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1168e:	31 c0                	xor    %eax,%eax
   11690:	6a 00                	push   $0x0
   11692:	8a 47 50             	mov    0x50(%edi),%al
   11695:	8d 04 83             	lea    (%ebx,%eax,4),%eax
   11698:	50                   	push   %eax
   11699:	e8 f2 34 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1169e:	8b 55 18             	mov    0x18(%ebp),%edx
   116a1:	8a 4d dc             	mov    0xffffffdc(%ebp),%cl
   116a4:	8b 02                	mov    (%edx),%eax
   116a6:	d3 e8                	shr    %cl,%eax
   116a8:	48                   	dec    %eax
   116a9:	25 ff 00 00 00       	and    $0xff,%eax
   116ae:	50                   	push   %eax
   116af:	31 c0                	xor    %eax,%eax
   116b1:	8a 47 50             	mov    0x50(%edi),%al
   116b4:	8d 44 83 02          	lea    0x2(%ebx,%eax,4),%eax
   116b8:	50                   	push   %eax
   116b9:	e8 d2 34 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   116be:	8b 55 18             	mov    0x18(%ebp),%edx
   116c1:	8a 4d dc             	mov    0xffffffdc(%ebp),%cl
   116c4:	8b 02                	mov    (%edx),%eax
   116c6:	d3 e8                	shr    %cl,%eax
   116c8:	48                   	dec    %eax
   116c9:	0f b6 c4             	movzbl %ah,%eax
   116cc:	50                   	push   %eax
   116cd:	31 c0                	xor    %eax,%eax
   116cf:	8a 47 50             	mov    0x50(%edi),%al
   116d2:	8d 44 83 02          	lea    0x2(%ebx,%eax,4),%eax
   116d6:	50                   	push   %eax
   116d7:	e8 b4 34 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   116dc:	31 c0                	xor    %eax,%eax
   116de:	8a 47 50             	mov    0x50(%edi),%al
   116e1:	50                   	push   %eax
   116e2:	56                   	push   %esi
   116e3:	e8 a8 34 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   116e8:	31 c0                	xor    %eax,%eax
   116ea:	8a 45 ef             	mov    0xffffffef(%ebp),%al
   116ed:	50                   	push   %eax
   116ee:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   116f1:	50                   	push   %eax
   116f2:	e8 29 36 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   116f7:	8b 45 10             	mov    0x10(%ebp),%eax
   116fa:	e9 f9 fd ff ff       	jmp    114f8 <_IoMapTransfer@24+0xb8>
   116ff:	90                   	nop    
   11700:	80 7f 58 00          	cmpb   $0x0,0x58(%edi)
   11704:	0f 84 08 fe ff ff    	je     11512 <_IoMapTransfer@24+0xd2>
   1170a:	e9 78 fd ff ff       	jmp    11487 <_IoMapTransfer@24+0x47>
   1170f:	90                   	nop    
   11710:	8a 47 54             	mov    0x54(%edi),%al
   11713:	e9 dc fe ff ff       	jmp    115f4 <_IoMapTransfer@24+0x1b4>
   11718:	83 ec 0c             	sub    $0xc,%esp
   1171b:	8b 55 14             	mov    0x14(%ebp),%edx
   1171e:	52                   	push   %edx
   1171f:	e9 ec fe ff ff       	jmp    11610 <_IoMapTransfer@24+0x1d0>
   11724:	8b 5f 10             	mov    0x10(%edi),%ebx
   11727:	50                   	push   %eax
   11728:	50                   	push   %eax
   11729:	8a 47 50             	mov    0x50(%edi),%al
   1172c:	8d 73 0a             	lea    0xa(%ebx),%esi
   1172f:	83 c8 04             	or     $0x4,%eax
   11732:	25 ff 00 00 00       	and    $0xff,%eax
   11737:	50                   	push   %eax
   11738:	56                   	push   %esi
   11739:	e8 52 34 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1173e:	8d 43 0c             	lea    0xc(%ebx),%eax
   11741:	6a 00                	push   $0x0
   11743:	50                   	push   %eax
   11744:	e8 47 34 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   11749:	31 c0                	xor    %eax,%eax
   1174b:	8a 47 54             	mov    0x54(%edi),%al
   1174e:	50                   	push   %eax
   1174f:	8d 43 0b             	lea    0xb(%ebx),%eax
   11752:	50                   	push   %eax
   11753:	e8 38 34 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   11758:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   1175b:	c1 e8 10             	shr    $0x10,%eax
   1175e:	25 ff 00 00 00       	and    $0xff,%eax
   11763:	50                   	push   %eax
   11764:	8b 47 4c             	mov    0x4c(%edi),%eax
   11767:	50                   	push   %eax
   11768:	e8 23 34 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1176d:	31 c0                	xor    %eax,%eax
   1176f:	6a 00                	push   $0x0
   11771:	8a 47 50             	mov    0x50(%edi),%al
   11774:	8d 04 43             	lea    (%ebx,%eax,2),%eax
   11777:	50                   	push   %eax
   11778:	e8 13 34 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1177d:	31 c0                	xor    %eax,%eax
   1177f:	6a 00                	push   $0x0
   11781:	8a 47 50             	mov    0x50(%edi),%al
   11784:	8d 04 43             	lea    (%ebx,%eax,2),%eax
   11787:	50                   	push   %eax
   11788:	e8 03 34 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1178d:	8b 55 18             	mov    0x18(%ebp),%edx
   11790:	8a 4d dc             	mov    0xffffffdc(%ebp),%cl
   11793:	8b 02                	mov    (%edx),%eax
   11795:	d3 e8                	shr    %cl,%eax
   11797:	48                   	dec    %eax
   11798:	25 ff 00 00 00       	and    $0xff,%eax
   1179d:	50                   	push   %eax
   1179e:	31 c0                	xor    %eax,%eax
   117a0:	8a 47 50             	mov    0x50(%edi),%al
   117a3:	8d 44 43 01          	lea    0x1(%ebx,%eax,2),%eax
   117a7:	50                   	push   %eax
   117a8:	e8 e3 33 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   117ad:	8b 55 18             	mov    0x18(%ebp),%edx
   117b0:	8a 4d dc             	mov    0xffffffdc(%ebp),%cl
   117b3:	8b 02                	mov    (%edx),%eax
   117b5:	d3 e8                	shr    %cl,%eax
   117b7:	48                   	dec    %eax
   117b8:	0f b6 c4             	movzbl %ah,%eax
   117bb:	50                   	push   %eax
   117bc:	31 c0                	xor    %eax,%eax
   117be:	8a 47 50             	mov    0x50(%edi),%al
   117c1:	8d 44 43 01          	lea    0x1(%ebx,%eax,2),%eax
   117c5:	e9 0c ff ff ff       	jmp    116d6 <_IoMapTransfer@24+0x296>
   117ca:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   117d0:	51                   	push   %ecx
   117d1:	68 a4 02 00 00       	push   $0x2a4
   117d6:	68 00 c0 01 00       	push   $0x1c000
   117db:	68 15 c0 01 00       	push   $0x1c015
   117e0:	e8 ab 90 00 00       	call   1a890 <_DbgPrint>
   117e5:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   117ec:	e8 7f 90 00 00       	call   1a870 <_KeBugCheck@4>
   117f1:	31 c0                	xor    %eax,%eax
   117f3:	e9 00 fd ff ff       	jmp    114f8 <_IoMapTransfer@24+0xb8>
   117f8:	50                   	push   %eax
   117f9:	50                   	push   %eax
   117fa:	6a 00                	push   $0x0
   117fc:	53                   	push   %ebx
   117fd:	e8 0e 90 00 00       	call   1a810 <_MmMapLockedPages@8>
   11802:	59                   	pop    %ecx
   11803:	5b                   	pop    %ebx
   11804:	e9 ca fd ff ff       	jmp    115d3 <_IoMapTransfer@24+0x193>
   11809:	57                   	push   %edi
   1180a:	57                   	push   %edi
   1180b:	6a 00                	push   $0x0
   1180d:	53                   	push   %ebx
   1180e:	e8 fd 8f 00 00       	call   1a810 <_MmMapLockedPages@8>
   11813:	59                   	pop    %ecx
   11814:	5b                   	pop    %ebx
   11815:	e9 4c fd ff ff       	jmp    11566 <_IoMapTransfer@24+0x126>
   1181a:	90                   	nop    
   1181b:	90                   	nop    
   1181c:	90                   	nop    
   1181d:	90                   	nop    
   1181e:	90                   	nop    
   1181f:	90                   	nop    

00011820 <_HalMakeBeep@4>:
   11820:	55                   	push   %ebp
   11821:	89 e5                	mov    %esp,%ebp
   11823:	56                   	push   %esi
   11824:	53                   	push   %ebx
   11825:	8b 5d 08             	mov    0x8(%ebp),%ebx
   11828:	9c                   	pushf  
   11829:	5e                   	pop    %esi
   1182a:	fa                   	cli    
   1182b:	83 ec 0c             	sub    $0xc,%esp
   1182e:	6a 61                	push   $0x61
   11830:	e8 ab 32 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   11835:	25 fc 00 00 00       	and    $0xfc,%eax
   1183a:	89 04 24             	mov    %eax,(%esp)
   1183d:	6a 61                	push   $0x61
   1183f:	e8 4c 33 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   11844:	85 db                	test   %ebx,%ebx
   11846:	58                   	pop    %eax
   11847:	5a                   	pop    %edx
   11848:	74 67                	je     118b1 <_HalMakeBeep@4+0x91>
   1184a:	31 d2                	xor    %edx,%edx
   1184c:	b8 cf 34 12 00       	mov    $0x1234cf,%eax
   11851:	f7 f3                	div    %ebx
   11853:	89 c3                	mov    %eax,%ebx
   11855:	3d 00 00 01 00       	cmp    $0x10000,%eax
   1185a:	76 14                	jbe    11870 <_HalMakeBeep@4+0x50>
   1185c:	56                   	push   %esi
   1185d:	9d                   	popf   
   1185e:	31 c0                	xor    %eax,%eax
   11860:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11863:	5b                   	pop    %ebx
   11864:	5e                   	pop    %esi
   11865:	5d                   	pop    %ebp
   11866:	c2 04 00             	ret    $0x4
   11869:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11870:	50                   	push   %eax
   11871:	50                   	push   %eax
   11872:	68 b6 00 00 00       	push   $0xb6
   11877:	6a 43                	push   $0x43
   11879:	e8 12 33 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1187e:	31 c0                	xor    %eax,%eax
   11880:	88 d8                	mov    %bl,%al
   11882:	50                   	push   %eax
   11883:	6a 42                	push   $0x42
   11885:	e8 06 33 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1188a:	0f b6 c7             	movzbl %bh,%eax
   1188d:	50                   	push   %eax
   1188e:	6a 42                	push   $0x42
   11890:	e8 fb 32 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   11895:	51                   	push   %ecx
   11896:	6a 61                	push   $0x61
   11898:	e8 43 32 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1189d:	83 c8 03             	or     $0x3,%eax
   118a0:	25 ff 00 00 00       	and    $0xff,%eax
   118a5:	89 04 24             	mov    %eax,(%esp)
   118a8:	6a 61                	push   $0x61
   118aa:	e8 e1 32 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   118af:	58                   	pop    %eax
   118b0:	5a                   	pop    %edx
   118b1:	56                   	push   %esi
   118b2:	9d                   	popf   
   118b3:	b8 01 00 00 00       	mov    $0x1,%eax
   118b8:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   118bb:	5b                   	pop    %ebx
   118bc:	5e                   	pop    %esi
   118bd:	5d                   	pop    %ebp
   118be:	c2 04 00             	ret    $0x4
   118c1:	90                   	nop    
   118c2:	90                   	nop    
   118c3:	90                   	nop    
   118c4:	90                   	nop    
   118c5:	90                   	nop    
   118c6:	90                   	nop    
   118c7:	90                   	nop    
   118c8:	90                   	nop    
   118c9:	90                   	nop    
   118ca:	90                   	nop    
   118cb:	90                   	nop    
   118cc:	90                   	nop    
   118cd:	90                   	nop    
   118ce:	90                   	nop    
   118cf:	90                   	nop    

000118d0 <_HalpNoAdjustResourceList@12>:
   118d0:	55                   	push   %ebp
   118d1:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   118d6:	89 e5                	mov    %esp,%ebp
   118d8:	5d                   	pop    %ebp
   118d9:	c2 0c 00             	ret    $0xc
   118dc:	8d 74 26 00          	lea    0x0(%esi),%esi

000118e0 <_HalpNoAssignSlotResources@32>:
   118e0:	55                   	push   %ebp
   118e1:	b8 bb 00 00 c0       	mov    $0xc00000bb,%eax
   118e6:	89 e5                	mov    %esp,%ebp
   118e8:	5d                   	pop    %ebp
   118e9:	c2 20 00             	ret    $0x20
   118ec:	8d 74 26 00          	lea    0x0(%esi),%esi

000118f0 <_HalpNoBusData@24>:
   118f0:	55                   	push   %ebp
   118f1:	31 c0                	xor    %eax,%eax
   118f3:	89 e5                	mov    %esp,%ebp
   118f5:	5d                   	pop    %ebp
   118f6:	c2 18 00             	ret    $0x18
   118f9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011900 <_HalpNoGetInterruptVector@24>:
   11900:	55                   	push   %ebp
   11901:	31 c0                	xor    %eax,%eax
   11903:	89 e5                	mov    %esp,%ebp
   11905:	5d                   	pop    %ebp
   11906:	c2 18 00             	ret    $0x18
   11909:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011910 <_HalpNoTranslateBusAddress@24>:
   11910:	55                   	push   %ebp
   11911:	31 c0                	xor    %eax,%eax
   11913:	89 e5                	mov    %esp,%ebp
   11915:	5d                   	pop    %ebp
   11916:	c2 18 00             	ret    $0x18
   11919:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011920 <_HalpAllocateBusHandler>:
   11920:	55                   	push   %ebp
   11921:	89 e5                	mov    %esp,%ebp
   11923:	53                   	push   %ebx
   11924:	50                   	push   %eax
   11925:	50                   	push   %eax
   11926:	68 42 55 53 48       	push   $0x48535542
   1192b:	6a 30                	push   $0x30
   1192d:	6a 00                	push   $0x0
   1192f:	e8 6c 8f 00 00       	call   1a8a0 <_ExAllocatePoolWithTag@12>
   11934:	89 c3                	mov    %eax,%ebx
   11936:	58                   	pop    %eax
   11937:	31 c0                	xor    %eax,%eax
   11939:	85 db                	test   %ebx,%ebx
   1193b:	74 60                	je     1199d <_HalpAllocateBusHandler+0x7d>
   1193d:	51                   	push   %ecx
   1193e:	51                   	push   %ecx
   1193f:	6a 30                	push   $0x30
   11941:	53                   	push   %ebx
   11942:	e8 49 8e 00 00       	call   1a790 <_RtlZeroMemory@8>
static __inline VOID
InsertTailList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   11947:	58                   	pop    %eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   11948:	a1 54 e5 03 00       	mov    0x3e554,%eax
   1194d:	5a                   	pop    %edx
	Entry->Flink = ListHead;
	Entry->Blink = OldBlink;
   1194e:	89 43 04             	mov    %eax,0x4(%ebx)
   11951:	c7 03 50 e5 03 00    	movl   $0x3e550,(%ebx)
	OldBlink->Flink = Entry;
   11957:	89 18                	mov    %ebx,(%eax)
   11959:	8b 45 08             	mov    0x8(%ebp),%eax
   1195c:	89 1d 54 e5 03 00    	mov    %ebx,0x3e554
   11962:	89 43 08             	mov    %eax,0x8(%ebx)
   11965:	8b 45 0c             	mov    0xc(%ebp),%eax
   11968:	89 43 0c             	mov    %eax,0xc(%ebx)
   1196b:	8b 45 10             	mov    0x10(%ebp),%eax
   1196e:	89 43 10             	mov    %eax,0x10(%ebx)
   11971:	c7 43 18 f0 18 01 00 	movl   $0x118f0,0x18(%ebx)
   11978:	c7 43 1c f0 18 01 00 	movl   $0x118f0,0x1c(%ebx)
   1197f:	c7 43 20 d0 18 01 00 	movl   $0x118d0,0x20(%ebx)
   11986:	c7 43 24 e0 18 01 00 	movl   $0x118e0,0x24(%ebx)
   1198d:	c7 43 28 00 19 01 00 	movl   $0x11900,0x28(%ebx)
   11994:	c7 43 2c 10 19 01 00 	movl   $0x11910,0x2c(%ebx)
   1199b:	89 d8                	mov    %ebx,%eax
   1199d:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   119a0:	c9                   	leave  
   119a1:	c3                   	ret    
   119a2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   119a9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000119b0 <_HalpInitBusHandlers>:
   119b0:	55                   	push   %ebp
   119b1:	89 e5                	mov    %esp,%ebp
   119b3:	83 ec 14             	sub    $0x14,%esp
   119b6:	68 00 e0 01 00       	push   $0x1e000
   119bb:	e8 10 8e 00 00       	call   1a7d0 <_KeInitializeSpinLock@4>
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   119c0:	58                   	pop    %eax
   119c1:	a1 10 11 04 00       	mov    0x41110,%eax
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   119c6:	5a                   	pop    %edx
	ListHead->Flink = ListHead->Blink = ListHead;
   119c7:	c7 05 54 e5 03 00 50 	movl   $0x3e550,0x3e554
   119ce:	e5 03 00 
   119d1:	c7 40 04 a0 4d 01 00 	movl   $0x14da0,0x4(%eax)
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   119d8:	c7 05 50 e5 03 00 50 	movl   $0x3e550,0x3e550
   119df:	e5 03 00 
   119e2:	6a 00                	push   $0x0
   119e4:	6a ff                	push   $0xffffffff
   119e6:	6a 00                	push   $0x0
   119e8:	e8 33 ff ff ff       	call   11920 <_HalpAllocateBusHandler>
   119ed:	83 c4 10             	add    $0x10,%esp
   119f0:	85 c0                	test   %eax,%eax
   119f2:	74 6c                	je     11a60 <_HalpInitBusHandlers+0xb0>
   119f4:	c7 40 28 40 4d 01 00 	movl   $0x14d40,0x28(%eax)
   119fb:	c7 40 2c 70 4d 01 00 	movl   $0x14d70,0x2c(%eax)
   11a02:	50                   	push   %eax
   11a03:	6a 00                	push   $0x0
   11a05:	6a 00                	push   $0x0
   11a07:	6a ff                	push   $0xffffffff
   11a09:	e8 12 ff ff ff       	call   11920 <_HalpAllocateBusHandler>
   11a0e:	83 c4 10             	add    $0x10,%esp
   11a11:	85 c0                	test   %eax,%eax
   11a13:	74 4b                	je     11a60 <_HalpInitBusHandlers+0xb0>
   11a15:	c7 40 18 c0 53 01 00 	movl   $0x153c0,0x18(%eax)
   11a1c:	c7 40 1c e0 54 01 00 	movl   $0x154e0,0x1c(%eax)
   11a23:	50                   	push   %eax
   11a24:	6a 00                	push   $0x0
   11a26:	6a ff                	push   $0xffffffff
   11a28:	6a 01                	push   $0x1
   11a2a:	e8 f1 fe ff ff       	call   11920 <_HalpAllocateBusHandler>
   11a2f:	83 c4 10             	add    $0x10,%esp
   11a32:	85 c0                	test   %eax,%eax
   11a34:	74 2a                	je     11a60 <_HalpInitBusHandlers+0xb0>
   11a36:	c7 40 28 00 31 01 00 	movl   $0x13100,0x28(%eax)
   11a3d:	c7 40 2c 90 30 01 00 	movl   $0x13090,0x2c(%eax)
   11a44:	50                   	push   %eax
   11a45:	6a 00                	push   $0x0
   11a47:	6a 02                	push   $0x2
   11a49:	6a 03                	push   $0x3
   11a4b:	e8 d0 fe ff ff       	call   11920 <_HalpAllocateBusHandler>
   11a50:	83 c4 10             	add    $0x10,%esp
   11a53:	85 c0                	test   %eax,%eax
   11a55:	74 09                	je     11a60 <_HalpInitBusHandlers+0xb0>
   11a57:	c7 40 18 d0 37 01 00 	movl   $0x137d0,0x18(%eax)
   11a5e:	89 f6                	mov    %esi,%esi
   11a60:	c9                   	leave  
   11a61:	c3                   	ret    
   11a62:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11a69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011a70 <@HaliHandlerForBus@8>:
   11a70:	55                   	push   %ebp
   11a71:	89 e5                	mov    %esp,%ebp
   11a73:	57                   	push   %edi
   11a74:	56                   	push   %esi
   11a75:	53                   	push   %ebx
   11a76:	83 ec 14             	sub    $0x14,%esp
   11a79:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   11a7c:	89 d7                	mov    %edx,%edi
   11a7e:	89 ce                	mov    %ecx,%esi
   11a80:	50                   	push   %eax
   11a81:	68 00 e0 01 00       	push   $0x1e000
   11a86:	e8 25 32 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   11a8b:	8b 1d 50 e5 03 00    	mov    0x3e550,%ebx
   11a91:	58                   	pop    %eax
   11a92:	81 fb 50 e5 03 00    	cmp    $0x3e550,%ebx
   11a98:	5a                   	pop    %edx
   11a99:	74 14                	je     11aaf <@HaliHandlerForBus@8+0x3f>
   11a9b:	90                   	nop    
   11a9c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11aa0:	39 73 08             	cmp    %esi,0x8(%ebx)
   11aa3:	74 2b                	je     11ad0 <@HaliHandlerForBus@8+0x60>
   11aa5:	8b 1b                	mov    (%ebx),%ebx
   11aa7:	81 fb 50 e5 03 00    	cmp    $0x3e550,%ebx
   11aad:	75 f1                	jne    11aa0 <@HaliHandlerForBus@8+0x30>
   11aaf:	31 c0                	xor    %eax,%eax
   11ab1:	51                   	push   %ecx
   11ab2:	51                   	push   %ecx
   11ab3:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11ab6:	50                   	push   %eax
   11ab7:	68 00 e0 01 00       	push   $0x1e000
   11abc:	e8 5f 32 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   11ac1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11ac4:	31 c0                	xor    %eax,%eax
   11ac6:	5b                   	pop    %ebx
   11ac7:	5e                   	pop    %esi
   11ac8:	5f                   	pop    %edi
   11ac9:	5d                   	pop    %ebp
   11aca:	c3                   	ret    
   11acb:	90                   	nop    
   11acc:	8d 74 26 00          	lea    0x0(%esi),%esi
   11ad0:	39 7b 10             	cmp    %edi,0x10(%ebx)
   11ad3:	75 d0                	jne    11aa5 <@HaliHandlerForBus@8+0x35>
   11ad5:	31 c0                	xor    %eax,%eax
   11ad7:	56                   	push   %esi
   11ad8:	56                   	push   %esi
   11ad9:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11adc:	50                   	push   %eax
   11add:	68 00 e0 01 00       	push   $0x1e000
   11ae2:	e8 39 32 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   11ae7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11aea:	89 d8                	mov    %ebx,%eax
   11aec:	5b                   	pop    %ebx
   11aed:	5e                   	pop    %esi
   11aee:	5f                   	pop    %edi
   11aef:	5d                   	pop    %ebp
   11af0:	c3                   	ret    
   11af1:	eb 0d                	jmp    11b00 <@HaliHandlerForConfigSpace@8>
   11af3:	90                   	nop    
   11af4:	90                   	nop    
   11af5:	90                   	nop    
   11af6:	90                   	nop    
   11af7:	90                   	nop    
   11af8:	90                   	nop    
   11af9:	90                   	nop    
   11afa:	90                   	nop    
   11afb:	90                   	nop    
   11afc:	90                   	nop    
   11afd:	90                   	nop    
   11afe:	90                   	nop    
   11aff:	90                   	nop    

00011b00 <@HaliHandlerForConfigSpace@8>:
   11b00:	55                   	push   %ebp
   11b01:	89 e5                	mov    %esp,%ebp
   11b03:	57                   	push   %edi
   11b04:	56                   	push   %esi
   11b05:	53                   	push   %ebx
   11b06:	83 ec 14             	sub    $0x14,%esp
   11b09:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   11b0c:	89 d7                	mov    %edx,%edi
   11b0e:	89 ce                	mov    %ecx,%esi
   11b10:	50                   	push   %eax
   11b11:	68 00 e0 01 00       	push   $0x1e000
   11b16:	e8 95 31 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   11b1b:	8b 1d 50 e5 03 00    	mov    0x3e550,%ebx
   11b21:	58                   	pop    %eax
   11b22:	81 fb 50 e5 03 00    	cmp    $0x3e550,%ebx
   11b28:	5a                   	pop    %edx
   11b29:	74 14                	je     11b3f <@HaliHandlerForConfigSpace@8+0x3f>
   11b2b:	90                   	nop    
   11b2c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11b30:	39 73 0c             	cmp    %esi,0xc(%ebx)
   11b33:	74 2b                	je     11b60 <@HaliHandlerForConfigSpace@8+0x60>
   11b35:	8b 1b                	mov    (%ebx),%ebx
   11b37:	81 fb 50 e5 03 00    	cmp    $0x3e550,%ebx
   11b3d:	75 f1                	jne    11b30 <@HaliHandlerForConfigSpace@8+0x30>
   11b3f:	31 c0                	xor    %eax,%eax
   11b41:	51                   	push   %ecx
   11b42:	51                   	push   %ecx
   11b43:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11b46:	50                   	push   %eax
   11b47:	68 00 e0 01 00       	push   $0x1e000
   11b4c:	e8 cf 31 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   11b51:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11b54:	31 c0                	xor    %eax,%eax
   11b56:	5b                   	pop    %ebx
   11b57:	5e                   	pop    %esi
   11b58:	5f                   	pop    %edi
   11b59:	5d                   	pop    %ebp
   11b5a:	c3                   	ret    
   11b5b:	90                   	nop    
   11b5c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11b60:	39 7b 10             	cmp    %edi,0x10(%ebx)
   11b63:	75 d0                	jne    11b35 <@HaliHandlerForConfigSpace@8+0x35>
   11b65:	31 c0                	xor    %eax,%eax
   11b67:	56                   	push   %esi
   11b68:	56                   	push   %esi
   11b69:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11b6c:	50                   	push   %eax
   11b6d:	68 00 e0 01 00       	push   $0x1e000
   11b72:	e8 a9 31 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   11b77:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11b7a:	89 d8                	mov    %ebx,%eax
   11b7c:	5b                   	pop    %ebx
   11b7d:	5e                   	pop    %esi
   11b7e:	5f                   	pop    %edi
   11b7f:	5d                   	pop    %ebp
   11b80:	c3                   	ret    
   11b81:	eb 0d                	jmp    11b90 <@HaliReferenceHandlerForBus@8>
   11b83:	90                   	nop    
   11b84:	90                   	nop    
   11b85:	90                   	nop    
   11b86:	90                   	nop    
   11b87:	90                   	nop    
   11b88:	90                   	nop    
   11b89:	90                   	nop    
   11b8a:	90                   	nop    
   11b8b:	90                   	nop    
   11b8c:	90                   	nop    
   11b8d:	90                   	nop    
   11b8e:	90                   	nop    
   11b8f:	90                   	nop    

00011b90 <@HaliReferenceHandlerForBus@8>:
   11b90:	55                   	push   %ebp
   11b91:	89 e5                	mov    %esp,%ebp
   11b93:	57                   	push   %edi
   11b94:	56                   	push   %esi
   11b95:	53                   	push   %ebx
   11b96:	83 ec 14             	sub    $0x14,%esp
   11b99:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   11b9c:	89 d7                	mov    %edx,%edi
   11b9e:	89 ce                	mov    %ecx,%esi
   11ba0:	50                   	push   %eax
   11ba1:	68 00 e0 01 00       	push   $0x1e000
   11ba6:	e8 05 31 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   11bab:	8b 1d 50 e5 03 00    	mov    0x3e550,%ebx
   11bb1:	58                   	pop    %eax
   11bb2:	81 fb 50 e5 03 00    	cmp    $0x3e550,%ebx
   11bb8:	5a                   	pop    %edx
   11bb9:	74 14                	je     11bcf <@HaliReferenceHandlerForBus@8+0x3f>
   11bbb:	90                   	nop    
   11bbc:	8d 74 26 00          	lea    0x0(%esi),%esi
   11bc0:	39 73 08             	cmp    %esi,0x8(%ebx)
   11bc3:	74 2b                	je     11bf0 <@HaliReferenceHandlerForBus@8+0x60>
   11bc5:	8b 1b                	mov    (%ebx),%ebx
   11bc7:	81 fb 50 e5 03 00    	cmp    $0x3e550,%ebx
   11bcd:	75 f1                	jne    11bc0 <@HaliReferenceHandlerForBus@8+0x30>
   11bcf:	31 c0                	xor    %eax,%eax
   11bd1:	51                   	push   %ecx
   11bd2:	51                   	push   %ecx
   11bd3:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11bd6:	50                   	push   %eax
   11bd7:	68 00 e0 01 00       	push   $0x1e000
   11bdc:	e8 3f 31 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   11be1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11be4:	31 c0                	xor    %eax,%eax
   11be6:	5b                   	pop    %ebx
   11be7:	5e                   	pop    %esi
   11be8:	5f                   	pop    %edi
   11be9:	5d                   	pop    %ebp
   11bea:	c3                   	ret    
   11beb:	90                   	nop    
   11bec:	8d 74 26 00          	lea    0x0(%esi),%esi
   11bf0:	39 7b 10             	cmp    %edi,0x10(%ebx)
   11bf3:	75 d0                	jne    11bc5 <@HaliReferenceHandlerForBus@8+0x35>
   11bf5:	8b 7b 14             	mov    0x14(%ebx),%edi
   11bf8:	47                   	inc    %edi
   11bf9:	31 c0                	xor    %eax,%eax
   11bfb:	89 7b 14             	mov    %edi,0x14(%ebx)
   11bfe:	56                   	push   %esi
   11bff:	56                   	push   %esi
   11c00:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11c03:	50                   	push   %eax
   11c04:	68 00 e0 01 00       	push   $0x1e000
   11c09:	e8 12 31 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   11c0e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11c11:	89 d8                	mov    %ebx,%eax
   11c13:	5b                   	pop    %ebx
   11c14:	5e                   	pop    %esi
   11c15:	5f                   	pop    %edi
   11c16:	5d                   	pop    %ebp
   11c17:	c3                   	ret    
   11c18:	90                   	nop    
   11c19:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011c20 <@HaliReferenceHandlerForConfigSpace@8>:
   11c20:	55                   	push   %ebp
   11c21:	89 e5                	mov    %esp,%ebp
   11c23:	57                   	push   %edi
   11c24:	56                   	push   %esi
   11c25:	53                   	push   %ebx
   11c26:	83 ec 14             	sub    $0x14,%esp
   11c29:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   11c2c:	89 d7                	mov    %edx,%edi
   11c2e:	89 ce                	mov    %ecx,%esi
   11c30:	50                   	push   %eax
   11c31:	68 00 e0 01 00       	push   $0x1e000
   11c36:	e8 75 30 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   11c3b:	8b 1d 50 e5 03 00    	mov    0x3e550,%ebx
   11c41:	58                   	pop    %eax
   11c42:	81 fb 50 e5 03 00    	cmp    $0x3e550,%ebx
   11c48:	5a                   	pop    %edx
   11c49:	74 14                	je     11c5f <@HaliReferenceHandlerForConfigSpace@8+0x3f>
   11c4b:	90                   	nop    
   11c4c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11c50:	39 73 0c             	cmp    %esi,0xc(%ebx)
   11c53:	74 2b                	je     11c80 <@HaliReferenceHandlerForConfigSpace@8+0x60>
   11c55:	8b 1b                	mov    (%ebx),%ebx
   11c57:	81 fb 50 e5 03 00    	cmp    $0x3e550,%ebx
   11c5d:	75 f1                	jne    11c50 <@HaliReferenceHandlerForConfigSpace@8+0x30>
   11c5f:	31 c0                	xor    %eax,%eax
   11c61:	51                   	push   %ecx
   11c62:	51                   	push   %ecx
   11c63:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11c66:	50                   	push   %eax
   11c67:	68 00 e0 01 00       	push   $0x1e000
   11c6c:	e8 af 30 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   11c71:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11c74:	31 c0                	xor    %eax,%eax
   11c76:	5b                   	pop    %ebx
   11c77:	5e                   	pop    %esi
   11c78:	5f                   	pop    %edi
   11c79:	5d                   	pop    %ebp
   11c7a:	c3                   	ret    
   11c7b:	90                   	nop    
   11c7c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11c80:	39 7b 10             	cmp    %edi,0x10(%ebx)
   11c83:	75 d0                	jne    11c55 <@HaliReferenceHandlerForConfigSpace@8+0x35>
   11c85:	8b 7b 14             	mov    0x14(%ebx),%edi
   11c88:	47                   	inc    %edi
   11c89:	31 c0                	xor    %eax,%eax
   11c8b:	89 7b 14             	mov    %edi,0x14(%ebx)
   11c8e:	56                   	push   %esi
   11c8f:	56                   	push   %esi
   11c90:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11c93:	50                   	push   %eax
   11c94:	68 00 e0 01 00       	push   $0x1e000
   11c99:	e8 82 30 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   11c9e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11ca1:	89 d8                	mov    %ebx,%eax
   11ca3:	5b                   	pop    %ebx
   11ca4:	5e                   	pop    %esi
   11ca5:	5f                   	pop    %edi
   11ca6:	5d                   	pop    %ebp
   11ca7:	c3                   	ret    
   11ca8:	90                   	nop    
   11ca9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011cb0 <@HaliDereferenceBusHandler@4>:
   11cb0:	55                   	push   %ebp
   11cb1:	89 e5                	mov    %esp,%ebp
   11cb3:	53                   	push   %ebx
   11cb4:	83 ec 0c             	sub    $0xc,%esp
   11cb7:	89 cb                	mov    %ecx,%ebx
   11cb9:	8d 45 fb             	lea    0xfffffffb(%ebp),%eax
   11cbc:	50                   	push   %eax
   11cbd:	68 00 e0 01 00       	push   $0x1e000
   11cc2:	e8 e9 2f 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   11cc7:	8b 4b 14             	mov    0x14(%ebx),%ecx
   11cca:	49                   	dec    %ecx
   11ccb:	31 c0                	xor    %eax,%eax
   11ccd:	8a 45 fb             	mov    0xfffffffb(%ebp),%al
   11cd0:	89 4b 14             	mov    %ecx,0x14(%ebx)
   11cd3:	50                   	push   %eax
   11cd4:	68 00 e0 01 00       	push   $0x1e000
   11cd9:	e8 42 30 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   11cde:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11ce1:	c9                   	leave  
   11ce2:	c3                   	ret    
   11ce3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11ce9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011cf0 <_HalAdjustResourceList@4>:
   11cf0:	55                   	push   %ebp
   11cf1:	89 e5                	mov    %esp,%ebp
   11cf3:	56                   	push   %esi
   11cf4:	53                   	push   %ebx
   11cf5:	8b 5d 08             	mov    0x8(%ebp),%ebx
   11cf8:	8b 53 08             	mov    0x8(%ebx),%edx
   11cfb:	8b 4b 04             	mov    0x4(%ebx),%ecx
   11cfe:	e8 8d fe ff ff       	call   11b90 <@HaliReferenceHandlerForBus@8>
   11d03:	89 c6                	mov    %eax,%esi
   11d05:	31 c0                	xor    %eax,%eax
   11d07:	85 f6                	test   %esi,%esi
   11d09:	74 16                	je     11d21 <_HalAdjustResourceList@4+0x31>
   11d0b:	50                   	push   %eax
   11d0c:	53                   	push   %ebx
   11d0d:	8b 43 08             	mov    0x8(%ebx),%eax
   11d10:	50                   	push   %eax
   11d11:	56                   	push   %esi
   11d12:	ff 56 20             	call   *0x20(%esi)
   11d15:	89 f1                	mov    %esi,%ecx
   11d17:	89 c3                	mov    %eax,%ebx
   11d19:	58                   	pop    %eax
   11d1a:	e8 91 ff ff ff       	call   11cb0 <@HaliDereferenceBusHandler@4>
   11d1f:	89 d8                	mov    %ebx,%eax
   11d21:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11d24:	5b                   	pop    %ebx
   11d25:	5e                   	pop    %esi
   11d26:	5d                   	pop    %ebp
   11d27:	c2 04 00             	ret    $0x4
   11d2a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011d30 <_HalAssignSlotResources@32>:
   11d30:	55                   	push   %ebp
   11d31:	89 e5                	mov    %esp,%ebp
   11d33:	56                   	push   %esi
   11d34:	53                   	push   %ebx
   11d35:	8b 5d 1c             	mov    0x1c(%ebp),%ebx
   11d38:	8b 4d 18             	mov    0x18(%ebp),%ecx
   11d3b:	89 da                	mov    %ebx,%edx
   11d3d:	e8 4e fe ff ff       	call   11b90 <@HaliReferenceHandlerForBus@8>
   11d42:	89 c6                	mov    %eax,%esi
   11d44:	b8 25 02 00 c0       	mov    $0xc0000225,%eax
   11d49:	85 f6                	test   %esi,%esi
   11d4b:	74 28                	je     11d75 <_HalAssignSlotResources@32+0x45>
   11d4d:	8b 45 24             	mov    0x24(%ebp),%eax
   11d50:	8b 4d 20             	mov    0x20(%ebp),%ecx
   11d53:	50                   	push   %eax
   11d54:	8b 55 14             	mov    0x14(%ebp),%edx
   11d57:	8b 45 10             	mov    0x10(%ebp),%eax
   11d5a:	51                   	push   %ecx
   11d5b:	52                   	push   %edx
   11d5c:	50                   	push   %eax
   11d5d:	8b 45 0c             	mov    0xc(%ebp),%eax
   11d60:	50                   	push   %eax
   11d61:	8b 45 08             	mov    0x8(%ebp),%eax
   11d64:	50                   	push   %eax
   11d65:	53                   	push   %ebx
   11d66:	56                   	push   %esi
   11d67:	ff 56 24             	call   *0x24(%esi)
   11d6a:	89 f1                	mov    %esi,%ecx
   11d6c:	89 c3                	mov    %eax,%ebx
   11d6e:	e8 3d ff ff ff       	call   11cb0 <@HaliDereferenceBusHandler@4>
   11d73:	89 d8                	mov    %ebx,%eax
   11d75:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11d78:	5b                   	pop    %ebx
   11d79:	5e                   	pop    %esi
   11d7a:	5d                   	pop    %ebp
   11d7b:	c2 20 00             	ret    $0x20
   11d7e:	89 f6                	mov    %esi,%esi

00011d80 <_HalGetBusDataByOffset@24>:
   11d80:	55                   	push   %ebp
   11d81:	89 e5                	mov    %esp,%ebp
   11d83:	56                   	push   %esi
   11d84:	53                   	push   %ebx
   11d85:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11d88:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11d8b:	89 da                	mov    %ebx,%edx
   11d8d:	e8 8e fe ff ff       	call   11c20 <@HaliReferenceHandlerForConfigSpace@8>
   11d92:	89 c6                	mov    %eax,%esi
   11d94:	31 c0                	xor    %eax,%eax
   11d96:	85 f6                	test   %esi,%esi
   11d98:	74 24                	je     11dbe <_HalGetBusDataByOffset@24+0x3e>
   11d9a:	50                   	push   %eax
   11d9b:	50                   	push   %eax
   11d9c:	8b 45 1c             	mov    0x1c(%ebp),%eax
   11d9f:	50                   	push   %eax
   11da0:	8b 45 18             	mov    0x18(%ebp),%eax
   11da3:	50                   	push   %eax
   11da4:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11da7:	8b 45 14             	mov    0x14(%ebp),%eax
   11daa:	50                   	push   %eax
   11dab:	51                   	push   %ecx
   11dac:	53                   	push   %ebx
   11dad:	56                   	push   %esi
   11dae:	ff 56 18             	call   *0x18(%esi)
   11db1:	89 f1                	mov    %esi,%ecx
   11db3:	89 c3                	mov    %eax,%ebx
   11db5:	58                   	pop    %eax
   11db6:	5a                   	pop    %edx
   11db7:	e8 f4 fe ff ff       	call   11cb0 <@HaliDereferenceBusHandler@4>
   11dbc:	89 d8                	mov    %ebx,%eax
   11dbe:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11dc1:	5b                   	pop    %ebx
   11dc2:	5e                   	pop    %esi
   11dc3:	5d                   	pop    %ebp
   11dc4:	c2 18 00             	ret    $0x18
   11dc7:	89 f6                	mov    %esi,%esi
   11dc9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011dd0 <_HalGetBusData@20>:
   11dd0:	55                   	push   %ebp
   11dd1:	89 e5                	mov    %esp,%ebp
   11dd3:	83 ec 10             	sub    $0x10,%esp
   11dd6:	8b 45 18             	mov    0x18(%ebp),%eax
   11dd9:	8b 4d 14             	mov    0x14(%ebp),%ecx
   11ddc:	50                   	push   %eax
   11ddd:	8b 55 10             	mov    0x10(%ebp),%edx
   11de0:	8b 45 0c             	mov    0xc(%ebp),%eax
   11de3:	6a 00                	push   $0x0
   11de5:	51                   	push   %ecx
   11de6:	52                   	push   %edx
   11de7:	50                   	push   %eax
   11de8:	8b 45 08             	mov    0x8(%ebp),%eax
   11deb:	50                   	push   %eax
   11dec:	e8 8f ff ff ff       	call   11d80 <_HalGetBusDataByOffset@24>
   11df1:	c9                   	leave  
   11df2:	c2 14 00             	ret    $0x14
   11df5:	8d 74 26 00          	lea    0x0(%esi),%esi
   11df9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011e00 <_HalGetInterruptVector@24>:
   11e00:	55                   	push   %ebp
   11e01:	89 e5                	mov    %esp,%ebp
   11e03:	56                   	push   %esi
   11e04:	53                   	push   %ebx
   11e05:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11e08:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11e0b:	89 da                	mov    %ebx,%edx
   11e0d:	e8 7e fd ff ff       	call   11b90 <@HaliReferenceHandlerForBus@8>
   11e12:	89 c6                	mov    %eax,%esi
   11e14:	31 c0                	xor    %eax,%eax
   11e16:	85 f6                	test   %esi,%esi
   11e18:	74 24                	je     11e3e <_HalGetInterruptVector@24+0x3e>
   11e1a:	50                   	push   %eax
   11e1b:	50                   	push   %eax
   11e1c:	8b 45 1c             	mov    0x1c(%ebp),%eax
   11e1f:	50                   	push   %eax
   11e20:	8b 45 18             	mov    0x18(%ebp),%eax
   11e23:	50                   	push   %eax
   11e24:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11e27:	8b 45 14             	mov    0x14(%ebp),%eax
   11e2a:	50                   	push   %eax
   11e2b:	51                   	push   %ecx
   11e2c:	53                   	push   %ebx
   11e2d:	56                   	push   %esi
   11e2e:	ff 56 28             	call   *0x28(%esi)
   11e31:	89 f1                	mov    %esi,%ecx
   11e33:	89 c3                	mov    %eax,%ebx
   11e35:	58                   	pop    %eax
   11e36:	5a                   	pop    %edx
   11e37:	e8 74 fe ff ff       	call   11cb0 <@HaliDereferenceBusHandler@4>
   11e3c:	89 d8                	mov    %ebx,%eax
   11e3e:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11e41:	5b                   	pop    %ebx
   11e42:	5e                   	pop    %esi
   11e43:	5d                   	pop    %ebp
   11e44:	c2 18 00             	ret    $0x18
   11e47:	89 f6                	mov    %esi,%esi
   11e49:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011e50 <_HalSetBusDataByOffset@24>:
   11e50:	55                   	push   %ebp
   11e51:	89 e5                	mov    %esp,%ebp
   11e53:	56                   	push   %esi
   11e54:	53                   	push   %ebx
   11e55:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11e58:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11e5b:	89 da                	mov    %ebx,%edx
   11e5d:	e8 be fd ff ff       	call   11c20 <@HaliReferenceHandlerForConfigSpace@8>
   11e62:	89 c6                	mov    %eax,%esi
   11e64:	31 c0                	xor    %eax,%eax
   11e66:	85 f6                	test   %esi,%esi
   11e68:	74 24                	je     11e8e <_HalSetBusDataByOffset@24+0x3e>
   11e6a:	50                   	push   %eax
   11e6b:	50                   	push   %eax
   11e6c:	8b 45 1c             	mov    0x1c(%ebp),%eax
   11e6f:	50                   	push   %eax
   11e70:	8b 45 18             	mov    0x18(%ebp),%eax
   11e73:	50                   	push   %eax
   11e74:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11e77:	8b 45 14             	mov    0x14(%ebp),%eax
   11e7a:	50                   	push   %eax
   11e7b:	51                   	push   %ecx
   11e7c:	53                   	push   %ebx
   11e7d:	56                   	push   %esi
   11e7e:	ff 56 1c             	call   *0x1c(%esi)
   11e81:	89 f1                	mov    %esi,%ecx
   11e83:	89 c3                	mov    %eax,%ebx
   11e85:	58                   	pop    %eax
   11e86:	5a                   	pop    %edx
   11e87:	e8 24 fe ff ff       	call   11cb0 <@HaliDereferenceBusHandler@4>
   11e8c:	89 d8                	mov    %ebx,%eax
   11e8e:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11e91:	5b                   	pop    %ebx
   11e92:	5e                   	pop    %esi
   11e93:	5d                   	pop    %ebp
   11e94:	c2 18 00             	ret    $0x18
   11e97:	89 f6                	mov    %esi,%esi
   11e99:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011ea0 <_HalSetBusData@20>:
   11ea0:	55                   	push   %ebp
   11ea1:	89 e5                	mov    %esp,%ebp
   11ea3:	83 ec 10             	sub    $0x10,%esp
   11ea6:	8b 45 18             	mov    0x18(%ebp),%eax
   11ea9:	8b 4d 14             	mov    0x14(%ebp),%ecx
   11eac:	50                   	push   %eax
   11ead:	8b 55 10             	mov    0x10(%ebp),%edx
   11eb0:	8b 45 0c             	mov    0xc(%ebp),%eax
   11eb3:	6a 00                	push   $0x0
   11eb5:	51                   	push   %ecx
   11eb6:	52                   	push   %edx
   11eb7:	50                   	push   %eax
   11eb8:	8b 45 08             	mov    0x8(%ebp),%eax
   11ebb:	50                   	push   %eax
   11ebc:	e8 8f ff ff ff       	call   11e50 <_HalSetBusDataByOffset@24>
   11ec1:	c9                   	leave  
   11ec2:	c2 14 00             	ret    $0x14
   11ec5:	8d 74 26 00          	lea    0x0(%esi),%esi
   11ec9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011ed0 <_HalTranslateBusAddress@24>:
   11ed0:	55                   	push   %ebp
   11ed1:	89 e5                	mov    %esp,%ebp
   11ed3:	56                   	push   %esi
   11ed4:	53                   	push   %ebx
   11ed5:	8b 75 0c             	mov    0xc(%ebp),%esi
   11ed8:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11edb:	89 f2                	mov    %esi,%edx
   11edd:	e8 ae fc ff ff       	call   11b90 <@HaliReferenceHandlerForBus@8>
   11ee2:	89 c3                	mov    %eax,%ebx
   11ee4:	31 c0                	xor    %eax,%eax
   11ee6:	85 db                	test   %ebx,%ebx
   11ee8:	74 29                	je     11f13 <_HalTranslateBusAddress@24+0x43>
   11eea:	50                   	push   %eax
   11eeb:	50                   	push   %eax
   11eec:	8b 45 1c             	mov    0x1c(%ebp),%eax
   11eef:	50                   	push   %eax
   11ef0:	8b 45 18             	mov    0x18(%ebp),%eax
   11ef3:	50                   	push   %eax
   11ef4:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11ef7:	8b 45 14             	mov    0x14(%ebp),%eax
   11efa:	50                   	push   %eax
   11efb:	51                   	push   %ecx
   11efc:	56                   	push   %esi
   11efd:	53                   	push   %ebx
   11efe:	ff 53 2c             	call   *0x2c(%ebx)
   11f01:	89 d9                	mov    %ebx,%ecx
   11f03:	89 c6                	mov    %eax,%esi
   11f05:	58                   	pop    %eax
   11f06:	5a                   	pop    %edx
   11f07:	e8 a4 fd ff ff       	call   11cb0 <@HaliDereferenceBusHandler@4>
   11f0c:	89 f0                	mov    %esi,%eax
   11f0e:	25 ff 00 00 00       	and    $0xff,%eax
   11f13:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11f16:	5b                   	pop    %ebx
   11f17:	5e                   	pop    %esi
   11f18:	5d                   	pop    %ebp
   11f19:	c2 18 00             	ret    $0x18
   11f1c:	90                   	nop    
   11f1d:	90                   	nop    
   11f1e:	90                   	nop    
   11f1f:	90                   	nop    

00011f20 <@HalClearDisplay@4>:
   11f20:	a1 04 b0 01 00       	mov    0x1b004,%eax
   11f25:	8b 15 08 b0 01 00    	mov    0x1b008,%edx
   11f2b:	0f af d0             	imul   %eax,%edx
   11f2e:	55                   	push   %ebp
   11f2f:	83 fa 00             	cmp    $0x0,%edx
   11f32:	89 e5                	mov    %esp,%ebp
   11f34:	53                   	push   %ebx
   11f35:	88 cb                	mov    %cl,%bl
   11f37:	8b 0d 40 e0 01 00    	mov    0x1e040,%ecx
   11f3d:	76 11                	jbe    11f50 <@HalClearDisplay@4+0x30>
   11f3f:	89 d8                	mov    %ebx,%eax
   11f41:	c1 e0 08             	shl    $0x8,%eax
   11f44:	83 c0 20             	add    $0x20,%eax
   11f47:	66 89 01             	mov    %ax,(%ecx)
   11f4a:	83 c1 02             	add    $0x2,%ecx
   11f4d:	4a                   	dec    %edx
   11f4e:	75 f7                	jne    11f47 <@HalClearDisplay@4+0x27>
   11f50:	5b                   	pop    %ebx
   11f51:	c7 05 20 e0 01 00 00 	movl   $0x0,0x1e020
   11f58:	00 00 00 
   11f5b:	c7 05 10 e0 01 00 00 	movl   $0x0,0x1e010
   11f62:	00 00 00 
   11f65:	5d                   	pop    %ebp
   11f66:	c3                   	ret    
   11f67:	89 f6                	mov    %esi,%esi
   11f69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011f70 <_HalDisablePalette>:
   11f70:	55                   	push   %ebp
   11f71:	89 e5                	mov    %esp,%ebp
   11f73:	83 ec 14             	sub    $0x14,%esp
   11f76:	68 da 03 00 00       	push   $0x3da
   11f7b:	e8 60 2b 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   11f80:	c7 04 24 20 00 00 00 	movl   $0x20,(%esp)
   11f87:	68 c0 03 00 00       	push   $0x3c0
   11f8c:	e8 ff 2b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   11f91:	c6 05 60 e0 01 00 00 	movb   $0x0,0x1e060
   11f98:	c9                   	leave  
   11f99:	c3                   	ret    
   11f9a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011fa0 <_HalEnablePalette>:
   11fa0:	55                   	push   %ebp
   11fa1:	89 e5                	mov    %esp,%ebp
   11fa3:	83 ec 14             	sub    $0x14,%esp
   11fa6:	68 da 03 00 00       	push   $0x3da
   11fab:	e8 30 2b 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   11fb0:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11fb7:	68 c0 03 00 00       	push   $0x3c0
   11fbc:	e8 cf 2b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   11fc1:	c6 05 60 e0 01 00 01 	movb   $0x1,0x1e060
   11fc8:	c9                   	leave  
   11fc9:	c3                   	ret    
   11fca:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011fd0 <@HalReadGc@4>:
   11fd0:	55                   	push   %ebp
   11fd1:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   11fd7:	89 e5                	mov    %esp,%ebp
   11fd9:	83 ec 10             	sub    $0x10,%esp
   11fdc:	51                   	push   %ecx
   11fdd:	68 ce 03 00 00       	push   $0x3ce
   11fe2:	e8 a9 2b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   11fe7:	50                   	push   %eax
   11fe8:	68 cf 03 00 00       	push   $0x3cf
   11fed:	e8 ee 2a 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   11ff2:	c9                   	leave  
   11ff3:	25 ff 00 00 00       	and    $0xff,%eax
   11ff8:	c3                   	ret    
   11ff9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00012000 <@HalWriteGc@8>:
   12000:	55                   	push   %ebp
   12001:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   12007:	89 e5                	mov    %esp,%ebp
   12009:	53                   	push   %ebx
   1200a:	83 ec 0c             	sub    $0xc,%esp
   1200d:	88 d3                	mov    %dl,%bl
   1200f:	51                   	push   %ecx
   12010:	68 ce 03 00 00       	push   $0x3ce
   12015:	e8 76 2b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1201a:	31 c0                	xor    %eax,%eax
   1201c:	88 d8                	mov    %bl,%al
   1201e:	50                   	push   %eax
   1201f:	68 cf 03 00 00       	push   $0x3cf
   12024:	e8 67 2b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12029:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1202c:	c9                   	leave  
   1202d:	c3                   	ret    
   1202e:	89 f6                	mov    %esi,%esi

00012030 <@HalReadSeq@4>:
   12030:	55                   	push   %ebp
   12031:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   12037:	89 e5                	mov    %esp,%ebp
   12039:	83 ec 10             	sub    $0x10,%esp
   1203c:	51                   	push   %ecx
   1203d:	68 c4 03 00 00       	push   $0x3c4
   12042:	e8 49 2b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12047:	52                   	push   %edx
   12048:	68 c5 03 00 00       	push   $0x3c5
   1204d:	e8 8e 2a 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12052:	c9                   	leave  
   12053:	25 ff 00 00 00       	and    $0xff,%eax
   12058:	c3                   	ret    
   12059:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00012060 <@HalWriteSeq@8>:
   12060:	55                   	push   %ebp
   12061:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   12067:	89 e5                	mov    %esp,%ebp
   12069:	53                   	push   %ebx
   1206a:	83 ec 0c             	sub    $0xc,%esp
   1206d:	88 d3                	mov    %dl,%bl
   1206f:	51                   	push   %ecx
   12070:	68 c4 03 00 00       	push   $0x3c4
   12075:	e8 16 2b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1207a:	31 c0                	xor    %eax,%eax
   1207c:	88 d8                	mov    %bl,%al
   1207e:	50                   	push   %eax
   1207f:	68 c5 03 00 00       	push   $0x3c5
   12084:	e8 07 2b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12089:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1208c:	c9                   	leave  
   1208d:	c3                   	ret    
   1208e:	89 f6                	mov    %esi,%esi

00012090 <@HalWriteAc@8>:
   12090:	55                   	push   %ebp
   12091:	89 e5                	mov    %esp,%ebp
   12093:	56                   	push   %esi
   12094:	80 3d 60 e0 01 00 00 	cmpb   $0x0,0x1e060
   1209b:	53                   	push   %ebx
   1209c:	89 d6                	mov    %edx,%esi
   1209e:	89 cb                	mov    %ecx,%ebx
   120a0:	74 3e                	je     120e0 <@HalWriteAc@8+0x50>
   120a2:	83 e3 df             	and    $0xffffffdf,%ebx
   120a5:	83 ec 0c             	sub    $0xc,%esp
   120a8:	68 da 03 00 00       	push   $0x3da
   120ad:	e8 2e 2a 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   120b2:	31 c0                	xor    %eax,%eax
   120b4:	88 d8                	mov    %bl,%al
   120b6:	89 04 24             	mov    %eax,(%esp)
   120b9:	68 c0 03 00 00       	push   $0x3c0
   120be:	e8 cd 2a 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   120c3:	89 f0                	mov    %esi,%eax
   120c5:	25 ff 00 00 00       	and    $0xff,%eax
   120ca:	50                   	push   %eax
   120cb:	68 c0 03 00 00       	push   $0x3c0
   120d0:	e8 bb 2a 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   120d5:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   120d8:	5b                   	pop    %ebx
   120d9:	5e                   	pop    %esi
   120da:	5d                   	pop    %ebp
   120db:	c3                   	ret    
   120dc:	8d 74 26 00          	lea    0x0(%esi),%esi
   120e0:	83 cb 20             	or     $0x20,%ebx
   120e3:	eb c0                	jmp    120a5 <@HalWriteAc@8+0x15>
   120e5:	8d 74 26 00          	lea    0x0(%esi),%esi
   120e9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000120f0 <@HalReadAc@4>:
   120f0:	55                   	push   %ebp
   120f1:	89 e5                	mov    %esp,%ebp
   120f3:	53                   	push   %ebx
   120f4:	53                   	push   %ebx
   120f5:	80 3d 60 e0 01 00 00 	cmpb   $0x0,0x1e060
   120fc:	89 cb                	mov    %ecx,%ebx
   120fe:	74 36                	je     12136 <@HalReadAc@4+0x46>
   12100:	83 e3 df             	and    $0xffffffdf,%ebx
   12103:	83 ec 0c             	sub    $0xc,%esp
   12106:	68 da 03 00 00       	push   $0x3da
   1210b:	e8 d0 29 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12110:	31 c0                	xor    %eax,%eax
   12112:	88 d8                	mov    %bl,%al
   12114:	89 04 24             	mov    %eax,(%esp)
   12117:	68 c0 03 00 00       	push   $0x3c0
   1211c:	e8 6f 2a 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12121:	51                   	push   %ecx
   12122:	68 c1 03 00 00       	push   $0x3c1
   12127:	e8 b4 29 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1212c:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1212f:	25 ff 00 00 00       	and    $0xff,%eax
   12134:	c9                   	leave  
   12135:	c3                   	ret    
   12136:	83 cb 20             	or     $0x20,%ebx
   12139:	eb c8                	jmp    12103 <@HalReadAc@4+0x13>
   1213b:	90                   	nop    
   1213c:	8d 74 26 00          	lea    0x0(%esi),%esi

00012140 <@HalWriteCrtc@8>:
   12140:	55                   	push   %ebp
   12141:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   12147:	89 e5                	mov    %esp,%ebp
   12149:	53                   	push   %ebx
   1214a:	83 ec 0c             	sub    $0xc,%esp
   1214d:	88 d3                	mov    %dl,%bl
   1214f:	51                   	push   %ecx
   12150:	68 d4 03 00 00       	push   $0x3d4
   12155:	e8 36 2a 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1215a:	31 c0                	xor    %eax,%eax
   1215c:	88 d8                	mov    %bl,%al
   1215e:	50                   	push   %eax
   1215f:	68 d5 03 00 00       	push   $0x3d5
   12164:	e8 27 2a 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12169:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1216c:	c9                   	leave  
   1216d:	c3                   	ret    
   1216e:	89 f6                	mov    %esi,%esi

00012170 <@HalResetSeq@4>:
   12170:	55                   	push   %ebp
   12171:	ba 01 00 00 00       	mov    $0x1,%edx
   12176:	89 e5                	mov    %esp,%ebp
   12178:	84 c9                	test   %cl,%cl
   1217a:	74 08                	je     12184 <@HalResetSeq@4+0x14>
   1217c:	31 c9                	xor    %ecx,%ecx
   1217e:	5d                   	pop    %ebp
   1217f:	e9 dc fe ff ff       	jmp    12060 <@HalWriteSeq@8>
   12184:	ba 03 00 00 00       	mov    $0x3,%edx
   12189:	31 c9                	xor    %ecx,%ecx
   1218b:	5d                   	pop    %ebp
   1218c:	e9 cf fe ff ff       	jmp    12060 <@HalWriteSeq@8>
   12191:	eb 0d                	jmp    121a0 <@HalBlankScreen@4>
   12193:	90                   	nop    
   12194:	90                   	nop    
   12195:	90                   	nop    
   12196:	90                   	nop    
   12197:	90                   	nop    
   12198:	90                   	nop    
   12199:	90                   	nop    
   1219a:	90                   	nop    
   1219b:	90                   	nop    
   1219c:	90                   	nop    
   1219d:	90                   	nop    
   1219e:	90                   	nop    
   1219f:	90                   	nop    

000121a0 <@HalBlankScreen@4>:
   121a0:	55                   	push   %ebp
   121a1:	89 e5                	mov    %esp,%ebp
   121a3:	56                   	push   %esi
   121a4:	53                   	push   %ebx
   121a5:	89 cb                	mov    %ecx,%ebx
   121a7:	b9 01 00 00 00       	mov    $0x1,%ecx
   121ac:	e8 7f fe ff ff       	call   12030 <@HalReadSeq@4>
   121b1:	84 db                	test   %bl,%bl
   121b3:	89 c6                	mov    %eax,%esi
   121b5:	74 29                	je     121e0 <@HalBlankScreen@4+0x40>
   121b7:	83 e6 df             	and    $0xffffffdf,%esi
   121ba:	b9 01 00 00 00       	mov    $0x1,%ecx
   121bf:	e8 ac ff ff ff       	call   12170 <@HalResetSeq@4>
   121c4:	89 f2                	mov    %esi,%edx
   121c6:	b9 01 00 00 00       	mov    $0x1,%ecx
   121cb:	81 e2 ff 00 00 00    	and    $0xff,%edx
   121d1:	e8 8a fe ff ff       	call   12060 <@HalWriteSeq@8>
   121d6:	31 c9                	xor    %ecx,%ecx
   121d8:	5b                   	pop    %ebx
   121d9:	5e                   	pop    %esi
   121da:	5d                   	pop    %ebp
   121db:	eb 93                	jmp    12170 <@HalResetSeq@4>
   121dd:	8d 76 00             	lea    0x0(%esi),%esi
   121e0:	83 ce 20             	or     $0x20,%esi
   121e3:	b9 01 00 00 00       	mov    $0x1,%ecx
   121e8:	e8 83 ff ff ff       	call   12170 <@HalResetSeq@4>
   121ed:	89 f2                	mov    %esi,%edx
   121ef:	b9 01 00 00 00       	mov    $0x1,%ecx
   121f4:	81 e2 ff 00 00 00    	and    $0xff,%edx
   121fa:	e8 61 fe ff ff       	call   12060 <@HalWriteSeq@8>
   121ff:	31 c9                	xor    %ecx,%ecx
   12201:	5b                   	pop    %ebx
   12202:	5e                   	pop    %esi
   12203:	5d                   	pop    %ebp
   12204:	e9 67 ff ff ff       	jmp    12170 <@HalResetSeq@4>
   12209:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00012210 <_HalDacDelay>:
   12210:	55                   	push   %ebp
   12211:	89 e5                	mov    %esp,%ebp
   12213:	83 ec 14             	sub    $0x14,%esp
   12216:	68 da 03 00 00       	push   $0x3da
   1221b:	e8 c0 28 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12220:	68 da 03 00 00       	push   $0x3da
   12225:	e8 b6 28 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1222a:	c9                   	leave  
   1222b:	c3                   	ret    
   1222c:	8d 74 26 00          	lea    0x0(%esi),%esi

00012230 <@HalInitializeDisplay@4>:
   12230:	55                   	push   %ebp
   12231:	89 e5                	mov    %esp,%ebp
   12233:	57                   	push   %edi
   12234:	56                   	push   %esi
   12235:	53                   	push   %ebx
   12236:	83 ec 0c             	sub    $0xc,%esp
   12239:	80 3d 30 e0 01 00 00 	cmpb   $0x0,0x1e030
   12240:	74 08                	je     1224a <@HalInitializeDisplay@4+0x1a>
   12242:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12245:	5b                   	pop    %ebx
   12246:	5e                   	pop    %esi
   12247:	5f                   	pop    %edi
   12248:	5d                   	pop    %ebp
   12249:	c3                   	ret    
   1224a:	31 d2                	xor    %edx,%edx
   1224c:	b8 00 00 0a 00       	mov    $0xa0000,%eax
   12251:	6a 00                	push   $0x0
   12253:	68 00 00 02 00       	push   $0x20000
   12258:	52                   	push   %edx
   12259:	50                   	push   %eax
   1225a:	e8 51 86 00 00       	call   1a8b0 <_MmMapIoSpace@16>
   1225f:	a3 70 e0 01 00       	mov    %eax,0x1e070
   12264:	85 c0                	test   %eax,%eax
   12266:	74 da                	je     12242 <@HalInitializeDisplay@4+0x12>
   12268:	05 00 80 01 00       	add    $0x18000,%eax
   1226d:	c7 05 20 e0 01 00 00 	movl   $0x0,0x1e020
   12274:	00 00 00 
   12277:	a3 40 e0 01 00       	mov    %eax,0x1e040
   1227c:	c7 05 10 e0 01 00 00 	movl   $0x0,0x1e010
   12283:	00 00 00 
   12286:	50                   	push   %eax
   12287:	50                   	push   %eax
   12288:	6a 01                	push   $0x1
   1228a:	68 d4 03 00 00       	push   $0x3d4
   1228f:	e8 fc 28 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12294:	50                   	push   %eax
   12295:	68 d5 03 00 00       	push   $0x3d5
   1229a:	e8 41 28 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1229f:	25 ff 00 00 00       	and    $0xff,%eax
   122a4:	40                   	inc    %eax
   122a5:	a3 08 b0 01 00       	mov    %eax,0x1b008
   122aa:	c7 04 24 12 00 00 00 	movl   $0x12,(%esp)
   122b1:	68 d4 03 00 00       	push   $0x3d4
   122b6:	e8 d5 28 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   122bb:	57                   	push   %edi
   122bc:	68 d5 03 00 00       	push   $0x3d5
   122c1:	e8 1a 28 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   122c6:	25 ff 00 00 00       	and    $0xff,%eax
   122cb:	a3 04 b0 01 00       	mov    %eax,0x1b004
   122d0:	c7 04 24 07 00 00 00 	movl   $0x7,(%esp)
   122d7:	68 d4 03 00 00       	push   $0x3d4
   122dc:	e8 af 28 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   122e1:	56                   	push   %esi
   122e2:	68 d5 03 00 00       	push   $0x3d5
   122e7:	e8 f4 27 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   122ec:	8b 1d 04 b0 01 00    	mov    0x1b004,%ebx
   122f2:	25 ff 00 00 00       	and    $0xff,%eax
   122f7:	89 c2                	mov    %eax,%edx
   122f9:	83 e0 40             	and    $0x40,%eax
   122fc:	c1 e0 03             	shl    $0x3,%eax
   122ff:	83 e2 02             	and    $0x2,%edx
   12302:	c1 e2 07             	shl    $0x7,%edx
   12305:	09 c2                	or     %eax,%edx
   12307:	09 da                	or     %ebx,%edx
   12309:	42                   	inc    %edx
   1230a:	89 15 04 b0 01 00    	mov    %edx,0x1b004
   12310:	c7 04 24 09 00 00 00 	movl   $0x9,(%esp)
   12317:	68 d4 03 00 00       	push   $0x3d4
   1231c:	e8 6f 28 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12321:	51                   	push   %ecx
   12322:	68 d5 03 00 00       	push   $0x3d5
   12327:	e8 b4 27 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1232c:	8b 1d 04 b0 01 00    	mov    0x1b004,%ebx
   12332:	83 e0 1f             	and    $0x1f,%eax
   12335:	31 d2                	xor    %edx,%edx
   12337:	8d 48 01             	lea    0x1(%eax),%ecx
   1233a:	89 d8                	mov    %ebx,%eax
   1233c:	f7 f1                	div    %ecx
   1233e:	31 c9                	xor    %ecx,%ecx
   12340:	a3 04 b0 01 00       	mov    %eax,0x1b004
   12345:	e8 d6 fb ff ff       	call   11f20 <@HalClearDisplay@4>
   1234a:	c6 05 30 e0 01 00 01 	movb   $0x1,0x1e030
   12351:	c7 04 24 ff 00 00 00 	movl   $0xff,(%esp)
   12358:	68 c6 03 00 00       	push   $0x3c6
   1235d:	e8 2e 28 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12362:	31 db                	xor    %ebx,%ebx
   12364:	6a 00                	push   $0x0
   12366:	68 c7 03 00 00       	push   $0x3c7
   1236b:	e8 20 28 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12370:	58                   	pop    %eax
   12371:	5a                   	pop    %edx
   12372:	83 ec 0c             	sub    $0xc,%esp
   12375:	68 c9 03 00 00       	push   $0x3c9
   1237a:	e8 61 27 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1237f:	83 c4 0c             	add    $0xc,%esp
   12382:	88 83 90 e0 01 00    	mov    %al,0x1e090(%ebx)
   12388:	43                   	inc    %ebx
   12389:	e8 82 fe ff ff       	call   12210 <_HalDacDelay>
   1238e:	81 fb ff 02 00 00    	cmp    $0x2ff,%ebx
   12394:	76 dc                	jbe    12372 <@HalInitializeDisplay@4+0x142>
   12396:	83 ec 0c             	sub    $0xc,%esp
   12399:	31 db                	xor    %ebx,%ebx
   1239b:	68 cc 03 00 00       	push   $0x3cc
   123a0:	e8 3b 27 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   123a5:	83 c4 0c             	add    $0xc,%esp
   123a8:	a2 90 e3 01 00       	mov    %al,0x1e390
   123ad:	31 c0                	xor    %eax,%eax
   123af:	88 d8                	mov    %bl,%al
   123b1:	57                   	push   %edi
   123b2:	57                   	push   %edi
   123b3:	50                   	push   %eax
   123b4:	68 d4 03 00 00       	push   $0x3d4
   123b9:	e8 d2 27 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   123be:	56                   	push   %esi
   123bf:	68 d5 03 00 00       	push   $0x3d5
   123c4:	e8 17 27 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   123c9:	83 c4 0c             	add    $0xc,%esp
   123cc:	88 83 a0 e3 01 00    	mov    %al,0x1e3a0(%ebx)
   123d2:	43                   	inc    %ebx
   123d3:	83 fb 18             	cmp    $0x18,%ebx
   123d6:	76 d5                	jbe    123ad <@HalInitializeDisplay@4+0x17d>
   123d8:	e8 c3 fb ff ff       	call   11fa0 <_HalEnablePalette>
   123dd:	31 db                	xor    %ebx,%ebx
   123df:	89 d9                	mov    %ebx,%ecx
   123e1:	e8 0a fd ff ff       	call   120f0 <@HalReadAc@4>
   123e6:	88 83 c0 e3 01 00    	mov    %al,0x1e3c0(%ebx)
   123ec:	43                   	inc    %ebx
   123ed:	83 fb 14             	cmp    $0x14,%ebx
   123f0:	76 ed                	jbe    123df <@HalInitializeDisplay@4+0x1af>
   123f2:	e8 79 fb ff ff       	call   11f70 <_HalDisablePalette>
   123f7:	31 db                	xor    %ebx,%ebx
   123f9:	89 d9                	mov    %ebx,%ecx
   123fb:	e8 d0 fb ff ff       	call   11fd0 <@HalReadGc@4>
   12400:	88 83 e0 e3 01 00    	mov    %al,0x1e3e0(%ebx)
   12406:	43                   	inc    %ebx
   12407:	83 fb 08             	cmp    $0x8,%ebx
   1240a:	76 ed                	jbe    123f9 <@HalInitializeDisplay@4+0x1c9>
   1240c:	31 db                	xor    %ebx,%ebx
   1240e:	89 d9                	mov    %ebx,%ecx
   12410:	e8 1b fc ff ff       	call   12030 <@HalReadSeq@4>
   12415:	88 83 f0 e3 01 00    	mov    %al,0x1e3f0(%ebx)
   1241b:	43                   	inc    %ebx
   1241c:	83 fb 04             	cmp    $0x4,%ebx
   1241f:	76 ed                	jbe    1240e <@HalInitializeDisplay@4+0x1de>
   12421:	b9 10 00 00 00       	mov    $0x10,%ecx
   12426:	e8 c5 fc ff ff       	call   120f0 <@HalReadAc@4>
   1242b:	89 c7                	mov    %eax,%edi
   1242d:	a8 01                	test   $0x1,%al
   1242f:	0f 85 0d fe ff ff    	jne    12242 <@HalInitializeDisplay@4+0x12>
   12435:	83 ec 0c             	sub    $0xc,%esp
   12438:	31 db                	xor    %ebx,%ebx
   1243a:	be 00 e4 01 00       	mov    $0x1e400,%esi
   1243f:	68 cc 03 00 00       	push   $0x3cc
   12444:	e8 97 26 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12449:	b9 04 00 00 00       	mov    $0x4,%ecx
   1244e:	83 c4 0c             	add    $0xc,%esp
   12451:	88 45 ef             	mov    %al,0xffffffef(%ebp)
   12454:	e8 77 fb ff ff       	call   11fd0 <@HalReadGc@4>
   12459:	b9 05 00 00 00       	mov    $0x5,%ecx
   1245e:	88 45 ee             	mov    %al,0xffffffee(%ebp)
   12461:	e8 6a fb ff ff       	call   11fd0 <@HalReadGc@4>
   12466:	b9 06 00 00 00       	mov    $0x6,%ecx
   1246b:	88 45 ed             	mov    %al,0xffffffed(%ebp)
   1246e:	e8 5d fb ff ff       	call   11fd0 <@HalReadGc@4>
   12473:	b9 02 00 00 00       	mov    $0x2,%ecx
   12478:	88 45 ec             	mov    %al,0xffffffec(%ebp)
   1247b:	e8 b0 fb ff ff       	call   12030 <@HalReadSeq@4>
   12480:	b9 04 00 00 00       	mov    $0x4,%ecx
   12485:	88 45 eb             	mov    %al,0xffffffeb(%ebp)
   12488:	e8 a3 fb ff ff       	call   12030 <@HalReadSeq@4>
   1248d:	88 45 ea             	mov    %al,0xffffffea(%ebp)
   12490:	51                   	push   %ecx
   12491:	51                   	push   %ecx
   12492:	8a 45 ef             	mov    0xffffffef(%ebp),%al
   12495:	83 c8 01             	or     $0x1,%eax
   12498:	25 ff 00 00 00       	and    $0xff,%eax
   1249d:	50                   	push   %eax
   1249e:	68 c2 03 00 00       	push   $0x3c2
   124a3:	e8 e8 26 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   124a8:	31 c9                	xor    %ecx,%ecx
   124aa:	58                   	pop    %eax
   124ab:	5a                   	pop    %edx
   124ac:	e8 ef fc ff ff       	call   121a0 <@HalBlankScreen@4>
   124b1:	88 d9                	mov    %bl,%cl
   124b3:	ba 04 00 00 00       	mov    $0x4,%edx
   124b8:	d3 e2                	shl    %cl,%edx
   124ba:	81 e2 ff 00 00 00    	and    $0xff,%edx
   124c0:	b9 02 00 00 00       	mov    $0x2,%ecx
   124c5:	e8 96 fb ff ff       	call   12060 <@HalWriteSeq@8>
   124ca:	ba 06 00 00 00       	mov    $0x6,%edx
   124cf:	b9 04 00 00 00       	mov    $0x4,%ecx
   124d4:	e8 87 fb ff ff       	call   12060 <@HalWriteSeq@8>
   124d9:	8d 53 02             	lea    0x2(%ebx),%edx
   124dc:	81 e2 ff 00 00 00    	and    $0xff,%edx
   124e2:	b9 04 00 00 00       	mov    $0x4,%ecx
   124e7:	e8 14 fb ff ff       	call   12000 <@HalWriteGc@8>
   124ec:	31 d2                	xor    %edx,%edx
   124ee:	b9 05 00 00 00       	mov    $0x5,%ecx
   124f3:	43                   	inc    %ebx
   124f4:	e8 07 fb ff ff       	call   12000 <@HalWriteGc@8>
   124f9:	ba 05 00 00 00       	mov    $0x5,%edx
   124fe:	b9 06 00 00 00       	mov    $0x6,%ecx
   12503:	e8 f8 fa ff ff       	call   12000 <@HalWriteGc@8>
   12508:	50                   	push   %eax
   12509:	68 00 00 01 00       	push   $0x10000
   1250e:	a1 70 e0 01 00       	mov    0x1e070,%eax
   12513:	50                   	push   %eax
   12514:	56                   	push   %esi
   12515:	81 c6 00 00 01 00    	add    $0x10000,%esi
   1251b:	e8 60 83 00 00       	call   1a880 <_memcpy>
   12520:	83 c4 10             	add    $0x10,%esp
   12523:	83 fb 01             	cmp    $0x1,%ebx
   12526:	76 89                	jbe    124b1 <@HalInitializeDisplay@4+0x281>
   12528:	89 fa                	mov    %edi,%edx
   1252a:	b9 10 00 00 00       	mov    $0x10,%ecx
   1252f:	81 e2 ff 00 00 00    	and    $0xff,%edx
   12535:	e8 56 fb ff ff       	call   12090 <@HalWriteAc@8>
   1253a:	31 d2                	xor    %edx,%edx
   1253c:	8a 55 eb             	mov    0xffffffeb(%ebp),%dl
   1253f:	b9 02 00 00 00       	mov    $0x2,%ecx
   12544:	e8 17 fb ff ff       	call   12060 <@HalWriteSeq@8>
   12549:	31 d2                	xor    %edx,%edx
   1254b:	8a 55 ea             	mov    0xffffffea(%ebp),%dl
   1254e:	b9 04 00 00 00       	mov    $0x4,%ecx
   12553:	e8 08 fb ff ff       	call   12060 <@HalWriteSeq@8>
   12558:	31 d2                	xor    %edx,%edx
   1255a:	8a 55 ee             	mov    0xffffffee(%ebp),%dl
   1255d:	b9 04 00 00 00       	mov    $0x4,%ecx
   12562:	e8 99 fa ff ff       	call   12000 <@HalWriteGc@8>
   12567:	31 d2                	xor    %edx,%edx
   12569:	8a 55 ed             	mov    0xffffffed(%ebp),%dl
   1256c:	b9 05 00 00 00       	mov    $0x5,%ecx
   12571:	e8 8a fa ff ff       	call   12000 <@HalWriteGc@8>
   12576:	31 d2                	xor    %edx,%edx
   12578:	8a 55 ec             	mov    0xffffffec(%ebp),%dl
   1257b:	b9 06 00 00 00       	mov    $0x6,%ecx
   12580:	e8 7b fa ff ff       	call   12000 <@HalWriteGc@8>
   12585:	50                   	push   %eax
   12586:	50                   	push   %eax
   12587:	31 c0                	xor    %eax,%eax
   12589:	8a 45 ef             	mov    0xffffffef(%ebp),%al
   1258c:	50                   	push   %eax
   1258d:	68 c2 03 00 00       	push   $0x3c2
   12592:	e8 f9 25 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12597:	b9 01 00 00 00       	mov    $0x1,%ecx
   1259c:	5e                   	pop    %esi
   1259d:	5f                   	pop    %edi
   1259e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   125a1:	5b                   	pop    %ebx
   125a2:	5e                   	pop    %esi
   125a3:	5f                   	pop    %edi
   125a4:	5d                   	pop    %ebp
   125a5:	e9 f6 fb ff ff       	jmp    121a0 <@HalBlankScreen@4>
   125aa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

000125b0 <_HalReleaseDisplayOwnership@0>:
   125b0:	55                   	push   %ebp
   125b1:	89 e5                	mov    %esp,%ebp
   125b3:	57                   	push   %edi
   125b4:	56                   	push   %esi
   125b5:	53                   	push   %ebx
   125b6:	83 ec 0c             	sub    $0xc,%esp
   125b9:	a1 50 e0 01 00       	mov    0x1e050,%eax
   125be:	85 c0                	test   %eax,%eax
   125c0:	74 39                	je     125fb <_HalReleaseDisplayOwnership@0+0x4b>
   125c2:	80 3d 00 b0 01 00 01 	cmpb   $0x1,0x1b000
   125c9:	74 30                	je     125fb <_HalReleaseDisplayOwnership@0+0x4b>
   125cb:	57                   	push   %edi
   125cc:	57                   	push   %edi
   125cd:	8b 35 04 b0 01 00    	mov    0x1b004,%esi
   125d3:	56                   	push   %esi
   125d4:	8b 1d 08 b0 01 00    	mov    0x1b008,%ebx
   125da:	53                   	push   %ebx
   125db:	ff d0                	call   *%eax
   125dd:	5a                   	pop    %edx
   125de:	84 c0                	test   %al,%al
   125e0:	59                   	pop    %ecx
   125e1:	74 20                	je     12603 <_HalReleaseDisplayOwnership@0+0x53>
   125e3:	c6 05 00 b0 01 00 01 	movb   $0x1,0x1b000
   125ea:	b9 17 00 00 00       	mov    $0x17,%ecx
   125ef:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   125f2:	5b                   	pop    %ebx
   125f3:	5e                   	pop    %esi
   125f4:	5f                   	pop    %edi
   125f5:	5d                   	pop    %ebp
   125f6:	e9 25 f9 ff ff       	jmp    11f20 <@HalClearDisplay@4>
   125fb:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   125fe:	5b                   	pop    %ebx
   125ff:	5e                   	pop    %esi
   12600:	5f                   	pop    %edi
   12601:	5d                   	pop    %ebp
   12602:	c3                   	ret    
   12603:	31 c0                	xor    %eax,%eax
   12605:	57                   	push   %edi
   12606:	57                   	push   %edi
   12607:	a0 90 e3 01 00       	mov    0x1e390,%al
   1260c:	50                   	push   %eax
   1260d:	68 c2 03 00 00       	push   $0x3c2
   12612:	e8 79 25 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12617:	5b                   	pop    %ebx
   12618:	bb 01 00 00 00       	mov    $0x1,%ebx
   1261d:	5e                   	pop    %esi
   1261e:	31 d2                	xor    %edx,%edx
   12620:	89 d9                	mov    %ebx,%ecx
   12622:	8a 93 f0 e3 01 00    	mov    0x1e3f0(%ebx),%dl
   12628:	43                   	inc    %ebx
   12629:	e8 32 fa ff ff       	call   12060 <@HalWriteSeq@8>
   1262e:	83 fb 04             	cmp    $0x4,%ebx
   12631:	76 eb                	jbe    1261e <_HalReleaseDisplayOwnership@0+0x6e>
   12633:	31 d2                	xor    %edx,%edx
   12635:	b9 11 00 00 00       	mov    $0x11,%ecx
   1263a:	8a 15 b1 e3 01 00    	mov    0x1e3b1,%dl
   12640:	31 db                	xor    %ebx,%ebx
   12642:	83 e2 7f             	and    $0x7f,%edx
   12645:	e8 f6 fa ff ff       	call   12140 <@HalWriteCrtc@8>
   1264a:	31 d2                	xor    %edx,%edx
   1264c:	89 d9                	mov    %ebx,%ecx
   1264e:	8a 93 a0 e3 01 00    	mov    0x1e3a0(%ebx),%dl
   12654:	43                   	inc    %ebx
   12655:	e8 e6 fa ff ff       	call   12140 <@HalWriteCrtc@8>
   1265a:	83 fb 18             	cmp    $0x18,%ebx
   1265d:	76 eb                	jbe    1264a <_HalReleaseDisplayOwnership@0+0x9a>
   1265f:	31 db                	xor    %ebx,%ebx
   12661:	31 d2                	xor    %edx,%edx
   12663:	89 d9                	mov    %ebx,%ecx
   12665:	8a 93 e0 e3 01 00    	mov    0x1e3e0(%ebx),%dl
   1266b:	43                   	inc    %ebx
   1266c:	e8 8f f9 ff ff       	call   12000 <@HalWriteGc@8>
   12671:	83 fb 08             	cmp    $0x8,%ebx
   12674:	76 eb                	jbe    12661 <_HalReleaseDisplayOwnership@0+0xb1>
   12676:	e8 25 f9 ff ff       	call   11fa0 <_HalEnablePalette>
   1267b:	31 db                	xor    %ebx,%ebx
   1267d:	31 d2                	xor    %edx,%edx
   1267f:	89 d9                	mov    %ebx,%ecx
   12681:	8a 93 c0 e3 01 00    	mov    0x1e3c0(%ebx),%dl
   12687:	43                   	inc    %ebx
   12688:	e8 03 fa ff ff       	call   12090 <@HalWriteAc@8>
   1268d:	83 fb 14             	cmp    $0x14,%ebx
   12690:	76 eb                	jbe    1267d <_HalReleaseDisplayOwnership@0+0xcd>
   12692:	e8 d9 f8 ff ff       	call   11f70 <_HalDisablePalette>
   12697:	83 ec 0c             	sub    $0xc,%esp
   1269a:	68 cc 03 00 00       	push   $0x3cc
   1269f:	e8 3c 24 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   126a4:	b9 10 00 00 00       	mov    $0x10,%ecx
   126a9:	83 c4 0c             	add    $0xc,%esp
   126ac:	89 c7                	mov    %eax,%edi
   126ae:	e8 3d fa ff ff       	call   120f0 <@HalReadAc@4>
   126b3:	b9 01 00 00 00       	mov    $0x1,%ecx
   126b8:	31 db                	xor    %ebx,%ebx
   126ba:	88 45 f3             	mov    %al,0xfffffff3(%ebp)
   126bd:	be 00 e4 01 00       	mov    $0x1e400,%esi
   126c2:	e8 09 f9 ff ff       	call   11fd0 <@HalReadGc@4>
   126c7:	b9 03 00 00 00       	mov    $0x3,%ecx
   126cc:	88 45 f2             	mov    %al,0xfffffff2(%ebp)
   126cf:	e8 fc f8 ff ff       	call   11fd0 <@HalReadGc@4>
   126d4:	b9 04 00 00 00       	mov    $0x4,%ecx
   126d9:	88 45 f1             	mov    %al,0xfffffff1(%ebp)
   126dc:	e8 ef f8 ff ff       	call   11fd0 <@HalReadGc@4>
   126e1:	b9 05 00 00 00       	mov    $0x5,%ecx
   126e6:	88 45 f0             	mov    %al,0xfffffff0(%ebp)
   126e9:	e8 e2 f8 ff ff       	call   11fd0 <@HalReadGc@4>
   126ee:	b9 06 00 00 00       	mov    $0x6,%ecx
   126f3:	88 45 ef             	mov    %al,0xffffffef(%ebp)
   126f6:	e8 d5 f8 ff ff       	call   11fd0 <@HalReadGc@4>
   126fb:	b9 08 00 00 00       	mov    $0x8,%ecx
   12700:	88 45 ee             	mov    %al,0xffffffee(%ebp)
   12703:	e8 c8 f8 ff ff       	call   11fd0 <@HalReadGc@4>
   12708:	b9 02 00 00 00       	mov    $0x2,%ecx
   1270d:	88 45 ed             	mov    %al,0xffffffed(%ebp)
   12710:	e8 1b f9 ff ff       	call   12030 <@HalReadSeq@4>
   12715:	b9 04 00 00 00       	mov    $0x4,%ecx
   1271a:	88 45 ec             	mov    %al,0xffffffec(%ebp)
   1271d:	e8 0e f9 ff ff       	call   12030 <@HalReadSeq@4>
   12722:	88 45 eb             	mov    %al,0xffffffeb(%ebp)
   12725:	89 f8                	mov    %edi,%eax
   12727:	83 c8 10             	or     $0x10,%eax
   1272a:	51                   	push   %ecx
   1272b:	25 ff 00 00 00       	and    $0xff,%eax
   12730:	51                   	push   %ecx
   12731:	50                   	push   %eax
   12732:	68 c2 03 00 00       	push   $0x3c2
   12737:	e8 54 24 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1273c:	31 c9                	xor    %ecx,%ecx
   1273e:	58                   	pop    %eax
   1273f:	5a                   	pop    %edx
   12740:	e8 5b fa ff ff       	call   121a0 <@HalBlankScreen@4>
   12745:	31 d2                	xor    %edx,%edx
   12747:	b9 03 00 00 00       	mov    $0x3,%ecx
   1274c:	e8 af f8 ff ff       	call   12000 <@HalWriteGc@8>
   12751:	ba ff 00 00 00       	mov    $0xff,%edx
   12756:	b9 08 00 00 00       	mov    $0x8,%ecx
   1275b:	e8 a0 f8 ff ff       	call   12000 <@HalWriteGc@8>
   12760:	31 d2                	xor    %edx,%edx
   12762:	b9 01 00 00 00       	mov    $0x1,%ecx
   12767:	e8 94 f8 ff ff       	call   12000 <@HalWriteGc@8>
   1276c:	88 d9                	mov    %bl,%cl
   1276e:	ba 04 00 00 00       	mov    $0x4,%edx
   12773:	d3 e2                	shl    %cl,%edx
   12775:	81 e2 ff 00 00 00    	and    $0xff,%edx
   1277b:	b9 02 00 00 00       	mov    $0x2,%ecx
   12780:	e8 db f8 ff ff       	call   12060 <@HalWriteSeq@8>
   12785:	ba 06 00 00 00       	mov    $0x6,%edx
   1278a:	b9 04 00 00 00       	mov    $0x4,%ecx
   1278f:	e8 cc f8 ff ff       	call   12060 <@HalWriteSeq@8>
   12794:	8d 53 02             	lea    0x2(%ebx),%edx
   12797:	81 e2 ff 00 00 00    	and    $0xff,%edx
   1279d:	b9 04 00 00 00       	mov    $0x4,%ecx
   127a2:	e8 59 f8 ff ff       	call   12000 <@HalWriteGc@8>
   127a7:	31 d2                	xor    %edx,%edx
   127a9:	b9 05 00 00 00       	mov    $0x5,%ecx
   127ae:	43                   	inc    %ebx
   127af:	e8 4c f8 ff ff       	call   12000 <@HalWriteGc@8>
   127b4:	ba 05 00 00 00       	mov    $0x5,%edx
   127b9:	b9 06 00 00 00       	mov    $0x6,%ecx
   127be:	e8 3d f8 ff ff       	call   12000 <@HalWriteGc@8>
   127c3:	50                   	push   %eax
   127c4:	68 00 00 01 00       	push   $0x10000
   127c9:	56                   	push   %esi
   127ca:	81 c6 00 00 01 00    	add    $0x10000,%esi
   127d0:	a1 70 e0 01 00       	mov    0x1e070,%eax
   127d5:	50                   	push   %eax
   127d6:	e8 a5 80 00 00       	call   1a880 <_memcpy>
   127db:	83 c4 10             	add    $0x10,%esp
   127de:	83 fb 01             	cmp    $0x1,%ebx
   127e1:	76 89                	jbe    1276c <_HalReleaseDisplayOwnership@0+0x1bc>
   127e3:	b9 01 00 00 00       	mov    $0x1,%ecx
   127e8:	e8 b3 f9 ff ff       	call   121a0 <@HalBlankScreen@4>
   127ed:	89 f8                	mov    %edi,%eax
   127ef:	25 ff 00 00 00       	and    $0xff,%eax
   127f4:	51                   	push   %ecx
   127f5:	51                   	push   %ecx
   127f6:	50                   	push   %eax
   127f7:	68 c2 03 00 00       	push   $0x3c2
   127fc:	e8 8f 23 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12801:	b9 10 00 00 00       	mov    $0x10,%ecx
   12806:	58                   	pop    %eax
   12807:	5a                   	pop    %edx
   12808:	31 d2                	xor    %edx,%edx
   1280a:	8a 55 f3             	mov    0xfffffff3(%ebp),%dl
   1280d:	e8 7e f8 ff ff       	call   12090 <@HalWriteAc@8>
   12812:	31 d2                	xor    %edx,%edx
   12814:	8a 55 f2             	mov    0xfffffff2(%ebp),%dl
   12817:	b9 01 00 00 00       	mov    $0x1,%ecx
   1281c:	e8 df f7 ff ff       	call   12000 <@HalWriteGc@8>
   12821:	31 d2                	xor    %edx,%edx
   12823:	8a 55 f1             	mov    0xfffffff1(%ebp),%dl
   12826:	b9 03 00 00 00       	mov    $0x3,%ecx
   1282b:	e8 d0 f7 ff ff       	call   12000 <@HalWriteGc@8>
   12830:	31 d2                	xor    %edx,%edx
   12832:	8a 55 f0             	mov    0xfffffff0(%ebp),%dl
   12835:	b9 04 00 00 00       	mov    $0x4,%ecx
   1283a:	e8 c1 f7 ff ff       	call   12000 <@HalWriteGc@8>
   1283f:	31 d2                	xor    %edx,%edx
   12841:	8a 55 ef             	mov    0xffffffef(%ebp),%dl
   12844:	b9 05 00 00 00       	mov    $0x5,%ecx
   12849:	e8 b2 f7 ff ff       	call   12000 <@HalWriteGc@8>
   1284e:	31 d2                	xor    %edx,%edx
   12850:	8a 55 ee             	mov    0xffffffee(%ebp),%dl
   12853:	b9 06 00 00 00       	mov    $0x6,%ecx
   12858:	e8 a3 f7 ff ff       	call   12000 <@HalWriteGc@8>
   1285d:	31 d2                	xor    %edx,%edx
   1285f:	8a 55 ed             	mov    0xffffffed(%ebp),%dl
   12862:	b9 08 00 00 00       	mov    $0x8,%ecx
   12867:	e8 94 f7 ff ff       	call   12000 <@HalWriteGc@8>
   1286c:	31 d2                	xor    %edx,%edx
   1286e:	8a 55 ec             	mov    0xffffffec(%ebp),%dl
   12871:	b9 02 00 00 00       	mov    $0x2,%ecx
   12876:	e8 e5 f7 ff ff       	call   12060 <@HalWriteSeq@8>
   1287b:	31 d2                	xor    %edx,%edx
   1287d:	8a 55 eb             	mov    0xffffffeb(%ebp),%dl
   12880:	b9 04 00 00 00       	mov    $0x4,%ecx
   12885:	e8 d6 f7 ff ff       	call   12060 <@HalWriteSeq@8>
   1288a:	57                   	push   %edi
   1288b:	57                   	push   %edi
   1288c:	68 ff 00 00 00       	push   $0xff
   12891:	68 c6 03 00 00       	push   $0x3c6
   12896:	e8 f5 22 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1289b:	6a 00                	push   $0x0
   1289d:	68 c8 03 00 00       	push   $0x3c8
   128a2:	e8 e9 22 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   128a7:	5b                   	pop    %ebx
   128a8:	31 db                	xor    %ebx,%ebx
   128aa:	5e                   	pop    %esi
   128ab:	90                   	nop    
   128ac:	8d 74 26 00          	lea    0x0(%esi),%esi
   128b0:	31 c0                	xor    %eax,%eax
   128b2:	51                   	push   %ecx
   128b3:	51                   	push   %ecx
   128b4:	8a 83 90 e0 01 00    	mov    0x1e090(%ebx),%al
   128ba:	43                   	inc    %ebx
   128bb:	50                   	push   %eax
   128bc:	68 c9 03 00 00       	push   $0x3c9
   128c1:	e8 ca 22 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   128c6:	58                   	pop    %eax
   128c7:	5a                   	pop    %edx
   128c8:	e8 43 f9 ff ff       	call   12210 <_HalDacDelay>
   128cd:	81 fb ff 02 00 00    	cmp    $0x2ff,%ebx
   128d3:	76 db                	jbe    128b0 <_HalReleaseDisplayOwnership@0+0x300>
   128d5:	e8 96 f6 ff ff       	call   11f70 <_HalDisablePalette>
   128da:	e9 04 fd ff ff       	jmp    125e3 <_HalReleaseDisplayOwnership@0+0x33>
   128df:	90                   	nop    

000128e0 <_HalAcquireDisplayOwnership@4>:
   128e0:	55                   	push   %ebp
   128e1:	c6 05 00 b0 01 00 00 	movb   $0x0,0x1b000
   128e8:	89 e5                	mov    %esp,%ebp
   128ea:	8b 45 08             	mov    0x8(%ebp),%eax
   128ed:	5d                   	pop    %ebp
   128ee:	a3 50 e0 01 00       	mov    %eax,0x1e050
   128f3:	c2 04 00             	ret    $0x4
   128f6:	8d 76 00             	lea    0x0(%esi),%esi
   128f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012900 <_HalDisplayString@4>:
   12900:	55                   	push   %ebp
   12901:	89 e5                	mov    %esp,%ebp
   12903:	57                   	push   %edi
   12904:	56                   	push   %esi
   12905:	53                   	push   %ebx
   12906:	83 ec 1c             	sub    $0x1c,%esp
   12909:	80 3d 00 b0 01 00 00 	cmpb   $0x0,0x1b000
   12910:	74 09                	je     1291b <_HalDisplayString@4+0x1b>
   12912:	80 3d 30 e0 01 00 00 	cmpb   $0x0,0x1e030
   12919:	75 0a                	jne    12925 <_HalDisplayString@4+0x25>
   1291b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1291e:	5b                   	pop    %ebx
   1291f:	5e                   	pop    %esi
   12920:	5f                   	pop    %edi
   12921:	5d                   	pop    %ebp
   12922:	c2 04 00             	ret    $0x4
   12925:	8b 45 08             	mov    0x8(%ebp),%eax
   12928:	b9 1f 00 00 00       	mov    $0x1f,%ecx
   1292d:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   12930:	e8 fb 76 00 00       	call   1a030 <@KfRaiseIrql@4>
   12935:	b9 80 e0 01 00       	mov    $0x1e080,%ecx
   1293a:	88 45 ef             	mov    %al,0xffffffef(%ebp)
   1293d:	e8 7e 7f 00 00       	call   1a8c0 <@KiAcquireSpinLock@4>
   12942:	9c                   	pushf  
   12943:	8f 45 e8             	popl   0xffffffe8(%ebp)
   12946:	fa                   	cli    
   12947:	52                   	push   %edx
   12948:	52                   	push   %edx
   12949:	6a 0e                	push   $0xe
   1294b:	68 d4 03 00 00       	push   $0x3d4
   12950:	e8 3b 22 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12955:	31 db                	xor    %ebx,%ebx
   12957:	50                   	push   %eax
   12958:	68 d5 03 00 00       	push   $0x3d5
   1295d:	e8 7e 21 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12962:	88 c3                	mov    %al,%bl
   12964:	c1 e3 08             	shl    $0x8,%ebx
   12967:	c7 04 24 0f 00 00 00 	movl   $0xf,(%esp)
   1296e:	68 d4 03 00 00       	push   $0x3d4
   12973:	e8 18 22 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12978:	50                   	push   %eax
   12979:	68 d5 03 00 00       	push   $0x3d5
   1297e:	e8 5d 21 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12983:	31 d2                	xor    %edx,%edx
   12985:	25 ff 00 00 00       	and    $0xff,%eax
   1298a:	8b 3d 08 b0 01 00    	mov    0x1b008,%edi
   12990:	01 c3                	add    %eax,%ebx
   12992:	83 c4 0c             	add    $0xc,%esp
   12995:	89 d8                	mov    %ebx,%eax
   12997:	f7 f7                	div    %edi
   12999:	89 15 20 e0 01 00    	mov    %edx,0x1e020
   1299f:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   129a2:	a3 10 e0 01 00       	mov    %eax,0x1e010
   129a7:	89 c6                	mov    %eax,%esi
   129a9:	8a 02                	mov    (%edx),%al
   129ab:	84 c0                	test   %al,%al
   129ad:	0f 84 d8 00 00 00    	je     12a8b <_HalDisplayString@4+0x18b>
   129b3:	8b 1d 04 b0 01 00    	mov    0x1b004,%ebx
   129b9:	89 5d e4             	mov    %ebx,0xffffffe4(%ebp)
   129bc:	eb 16                	jmp    129d4 <_HalDisplayString@4+0xd4>
   129be:	89 f6                	mov    %esi,%esi
   129c0:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   129c3:	40                   	inc    %eax
   129c4:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   129c7:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   129ca:	8a 02                	mov    (%edx),%al
   129cc:	84 c0                	test   %al,%al
   129ce:	0f 84 b7 00 00 00    	je     12a8b <_HalDisplayString@4+0x18b>
   129d4:	3c 0a                	cmp    $0xa,%al
   129d6:	74 31                	je     12a09 <_HalDisplayString@4+0x109>
   129d8:	3c 08                	cmp    $0x8,%al
   129da:	0f 84 9a 00 00 00    	je     12a7a <_HalDisplayString@4+0x17a>
   129e0:	3c 0d                	cmp    $0xd,%al
   129e2:	74 36                	je     12a1a <_HalDisplayString@4+0x11a>
   129e4:	89 f1                	mov    %esi,%ecx
   129e6:	8b 1d 20 e0 01 00    	mov    0x1e020,%ebx
   129ec:	0f af cf             	imul   %edi,%ecx
   129ef:	66 98                	cbtw   
   129f1:	01 d9                	add    %ebx,%ecx
   129f3:	8b 15 40 e0 01 00    	mov    0x1e040,%edx
   129f9:	05 00 17 00 00       	add    $0x1700,%eax
   129fe:	66 89 04 4a          	mov    %ax,(%edx,%ecx,2)
   12a02:	8d 43 01             	lea    0x1(%ebx),%eax
   12a05:	39 f8                	cmp    %edi,%eax
   12a07:	72 7b                	jb     12a84 <_HalDisplayString@4+0x184>
   12a09:	46                   	inc    %esi
   12a0a:	c7 05 20 e0 01 00 00 	movl   $0x0,0x1e020
   12a11:	00 00 00 
   12a14:	89 35 10 e0 01 00    	mov    %esi,0x1e010
   12a1a:	3b 75 e4             	cmp    0xffffffe4(%ebp),%esi
   12a1d:	72 a1                	jb     129c0 <_HalDisplayString@4+0xc0>
   12a1f:	8b 15 40 e0 01 00    	mov    0x1e040,%edx
   12a25:	50                   	push   %eax
   12a26:	8b 5d e4             	mov    0xffffffe4(%ebp),%ebx
   12a29:	8d 0c 7a             	lea    (%edx,%edi,2),%ecx
   12a2c:	8d 44 1b fe          	lea    0xfffffffe(%ebx,%ebx,1),%eax
   12a30:	0f af c7             	imul   %edi,%eax
   12a33:	50                   	push   %eax
   12a34:	51                   	push   %ecx
   12a35:	52                   	push   %edx
   12a36:	e8 95 7e 00 00       	call   1a8d0 <_RtlMoveMemory@12>
   12a3b:	58                   	pop    %eax
   12a3c:	a1 04 b0 01 00       	mov    0x1b004,%eax
   12a41:	8b 3d 08 b0 01 00    	mov    0x1b008,%edi
   12a47:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   12a4a:	8d 4c 00 fe          	lea    0xfffffffe(%eax,%eax,1),%ecx
   12a4e:	a1 40 e0 01 00       	mov    0x1e040,%eax
   12a53:	0f af cf             	imul   %edi,%ecx
   12a56:	01 c1                	add    %eax,%ecx
   12a58:	83 ff 00             	cmp    $0x0,%edi
   12a5b:	7e 0e                	jle    12a6b <_HalDisplayString@4+0x16b>
   12a5d:	89 f8                	mov    %edi,%eax
   12a5f:	90                   	nop    
   12a60:	66 c7 01 20 17       	movw   $0x1720,(%ecx)
   12a65:	83 c1 02             	add    $0x2,%ecx
   12a68:	48                   	dec    %eax
   12a69:	75 f5                	jne    12a60 <_HalDisplayString@4+0x160>
   12a6b:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
   12a6e:	4e                   	dec    %esi
   12a6f:	89 35 10 e0 01 00    	mov    %esi,0x1e010
   12a75:	e9 46 ff ff ff       	jmp    129c0 <_HalDisplayString@4+0xc0>
   12a7a:	a1 20 e0 01 00       	mov    0x1e020,%eax
   12a7f:	85 c0                	test   %eax,%eax
   12a81:	74 97                	je     12a1a <_HalDisplayString@4+0x11a>
   12a83:	48                   	dec    %eax
   12a84:	a3 20 e0 01 00       	mov    %eax,0x1e020
   12a89:	eb 8f                	jmp    12a1a <_HalDisplayString@4+0x11a>
   12a8b:	89 f3                	mov    %esi,%ebx
   12a8d:	0f af df             	imul   %edi,%ebx
   12a90:	8b 35 20 e0 01 00    	mov    0x1e020,%esi
   12a96:	51                   	push   %ecx
   12a97:	51                   	push   %ecx
   12a98:	6a 0f                	push   $0xf
   12a9a:	68 d4 03 00 00       	push   $0x3d4
   12a9f:	e8 ec 20 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12aa4:	01 f3                	add    %esi,%ebx
   12aa6:	31 c0                	xor    %eax,%eax
   12aa8:	88 d8                	mov    %bl,%al
   12aaa:	50                   	push   %eax
   12aab:	68 d5 03 00 00       	push   $0x3d5
   12ab0:	e8 db 20 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12ab5:	6a 0e                	push   $0xe
   12ab7:	68 d4 03 00 00       	push   $0x3d4
   12abc:	e8 cf 20 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12ac1:	0f b6 c7             	movzbl %bh,%eax
   12ac4:	50                   	push   %eax
   12ac5:	68 d5 03 00 00       	push   $0x3d5
   12aca:	e8 c1 20 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12acf:	ff 75 e8             	pushl  0xffffffe8(%ebp)
   12ad2:	9d                   	popf   
   12ad3:	b9 80 e0 01 00       	mov    $0x1e080,%ecx
   12ad8:	58                   	pop    %eax
   12ad9:	5a                   	pop    %edx
   12ada:	e8 01 7e 00 00       	call   1a8e0 <@KiReleaseSpinLock@4>
   12adf:	31 c9                	xor    %ecx,%ecx
   12ae1:	8a 4d ef             	mov    0xffffffef(%ebp),%cl
   12ae4:	e8 87 74 00 00       	call   19f70 <@KfLowerIrql@4>
   12ae9:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12aec:	5b                   	pop    %ebx
   12aed:	5e                   	pop    %esi
   12aee:	5f                   	pop    %edi
   12aef:	5d                   	pop    %ebp
   12af0:	c2 04 00             	ret    $0x4
   12af3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12af9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012b00 <_HalQueryDisplayParameters@16>:
   12b00:	55                   	push   %ebp
   12b01:	89 e5                	mov    %esp,%ebp
   12b03:	56                   	push   %esi
   12b04:	53                   	push   %ebx
   12b05:	8b 55 08             	mov    0x8(%ebp),%edx
   12b08:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   12b0b:	8b 5d 10             	mov    0x10(%ebp),%ebx
   12b0e:	8b 75 14             	mov    0x14(%ebp),%esi
   12b11:	85 d2                	test   %edx,%edx
   12b13:	74 07                	je     12b1c <_HalQueryDisplayParameters@16+0x1c>
   12b15:	a1 08 b0 01 00       	mov    0x1b008,%eax
   12b1a:	89 02                	mov    %eax,(%edx)
   12b1c:	85 c9                	test   %ecx,%ecx
   12b1e:	74 07                	je     12b27 <_HalQueryDisplayParameters@16+0x27>
   12b20:	a1 04 b0 01 00       	mov    0x1b004,%eax
   12b25:	89 01                	mov    %eax,(%ecx)
   12b27:	85 db                	test   %ebx,%ebx
   12b29:	74 07                	je     12b32 <_HalQueryDisplayParameters@16+0x32>
   12b2b:	a1 20 e0 01 00       	mov    0x1e020,%eax
   12b30:	89 03                	mov    %eax,(%ebx)
   12b32:	85 f6                	test   %esi,%esi
   12b34:	74 07                	je     12b3d <_HalQueryDisplayParameters@16+0x3d>
   12b36:	a1 10 e0 01 00       	mov    0x1e010,%eax
   12b3b:	89 06                	mov    %eax,(%esi)
   12b3d:	5b                   	pop    %ebx
   12b3e:	5e                   	pop    %esi
   12b3f:	5d                   	pop    %ebp
   12b40:	c2 10 00             	ret    $0x10
   12b43:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12b49:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012b50 <_HalSetDisplayParameters@8>:
   12b50:	55                   	push   %ebp
   12b51:	8b 15 08 b0 01 00    	mov    0x1b008,%edx
   12b57:	89 e5                	mov    %esp,%ebp
   12b59:	8b 45 08             	mov    0x8(%ebp),%eax
   12b5c:	39 d0                	cmp    %edx,%eax
   12b5e:	72 03                	jb     12b63 <_HalSetDisplayParameters@8+0x13>
   12b60:	8d 42 ff             	lea    0xffffffff(%edx),%eax
   12b63:	a3 20 e0 01 00       	mov    %eax,0x1e020
   12b68:	8b 15 04 b0 01 00    	mov    0x1b004,%edx
   12b6e:	8b 45 0c             	mov    0xc(%ebp),%eax
   12b71:	39 d0                	cmp    %edx,%eax
   12b73:	72 03                	jb     12b78 <_HalSetDisplayParameters@8+0x28>
   12b75:	8d 42 ff             	lea    0xffffffff(%edx),%eax
   12b78:	a3 10 e0 01 00       	mov    %eax,0x1e010
   12b7d:	5d                   	pop    %ebp
   12b7e:	c2 08 00             	ret    $0x8
   12b81:	eb 0d                	jmp    12b90 <_HalQueryDisplayOwnership@0>
   12b83:	90                   	nop    
   12b84:	90                   	nop    
   12b85:	90                   	nop    
   12b86:	90                   	nop    
   12b87:	90                   	nop    
   12b88:	90                   	nop    
   12b89:	90                   	nop    
   12b8a:	90                   	nop    
   12b8b:	90                   	nop    
   12b8c:	90                   	nop    
   12b8d:	90                   	nop    
   12b8e:	90                   	nop    
   12b8f:	90                   	nop    

00012b90 <_HalQueryDisplayOwnership@0>:
   12b90:	80 3d 00 b0 01 00 00 	cmpb   $0x0,0x1b000
   12b97:	0f 94 c0             	sete   %al
   12b9a:	55                   	push   %ebp
   12b9b:	25 ff 00 00 00       	and    $0xff,%eax
   12ba0:	89 e5                	mov    %esp,%ebp
   12ba2:	5d                   	pop    %ebp
   12ba3:	c3                   	ret    
   12ba4:	90                   	nop    
   12ba5:	90                   	nop    
   12ba6:	90                   	nop    
   12ba7:	90                   	nop    
   12ba8:	90                   	nop    
   12ba9:	90                   	nop    
   12baa:	90                   	nop    
   12bab:	90                   	nop    
   12bac:	90                   	nop    
   12bad:	90                   	nop    
   12bae:	90                   	nop    
   12baf:	90                   	nop    

00012bb0 <_HalpInitDma>:
   12bb0:	55                   	push   %ebp
   12bb1:	89 e5                	mov    %esp,%ebp
   12bb3:	5d                   	pop    %ebp
   12bb4:	c3                   	ret    
   12bb5:	8d 74 26 00          	lea    0x0(%esi),%esi
   12bb9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012bc0 <_HalAllocateCommonBuffer@16>:
   12bc0:	55                   	push   %ebp
   12bc1:	89 e5                	mov    %esp,%ebp
   12bc3:	53                   	push   %ebx
   12bc4:	52                   	push   %edx
   12bc5:	31 c9                	xor    %ecx,%ecx
   12bc7:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12bca:	8a 45 14             	mov    0x14(%ebp),%al
   12bcd:	80 7b 5a 00          	cmpb   $0x0,0x5a(%ebx)
   12bd1:	74 06                	je     12bd9 <_HalAllocateCommonBuffer@16+0x19>
   12bd3:	80 7b 56 00          	cmpb   $0x0,0x56(%ebx)
   12bd7:	75 57                	jne    12c30 <_HalAllocateCommonBuffer@16+0x70>
   12bd9:	ba ff ff ff 00       	mov    $0xffffff,%edx
   12bde:	83 ec 0c             	sub    $0xc,%esp
   12be1:	84 c0                	test   %al,%al
   12be3:	0f 95 c0             	setne  %al
   12be6:	25 ff 00 00 00       	and    $0xff,%eax
   12beb:	68 00 00 01 00       	push   $0x10000
   12bf0:	50                   	push   %eax
   12bf1:	8b 45 0c             	mov    0xc(%ebp),%eax
   12bf4:	6a 00                	push   $0x0
   12bf6:	6a 00                	push   $0x0
   12bf8:	51                   	push   %ecx
   12bf9:	52                   	push   %edx
   12bfa:	6a 00                	push   $0x0
   12bfc:	6a 00                	push   $0x0
   12bfe:	50                   	push   %eax
   12bff:	e8 3c 7c 00 00       	call   1a840 <_MmAllocateContiguousAlignedMemory@36>
   12c04:	89 c3                	mov    %eax,%ebx
   12c06:	83 c4 0c             	add    $0xc,%esp
   12c09:	31 c0                	xor    %eax,%eax
   12c0b:	85 db                	test   %ebx,%ebx
   12c0d:	74 13                	je     12c22 <_HalAllocateCommonBuffer@16+0x62>
   12c0f:	83 ec 0c             	sub    $0xc,%esp
   12c12:	53                   	push   %ebx
   12c13:	e8 48 7c 00 00       	call   1a860 <_MmGetPhysicalAddress@4>
   12c18:	8b 4d 10             	mov    0x10(%ebp),%ecx
   12c1b:	89 01                	mov    %eax,(%ecx)
   12c1d:	89 51 04             	mov    %edx,0x4(%ecx)
   12c20:	89 d8                	mov    %ebx,%eax
   12c22:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   12c25:	c9                   	leave  
   12c26:	c2 10 00             	ret    $0x10
   12c29:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   12c30:	83 ca ff             	or     $0xffffffff,%edx
   12c33:	eb a9                	jmp    12bde <_HalAllocateCommonBuffer@16+0x1e>
   12c35:	8d 74 26 00          	lea    0x0(%esi),%esi
   12c39:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012c40 <_HalFlushCommonBuffer@32>:
   12c40:	55                   	push   %ebp
   12c41:	b8 01 00 00 00       	mov    $0x1,%eax
   12c46:	89 e5                	mov    %esp,%ebp
   12c48:	5d                   	pop    %ebp
   12c49:	c2 20 00             	ret    $0x20
   12c4c:	8d 74 26 00          	lea    0x0(%esi),%esi

00012c50 <_HalFreeCommonBuffer@24>:
   12c50:	55                   	push   %ebp
   12c51:	89 e5                	mov    %esp,%ebp
   12c53:	83 ec 14             	sub    $0x14,%esp
   12c56:	8b 4d 18             	mov    0x18(%ebp),%ecx
   12c59:	51                   	push   %ecx
   12c5a:	e8 c1 7b 00 00       	call   1a820 <_MmFreeContiguousMemory@4>
   12c5f:	c9                   	leave  
   12c60:	c2 18 00             	ret    $0x18
   12c63:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12c69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012c70 <_HalGetAdapter@8>:
   12c70:	55                   	push   %ebp
   12c71:	31 c0                	xor    %eax,%eax
   12c73:	89 e5                	mov    %esp,%ebp
   12c75:	57                   	push   %edi
   12c76:	56                   	push   %esi
   12c77:	53                   	push   %ebx
   12c78:	83 ec 0c             	sub    $0xc,%esp
   12c7b:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12c7e:	8b 13                	mov    (%ebx),%edx
   12c80:	85 d2                	test   %edx,%edx
   12c82:	0f 85 d4 00 00 00    	jne    12d5c <_HalGetAdapter@8+0xec>
   12c88:	8b 53 14             	mov    0x14(%ebx),%edx
   12c8b:	83 fa 05             	cmp    $0x5,%edx
   12c8e:	0f 84 8f 01 00 00    	je     12e23 <_HalGetAdapter@8+0x1b3>
   12c94:	80 7b 05 00          	cmpb   $0x0,0x5(%ebx)
   12c98:	0f 84 c8 00 00 00    	je     12d66 <_HalGetAdapter@8+0xf6>
   12c9e:	8b 45 0c             	mov    0xc(%ebp),%eax
   12ca1:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   12ca7:	50                   	push   %eax
   12ca8:	50                   	push   %eax
   12ca9:	6a 2a                	push   $0x2a
   12cab:	68 81 00 00 00       	push   $0x81
   12cb0:	e8 db 1e 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12cb5:	50                   	push   %eax
   12cb6:	68 81 00 00 00       	push   $0x81
   12cbb:	e8 20 1e 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12cc0:	83 c4 0c             	add    $0xc,%esp
   12cc3:	3c 2a                	cmp    $0x2a,%al
   12cc5:	0f 84 c8 00 00 00    	je     12d93 <_HalGetAdapter@8+0x123>
   12ccb:	8b 43 20             	mov    0x20(%ebx),%eax
   12cce:	89 c2                	mov    %eax,%edx
   12cd0:	81 e2 ff ff ff 7f    	and    $0x7fffffff,%edx
   12cd6:	c1 ea 0c             	shr    $0xc,%edx
   12cd9:	a9 ff 0f 00 00       	test   $0xfff,%eax
   12cde:	0f 84 d2 00 00 00    	je     12db6 <_HalGetAdapter@8+0x146>
   12ce4:	8d 72 02             	lea    0x2(%edx),%esi
   12ce7:	8b 55 0c             	mov    0xc(%ebp),%edx
   12cea:	89 32                	mov    %esi,(%edx)
   12cec:	8b 53 10             	mov    0x10(%ebx),%edx
   12cef:	89 d0                	mov    %edx,%eax
   12cf1:	c1 e8 02             	shr    $0x2,%eax
   12cf4:	83 e0 01             	and    $0x1,%eax
   12cf7:	83 f8 01             	cmp    $0x1,%eax
   12cfa:	8b 04 95 60 e5 03 00 	mov    0x3e560(,%edx,4),%eax
   12d01:	19 ff                	sbb    %edi,%edi
   12d03:	83 c7 02             	add    $0x2,%edi
   12d06:	85 c0                	test   %eax,%eax
   12d08:	0f 84 d2 00 00 00    	je     12de0 <_HalGetAdapter@8+0x170>
   12d0e:	89 c1                	mov    %eax,%ecx
   12d10:	80 78 55 00          	cmpb   $0x0,0x55(%eax)
   12d14:	74 0a                	je     12d20 <_HalGetAdapter@8+0xb0>
   12d16:	3b 70 0c             	cmp    0xc(%eax),%esi
   12d19:	0f 87 13 01 00 00    	ja     12e32 <_HalGetAdapter@8+0x1c2>
   12d1f:	90                   	nop    
   12d20:	4f                   	dec    %edi
   12d21:	0f 94 c0             	sete   %al
   12d24:	25 ff 00 00 00       	and    $0xff,%eax
   12d29:	48                   	dec    %eax
   12d2a:	25 c0 00 00 00       	and    $0xc0,%eax
   12d2f:	89 41 10             	mov    %eax,0x10(%ecx)
   12d32:	8a 43 09             	mov    0x9(%ebx),%al
   12d35:	88 41 59             	mov    %al,0x59(%ecx)
   12d38:	8a 43 08             	mov    0x8(%ebx),%al
   12d3b:	88 41 5a             	mov    %al,0x5a(%ecx)
   12d3e:	8a 43 0b             	mov    0xb(%ebx),%al
   12d41:	88 41 5b             	mov    %al,0x5b(%ecx)
   12d44:	8a 43 05             	mov    0x5(%ebx),%al
   12d47:	88 41 58             	mov    %al,0x58(%ecx)
   12d4a:	8a 43 04             	mov    0x4(%ebx),%al
   12d4d:	88 41 56             	mov    %al,0x56(%ecx)
   12d50:	83 7b 14 05          	cmpl   $0x5,0x14(%ebx)
   12d54:	74 04                	je     12d5a <_HalGetAdapter@8+0xea>
   12d56:	c6 41 5c 01          	movb   $0x1,0x5c(%ecx)
   12d5a:	89 c8                	mov    %ecx,%eax
   12d5c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12d5f:	5b                   	pop    %ebx
   12d60:	5e                   	pop    %esi
   12d61:	5f                   	pop    %edi
   12d62:	5d                   	pop    %ebp
   12d63:	c2 08 00             	ret    $0x8
   12d66:	83 fa 05             	cmp    $0x5,%edx
   12d69:	0f 84 2f ff ff ff    	je     12c9e <_HalGetAdapter@8+0x2e>
   12d6f:	50                   	push   %eax
   12d70:	50                   	push   %eax
   12d71:	6a 2a                	push   $0x2a
   12d73:	68 81 00 00 00       	push   $0x81
   12d78:	e8 13 1e 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12d7d:	50                   	push   %eax
   12d7e:	68 81 00 00 00       	push   $0x81
   12d83:	e8 58 1d 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12d88:	83 c4 0c             	add    $0xc,%esp
   12d8b:	3c 2a                	cmp    $0x2a,%al
   12d8d:	0f 85 38 ff ff ff    	jne    12ccb <_HalGetAdapter@8+0x5b>
   12d93:	8b 43 20             	mov    0x20(%ebx),%eax
   12d96:	c7 05 40 e5 03 00 01 	movl   $0x1,0x3e540
   12d9d:	00 00 00 
   12da0:	89 c2                	mov    %eax,%edx
   12da2:	81 e2 ff ff ff 7f    	and    $0x7fffffff,%edx
   12da8:	c1 ea 0c             	shr    $0xc,%edx
   12dab:	a9 ff 0f 00 00       	test   $0xfff,%eax
   12db0:	0f 85 2e ff ff ff    	jne    12ce4 <_HalGetAdapter@8+0x74>
   12db6:	8d 72 01             	lea    0x1(%edx),%esi
   12db9:	8b 55 0c             	mov    0xc(%ebp),%edx
   12dbc:	89 32                	mov    %esi,(%edx)
   12dbe:	8b 53 10             	mov    0x10(%ebx),%edx
   12dc1:	89 d0                	mov    %edx,%eax
   12dc3:	c1 e8 02             	shr    $0x2,%eax
   12dc6:	83 e0 01             	and    $0x1,%eax
   12dc9:	83 f8 01             	cmp    $0x1,%eax
   12dcc:	8b 04 95 60 e5 03 00 	mov    0x3e560(,%edx,4),%eax
   12dd3:	19 ff                	sbb    %edi,%edi
   12dd5:	83 c7 02             	add    $0x2,%edi
   12dd8:	85 c0                	test   %eax,%eax
   12dda:	0f 85 2e ff ff ff    	jne    12d0e <_HalGetAdapter@8+0x9e>
   12de0:	50                   	push   %eax
   12de1:	31 c0                	xor    %eax,%eax
   12de3:	8a 43 08             	mov    0x8(%ebx),%al
   12de6:	50                   	push   %eax
   12de7:	6a 00                	push   $0x0
   12de9:	56                   	push   %esi
   12dea:	e8 21 e2 ff ff       	call   11010 <_HalpAllocateAdapterEx@12>
   12def:	89 c1                	mov    %eax,%ecx
   12df1:	58                   	pop    %eax
   12df2:	31 c0                	xor    %eax,%eax
   12df4:	85 c9                	test   %ecx,%ecx
   12df6:	0f 84 60 ff ff ff    	je     12d5c <_HalGetAdapter@8+0xec>
   12dfc:	8b 43 10             	mov    0x10(%ebx),%eax
   12dff:	8b 75 0c             	mov    0xc(%ebp),%esi
   12e02:	89 0c 85 60 e5 03 00 	mov    %ecx,0x3e560(,%eax,4)
   12e09:	8b 06                	mov    (%esi),%eax
   12e0b:	85 c0                	test   %eax,%eax
   12e0d:	75 31                	jne    12e40 <_HalGetAdapter@8+0x1d0>
   12e0f:	c6 41 55 00          	movb   $0x0,0x55(%ecx)
   12e13:	80 7b 04 00          	cmpb   $0x0,0x4(%ebx)
   12e17:	74 4b                	je     12e64 <_HalGetAdapter@8+0x1f4>
   12e19:	8b 06                	mov    (%esi),%eax
   12e1b:	89 41 0c             	mov    %eax,0xc(%ecx)
   12e1e:	e9 fd fe ff ff       	jmp    12d20 <_HalGetAdapter@8+0xb0>
   12e23:	80 7b 04 00          	cmpb   $0x0,0x4(%ebx)
   12e27:	0f 85 67 fe ff ff    	jne    12c94 <_HalGetAdapter@8+0x24>
   12e2d:	e9 2a ff ff ff       	jmp    12d5c <_HalGetAdapter@8+0xec>
   12e32:	89 70 0c             	mov    %esi,0xc(%eax)
   12e35:	e9 e6 fe ff ff       	jmp    12d20 <_HalGetAdapter@8+0xb0>
   12e3a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12e40:	c6 41 55 01          	movb   $0x1,0x55(%ecx)
   12e44:	8b 55 0c             	mov    0xc(%ebp),%edx
   12e47:	8b 75 0c             	mov    0xc(%ebp),%esi
   12e4a:	8b 02                	mov    (%edx),%eax
   12e4c:	8b 15 30 e5 03 00    	mov    0x3e530,%edx
   12e52:	89 41 0c             	mov    %eax,0xc(%ecx)
   12e55:	8b 06                	mov    (%esi),%eax
   12e57:	8b 72 1c             	mov    0x1c(%edx),%esi
   12e5a:	01 c6                	add    %eax,%esi
   12e5c:	89 72 1c             	mov    %esi,0x1c(%edx)
   12e5f:	e9 bc fe ff ff       	jmp    12d20 <_HalGetAdapter@8+0xb0>
   12e64:	c7 41 0c 01 00 00 00 	movl   $0x1,0xc(%ecx)
   12e6b:	e9 b0 fe ff ff       	jmp    12d20 <_HalGetAdapter@8+0xb0>

00012e70 <_HalReadDmaCounter@4>:
   12e70:	55                   	push   %ebp
   12e71:	89 e5                	mov    %esp,%ebp
   12e73:	57                   	push   %edi
   12e74:	56                   	push   %esi
   12e75:	53                   	push   %ebx
   12e76:	83 ec 14             	sub    $0x14,%esp
   12e79:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   12e7c:	8b 7d 08             	mov    0x8(%ebp),%edi
   12e7f:	50                   	push   %eax
   12e80:	8b 47 08             	mov    0x8(%edi),%eax
   12e83:	83 c0 44             	add    $0x44,%eax
   12e86:	50                   	push   %eax
   12e87:	e8 24 1e 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   12e8c:	80 7f 51 01          	cmpb   $0x1,0x51(%edi)
   12e90:	58                   	pop    %eax
   12e91:	5a                   	pop    %edx
   12e92:	74 6c                	je     12f00 <_HalReadDmaCounter@4+0x90>
   12e94:	8b 5f 10             	mov    0x10(%edi),%ebx
   12e97:	50                   	push   %eax
   12e98:	50                   	push   %eax
   12e99:	8d 43 18             	lea    0x18(%ebx),%eax
   12e9c:	6a 00                	push   $0x0
   12e9e:	50                   	push   %eax
   12e9f:	e8 ec 1c 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12ea4:	31 c0                	xor    %eax,%eax
   12ea6:	56                   	push   %esi
   12ea7:	8a 47 50             	mov    0x50(%edi),%al
   12eaa:	8d 44 83 02          	lea    0x2(%ebx,%eax,4),%eax
   12eae:	50                   	push   %eax
   12eaf:	e8 2c 1c 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12eb4:	25 ff 00 00 00       	and    $0xff,%eax
   12eb9:	89 c6                	mov    %eax,%esi
   12ebb:	31 c0                	xor    %eax,%eax
   12ebd:	8a 47 50             	mov    0x50(%edi),%al
   12ec0:	8d 44 83 02          	lea    0x2(%ebx,%eax,4),%eax
   12ec4:	50                   	push   %eax
   12ec5:	e8 16 1c 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12eca:	25 ff 00 00 00       	and    $0xff,%eax
   12ecf:	83 c4 0c             	add    $0xc,%esp
   12ed2:	c1 e0 08             	shl    $0x8,%eax
   12ed5:	09 c6                	or     %eax,%esi
   12ed7:	46                   	inc    %esi
   12ed8:	80 7f 57 00          	cmpb   $0x0,0x57(%edi)
   12edc:	74 02                	je     12ee0 <_HalReadDmaCounter@4+0x70>
   12ede:	01 f6                	add    %esi,%esi
   12ee0:	31 c0                	xor    %eax,%eax
   12ee2:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   12ee5:	51                   	push   %ecx
   12ee6:	51                   	push   %ecx
   12ee7:	50                   	push   %eax
   12ee8:	8b 47 08             	mov    0x8(%edi),%eax
   12eeb:	83 c0 44             	add    $0x44,%eax
   12eee:	50                   	push   %eax
   12eef:	e8 2c 1e 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   12ef4:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12ef7:	89 f0                	mov    %esi,%eax
   12ef9:	5b                   	pop    %ebx
   12efa:	5e                   	pop    %esi
   12efb:	5f                   	pop    %edi
   12efc:	5d                   	pop    %ebp
   12efd:	c2 04 00             	ret    $0x4
   12f00:	8b 5f 10             	mov    0x10(%edi),%ebx
   12f03:	50                   	push   %eax
   12f04:	50                   	push   %eax
   12f05:	8d 43 0c             	lea    0xc(%ebx),%eax
   12f08:	6a 00                	push   $0x0
   12f0a:	50                   	push   %eax
   12f0b:	e8 80 1c 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   12f10:	50                   	push   %eax
   12f11:	31 c0                	xor    %eax,%eax
   12f13:	8a 47 50             	mov    0x50(%edi),%al
   12f16:	8d 44 43 01          	lea    0x1(%ebx,%eax,2),%eax
   12f1a:	50                   	push   %eax
   12f1b:	e8 c0 1b 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   12f20:	25 ff 00 00 00       	and    $0xff,%eax
   12f25:	89 c6                	mov    %eax,%esi
   12f27:	31 c0                	xor    %eax,%eax
   12f29:	8a 47 50             	mov    0x50(%edi),%al
   12f2c:	8d 44 43 01          	lea    0x1(%ebx,%eax,2),%eax
   12f30:	eb 92                	jmp    12ec4 <_HalReadDmaCounter@4+0x54>
   12f32:	90                   	nop    
   12f33:	90                   	nop    
   12f34:	90                   	nop    
   12f35:	90                   	nop    
   12f36:	90                   	nop    
   12f37:	90                   	nop    
   12f38:	90                   	nop    
   12f39:	90                   	nop    
   12f3a:	90                   	nop    
   12f3b:	90                   	nop    
   12f3c:	90                   	nop    
   12f3d:	90                   	nop    
   12f3e:	90                   	nop    
   12f3f:	90                   	nop    

00012f40 <_IoAssignDriveLetters@16>:
   12f40:	55                   	push   %ebp
   12f41:	89 e5                	mov    %esp,%ebp
   12f43:	83 ec 10             	sub    $0x10,%esp
   12f46:	8b 45 14             	mov    0x14(%ebp),%eax
   12f49:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12f4c:	50                   	push   %eax
   12f4d:	8b 45 10             	mov    0x10(%ebp),%eax
   12f50:	50                   	push   %eax
   12f51:	a1 10 11 04 00       	mov    0x41110,%eax
   12f56:	8b 55 0c             	mov    0xc(%ebp),%edx
   12f59:	ff 50 18             	call   *0x18(%eax)
   12f5c:	c9                   	leave  
   12f5d:	c2 10 00             	ret    $0x10

00012f60 <_HalpStartEnumerator>:
   12f60:	55                   	push   %ebp
   12f61:	89 e5                	mov    %esp,%ebp
   12f63:	5d                   	pop    %ebp
   12f64:	c3                   	ret    
   12f65:	90                   	nop    
   12f66:	90                   	nop    
   12f67:	90                   	nop    
   12f68:	90                   	nop    
   12f69:	90                   	nop    
   12f6a:	90                   	nop    
   12f6b:	90                   	nop    
   12f6c:	90                   	nop    
   12f6d:	90                   	nop    
   12f6e:	90                   	nop    
   12f6f:	90                   	nop    

00012f70 <@ExAcquireFastMutex@4>:
   12f70:	55                   	push   %ebp
   12f71:	89 e5                	mov    %esp,%ebp
   12f73:	53                   	push   %ebx
   12f74:	89 cb                	mov    %ecx,%ebx
   12f76:	52                   	push   %edx
   12f77:	e8 74 79 00 00       	call   1a8f0 <_KeEnterCriticalRegion@0>
   12f7c:	89 d9                	mov    %ebx,%ecx
   12f7e:	58                   	pop    %eax
   12f7f:	5b                   	pop    %ebx
   12f80:	5d                   	pop    %ebp
   12f81:	e9 7a 79 00 00       	jmp    1a900 <@ExAcquireFastMutexUnsafe@4>
   12f86:	8d 76 00             	lea    0x0(%esi),%esi
   12f89:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012f90 <@ExReleaseFastMutex@4>:
   12f90:	55                   	push   %ebp
   12f91:	89 e5                	mov    %esp,%ebp
   12f93:	50                   	push   %eax
   12f94:	50                   	push   %eax
   12f95:	e8 76 79 00 00       	call   1a910 <@ExReleaseFastMutexUnsafe@4>
   12f9a:	c9                   	leave  
   12f9b:	e9 80 79 00 00       	jmp    1a920 <_KeLeaveCriticalRegion@0>

00012fa0 <@ExTryToAcquireFastMutex@4>:
   12fa0:	55                   	push   %ebp
   12fa1:	89 e5                	mov    %esp,%ebp
   12fa3:	53                   	push   %ebx
   12fa4:	53                   	push   %ebx
   12fa5:	89 cb                	mov    %ecx,%ebx
   12fa7:	e8 44 79 00 00       	call   1a8f0 <_KeEnterCriticalRegion@0>
   12fac:	31 d2                	xor    %edx,%edx
   12fae:	89 d9                	mov    %ebx,%ecx
   12fb0:	e8 7b 79 00 00       	call   1a930 <@InterlockedExchange@8>
   12fb5:	48                   	dec    %eax
   12fb6:	74 0b                	je     12fc3 <@ExTryToAcquireFastMutex@4+0x23>
   12fb8:	e8 63 79 00 00       	call   1a920 <_KeLeaveCriticalRegion@0>
   12fbd:	31 c0                	xor    %eax,%eax
   12fbf:	5a                   	pop    %edx
   12fc0:	5b                   	pop    %ebx
   12fc1:	5d                   	pop    %ebp
   12fc2:	c3                   	ret    
   12fc3:	e8 78 79 00 00       	call   1a940 <_KeGetCurrentThread@0>
   12fc8:	89 43 04             	mov    %eax,0x4(%ebx)
   12fcb:	b8 01 00 00 00       	mov    $0x1,%eax
   12fd0:	5a                   	pop    %edx
   12fd1:	5b                   	pop    %ebx
   12fd2:	5d                   	pop    %ebp
   12fd3:	c3                   	ret    
   12fd4:	90                   	nop    
   12fd5:	90                   	nop    
   12fd6:	90                   	nop    
   12fd7:	90                   	nop    
   12fd8:	90                   	nop    
   12fd9:	90                   	nop    
   12fda:	90                   	nop    
   12fdb:	90                   	nop    
   12fdc:	90                   	nop    
   12fdd:	90                   	nop    
   12fde:	90                   	nop    
   12fdf:	90                   	nop    

00012fe0 <_DriverEntry@8>:
   12fe0:	55                   	push   %ebp
   12fe1:	31 c0                	xor    %eax,%eax
   12fe3:	89 e5                	mov    %esp,%ebp
   12fe5:	5d                   	pop    %ebp
   12fe6:	c2 08 00             	ret    $0x8
   12fe9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00012ff0 <_HalInitSystem@8>:
   12ff0:	55                   	push   %ebp
   12ff1:	89 e5                	mov    %esp,%ebp
   12ff3:	50                   	push   %eax
   12ff4:	50                   	push   %eax
   12ff5:	8b 45 08             	mov    0x8(%ebp),%eax
   12ff8:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   12ffb:	85 c0                	test   %eax,%eax
   12ffd:	74 13                	je     13012 <_HalInitSystem@8+0x22>
   12fff:	83 f8 01             	cmp    $0x1,%eax
   13002:	74 2c                	je     13030 <_HalInitSystem@8+0x40>
   13004:	83 f8 02             	cmp    $0x2,%eax
   13007:	74 44                	je     1304d <_HalInitSystem@8+0x5d>
   13009:	b8 01 00 00 00       	mov    $0x1,%eax
   1300e:	c9                   	leave  
   1300f:	c2 08 00             	ret    $0x8
   13012:	51                   	push   %ecx
   13013:	51                   	push   %ecx
   13014:	6a 04                	push   $0x4
   13016:	68 80 e5 03 00       	push   $0x3e580
   1301b:	e8 70 77 00 00       	call   1a790 <_RtlZeroMemory@8>
   13020:	58                   	pop    %eax
   13021:	5a                   	pop    %edx
   13022:	e8 d9 4d 00 00       	call   17e00 <_HalpInitPhase0>
   13027:	b8 01 00 00 00       	mov    $0x1,%eax
   1302c:	c9                   	leave  
   1302d:	c2 08 00             	ret    $0x8
   13030:	e8 fb f1 ff ff       	call   12230 <@HalInitializeDisplay@4>
   13035:	e8 76 e9 ff ff       	call   119b0 <_HalpInitBusHandlers>
   1303a:	e8 71 fb ff ff       	call   12bb0 <_HalpInitDma>
   1303f:	e8 1c ff ff ff       	call   12f60 <_HalpStartEnumerator>
   13044:	b8 01 00 00 00       	mov    $0x1,%eax
   13049:	c9                   	leave  
   1304a:	c2 08 00             	ret    $0x8
   1304d:	b9 17 00 00 00       	mov    $0x17,%ecx
   13052:	e8 c9 ee ff ff       	call   11f20 <@HalClearDisplay@4>
   13057:	6a 00                	push   $0x0
   13059:	68 00 10 00 00       	push   $0x1000
   1305e:	6a 00                	push   $0x0
   13060:	6a 00                	push   $0x0
   13062:	e8 49 78 00 00       	call   1a8b0 <_MmMapIoSpace@16>
   13067:	a3 00 e4 03 00       	mov    %eax,0x3e400
   1306c:	eb 9b                	jmp    13009 <_HalInitSystem@8+0x19>
   1306e:	90                   	nop    
   1306f:	90                   	nop    

00013070 <_HalIsaProbe>:
   13070:	55                   	push   %ebp
   13071:	89 e5                	mov    %esp,%ebp
   13073:	83 ec 14             	sub    $0x14,%esp
   13076:	68 30 c0 01 00       	push   $0x1c030
   1307b:	e8 10 78 00 00       	call   1a890 <_DbgPrint>
   13080:	b8 01 00 00 00       	mov    $0x1,%eax
   13085:	c9                   	leave  
   13086:	c3                   	ret    
   13087:	89 f6                	mov    %esi,%esi
   13089:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00013090 <_HalpTranslateIsaBusAddress@24>:
   13090:	55                   	push   %ebp
   13091:	89 e5                	mov    %esp,%ebp
   13093:	57                   	push   %edi
   13094:	56                   	push   %esi
   13095:	53                   	push   %ebx
   13096:	83 ec 14             	sub    $0x14,%esp
   13099:	8b 7d 1c             	mov    0x1c(%ebp),%edi
   1309c:	8b 5d 10             	mov    0x10(%ebp),%ebx
   1309f:	8b 75 14             	mov    0x14(%ebp),%esi
   130a2:	57                   	push   %edi
   130a3:	8b 45 18             	mov    0x18(%ebp),%eax
   130a6:	50                   	push   %eax
   130a7:	56                   	push   %esi
   130a8:	8b 45 0c             	mov    0xc(%ebp),%eax
   130ab:	53                   	push   %ebx
   130ac:	50                   	push   %eax
   130ad:	6a 05                	push   $0x5
   130af:	e8 1c ee ff ff       	call   11ed0 <_HalTranslateBusAddress@24>
   130b4:	5a                   	pop    %edx
   130b5:	84 c0                	test   %al,%al
   130b7:	59                   	pop    %ecx
   130b8:	74 16                	je     130d0 <_HalpTranslateIsaBusAddress@24+0x40>
   130ba:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   130bd:	25 ff 00 00 00       	and    $0xff,%eax
   130c2:	5b                   	pop    %ebx
   130c3:	5e                   	pop    %esi
   130c4:	5f                   	pop    %edi
   130c5:	5d                   	pop    %ebp
   130c6:	c2 18 00             	ret    $0x18
   130c9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   130d0:	51                   	push   %ecx
   130d1:	51                   	push   %ecx
   130d2:	57                   	push   %edi
   130d3:	8b 55 18             	mov    0x18(%ebp),%edx
   130d6:	52                   	push   %edx
   130d7:	56                   	push   %esi
   130d8:	8b 45 0c             	mov    0xc(%ebp),%eax
   130db:	53                   	push   %ebx
   130dc:	50                   	push   %eax
   130dd:	6a 00                	push   $0x0
   130df:	e8 ec ed ff ff       	call   11ed0 <_HalTranslateBusAddress@24>
   130e4:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   130e7:	25 ff 00 00 00       	and    $0xff,%eax
   130ec:	5b                   	pop    %ebx
   130ed:	5e                   	pop    %esi
   130ee:	5f                   	pop    %edi
   130ef:	5d                   	pop    %ebp
   130f0:	c2 18 00             	ret    $0x18
   130f3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   130f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00013100 <_HalpGetIsaInterruptVector@24>:
   13100:	55                   	push   %ebp
   13101:	ba 17 00 00 00       	mov    $0x17,%edx
   13106:	89 e5                	mov    %esp,%ebp
   13108:	8b 45 14             	mov    0x14(%ebp),%eax
   1310b:	8b 4d 18             	mov    0x18(%ebp),%ecx
   1310e:	29 c2                	sub    %eax,%edx
   13110:	c1 e2 03             	shl    $0x3,%edx
   13113:	8d 42 30             	lea    0x30(%edx),%eax
   13116:	c1 ea 03             	shr    $0x3,%edx
   13119:	83 c2 04             	add    $0x4,%edx
   1311c:	88 11                	mov    %dl,(%ecx)
   1311e:	8b 55 1c             	mov    0x1c(%ebp),%edx
   13121:	c7 02 ff ff ff ff    	movl   $0xffffffff,(%edx)
   13127:	5d                   	pop    %ebp
   13128:	c2 18 00             	ret    $0x18
   1312b:	90                   	nop    
   1312c:	90                   	nop    
   1312d:	90                   	nop    
   1312e:	90                   	nop    
   1312f:	90                   	nop    

00013130 <_KdpDoesComPortExist>:
   13130:	55                   	push   %ebp
   13131:	89 e5                	mov    %esp,%ebp
   13133:	57                   	push   %edi
   13134:	56                   	push   %esi
   13135:	53                   	push   %ebx
   13136:	83 ec 18             	sub    $0x18,%esp
   13139:	8d 70 04             	lea    0x4(%eax),%esi
   1313c:	89 c7                	mov    %eax,%edi
   1313e:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
   13142:	56                   	push   %esi
   13143:	e8 98 19 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13148:	8d 5f 06             	lea    0x6(%edi),%ebx
   1314b:	88 45 f2             	mov    %al,0xfffffff2(%ebp)
   1314e:	c7 04 24 10 00 00 00 	movl   $0x10,(%esp)
   13155:	56                   	push   %esi
   13156:	e8 35 1a 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1315b:	6a 10                	push   $0x10
   1315d:	56                   	push   %esi
   1315e:	e8 2d 1a 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13163:	50                   	push   %eax
   13164:	53                   	push   %ebx
   13165:	e8 76 19 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1316a:	83 c4 0c             	add    $0xc,%esp
   1316d:	a8 f0                	test   $0xf0,%al
   1316f:	74 1f                	je     13190 <_KdpDoesComPortExist+0x60>
   13171:	50                   	push   %eax
   13172:	50                   	push   %eax
   13173:	31 c0                	xor    %eax,%eax
   13175:	8a 45 f2             	mov    0xfffffff2(%ebp),%al
   13178:	50                   	push   %eax
   13179:	56                   	push   %esi
   1317a:	e8 11 1a 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1317f:	31 c0                	xor    %eax,%eax
   13181:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   13184:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13187:	5b                   	pop    %ebx
   13188:	5e                   	pop    %esi
   13189:	5f                   	pop    %edi
   1318a:	5d                   	pop    %ebp
   1318b:	c3                   	ret    
   1318c:	8d 74 26 00          	lea    0x0(%esi),%esi
   13190:	50                   	push   %eax
   13191:	50                   	push   %eax
   13192:	6a 1f                	push   $0x1f
   13194:	56                   	push   %esi
   13195:	e8 f6 19 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1319a:	50                   	push   %eax
   1319b:	53                   	push   %ebx
   1319c:	e8 3f 19 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   131a1:	25 f0 00 00 00       	and    $0xf0,%eax
   131a6:	83 c4 0c             	add    $0xc,%esp
   131a9:	3d f0 00 00 00       	cmp    $0xf0,%eax
   131ae:	75 c1                	jne    13171 <_KdpDoesComPortExist+0x41>
   131b0:	8d 5f 02             	lea    0x2(%edi),%ebx
   131b3:	50                   	push   %eax
   131b4:	50                   	push   %eax
   131b5:	6a 07                	push   $0x7
   131b7:	53                   	push   %ebx
   131b8:	e8 d3 19 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   131bd:	6a 00                	push   $0x0
   131bf:	53                   	push   %ebx
   131c0:	e8 cb 19 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   131c5:	53                   	push   %ebx
   131c6:	57                   	push   %edi
   131c7:	e8 14 19 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   131cc:	8d 47 01             	lea    0x1(%edi),%eax
   131cf:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   131d6:	50                   	push   %eax
   131d7:	e8 b4 19 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   131dc:	c6 45 f3 01          	movb   $0x1,0xfffffff3(%ebp)
   131e0:	5a                   	pop    %edx
   131e1:	59                   	pop    %ecx
   131e2:	eb 8d                	jmp    13171 <_KdpDoesComPortExist+0x41>
   131e4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   131ea:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

000131f0 <_KdPortInitialize@12>:
   131f0:	55                   	push   %ebp
   131f1:	89 e5                	mov    %esp,%ebp
   131f3:	57                   	push   %edi
   131f4:	56                   	push   %esi
   131f5:	53                   	push   %ebx
   131f6:	83 ec 7c             	sub    $0x7c,%esp
   131f9:	c7 45 c8 00 00 00 00 	movl   $0x0,0xffffffc8(%ebp)
   13200:	8b 5d 08             	mov    0x8(%ebp),%ebx
   13203:	c7 45 cc f8 03 00 00 	movl   $0x3f8,0xffffffcc(%ebp)
   1320a:	c7 45 d0 f8 02 00 00 	movl   $0x2f8,0xffffffd0(%ebp)
   13211:	c7 45 d4 e8 03 00 00 	movl   $0x3e8,0xffffffd4(%ebp)
   13218:	c7 45 d8 e8 02 00 00 	movl   $0x2e8,0xffffffd8(%ebp)
   1321f:	80 3d 28 e4 03 00 00 	cmpb   $0x0,0x3e428
   13226:	75 51                	jne    13279 <_KdPortInitialize@12+0x89>
   13228:	8b 43 04             	mov    0x4(%ebx),%eax
   1322b:	85 c0                	test   %eax,%eax
   1322d:	0f 85 10 01 00 00    	jne    13343 <_KdPortInitialize@12+0x153>
   13233:	8b 03                	mov    (%ebx),%eax
   13235:	c7 05 48 e4 03 00 00 	movl   $0x4b00,0x3e448
   1323c:	4b 00 00 
   1323f:	85 c0                	test   %eax,%eax
   13241:	0f 85 0b 01 00 00    	jne    13352 <_KdPortInitialize@12+0x162>
   13247:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
   1324a:	e8 e1 fe ff ff       	call   13130 <_KdpDoesComPortExist>
   1324f:	84 c0                	test   %al,%al
   13251:	0f 84 21 01 00 00    	je     13378 <_KdPortInitialize@12+0x188>
   13257:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
   1325a:	c7 05 38 e4 03 00 02 	movl   $0x2,0x3e438
   13261:	00 00 00 
   13264:	a3 18 e4 03 00       	mov    %eax,0x3e418
   13269:	89 43 08             	mov    %eax,0x8(%ebx)
   1326c:	c7 03 02 00 00 00    	movl   $0x2,(%ebx)
   13272:	c6 05 28 e4 03 00 01 	movb   $0x1,0x3e428
   13279:	50                   	push   %eax
   1327a:	50                   	push   %eax
   1327b:	6a 03                	push   $0x3
   1327d:	a1 18 e4 03 00       	mov    0x3e418,%eax
   13282:	bb 00 c2 01 00       	mov    $0x1c200,%ebx
   13287:	83 c0 04             	add    $0x4,%eax
   1328a:	50                   	push   %eax
   1328b:	e8 00 19 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13290:	57                   	push   %edi
   13291:	a1 18 e4 03 00       	mov    0x3e418,%eax
   13296:	83 c0 03             	add    $0x3,%eax
   13299:	50                   	push   %eax
   1329a:	e8 41 18 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1329f:	83 c8 80             	or     $0xffffff80,%eax
   132a2:	25 ff 00 00 00       	and    $0xff,%eax
   132a7:	89 04 24             	mov    %eax,(%esp)
   132aa:	a1 18 e4 03 00       	mov    0x3e418,%eax
   132af:	83 c0 03             	add    $0x3,%eax
   132b2:	50                   	push   %eax
   132b3:	e8 d8 18 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   132b8:	89 d8                	mov    %ebx,%eax
   132ba:	31 d2                	xor    %edx,%edx
   132bc:	f7 35 48 e4 03 00    	divl   0x3e448
   132c2:	89 c3                	mov    %eax,%ebx
   132c4:	31 c0                	xor    %eax,%eax
   132c6:	88 d8                	mov    %bl,%al
   132c8:	50                   	push   %eax
   132c9:	8b 35 18 e4 03 00    	mov    0x3e418,%esi
   132cf:	56                   	push   %esi
   132d0:	e8 bb 18 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   132d5:	0f b6 df             	movzbl %bh,%ebx
   132d8:	53                   	push   %ebx
   132d9:	a1 18 e4 03 00       	mov    0x3e418,%eax
   132de:	40                   	inc    %eax
   132df:	50                   	push   %eax
   132e0:	e8 ab 18 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   132e5:	6a 03                	push   $0x3
   132e7:	a1 18 e4 03 00       	mov    0x3e418,%eax
   132ec:	83 c0 03             	add    $0x3,%eax
   132ef:	50                   	push   %eax
   132f0:	e8 9b 18 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   132f5:	53                   	push   %ebx
   132f6:	8d 9d 78 ff ff ff    	lea    0xffffff78(%ebp),%ebx
   132fc:	8b 0d 18 e4 03 00    	mov    0x3e418,%ecx
   13302:	51                   	push   %ecx
   13303:	e8 d8 17 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13308:	a1 18 e4 03 00       	mov    0x3e418,%eax
   1330d:	8b 15 48 e4 03 00    	mov    0x3e448,%edx
   13313:	a3 10 e4 03 00       	mov    %eax,0x3e410
   13318:	52                   	push   %edx
   13319:	50                   	push   %eax
   1331a:	a1 38 e4 03 00       	mov    0x3e438,%eax
   1331f:	50                   	push   %eax
   13320:	68 50 c0 01 00       	push   $0x1c050
   13325:	53                   	push   %ebx
   13326:	e8 25 76 00 00       	call   1a950 <_sprintf>
   1332b:	83 c4 14             	add    $0x14,%esp
   1332e:	53                   	push   %ebx
   1332f:	e8 cc f5 ff ff       	call   12900 <_HalDisplayString@4>
   13334:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13337:	b8 01 00 00 00       	mov    $0x1,%eax
   1333c:	5b                   	pop    %ebx
   1333d:	5e                   	pop    %esi
   1333e:	5f                   	pop    %edi
   1333f:	5d                   	pop    %ebp
   13340:	c2 0c 00             	ret    $0xc
   13343:	a3 48 e4 03 00       	mov    %eax,0x3e448
   13348:	8b 03                	mov    (%ebx),%eax
   1334a:	85 c0                	test   %eax,%eax
   1334c:	0f 84 f5 fe ff ff    	je     13247 <_KdPortInitialize@12+0x57>
   13352:	8b 44 85 c8          	mov    0xffffffc8(%ebp,%eax,4),%eax
   13356:	e8 d5 fd ff ff       	call   13130 <_KdpDoesComPortExist>
   1335b:	84 c0                	test   %al,%al
   1335d:	74 45                	je     133a4 <_KdPortInitialize@12+0x1b4>
   1335f:	8b 03                	mov    (%ebx),%eax
   13361:	a3 38 e4 03 00       	mov    %eax,0x3e438
   13366:	8b 54 85 c8          	mov    0xffffffc8(%ebp,%eax,4),%edx
   1336a:	89 15 18 e4 03 00    	mov    %edx,0x3e418
   13370:	89 53 08             	mov    %edx,0x8(%ebx)
   13373:	e9 fa fe ff ff       	jmp    13272 <_KdPortInitialize@12+0x82>
   13378:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
   1337b:	e8 b0 fd ff ff       	call   13130 <_KdpDoesComPortExist>
   13380:	84 c0                	test   %al,%al
   13382:	74 4e                	je     133d2 <_KdPortInitialize@12+0x1e2>
   13384:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
   13387:	c7 05 38 e4 03 00 01 	movl   $0x1,0x3e438
   1338e:	00 00 00 
   13391:	a3 18 e4 03 00       	mov    %eax,0x3e418
   13396:	89 43 08             	mov    %eax,0x8(%ebx)
   13399:	c7 03 01 00 00 00    	movl   $0x1,(%ebx)
   1339f:	e9 ce fe ff ff       	jmp    13272 <_KdPortInitialize@12+0x82>
   133a4:	fc                   	cld    
   133a5:	be 88 c0 01 00       	mov    $0x1c088,%esi
   133aa:	8d bd 78 ff ff ff    	lea    0xffffff78(%ebp),%edi
   133b0:	b9 0b 00 00 00       	mov    $0xb,%ecx
   133b5:	f3 a5                	repz movsl %ds:(%esi),%es:(%edi)
   133b7:	83 ec 0c             	sub    $0xc,%esp
   133ba:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
   133c0:	50                   	push   %eax
   133c1:	e8 3a f5 ff ff       	call   12900 <_HalDisplayString@4>
   133c6:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   133c9:	31 c0                	xor    %eax,%eax
   133cb:	5b                   	pop    %ebx
   133cc:	5e                   	pop    %esi
   133cd:	5f                   	pop    %edi
   133ce:	5d                   	pop    %ebp
   133cf:	c2 0c 00             	ret    $0xc
   133d2:	fc                   	cld    
   133d3:	be b4 c0 01 00       	mov    $0x1c0b4,%esi
   133d8:	8d bd 78 ff ff ff    	lea    0xffffff78(%ebp),%edi
   133de:	b9 0a 00 00 00       	mov    $0xa,%ecx
   133e3:	a0 dc c0 01 00       	mov    0x1c0dc,%al
   133e8:	f3 a5                	repz movsl %ds:(%esi),%es:(%edi)
   133ea:	88 07                	mov    %al,(%edi)
   133ec:	eb c9                	jmp    133b7 <_KdPortInitialize@12+0x1c7>
   133ee:	89 f6                	mov    %esi,%esi

000133f0 <_KdPortInitializeEx@12>:
   133f0:	55                   	push   %ebp
   133f1:	89 e5                	mov    %esp,%ebp
   133f3:	57                   	push   %edi
   133f4:	56                   	push   %esi
   133f5:	53                   	push   %ebx
   133f6:	81 ec 8c 00 00 00    	sub    $0x8c,%esp
   133fc:	c7 45 c8 00 00 00 00 	movl   $0x0,0xffffffc8(%ebp)
   13403:	8b 7d 08             	mov    0x8(%ebp),%edi
   13406:	c7 45 cc f8 03 00 00 	movl   $0x3f8,0xffffffcc(%ebp)
   1340d:	c7 45 d0 f8 02 00 00 	movl   $0x2f8,0xffffffd0(%ebp)
   13414:	c7 45 d4 e8 03 00 00 	movl   $0x3e8,0xffffffd4(%ebp)
   1341b:	c7 45 d8 e8 02 00 00 	movl   $0x2e8,0xffffffd8(%ebp)
   13422:	8b 57 04             	mov    0x4(%edi),%edx
   13425:	85 d2                	test   %edx,%edx
   13427:	75 07                	jne    13430 <_KdPortInitializeEx@12+0x40>
   13429:	c7 47 04 00 4b 00 00 	movl   $0x4b00,0x4(%edi)
   13430:	8b 17                	mov    (%edi),%edx
   13432:	31 c0                	xor    %eax,%eax
   13434:	85 d2                	test   %edx,%edx
   13436:	75 0a                	jne    13442 <_KdPortInitializeEx@12+0x52>
   13438:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1343b:	5b                   	pop    %ebx
   1343c:	5e                   	pop    %esi
   1343d:	5f                   	pop    %edi
   1343e:	5d                   	pop    %ebp
   1343f:	c2 0c 00             	ret    $0xc
   13442:	8b 44 95 c8          	mov    0xffffffc8(%ebp,%edx,4),%eax
   13446:	e8 e5 fc ff ff       	call   13130 <_KdpDoesComPortExist>
   1344b:	84 c0                	test   %al,%al
   1344d:	75 37                	jne    13486 <_KdPortInitializeEx@12+0x96>
   1344f:	8d 95 78 ff ff ff    	lea    0xffffff78(%ebp),%edx
   13455:	be e0 c0 01 00       	mov    $0x1c0e0,%esi
   1345a:	fc                   	cld    
   1345b:	89 d7                	mov    %edx,%edi
   1345d:	b9 0b 00 00 00       	mov    $0xb,%ecx
   13462:	f3 a5                	repz movsl %ds:(%esi),%es:(%edi)
   13464:	a0 0c c1 01 00       	mov    0x1c10c,%al
   13469:	83 ec 0c             	sub    $0xc,%esp
   1346c:	88 07                	mov    %al,(%edi)
   1346e:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
   13474:	50                   	push   %eax
   13475:	e8 86 f4 ff ff       	call   12900 <_HalDisplayString@4>
   1347a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1347d:	31 c0                	xor    %eax,%eax
   1347f:	5b                   	pop    %ebx
   13480:	5e                   	pop    %esi
   13481:	5f                   	pop    %edi
   13482:	5d                   	pop    %ebp
   13483:	c2 0c 00             	ret    $0xc
   13486:	8b 07                	mov    (%edi),%eax
   13488:	bb 00 c2 01 00       	mov    $0x1c200,%ebx
   1348d:	8b 74 85 c8          	mov    0xffffffc8(%ebp,%eax,4),%esi
   13491:	89 77 08             	mov    %esi,0x8(%edi)
   13494:	50                   	push   %eax
   13495:	50                   	push   %eax
   13496:	8d 46 04             	lea    0x4(%esi),%eax
   13499:	6a 03                	push   $0x3
   1349b:	50                   	push   %eax
   1349c:	e8 ef 16 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   134a1:	50                   	push   %eax
   134a2:	8d 46 03             	lea    0x3(%esi),%eax
   134a5:	89 85 74 ff ff ff    	mov    %eax,0xffffff74(%ebp)
   134ab:	50                   	push   %eax
   134ac:	e8 2f 16 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   134b1:	83 c8 80             	or     $0xffffff80,%eax
   134b4:	25 ff 00 00 00       	and    $0xff,%eax
   134b9:	89 04 24             	mov    %eax,(%esp)
   134bc:	8b 85 74 ff ff ff    	mov    0xffffff74(%ebp),%eax
   134c2:	50                   	push   %eax
   134c3:	e8 c8 16 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   134c8:	89 d8                	mov    %ebx,%eax
   134ca:	31 d2                	xor    %edx,%edx
   134cc:	f7 77 04             	divl   0x4(%edi)
   134cf:	89 c3                	mov    %eax,%ebx
   134d1:	31 c0                	xor    %eax,%eax
   134d3:	88 d8                	mov    %bl,%al
   134d5:	50                   	push   %eax
   134d6:	56                   	push   %esi
   134d7:	e8 b4 16 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   134dc:	8d 46 01             	lea    0x1(%esi),%eax
   134df:	0f b6 df             	movzbl %bh,%ebx
   134e2:	53                   	push   %ebx
   134e3:	50                   	push   %eax
   134e4:	e8 a7 16 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   134e9:	6a 03                	push   $0x3
   134eb:	8b 85 74 ff ff ff    	mov    0xffffff74(%ebp),%eax
   134f1:	50                   	push   %eax
   134f2:	e8 99 16 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   134f7:	50                   	push   %eax
   134f8:	56                   	push   %esi
   134f9:	e8 e2 15 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   134fe:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13501:	b8 01 00 00 00       	mov    $0x1,%eax
   13506:	5b                   	pop    %ebx
   13507:	5e                   	pop    %esi
   13508:	5f                   	pop    %edi
   13509:	5d                   	pop    %ebp
   1350a:	c2 0c 00             	ret    $0xc
   1350d:	8d 76 00             	lea    0x0(%esi),%esi

00013510 <_KdPortGetByte@4>:
   13510:	55                   	push   %ebp
   13511:	89 e5                	mov    %esp,%ebp
   13513:	50                   	push   %eax
   13514:	50                   	push   %eax
   13515:	31 d2                	xor    %edx,%edx
   13517:	80 3d 28 e4 03 00 00 	cmpb   $0x0,0x3e428
   1351e:	75 06                	jne    13526 <_KdPortGetByte@4+0x16>
   13520:	89 d0                	mov    %edx,%eax
   13522:	c9                   	leave  
   13523:	c2 04 00             	ret    $0x4
   13526:	83 ec 0c             	sub    $0xc,%esp
   13529:	a1 18 e4 03 00       	mov    0x3e418,%eax
   1352e:	83 c0 05             	add    $0x5,%eax
   13531:	50                   	push   %eax
   13532:	e8 a9 15 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13537:	31 d2                	xor    %edx,%edx
   13539:	83 c4 0c             	add    $0xc,%esp
   1353c:	a8 01                	test   $0x1,%al
   1353e:	74 e0                	je     13520 <_KdPortGetByte@4+0x10>
   13540:	83 ec 0c             	sub    $0xc,%esp
   13543:	8b 0d 18 e4 03 00    	mov    0x3e418,%ecx
   13549:	51                   	push   %ecx
   1354a:	e8 91 15 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1354f:	8b 55 08             	mov    0x8(%ebp),%edx
   13552:	88 02                	mov    %al,(%edx)
   13554:	ba 01 00 00 00       	mov    $0x1,%edx
   13559:	eb c5                	jmp    13520 <_KdPortGetByte@4+0x10>
   1355b:	90                   	nop    
   1355c:	8d 74 26 00          	lea    0x0(%esi),%esi

00013560 <_KdPortGetByteEx@8>:
   13560:	55                   	push   %ebp
   13561:	89 e5                	mov    %esp,%ebp
   13563:	53                   	push   %ebx
   13564:	83 ec 10             	sub    $0x10,%esp
   13567:	8b 45 08             	mov    0x8(%ebp),%eax
   1356a:	8b 58 08             	mov    0x8(%eax),%ebx
   1356d:	8d 43 05             	lea    0x5(%ebx),%eax
   13570:	50                   	push   %eax
   13571:	e8 6a 15 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13576:	31 d2                	xor    %edx,%edx
   13578:	83 c4 0c             	add    $0xc,%esp
   1357b:	a8 01                	test   $0x1,%al
   1357d:	75 09                	jne    13588 <_KdPortGetByteEx@8+0x28>
   1357f:	89 d0                	mov    %edx,%eax
   13581:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   13584:	c9                   	leave  
   13585:	c2 08 00             	ret    $0x8
   13588:	83 ec 0c             	sub    $0xc,%esp
   1358b:	53                   	push   %ebx
   1358c:	e8 4f 15 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13591:	8b 55 0c             	mov    0xc(%ebp),%edx
   13594:	88 02                	mov    %al,(%edx)
   13596:	ba 01 00 00 00       	mov    $0x1,%edx
   1359b:	89 d0                	mov    %edx,%eax
   1359d:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   135a0:	c9                   	leave  
   135a1:	c2 08 00             	ret    $0x8
   135a4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   135aa:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

000135b0 <_KdPortPollByte@4>:
   135b0:	55                   	push   %ebp
   135b1:	89 e5                	mov    %esp,%ebp
   135b3:	50                   	push   %eax
   135b4:	50                   	push   %eax
   135b5:	31 c0                	xor    %eax,%eax
   135b7:	80 3d 28 e4 03 00 00 	cmpb   $0x0,0x3e428
   135be:	75 04                	jne    135c4 <_KdPortPollByte@4+0x14>
   135c0:	c9                   	leave  
   135c1:	c2 04 00             	ret    $0x4
   135c4:	83 ec 0c             	sub    $0xc,%esp
   135c7:	a1 18 e4 03 00       	mov    0x3e418,%eax
   135cc:	83 c0 05             	add    $0x5,%eax
   135cf:	50                   	push   %eax
   135d0:	e8 0b 15 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   135d5:	83 c4 0c             	add    $0xc,%esp
   135d8:	a8 01                	test   $0x1,%al
   135da:	74 e8                	je     135c4 <_KdPortPollByte@4+0x14>
   135dc:	83 ec 0c             	sub    $0xc,%esp
   135df:	a1 18 e4 03 00       	mov    0x3e418,%eax
   135e4:	50                   	push   %eax
   135e5:	e8 f6 14 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   135ea:	8b 55 08             	mov    0x8(%ebp),%edx
   135ed:	88 02                	mov    %al,(%edx)
   135ef:	b8 01 00 00 00       	mov    $0x1,%eax
   135f4:	c9                   	leave  
   135f5:	c2 04 00             	ret    $0x4
   135f8:	90                   	nop    
   135f9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00013600 <_KdPortPollByteEx@8>:
   13600:	55                   	push   %ebp
   13601:	89 e5                	mov    %esp,%ebp
   13603:	56                   	push   %esi
   13604:	53                   	push   %ebx
   13605:	8b 45 08             	mov    0x8(%ebp),%eax
   13608:	8b 70 08             	mov    0x8(%eax),%esi
   1360b:	8d 5e 05             	lea    0x5(%esi),%ebx
   1360e:	89 f6                	mov    %esi,%esi
   13610:	83 ec 0c             	sub    $0xc,%esp
   13613:	53                   	push   %ebx
   13614:	e8 c7 14 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13619:	83 c4 0c             	add    $0xc,%esp
   1361c:	a8 01                	test   $0x1,%al
   1361e:	74 f0                	je     13610 <_KdPortPollByteEx@8+0x10>
   13620:	83 ec 0c             	sub    $0xc,%esp
   13623:	56                   	push   %esi
   13624:	e8 b7 14 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13629:	8b 55 0c             	mov    0xc(%ebp),%edx
   1362c:	88 02                	mov    %al,(%edx)
   1362e:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   13631:	b8 01 00 00 00       	mov    $0x1,%eax
   13636:	5b                   	pop    %ebx
   13637:	5e                   	pop    %esi
   13638:	5d                   	pop    %ebp
   13639:	c2 08 00             	ret    $0x8
   1363c:	8d 74 26 00          	lea    0x0(%esi),%esi

00013640 <_KdPortPutByte@4>:
   13640:	55                   	push   %ebp
   13641:	89 e5                	mov    %esp,%ebp
   13643:	53                   	push   %ebx
   13644:	50                   	push   %eax
   13645:	8a 5d 08             	mov    0x8(%ebp),%bl
   13648:	80 3d 28 e4 03 00 00 	cmpb   $0x0,0x3e428
   1364f:	75 07                	jne    13658 <_KdPortPutByte@4+0x18>
   13651:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   13654:	c9                   	leave  
   13655:	c2 04 00             	ret    $0x4
   13658:	83 ec 0c             	sub    $0xc,%esp
   1365b:	a1 18 e4 03 00       	mov    0x3e418,%eax
   13660:	83 c0 05             	add    $0x5,%eax
   13663:	50                   	push   %eax
   13664:	e8 77 14 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13669:	83 c4 0c             	add    $0xc,%esp
   1366c:	a8 20                	test   $0x20,%al
   1366e:	74 e8                	je     13658 <_KdPortPutByte@4+0x18>
   13670:	50                   	push   %eax
   13671:	50                   	push   %eax
   13672:	31 c0                	xor    %eax,%eax
   13674:	88 d8                	mov    %bl,%al
   13676:	50                   	push   %eax
   13677:	a1 18 e4 03 00       	mov    0x3e418,%eax
   1367c:	50                   	push   %eax
   1367d:	e8 0e 15 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13682:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   13685:	c9                   	leave  
   13686:	c2 04 00             	ret    $0x4
   13689:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00013690 <_KdPortPutByteEx@8>:
   13690:	55                   	push   %ebp
   13691:	89 e5                	mov    %esp,%ebp
   13693:	57                   	push   %edi
   13694:	56                   	push   %esi
   13695:	53                   	push   %ebx
   13696:	83 ec 0c             	sub    $0xc,%esp
   13699:	8b 45 08             	mov    0x8(%ebp),%eax
   1369c:	0f b6 7d 0c          	movzbl 0xc(%ebp),%edi
   136a0:	8b 70 08             	mov    0x8(%eax),%esi
   136a3:	8d 5e 05             	lea    0x5(%esi),%ebx
   136a6:	83 ec 0c             	sub    $0xc,%esp
   136a9:	53                   	push   %ebx
   136aa:	e8 31 14 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   136af:	83 c4 0c             	add    $0xc,%esp
   136b2:	a8 20                	test   $0x20,%al
   136b4:	74 f0                	je     136a6 <_KdPortPutByteEx@8+0x16>
   136b6:	89 f8                	mov    %edi,%eax
   136b8:	89 75 08             	mov    %esi,0x8(%ebp)
   136bb:	25 ff 00 00 00       	and    $0xff,%eax
   136c0:	89 45 0c             	mov    %eax,0xc(%ebp)
   136c3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   136c6:	5b                   	pop    %ebx
   136c7:	5e                   	pop    %esi
   136c8:	5f                   	pop    %edi
   136c9:	5d                   	pop    %ebp
   136ca:	e9 c1 14 00 00       	jmp    14b90 <_WRITE_PORT_UCHAR@8>
   136cf:	90                   	nop    

000136d0 <_KdPortRestore@0>:
   136d0:	55                   	push   %ebp
   136d1:	89 e5                	mov    %esp,%ebp
   136d3:	5d                   	pop    %ebp
   136d4:	c3                   	ret    
   136d5:	8d 74 26 00          	lea    0x0(%esi),%esi
   136d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000136e0 <_KdPortSave@0>:
   136e0:	55                   	push   %ebp
   136e1:	89 e5                	mov    %esp,%ebp
   136e3:	5d                   	pop    %ebp
   136e4:	c3                   	ret    
   136e5:	8d 74 26 00          	lea    0x0(%esi),%esi
   136e9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000136f0 <_KdPortDisableInterrupts@0>:
   136f0:	55                   	push   %ebp
   136f1:	89 e5                	mov    %esp,%ebp
   136f3:	51                   	push   %ecx
   136f4:	51                   	push   %ecx
   136f5:	31 c0                	xor    %eax,%eax
   136f7:	80 3d 28 e4 03 00 00 	cmpb   $0x0,0x3e428
   136fe:	75 02                	jne    13702 <_KdPortDisableInterrupts@0+0x12>
   13700:	c9                   	leave  
   13701:	c3                   	ret    
   13702:	a1 18 e4 03 00       	mov    0x3e418,%eax
   13707:	83 ec 0c             	sub    $0xc,%esp
   1370a:	83 c0 04             	add    $0x4,%eax
   1370d:	50                   	push   %eax
   1370e:	e8 cd 13 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13713:	25 f3 00 00 00       	and    $0xf3,%eax
   13718:	89 04 24             	mov    %eax,(%esp)
   1371b:	a1 18 e4 03 00       	mov    0x3e418,%eax
   13720:	83 c0 04             	add    $0x4,%eax
   13723:	50                   	push   %eax
   13724:	e8 67 14 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13729:	52                   	push   %edx
   1372a:	a1 18 e4 03 00       	mov    0x3e418,%eax
   1372f:	40                   	inc    %eax
   13730:	50                   	push   %eax
   13731:	e8 aa 13 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13736:	25 f0 00 00 00       	and    $0xf0,%eax
   1373b:	89 04 24             	mov    %eax,(%esp)
   1373e:	a1 18 e4 03 00       	mov    0x3e418,%eax
   13743:	40                   	inc    %eax
   13744:	50                   	push   %eax
   13745:	e8 46 14 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1374a:	b8 01 00 00 00       	mov    $0x1,%eax
   1374f:	c9                   	leave  
   13750:	c3                   	ret    
   13751:	eb 0d                	jmp    13760 <_KdPortEnableInterrupts@0>
   13753:	90                   	nop    
   13754:	90                   	nop    
   13755:	90                   	nop    
   13756:	90                   	nop    
   13757:	90                   	nop    
   13758:	90                   	nop    
   13759:	90                   	nop    
   1375a:	90                   	nop    
   1375b:	90                   	nop    
   1375c:	90                   	nop    
   1375d:	90                   	nop    
   1375e:	90                   	nop    
   1375f:	90                   	nop    

00013760 <_KdPortEnableInterrupts@0>:
   13760:	55                   	push   %ebp
   13761:	89 e5                	mov    %esp,%ebp
   13763:	50                   	push   %eax
   13764:	50                   	push   %eax
   13765:	31 c0                	xor    %eax,%eax
   13767:	80 3d 28 e4 03 00 00 	cmpb   $0x0,0x3e428
   1376e:	75 02                	jne    13772 <_KdPortEnableInterrupts@0+0x12>
   13770:	c9                   	leave  
   13771:	c3                   	ret    
   13772:	a1 18 e4 03 00       	mov    0x3e418,%eax
   13777:	83 ec 0c             	sub    $0xc,%esp
   1377a:	40                   	inc    %eax
   1377b:	50                   	push   %eax
   1377c:	e8 5f 13 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13781:	83 e0 f0             	and    $0xfffffff0,%eax
   13784:	83 c8 01             	or     $0x1,%eax
   13787:	25 ff 00 00 00       	and    $0xff,%eax
   1378c:	89 04 24             	mov    %eax,(%esp)
   1378f:	a1 18 e4 03 00       	mov    0x3e418,%eax
   13794:	40                   	inc    %eax
   13795:	50                   	push   %eax
   13796:	e8 f5 13 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1379b:	50                   	push   %eax
   1379c:	a1 18 e4 03 00       	mov    0x3e418,%eax
   137a1:	83 c0 04             	add    $0x4,%eax
   137a4:	50                   	push   %eax
   137a5:	e8 36 13 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   137aa:	83 e0 ef             	and    $0xffffffef,%eax
   137ad:	83 c8 0c             	or     $0xc,%eax
   137b0:	25 ff 00 00 00       	and    $0xff,%eax
   137b5:	89 04 24             	mov    %eax,(%esp)
   137b8:	a1 18 e4 03 00       	mov    0x3e418,%eax
   137bd:	83 c0 04             	add    $0x4,%eax
   137c0:	50                   	push   %eax
   137c1:	e8 ca 13 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   137c6:	b8 01 00 00 00       	mov    $0x1,%eax
   137cb:	c9                   	leave  
   137cc:	c3                   	ret    
   137cd:	90                   	nop    
   137ce:	90                   	nop    
   137cf:	90                   	nop    

000137d0 <_HalpGetMicroChannelData@24>:
   137d0:	55                   	push   %ebp
   137d1:	89 e5                	mov    %esp,%ebp
   137d3:	57                   	push   %edi
   137d4:	56                   	push   %esi
   137d5:	53                   	push   %ebx
   137d6:	83 ec 0c             	sub    $0xc,%esp
   137d9:	8b 4d 10             	mov    0x10(%ebp),%ecx
   137dc:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   137df:	85 db                	test   %ebx,%ebx
   137e1:	8b 75 14             	mov    0x14(%ebp),%esi
   137e4:	0f 95 c2             	setne  %dl
   137e7:	85 c9                	test   %ecx,%ecx
   137e9:	0f 94 c0             	sete   %al
   137ec:	09 d0                	or     %edx,%eax
   137ee:	a8 01                	test   $0x1,%al
   137f0:	75 13                	jne    13805 <_HalpGetMicroChannelData@24+0x35>
   137f2:	83 f9 08             	cmp    $0x8,%ecx
   137f5:	0f 97 c2             	seta   %dl
   137f8:	83 7d 1c 05          	cmpl   $0x5,0x1c(%ebp)
   137fc:	0f 96 c0             	setbe  %al
   137ff:	09 d0                	or     %edx,%eax
   13801:	a8 01                	test   $0x1,%al
   13803:	74 0c                	je     13811 <_HalpGetMicroChannelData@24+0x41>
   13805:	31 c0                	xor    %eax,%eax
   13807:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1380a:	5b                   	pop    %ebx
   1380b:	5e                   	pop    %esi
   1380c:	5f                   	pop    %edi
   1380d:	5d                   	pop    %ebp
   1380e:	c2 18 00             	ret    $0x18
   13811:	8d 59 ff             	lea    0xffffffff(%ecx),%ebx
   13814:	89 d8                	mov    %ebx,%eax
   13816:	52                   	push   %edx
   13817:	83 c8 08             	or     $0x8,%eax
   1381a:	52                   	push   %edx
   1381b:	83 e0 0f             	and    $0xf,%eax
   1381e:	83 e3 07             	and    $0x7,%ebx
   13821:	50                   	push   %eax
   13822:	68 96 00 00 00       	push   $0x96
   13827:	e8 64 13 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1382c:	50                   	push   %eax
   1382d:	68 01 01 00 00       	push   $0x101
   13832:	e8 a9 12 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13837:	25 ff 00 00 00       	and    $0xff,%eax
   1383c:	89 c7                	mov    %eax,%edi
   1383e:	68 00 01 00 00       	push   $0x100
   13843:	c1 e7 08             	shl    $0x8,%edi
   13846:	e8 95 12 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1384b:	25 ff 00 00 00       	and    $0xff,%eax
   13850:	01 f8                	add    %edi,%eax
   13852:	66 89 06             	mov    %ax,(%esi)
   13855:	68 02 01 00 00       	push   $0x102
   1385a:	e8 81 12 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1385f:	88 46 02             	mov    %al,0x2(%esi)
   13862:	68 03 01 00 00       	push   $0x103
   13867:	e8 74 12 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1386c:	88 46 03             	mov    %al,0x3(%esi)
   1386f:	68 04 01 00 00       	push   $0x104
   13874:	e8 67 12 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13879:	88 46 04             	mov    %al,0x4(%esi)
   1387c:	68 05 01 00 00       	push   $0x105
   13881:	e8 5a 12 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13886:	88 46 05             	mov    %al,0x5(%esi)
   13889:	89 1c 24             	mov    %ebx,(%esp)
   1388c:	68 96 00 00 00       	push   $0x96
   13891:	e8 fa 12 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13896:	b8 06 00 00 00       	mov    $0x6,%eax
   1389b:	e9 67 ff ff ff       	jmp    13807 <_HalpGetMicroChannelData@24+0x37>

000138a0 <_HalHandleNMI@4>:
   138a0:	55                   	push   %ebp
   138a1:	89 e5                	mov    %esp,%ebp
   138a3:	53                   	push   %ebx
   138a4:	83 ec 10             	sub    $0x10,%esp
   138a7:	6a 61                	push   $0x61
   138a9:	e8 32 12 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   138ae:	88 c3                	mov    %al,%bl
   138b0:	68 10 c1 01 00       	push   $0x1c110
   138b5:	e8 46 f0 ff ff       	call   12900 <_HalDisplayString@4>
   138ba:	68 2c c1 01 00       	push   $0x1c12c
   138bf:	e8 3c f0 ff ff       	call   12900 <_HalDisplayString@4>
   138c4:	83 c4 0c             	add    $0xc,%esp
   138c7:	84 db                	test   %bl,%bl
   138c9:	78 55                	js     13920 <_HalHandleNMI@4+0x80>
   138cb:	83 e3 40             	and    $0x40,%ebx
   138ce:	75 20                	jne    138f0 <_HalHandleNMI@4+0x50>
   138d0:	83 ec 0c             	sub    $0xc,%esp
   138d3:	68 54 c1 01 00       	push   $0x1c154
   138d8:	e8 23 f0 ff ff       	call   12900 <_HalDisplayString@4>
   138dd:	83 c4 0c             	add    $0xc,%esp
   138e0:	e8 7b 70 00 00       	call   1a960 <_KeEnterKernelDebugger@0>
   138e5:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   138e8:	c9                   	leave  
   138e9:	c2 04 00             	ret    $0x4
   138ec:	8d 74 26 00          	lea    0x0(%esi),%esi
   138f0:	83 ec 0c             	sub    $0xc,%esp
   138f3:	68 74 c1 01 00       	push   $0x1c174
   138f8:	e8 03 f0 ff ff       	call   12900 <_HalDisplayString@4>
   138fd:	83 c4 0c             	add    $0xc,%esp
   13900:	83 ec 0c             	sub    $0xc,%esp
   13903:	68 54 c1 01 00       	push   $0x1c154
   13908:	e8 f3 ef ff ff       	call   12900 <_HalDisplayString@4>
   1390d:	83 c4 0c             	add    $0xc,%esp
   13910:	e8 4b 70 00 00       	call   1a960 <_KeEnterKernelDebugger@0>
   13915:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   13918:	c9                   	leave  
   13919:	c2 04 00             	ret    $0x4
   1391c:	8d 74 26 00          	lea    0x0(%esi),%esi
   13920:	83 ec 0c             	sub    $0xc,%esp
   13923:	68 90 c1 01 00       	push   $0x1c190
   13928:	e8 d3 ef ff ff       	call   12900 <_HalDisplayString@4>
   1392d:	83 c4 0c             	add    $0xc,%esp
   13930:	eb 99                	jmp    138cb <_HalHandleNMI@4+0x2b>
   13932:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   13939:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00013940 <_HalProcessorIdle@0>:
   13940:	55                   	push   %ebp
   13941:	89 e5                	mov    %esp,%ebp
   13943:	fb                   	sti    
   13944:	f4                   	hlt    
   13945:	5d                   	pop    %ebp
   13946:	c3                   	ret    
   13947:	89 f6                	mov    %esi,%esi
   13949:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00013950 <@HalSystemVectorDispatchEntry@12>:
   13950:	55                   	push   %ebp
   13951:	31 c0                	xor    %eax,%eax
   13953:	89 e5                	mov    %esp,%ebp
   13955:	5d                   	pop    %ebp
   13956:	c2 04 00             	ret    $0x4
   13959:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00013960 <_KeFlushWriteBuffer@0>:
   13960:	55                   	push   %ebp
   13961:	89 e5                	mov    %esp,%ebp
   13963:	5d                   	pop    %ebp
   13964:	c3                   	ret    
   13965:	90                   	nop    
   13966:	90                   	nop    
   13967:	90                   	nop    
   13968:	90                   	nop    
   13969:	90                   	nop    
   1396a:	90                   	nop    
   1396b:	90                   	nop    
   1396c:	90                   	nop    
   1396d:	90                   	nop    
   1396e:	90                   	nop    
   1396f:	90                   	nop    

00013970 <_ReadPciConfigUchar>:
   13970:	55                   	push   %ebp
   13971:	89 e5                	mov    %esp,%ebp
   13973:	57                   	push   %edi
   13974:	56                   	push   %esi
   13975:	53                   	push   %ebx
   13976:	83 ec 0c             	sub    $0xc,%esp
   13979:	89 c6                	mov    %eax,%esi
   1397b:	a1 60 e4 03 00       	mov    0x3e460,%eax
   13980:	88 d3                	mov    %dl,%bl
   13982:	0f b6 7d 08          	movzbl 0x8(%ebp),%edi
   13986:	83 f8 01             	cmp    $0x1,%eax
   13989:	0f 84 a1 00 00 00    	je     13a30 <_ReadPciConfigUchar+0xc0>
   1398f:	83 f8 02             	cmp    $0x2,%eax
   13992:	0f 85 88 00 00 00    	jne    13a20 <_ReadPciConfigUchar+0xb0>
   13998:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   1399b:	52                   	push   %edx
   1399c:	52                   	push   %edx
   1399d:	50                   	push   %eax
   1399e:	68 70 e4 03 00       	push   $0x3e470
   139a3:	e8 08 13 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   139a8:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   139ae:	89 d8                	mov    %ebx,%eax
   139b0:	83 e3 1f             	and    $0x1f,%ebx
   139b3:	c1 e3 08             	shl    $0x8,%ebx
   139b6:	25 e0 00 00 00       	and    $0xe0,%eax
   139bb:	c1 f8 04             	sar    $0x4,%eax
   139be:	0c f0                	or     $0xf0,%al
   139c0:	50                   	push   %eax
   139c1:	68 f8 0c 00 00       	push   $0xcf8
   139c6:	e8 c5 11 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   139cb:	89 f0                	mov    %esi,%eax
   139cd:	25 ff 00 00 00       	and    $0xff,%eax
   139d2:	50                   	push   %eax
   139d3:	68 fa 0c 00 00       	push   $0xcfa
   139d8:	e8 b3 11 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   139dd:	50                   	push   %eax
   139de:	89 f8                	mov    %edi,%eax
   139e0:	25 ff 00 00 00       	and    $0xff,%eax
   139e5:	09 c3                	or     %eax,%ebx
   139e7:	80 cf c0             	or     $0xc0,%bh
   139ea:	53                   	push   %ebx
   139eb:	e8 f0 10 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   139f0:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   139f3:	88 01                	mov    %al,(%ecx)
   139f5:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   139fc:	68 f8 0c 00 00       	push   $0xcf8
   13a01:	e8 8a 11 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13a06:	31 c0                	xor    %eax,%eax
   13a08:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   13a0b:	50                   	push   %eax
   13a0c:	68 70 e4 03 00       	push   $0x3e470
   13a11:	e8 0a 13 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   13a16:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13a19:	31 c0                	xor    %eax,%eax
   13a1b:	5b                   	pop    %ebx
   13a1c:	5e                   	pop    %esi
   13a1d:	5f                   	pop    %edi
   13a1e:	5d                   	pop    %ebp
   13a1f:	c3                   	ret    
   13a20:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13a23:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   13a28:	5b                   	pop    %ebx
   13a29:	5e                   	pop    %esi
   13a2a:	5f                   	pop    %edi
   13a2b:	5d                   	pop    %ebp
   13a2c:	c3                   	ret    
   13a2d:	8d 76 00             	lea    0x0(%esi),%esi
   13a30:	50                   	push   %eax
   13a31:	50                   	push   %eax
   13a32:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13a35:	50                   	push   %eax
   13a36:	68 70 e4 03 00       	push   $0x3e470
   13a3b:	e8 70 12 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   13a40:	31 c9                	xor    %ecx,%ecx
   13a42:	88 d9                	mov    %bl,%cl
   13a44:	89 f2                	mov    %esi,%edx
   13a46:	89 c8                	mov    %ecx,%eax
   13a48:	81 e2 ff 00 00 00    	and    $0xff,%edx
   13a4e:	83 e0 1f             	and    $0x1f,%eax
   13a51:	89 fb                	mov    %edi,%ebx
   13a53:	c1 e0 0b             	shl    $0xb,%eax
   13a56:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   13a5c:	c1 e2 10             	shl    $0x10,%edx
   13a5f:	81 e1 e0 00 00 00    	and    $0xe0,%ecx
   13a65:	c1 e1 03             	shl    $0x3,%ecx
   13a68:	09 c2                	or     %eax,%edx
   13a6a:	89 d8                	mov    %ebx,%eax
   13a6c:	09 ca                	or     %ecx,%edx
   13a6e:	83 e0 fc             	and    $0xfffffffc,%eax
   13a71:	81 cb fc 0c 00 00    	or     $0xcfc,%ebx
   13a77:	09 c2                	or     %eax,%edx
   13a79:	81 ca 00 00 00 80    	or     $0x80000000,%edx
   13a7f:	52                   	push   %edx
   13a80:	68 f8 0c 00 00       	push   $0xcf8
   13a85:	e8 36 11 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   13a8a:	51                   	push   %ecx
   13a8b:	53                   	push   %ebx
   13a8c:	e8 4f 10 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   13a91:	8b 55 0c             	mov    0xc(%ebp),%edx
   13a94:	88 02                	mov    %al,(%edx)
   13a96:	31 c0                	xor    %eax,%eax
   13a98:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   13a9b:	89 04 24             	mov    %eax,(%esp)
   13a9e:	68 70 e4 03 00       	push   $0x3e470
   13aa3:	e8 78 12 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   13aa8:	e9 69 ff ff ff       	jmp    13a16 <_ReadPciConfigUchar+0xa6>
   13aad:	8d 76 00             	lea    0x0(%esi),%esi

00013ab0 <_ReadPciConfigUshort>:
   13ab0:	55                   	push   %ebp
   13ab1:	89 e5                	mov    %esp,%ebp
   13ab3:	57                   	push   %edi
   13ab4:	56                   	push   %esi
   13ab5:	53                   	push   %ebx
   13ab6:	83 ec 0c             	sub    $0xc,%esp
   13ab9:	89 c7                	mov    %eax,%edi
   13abb:	8a 45 08             	mov    0x8(%ebp),%al
   13abe:	88 d3                	mov    %dl,%bl
   13ac0:	25 ff 00 00 00       	and    $0xff,%eax
   13ac5:	89 c6                	mov    %eax,%esi
   13ac7:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
   13acc:	f7 c6 01 00 00 00    	test   $0x1,%esi
   13ad2:	0f 85 91 00 00 00    	jne    13b69 <_ReadPciConfigUshort+0xb9>
   13ad8:	a1 60 e4 03 00       	mov    0x3e460,%eax
   13add:	83 f8 01             	cmp    $0x1,%eax
   13ae0:	0f 84 9a 00 00 00    	je     13b80 <_ReadPciConfigUshort+0xd0>
   13ae6:	83 f8 02             	cmp    $0x2,%eax
   13ae9:	0f 85 82 00 00 00    	jne    13b71 <_ReadPciConfigUshort+0xc1>
   13aef:	50                   	push   %eax
   13af0:	50                   	push   %eax
   13af1:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13af4:	50                   	push   %eax
   13af5:	68 70 e4 03 00       	push   $0x3e470
   13afa:	e8 b1 11 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   13aff:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   13b05:	89 d8                	mov    %ebx,%eax
   13b07:	83 e3 1f             	and    $0x1f,%ebx
   13b0a:	c1 e3 08             	shl    $0x8,%ebx
   13b0d:	25 e0 00 00 00       	and    $0xe0,%eax
   13b12:	c1 f8 04             	sar    $0x4,%eax
   13b15:	09 f3                	or     %esi,%ebx
   13b17:	0c f0                	or     $0xf0,%al
   13b19:	80 cf c0             	or     $0xc0,%bh
   13b1c:	50                   	push   %eax
   13b1d:	68 f8 0c 00 00       	push   $0xcf8
   13b22:	e8 69 10 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13b27:	89 f8                	mov    %edi,%eax
   13b29:	25 ff 00 00 00       	and    $0xff,%eax
   13b2e:	50                   	push   %eax
   13b2f:	68 fa 0c 00 00       	push   $0xcfa
   13b34:	e8 57 10 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13b39:	50                   	push   %eax
   13b3a:	53                   	push   %ebx
   13b3b:	e8 c0 0f 00 00       	call   14b00 <_READ_PORT_USHORT@4>
   13b40:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   13b43:	66 89 01             	mov    %ax,(%ecx)
   13b46:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   13b4d:	68 f8 0c 00 00       	push   $0xcf8
   13b52:	e8 39 10 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13b57:	31 c0                	xor    %eax,%eax
   13b59:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   13b5c:	50                   	push   %eax
   13b5d:	68 70 e4 03 00       	push   $0x3e470
   13b62:	e8 b9 11 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   13b67:	31 c0                	xor    %eax,%eax
   13b69:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13b6c:	5b                   	pop    %ebx
   13b6d:	5e                   	pop    %esi
   13b6e:	5f                   	pop    %edi
   13b6f:	5d                   	pop    %ebp
   13b70:	c3                   	ret    
   13b71:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13b74:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   13b79:	5b                   	pop    %ebx
   13b7a:	5e                   	pop    %esi
   13b7b:	5f                   	pop    %edi
   13b7c:	5d                   	pop    %ebp
   13b7d:	c3                   	ret    
   13b7e:	89 f6                	mov    %esi,%esi
   13b80:	50                   	push   %eax
   13b81:	50                   	push   %eax
   13b82:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13b85:	50                   	push   %eax
   13b86:	68 70 e4 03 00       	push   $0x3e470
   13b8b:	e8 20 11 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   13b90:	31 c9                	xor    %ecx,%ecx
   13b92:	88 d9                	mov    %bl,%cl
   13b94:	89 fa                	mov    %edi,%edx
   13b96:	89 c8                	mov    %ecx,%eax
   13b98:	81 e2 ff 00 00 00    	and    $0xff,%edx
   13b9e:	83 e0 1f             	and    $0x1f,%eax
   13ba1:	81 e1 e0 00 00 00    	and    $0xe0,%ecx
   13ba7:	c1 e0 0b             	shl    $0xb,%eax
   13baa:	c1 e2 10             	shl    $0x10,%edx
   13bad:	c1 e1 03             	shl    $0x3,%ecx
   13bb0:	09 c2                	or     %eax,%edx
   13bb2:	89 f0                	mov    %esi,%eax
   13bb4:	09 ca                	or     %ecx,%edx
   13bb6:	83 e0 fc             	and    $0xfffffffc,%eax
   13bb9:	83 e6 02             	and    $0x2,%esi
   13bbc:	09 c2                	or     %eax,%edx
   13bbe:	81 ca 00 00 00 80    	or     $0x80000000,%edx
   13bc4:	52                   	push   %edx
   13bc5:	68 f8 0c 00 00       	push   $0xcf8
   13bca:	e8 f1 0f 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   13bcf:	50                   	push   %eax
   13bd0:	8d 04 36             	lea    (%esi,%esi,1),%eax
   13bd3:	05 fc 0c 00 00       	add    $0xcfc,%eax
   13bd8:	50                   	push   %eax
   13bd9:	e8 22 0f 00 00       	call   14b00 <_READ_PORT_USHORT@4>
   13bde:	8b 55 0c             	mov    0xc(%ebp),%edx
   13be1:	66 89 02             	mov    %ax,(%edx)
   13be4:	31 c0                	xor    %eax,%eax
   13be6:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   13be9:	89 04 24             	mov    %eax,(%esp)
   13bec:	68 70 e4 03 00       	push   $0x3e470
   13bf1:	e8 2a 11 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   13bf6:	e9 6c ff ff ff       	jmp    13b67 <_ReadPciConfigUshort+0xb7>
   13bfb:	90                   	nop    
   13bfc:	8d 74 26 00          	lea    0x0(%esi),%esi

00013c00 <_ReadPciConfigUlong>:
   13c00:	55                   	push   %ebp
   13c01:	89 e5                	mov    %esp,%ebp
   13c03:	57                   	push   %edi
   13c04:	56                   	push   %esi
   13c05:	53                   	push   %ebx
   13c06:	83 ec 0c             	sub    $0xc,%esp
   13c09:	89 c7                	mov    %eax,%edi
   13c0b:	8a 45 08             	mov    0x8(%ebp),%al
   13c0e:	88 d3                	mov    %dl,%bl
   13c10:	25 ff 00 00 00       	and    $0xff,%eax
   13c15:	89 c6                	mov    %eax,%esi
   13c17:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
   13c1c:	f7 c6 03 00 00 00    	test   $0x3,%esi
   13c22:	0f 85 90 00 00 00    	jne    13cb8 <_ReadPciConfigUlong+0xb8>
   13c28:	a1 60 e4 03 00       	mov    0x3e460,%eax
   13c2d:	83 f8 01             	cmp    $0x1,%eax
   13c30:	0f 84 9a 00 00 00    	je     13cd0 <_ReadPciConfigUlong+0xd0>
   13c36:	83 f8 02             	cmp    $0x2,%eax
   13c39:	0f 85 81 00 00 00    	jne    13cc0 <_ReadPciConfigUlong+0xc0>
   13c3f:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13c42:	52                   	push   %edx
   13c43:	52                   	push   %edx
   13c44:	50                   	push   %eax
   13c45:	68 70 e4 03 00       	push   $0x3e470
   13c4a:	e8 61 10 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   13c4f:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   13c55:	89 d8                	mov    %ebx,%eax
   13c57:	83 e3 1f             	and    $0x1f,%ebx
   13c5a:	c1 e3 08             	shl    $0x8,%ebx
   13c5d:	25 e0 00 00 00       	and    $0xe0,%eax
   13c62:	c1 f8 04             	sar    $0x4,%eax
   13c65:	09 f3                	or     %esi,%ebx
   13c67:	0c f0                	or     $0xf0,%al
   13c69:	80 cf c0             	or     $0xc0,%bh
   13c6c:	50                   	push   %eax
   13c6d:	68 f8 0c 00 00       	push   $0xcf8
   13c72:	e8 19 0f 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13c77:	89 f8                	mov    %edi,%eax
   13c79:	25 ff 00 00 00       	and    $0xff,%eax
   13c7e:	50                   	push   %eax
   13c7f:	68 fa 0c 00 00       	push   $0xcfa
   13c84:	e8 07 0f 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13c89:	50                   	push   %eax
   13c8a:	53                   	push   %ebx
   13c8b:	e8 90 0e 00 00       	call   14b20 <_READ_PORT_ULONG@4>
   13c90:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   13c93:	89 01                	mov    %eax,(%ecx)
   13c95:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   13c9c:	68 f8 0c 00 00       	push   $0xcf8
   13ca1:	e8 ea 0e 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13ca6:	31 c0                	xor    %eax,%eax
   13ca8:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   13cab:	50                   	push   %eax
   13cac:	68 70 e4 03 00       	push   $0x3e470
   13cb1:	e8 6a 10 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   13cb6:	31 c0                	xor    %eax,%eax
   13cb8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13cbb:	5b                   	pop    %ebx
   13cbc:	5e                   	pop    %esi
   13cbd:	5f                   	pop    %edi
   13cbe:	5d                   	pop    %ebp
   13cbf:	c3                   	ret    
   13cc0:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13cc3:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   13cc8:	5b                   	pop    %ebx
   13cc9:	5e                   	pop    %esi
   13cca:	5f                   	pop    %edi
   13ccb:	5d                   	pop    %ebp
   13ccc:	c3                   	ret    
   13ccd:	8d 76 00             	lea    0x0(%esi),%esi
   13cd0:	50                   	push   %eax
   13cd1:	50                   	push   %eax
   13cd2:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13cd5:	50                   	push   %eax
   13cd6:	68 70 e4 03 00       	push   $0x3e470
   13cdb:	e8 d0 0f 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   13ce0:	31 c9                	xor    %ecx,%ecx
   13ce2:	88 d9                	mov    %bl,%cl
   13ce4:	89 fa                	mov    %edi,%edx
   13ce6:	89 c8                	mov    %ecx,%eax
   13ce8:	81 e2 ff 00 00 00    	and    $0xff,%edx
   13cee:	83 e0 1f             	and    $0x1f,%eax
   13cf1:	81 e1 e0 00 00 00    	and    $0xe0,%ecx
   13cf7:	c1 e0 0b             	shl    $0xb,%eax
   13cfa:	83 e6 fc             	and    $0xfffffffc,%esi
   13cfd:	c1 e2 10             	shl    $0x10,%edx
   13d00:	c1 e1 03             	shl    $0x3,%ecx
   13d03:	09 c2                	or     %eax,%edx
   13d05:	09 ca                	or     %ecx,%edx
   13d07:	09 f2                	or     %esi,%edx
   13d09:	81 ca 00 00 00 80    	or     $0x80000000,%edx
   13d0f:	52                   	push   %edx
   13d10:	68 f8 0c 00 00       	push   $0xcf8
   13d15:	e8 a6 0e 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   13d1a:	51                   	push   %ecx
   13d1b:	68 fc 0c 00 00       	push   $0xcfc
   13d20:	e8 fb 0d 00 00       	call   14b20 <_READ_PORT_ULONG@4>
   13d25:	8b 55 0c             	mov    0xc(%ebp),%edx
   13d28:	89 02                	mov    %eax,(%edx)
   13d2a:	31 c0                	xor    %eax,%eax
   13d2c:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   13d2f:	89 04 24             	mov    %eax,(%esp)
   13d32:	68 70 e4 03 00       	push   $0x3e470
   13d37:	e8 e4 0f 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   13d3c:	e9 75 ff ff ff       	jmp    13cb6 <_ReadPciConfigUlong+0xb6>
   13d41:	eb 0d                	jmp    13d50 <_WritePciConfigUchar>
   13d43:	90                   	nop    
   13d44:	90                   	nop    
   13d45:	90                   	nop    
   13d46:	90                   	nop    
   13d47:	90                   	nop    
   13d48:	90                   	nop    
   13d49:	90                   	nop    
   13d4a:	90                   	nop    
   13d4b:	90                   	nop    
   13d4c:	90                   	nop    
   13d4d:	90                   	nop    
   13d4e:	90                   	nop    
   13d4f:	90                   	nop    

00013d50 <_WritePciConfigUchar>:
   13d50:	55                   	push   %ebp
   13d51:	89 e5                	mov    %esp,%ebp
   13d53:	57                   	push   %edi
   13d54:	56                   	push   %esi
   13d55:	53                   	push   %ebx
   13d56:	83 ec 0c             	sub    $0xc,%esp
   13d59:	89 c6                	mov    %eax,%esi
   13d5b:	8a 45 0c             	mov    0xc(%ebp),%al
   13d5e:	88 d3                	mov    %dl,%bl
   13d60:	88 45 f2             	mov    %al,0xfffffff2(%ebp)
   13d63:	a1 60 e4 03 00       	mov    0x3e460,%eax
   13d68:	0f b6 7d 08          	movzbl 0x8(%ebp),%edi
   13d6c:	83 f8 01             	cmp    $0x1,%eax
   13d6f:	0f 84 9b 00 00 00    	je     13e10 <_WritePciConfigUchar+0xc0>
   13d75:	83 f8 02             	cmp    $0x2,%eax
   13d78:	0f 85 83 00 00 00    	jne    13e01 <_WritePciConfigUchar+0xb1>
   13d7e:	50                   	push   %eax
   13d7f:	50                   	push   %eax
   13d80:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13d83:	50                   	push   %eax
   13d84:	68 70 e4 03 00       	push   $0x3e470
   13d89:	e8 22 0f 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   13d8e:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   13d94:	89 d8                	mov    %ebx,%eax
   13d96:	83 e3 1f             	and    $0x1f,%ebx
   13d99:	c1 e3 08             	shl    $0x8,%ebx
   13d9c:	25 e0 00 00 00       	and    $0xe0,%eax
   13da1:	c1 f8 04             	sar    $0x4,%eax
   13da4:	0c f0                	or     $0xf0,%al
   13da6:	50                   	push   %eax
   13da7:	68 f8 0c 00 00       	push   $0xcf8
   13dac:	e8 df 0d 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13db1:	89 f0                	mov    %esi,%eax
   13db3:	25 ff 00 00 00       	and    $0xff,%eax
   13db8:	50                   	push   %eax
   13db9:	68 fa 0c 00 00       	push   $0xcfa
   13dbe:	e8 cd 0d 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13dc3:	31 c0                	xor    %eax,%eax
   13dc5:	8a 45 f2             	mov    0xfffffff2(%ebp),%al
   13dc8:	50                   	push   %eax
   13dc9:	89 f8                	mov    %edi,%eax
   13dcb:	25 ff 00 00 00       	and    $0xff,%eax
   13dd0:	09 c3                	or     %eax,%ebx
   13dd2:	80 cf c0             	or     $0xc0,%bh
   13dd5:	53                   	push   %ebx
   13dd6:	e8 b5 0d 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13ddb:	6a 00                	push   $0x0
   13ddd:	68 f8 0c 00 00       	push   $0xcf8
   13de2:	e8 a9 0d 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13de7:	31 c0                	xor    %eax,%eax
   13de9:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   13dec:	50                   	push   %eax
   13ded:	68 70 e4 03 00       	push   $0x3e470
   13df2:	e8 29 0f 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   13df7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13dfa:	31 c0                	xor    %eax,%eax
   13dfc:	5b                   	pop    %ebx
   13dfd:	5e                   	pop    %esi
   13dfe:	5f                   	pop    %edi
   13dff:	5d                   	pop    %ebp
   13e00:	c3                   	ret    
   13e01:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13e04:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   13e09:	5b                   	pop    %ebx
   13e0a:	5e                   	pop    %esi
   13e0b:	5f                   	pop    %edi
   13e0c:	5d                   	pop    %ebp
   13e0d:	c3                   	ret    
   13e0e:	89 f6                	mov    %esi,%esi
   13e10:	50                   	push   %eax
   13e11:	50                   	push   %eax
   13e12:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13e15:	50                   	push   %eax
   13e16:	68 70 e4 03 00       	push   $0x3e470
   13e1b:	e8 90 0e 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   13e20:	31 c9                	xor    %ecx,%ecx
   13e22:	88 d9                	mov    %bl,%cl
   13e24:	89 f2                	mov    %esi,%edx
   13e26:	89 c8                	mov    %ecx,%eax
   13e28:	81 e2 ff 00 00 00    	and    $0xff,%edx
   13e2e:	83 e0 1f             	and    $0x1f,%eax
   13e31:	89 fb                	mov    %edi,%ebx
   13e33:	c1 e0 0b             	shl    $0xb,%eax
   13e36:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   13e3c:	c1 e2 10             	shl    $0x10,%edx
   13e3f:	81 e1 e0 00 00 00    	and    $0xe0,%ecx
   13e45:	c1 e1 03             	shl    $0x3,%ecx
   13e48:	09 c2                	or     %eax,%edx
   13e4a:	89 d8                	mov    %ebx,%eax
   13e4c:	09 ca                	or     %ecx,%edx
   13e4e:	83 e0 fc             	and    $0xfffffffc,%eax
   13e51:	81 cb fc 0c 00 00    	or     $0xcfc,%ebx
   13e57:	09 c2                	or     %eax,%edx
   13e59:	81 ca 00 00 00 80    	or     $0x80000000,%edx
   13e5f:	52                   	push   %edx
   13e60:	68 f8 0c 00 00       	push   $0xcf8
   13e65:	e8 56 0d 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   13e6a:	31 c0                	xor    %eax,%eax
   13e6c:	8a 45 f2             	mov    0xfffffff2(%ebp),%al
   13e6f:	50                   	push   %eax
   13e70:	53                   	push   %ebx
   13e71:	e9 6c ff ff ff       	jmp    13de2 <_WritePciConfigUchar+0x92>
   13e76:	8d 76 00             	lea    0x0(%esi),%esi
   13e79:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00013e80 <_WritePciConfigUshort>:
   13e80:	55                   	push   %ebp
   13e81:	89 e5                	mov    %esp,%ebp
   13e83:	57                   	push   %edi
   13e84:	56                   	push   %esi
   13e85:	53                   	push   %ebx
   13e86:	83 ec 0c             	sub    $0xc,%esp
   13e89:	89 c7                	mov    %eax,%edi
   13e8b:	8b 45 0c             	mov    0xc(%ebp),%eax
   13e8e:	88 d3                	mov    %dl,%bl
   13e90:	66 89 45 f0          	mov    %ax,0xfffffff0(%ebp)
   13e94:	8a 45 08             	mov    0x8(%ebp),%al
   13e97:	25 ff 00 00 00       	and    $0xff,%eax
   13e9c:	89 c6                	mov    %eax,%esi
   13e9e:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
   13ea3:	f7 c6 01 00 00 00    	test   $0x1,%esi
   13ea9:	0f 85 8e 00 00 00    	jne    13f3d <_WritePciConfigUshort+0xbd>
   13eaf:	a1 60 e4 03 00       	mov    0x3e460,%eax
   13eb4:	83 f8 01             	cmp    $0x1,%eax
   13eb7:	0f 84 95 00 00 00    	je     13f52 <_WritePciConfigUshort+0xd2>
   13ebd:	83 f8 02             	cmp    $0x2,%eax
   13ec0:	0f 85 7f 00 00 00    	jne    13f45 <_WritePciConfigUshort+0xc5>
   13ec6:	50                   	push   %eax
   13ec7:	50                   	push   %eax
   13ec8:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13ecb:	50                   	push   %eax
   13ecc:	68 70 e4 03 00       	push   $0x3e470
   13ed1:	e8 da 0d 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   13ed6:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   13edc:	89 d8                	mov    %ebx,%eax
   13ede:	83 e3 1f             	and    $0x1f,%ebx
   13ee1:	c1 e3 08             	shl    $0x8,%ebx
   13ee4:	25 e0 00 00 00       	and    $0xe0,%eax
   13ee9:	c1 f8 04             	sar    $0x4,%eax
   13eec:	09 f3                	or     %esi,%ebx
   13eee:	0c f0                	or     $0xf0,%al
   13ef0:	80 cf c0             	or     $0xc0,%bh
   13ef3:	50                   	push   %eax
   13ef4:	68 f8 0c 00 00       	push   $0xcf8
   13ef9:	e8 92 0c 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13efe:	89 f8                	mov    %edi,%eax
   13f00:	25 ff 00 00 00       	and    $0xff,%eax
   13f05:	50                   	push   %eax
   13f06:	68 fa 0c 00 00       	push   $0xcfa
   13f0b:	e8 80 0c 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13f10:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   13f13:	25 ff ff 00 00       	and    $0xffff,%eax
   13f18:	50                   	push   %eax
   13f19:	53                   	push   %ebx
   13f1a:	e8 81 0c 00 00       	call   14ba0 <_WRITE_PORT_USHORT@8>
   13f1f:	6a 00                	push   $0x0
   13f21:	68 f8 0c 00 00       	push   $0xcf8
   13f26:	e8 65 0c 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   13f2b:	31 c0                	xor    %eax,%eax
   13f2d:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   13f30:	50                   	push   %eax
   13f31:	68 70 e4 03 00       	push   $0x3e470
   13f36:	e8 e5 0d 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   13f3b:	31 c0                	xor    %eax,%eax
   13f3d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13f40:	5b                   	pop    %ebx
   13f41:	5e                   	pop    %esi
   13f42:	5f                   	pop    %edi
   13f43:	5d                   	pop    %ebp
   13f44:	c3                   	ret    
   13f45:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13f48:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   13f4d:	5b                   	pop    %ebx
   13f4e:	5e                   	pop    %esi
   13f4f:	5f                   	pop    %edi
   13f50:	5d                   	pop    %ebp
   13f51:	c3                   	ret    
   13f52:	50                   	push   %eax
   13f53:	50                   	push   %eax
   13f54:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13f57:	50                   	push   %eax
   13f58:	68 70 e4 03 00       	push   $0x3e470
   13f5d:	e8 4e 0d 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   13f62:	31 c9                	xor    %ecx,%ecx
   13f64:	88 d9                	mov    %bl,%cl
   13f66:	89 fa                	mov    %edi,%edx
   13f68:	89 c8                	mov    %ecx,%eax
   13f6a:	81 e2 ff 00 00 00    	and    $0xff,%edx
   13f70:	83 e0 1f             	and    $0x1f,%eax
   13f73:	81 e1 e0 00 00 00    	and    $0xe0,%ecx
   13f79:	c1 e0 0b             	shl    $0xb,%eax
   13f7c:	c1 e2 10             	shl    $0x10,%edx
   13f7f:	c1 e1 03             	shl    $0x3,%ecx
   13f82:	09 c2                	or     %eax,%edx
   13f84:	89 f0                	mov    %esi,%eax
   13f86:	09 ca                	or     %ecx,%edx
   13f88:	83 e0 fc             	and    $0xfffffffc,%eax
   13f8b:	83 e6 02             	and    $0x2,%esi
   13f8e:	09 c2                	or     %eax,%edx
   13f90:	81 ca 00 00 00 80    	or     $0x80000000,%edx
   13f96:	52                   	push   %edx
   13f97:	68 f8 0c 00 00       	push   $0xcf8
   13f9c:	e8 1f 0c 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   13fa1:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   13fa4:	25 ff ff 00 00       	and    $0xffff,%eax
   13fa9:	50                   	push   %eax
   13faa:	8d 04 36             	lea    (%esi,%esi,1),%eax
   13fad:	05 fc 0c 00 00       	add    $0xcfc,%eax
   13fb2:	50                   	push   %eax
   13fb3:	e8 e8 0b 00 00       	call   14ba0 <_WRITE_PORT_USHORT@8>
   13fb8:	e9 6e ff ff ff       	jmp    13f2b <_WritePciConfigUshort+0xab>
   13fbd:	8d 76 00             	lea    0x0(%esi),%esi

00013fc0 <_WritePciConfigUlong>:
   13fc0:	55                   	push   %ebp
   13fc1:	89 e5                	mov    %esp,%ebp
   13fc3:	57                   	push   %edi
   13fc4:	56                   	push   %esi
   13fc5:	53                   	push   %ebx
   13fc6:	83 ec 0c             	sub    $0xc,%esp
   13fc9:	89 c7                	mov    %eax,%edi
   13fcb:	8a 45 08             	mov    0x8(%ebp),%al
   13fce:	88 d3                	mov    %dl,%bl
   13fd0:	25 ff 00 00 00       	and    $0xff,%eax
   13fd5:	89 c6                	mov    %eax,%esi
   13fd7:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
   13fdc:	f7 c6 03 00 00 00    	test   $0x3,%esi
   13fe2:	0f 85 85 00 00 00    	jne    1406d <_WritePciConfigUlong+0xad>
   13fe8:	a1 60 e4 03 00       	mov    0x3e460,%eax
   13fed:	83 f8 01             	cmp    $0x1,%eax
   13ff0:	0f 84 8c 00 00 00    	je     14082 <_WritePciConfigUlong+0xc2>
   13ff6:	83 f8 02             	cmp    $0x2,%eax
   13ff9:	75 7a                	jne    14075 <_WritePciConfigUlong+0xb5>
   13ffb:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   13ffe:	52                   	push   %edx
   13fff:	52                   	push   %edx
   14000:	50                   	push   %eax
   14001:	68 70 e4 03 00       	push   $0x3e470
   14006:	e8 a5 0c 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   1400b:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   14011:	89 d8                	mov    %ebx,%eax
   14013:	83 e3 1f             	and    $0x1f,%ebx
   14016:	c1 e3 08             	shl    $0x8,%ebx
   14019:	25 e0 00 00 00       	and    $0xe0,%eax
   1401e:	c1 f8 04             	sar    $0x4,%eax
   14021:	09 f3                	or     %esi,%ebx
   14023:	0c f0                	or     $0xf0,%al
   14025:	80 cf c0             	or     $0xc0,%bh
   14028:	50                   	push   %eax
   14029:	68 f8 0c 00 00       	push   $0xcf8
   1402e:	e8 5d 0b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14033:	89 f8                	mov    %edi,%eax
   14035:	25 ff 00 00 00       	and    $0xff,%eax
   1403a:	50                   	push   %eax
   1403b:	68 fa 0c 00 00       	push   $0xcfa
   14040:	e8 4b 0b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14045:	8b 45 0c             	mov    0xc(%ebp),%eax
   14048:	50                   	push   %eax
   14049:	53                   	push   %ebx
   1404a:	e8 71 0b 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   1404f:	6a 00                	push   $0x0
   14051:	68 f8 0c 00 00       	push   $0xcf8
   14056:	e8 35 0b 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1405b:	31 c0                	xor    %eax,%eax
   1405d:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   14060:	50                   	push   %eax
   14061:	68 70 e4 03 00       	push   $0x3e470
   14066:	e8 b5 0c 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   1406b:	31 c0                	xor    %eax,%eax
   1406d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   14070:	5b                   	pop    %ebx
   14071:	5e                   	pop    %esi
   14072:	5f                   	pop    %edi
   14073:	5d                   	pop    %ebp
   14074:	c3                   	ret    
   14075:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   14078:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   1407d:	5b                   	pop    %ebx
   1407e:	5e                   	pop    %esi
   1407f:	5f                   	pop    %edi
   14080:	5d                   	pop    %ebp
   14081:	c3                   	ret    
   14082:	50                   	push   %eax
   14083:	50                   	push   %eax
   14084:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   14087:	50                   	push   %eax
   14088:	68 70 e4 03 00       	push   $0x3e470
   1408d:	e8 1e 0c 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   14092:	31 c9                	xor    %ecx,%ecx
   14094:	88 d9                	mov    %bl,%cl
   14096:	89 fa                	mov    %edi,%edx
   14098:	89 c8                	mov    %ecx,%eax
   1409a:	81 e2 ff 00 00 00    	and    $0xff,%edx
   140a0:	83 e0 1f             	and    $0x1f,%eax
   140a3:	81 e1 e0 00 00 00    	and    $0xe0,%ecx
   140a9:	c1 e0 0b             	shl    $0xb,%eax
   140ac:	83 e6 fc             	and    $0xfffffffc,%esi
   140af:	c1 e2 10             	shl    $0x10,%edx
   140b2:	c1 e1 03             	shl    $0x3,%ecx
   140b5:	09 c2                	or     %eax,%edx
   140b7:	09 ca                	or     %ecx,%edx
   140b9:	09 f2                	or     %esi,%edx
   140bb:	81 ca 00 00 00 80    	or     $0x80000000,%edx
   140c1:	52                   	push   %edx
   140c2:	68 f8 0c 00 00       	push   $0xcf8
   140c7:	e8 f4 0a 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   140cc:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   140cf:	51                   	push   %ecx
   140d0:	68 fc 0c 00 00       	push   $0xcfc
   140d5:	e8 e6 0a 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   140da:	e9 7c ff ff ff       	jmp    1405b <_WritePciConfigUlong+0x9b>
   140df:	90                   	nop    

000140e0 <_HalpGetPciData@24>:
   140e0:	55                   	push   %ebp
   140e1:	89 e5                	mov    %esp,%ebp
   140e3:	57                   	push   %edi
   140e4:	56                   	push   %esi
   140e5:	53                   	push   %ebx
   140e6:	83 ec 2c             	sub    $0x2c,%esp
   140e9:	8b 7d 1c             	mov    0x1c(%ebp),%edi
   140ec:	8b 45 14             	mov    0x14(%ebp),%eax
   140ef:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   140f2:	8b 75 18             	mov    0x18(%ebp),%esi
   140f5:	89 fb                	mov    %edi,%ebx
   140f7:	85 ff                	test   %edi,%edi
   140f9:	74 09                	je     14104 <_HalpGetPciData@24+0x24>
   140fb:	a1 60 e4 03 00       	mov    0x3e460,%eax
   14100:	85 c0                	test   %eax,%eax
   14102:	75 0e                	jne    14112 <_HalpGetPciData@24+0x32>
   14104:	31 c9                	xor    %ecx,%ecx
   14106:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   14109:	89 c8                	mov    %ecx,%eax
   1410b:	5b                   	pop    %ebx
   1410c:	5e                   	pop    %esi
   1410d:	5f                   	pop    %edi
   1410e:	5d                   	pop    %ebp
   1410f:	c2 18 00             	ret    $0x18
   14112:	50                   	push   %eax
   14113:	50                   	push   %eax
   14114:	8b 45 10             	mov    0x10(%ebp),%eax
   14117:	83 e0 1f             	and    $0x1f,%eax
   1411a:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   1411d:	8a 45 0c             	mov    0xc(%ebp),%al
   14120:	25 ff 00 00 00       	and    $0xff,%eax
   14125:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   14128:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   1412b:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   1412e:	50                   	push   %eax
   1412f:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   14132:	6a 00                	push   $0x0
   14134:	e8 c7 fa ff ff       	call   13c00 <_ReadPciConfigUlong>
   14139:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   1413c:	83 c4 10             	add    $0x10,%esp
   1413f:	83 f8 ff             	cmp    $0xffffffff,%eax
   14142:	0f 94 c2             	sete   %dl
   14145:	85 c0                	test   %eax,%eax
   14147:	0f 94 c0             	sete   %al
   1414a:	09 d0                	or     %edx,%eax
   1414c:	a8 01                	test   $0x1,%al
   1414e:	74 23                	je     14173 <_HalpGetPciData@24+0x93>
   14150:	0b 75 0c             	or     0xc(%ebp),%esi
   14153:	0f 94 c2             	sete   %dl
   14156:	83 ff 01             	cmp    $0x1,%edi
   14159:	0f 97 c0             	seta   %al
   1415c:	25 ff 00 00 00       	and    $0xff,%eax
   14161:	31 c9                	xor    %ecx,%ecx
   14163:	85 c2                	test   %eax,%edx
   14165:	74 9f                	je     14106 <_HalpGetPciData@24+0x26>
   14167:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   1416a:	b1 02                	mov    $0x2,%cl
   1416c:	66 c7 00 ff ff       	movw   $0xffff,(%eax)
   14171:	eb 93                	jmp    14106 <_HalpGetPciData@24+0x26>
   14173:	50                   	push   %eax
   14174:	50                   	push   %eax
   14175:	8d 45 ef             	lea    0xffffffef(%ebp),%eax
   14178:	50                   	push   %eax
   14179:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   1417c:	6a 0e                	push   $0xe
   1417e:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   14181:	e8 ea f7 ff ff       	call   13970 <_ReadPciConfigUchar>
   14186:	83 c4 10             	add    $0x10,%esp
   14189:	80 7d ef 00          	cmpb   $0x0,0xffffffef(%ebp)
   1418d:	78 0a                	js     14199 <_HalpGetPciData@24+0xb9>
   1418f:	f6 45 10 e0          	testb  $0xe0,0x10(%ebp)
   14193:	74 04                	je     14199 <_HalpGetPciData@24+0xb9>
   14195:	85 f6                	test   %esi,%esi
   14197:	eb ba                	jmp    14153 <_HalpGetPciData@24+0x73>
   14199:	50                   	push   %eax
   1419a:	50                   	push   %eax
   1419b:	8a 45 10             	mov    0x10(%ebp),%al
   1419e:	25 ff 00 00 00       	and    $0xff,%eax
   141a3:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   141a6:	8a 45 0c             	mov    0xc(%ebp),%al
   141a9:	25 ff 00 00 00       	and    $0xff,%eax
   141ae:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   141b1:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   141b4:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   141b7:	50                   	push   %eax
   141b8:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   141bb:	6a 00                	push   $0x0
   141bd:	e8 3e fa ff ff       	call   13c00 <_ReadPciConfigUlong>
   141c2:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   141c5:	83 c4 10             	add    $0x10,%esp
   141c8:	83 f8 ff             	cmp    $0xffffffff,%eax
   141cb:	0f 94 c2             	sete   %dl
   141ce:	85 c0                	test   %eax,%eax
   141d0:	0f 94 c0             	sete   %al
   141d3:	09 d0                	or     %edx,%eax
   141d5:	a8 01                	test   $0x1,%al
   141d7:	74 27                	je     14200 <_HalpGetPciData@24+0x120>
   141d9:	8b 45 0c             	mov    0xc(%ebp),%eax
   141dc:	0b 45 18             	or     0x18(%ebp),%eax
   141df:	0f 94 c2             	sete   %dl
   141e2:	83 ff 01             	cmp    $0x1,%edi
   141e5:	0f 97 c0             	seta   %al
   141e8:	25 ff 00 00 00       	and    $0xff,%eax
   141ed:	31 c9                	xor    %ecx,%ecx
   141ef:	85 c2                	test   %eax,%edx
   141f1:	0f 84 0f ff ff ff    	je     14106 <_HalpGetPciData@24+0x26>
   141f7:	8b 45 14             	mov    0x14(%ebp),%eax
   141fa:	e9 6b ff ff ff       	jmp    1416a <_HalpGetPciData@24+0x8a>
   141ff:	90                   	nop    
   14200:	85 ff                	test   %edi,%edi
   14202:	0f 95 c0             	setne  %al
   14205:	25 ff 00 00 00       	and    $0xff,%eax
   1420a:	85 45 18             	test   %eax,0x18(%ebp)
   1420d:	0f 85 f7 00 00 00    	jne    1430a <_HalpGetPciData@24+0x22a>
   14213:	89 f2                	mov    %esi,%edx
   14215:	d1 ea                	shr    %edx
   14217:	83 fb 01             	cmp    $0x1,%ebx
   1421a:	0f 97 c0             	seta   %al
   1421d:	25 ff 00 00 00       	and    $0xff,%eax
   14222:	85 d0                	test   %edx,%eax
   14224:	0f 85 b0 00 00 00    	jne    142da <_HalpGetPciData@24+0x1fa>
   1422a:	83 fb 03             	cmp    $0x3,%ebx
   1422d:	76 3c                	jbe    1426b <_HalpGetPciData@24+0x18b>
   1422f:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   14232:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   14235:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   14238:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   1423b:	50                   	push   %eax
   1423c:	50                   	push   %eax
   1423d:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   14240:	50                   	push   %eax
   14241:	89 f0                	mov    %esi,%eax
   14243:	25 ff 00 00 00       	and    $0xff,%eax
   14248:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
   1424b:	50                   	push   %eax
   1424c:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
   1424f:	e8 ac f9 ff ff       	call   13c00 <_ReadPciConfigUlong>
   14254:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   14257:	83 c0 04             	add    $0x4,%eax
   1425a:	83 eb 04             	sub    $0x4,%ebx
   1425d:	83 c6 04             	add    $0x4,%esi
   14260:	83 c4 10             	add    $0x10,%esp
   14263:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   14266:	83 fb 03             	cmp    $0x3,%ebx
   14269:	77 d0                	ja     1423b <_HalpGetPciData@24+0x15b>
   1426b:	83 fb 01             	cmp    $0x1,%ebx
   1426e:	77 38                	ja     142a8 <_HalpGetPciData@24+0x1c8>
   14270:	85 db                	test   %ebx,%ebx
   14272:	75 09                	jne    1427d <_HalpGetPciData@24+0x19d>
   14274:	89 f9                	mov    %edi,%ecx
   14276:	29 d9                	sub    %ebx,%ecx
   14278:	e9 89 fe ff ff       	jmp    14106 <_HalpGetPciData@24+0x26>
   1427d:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   14280:	31 d2                	xor    %edx,%edx
   14282:	50                   	push   %eax
   14283:	50                   	push   %eax
   14284:	31 c0                	xor    %eax,%eax
   14286:	51                   	push   %ecx
   14287:	89 f1                	mov    %esi,%ecx
   14289:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   1428f:	8a 55 10             	mov    0x10(%ebp),%dl
   14292:	8a 45 0c             	mov    0xc(%ebp),%al
   14295:	51                   	push   %ecx
   14296:	e8 d5 f6 ff ff       	call   13970 <_ReadPciConfigUchar>
   1429b:	4b                   	dec    %ebx
   1429c:	89 f9                	mov    %edi,%ecx
   1429e:	83 c4 10             	add    $0x10,%esp
   142a1:	29 d9                	sub    %ebx,%ecx
   142a3:	e9 5e fe ff ff       	jmp    14106 <_HalpGetPciData@24+0x26>
   142a8:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   142ab:	31 d2                	xor    %edx,%edx
   142ad:	50                   	push   %eax
   142ae:	50                   	push   %eax
   142af:	31 c0                	xor    %eax,%eax
   142b1:	51                   	push   %ecx
   142b2:	89 f1                	mov    %esi,%ecx
   142b4:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   142ba:	8a 55 10             	mov    0x10(%ebp),%dl
   142bd:	8a 45 0c             	mov    0xc(%ebp),%al
   142c0:	51                   	push   %ecx
   142c1:	e8 ea f7 ff ff       	call   13ab0 <_ReadPciConfigUshort>
   142c6:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   142c9:	83 c0 02             	add    $0x2,%eax
   142cc:	83 c6 02             	add    $0x2,%esi
   142cf:	83 eb 02             	sub    $0x2,%ebx
   142d2:	83 c4 10             	add    $0x10,%esp
   142d5:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   142d8:	eb 96                	jmp    14270 <_HalpGetPciData@24+0x190>
   142da:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   142dd:	52                   	push   %edx
   142de:	52                   	push   %edx
   142df:	50                   	push   %eax
   142e0:	89 f0                	mov    %esi,%eax
   142e2:	25 ff 00 00 00       	and    $0xff,%eax
   142e7:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   142ea:	50                   	push   %eax
   142eb:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   142ee:	e8 bd f7 ff ff       	call   13ab0 <_ReadPciConfigUshort>
   142f3:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   142f6:	83 c0 02             	add    $0x2,%eax
   142f9:	83 c6 02             	add    $0x2,%esi
   142fc:	83 eb 02             	sub    $0x2,%ebx
   142ff:	83 c4 10             	add    $0x10,%esp
   14302:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   14305:	e9 20 ff ff ff       	jmp    1422a <_HalpGetPciData@24+0x14a>
   1430a:	31 c0                	xor    %eax,%eax
   1430c:	8b 4d 14             	mov    0x14(%ebp),%ecx
   1430f:	8a 45 18             	mov    0x18(%ebp),%al
   14312:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   14315:	53                   	push   %ebx
   14316:	53                   	push   %ebx
   14317:	51                   	push   %ecx
   14318:	50                   	push   %eax
   14319:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   1431c:	e8 4f f6 ff ff       	call   13970 <_ReadPciConfigUchar>
   14321:	8b 45 14             	mov    0x14(%ebp),%eax
   14324:	8b 75 18             	mov    0x18(%ebp),%esi
   14327:	40                   	inc    %eax
   14328:	46                   	inc    %esi
   14329:	8d 5f ff             	lea    0xffffffff(%edi),%ebx
   1432c:	83 c4 10             	add    $0x10,%esp
   1432f:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   14332:	e9 dc fe ff ff       	jmp    14213 <_HalpGetPciData@24+0x133>
   14337:	89 f6                	mov    %esi,%esi
   14339:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014340 <_HalpSetPciData@24>:
   14340:	55                   	push   %ebp
   14341:	89 e5                	mov    %esp,%ebp
   14343:	57                   	push   %edi
   14344:	56                   	push   %esi
   14345:	53                   	push   %ebx
   14346:	83 ec 2c             	sub    $0x2c,%esp
   14349:	8b 5d 1c             	mov    0x1c(%ebp),%ebx
   1434c:	8b 7d 14             	mov    0x14(%ebp),%edi
   1434f:	8b 75 18             	mov    0x18(%ebp),%esi
   14352:	85 db                	test   %ebx,%ebx
   14354:	74 0a                	je     14360 <_HalpSetPciData@24+0x20>
   14356:	8b 15 60 e4 03 00    	mov    0x3e460,%edx
   1435c:	85 d2                	test   %edx,%edx
   1435e:	75 10                	jne    14370 <_HalpSetPciData@24+0x30>
   14360:	31 d2                	xor    %edx,%edx
   14362:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   14365:	89 d0                	mov    %edx,%eax
   14367:	5b                   	pop    %ebx
   14368:	5e                   	pop    %esi
   14369:	5f                   	pop    %edi
   1436a:	5d                   	pop    %ebp
   1436b:	c2 18 00             	ret    $0x18
   1436e:	89 f6                	mov    %esi,%esi
   14370:	8a 55 0c             	mov    0xc(%ebp),%dl
   14373:	50                   	push   %eax
   14374:	50                   	push   %eax
   14375:	8b 45 10             	mov    0x10(%ebp),%eax
   14378:	81 e2 ff 00 00 00    	and    $0xff,%edx
   1437e:	83 e0 1f             	and    $0x1f,%eax
   14381:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   14384:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   14387:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   1438a:	50                   	push   %eax
   1438b:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   1438e:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   14391:	6a 00                	push   $0x0
   14393:	e8 68 f8 ff ff       	call   13c00 <_ReadPciConfigUlong>
   14398:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   1439b:	83 c4 10             	add    $0x10,%esp
   1439e:	83 f8 ff             	cmp    $0xffffffff,%eax
   143a1:	0f 94 c2             	sete   %dl
   143a4:	85 c0                	test   %eax,%eax
   143a6:	0f 94 c0             	sete   %al
   143a9:	09 d0                	or     %edx,%eax
   143ab:	31 d2                	xor    %edx,%edx
   143ad:	a8 01                	test   $0x1,%al
   143af:	75 b1                	jne    14362 <_HalpSetPciData@24+0x22>
   143b1:	50                   	push   %eax
   143b2:	50                   	push   %eax
   143b3:	8d 45 ef             	lea    0xffffffef(%ebp),%eax
   143b6:	50                   	push   %eax
   143b7:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   143ba:	6a 0e                	push   $0xe
   143bc:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   143bf:	e8 ac f5 ff ff       	call   13970 <_ReadPciConfigUchar>
   143c4:	83 c4 10             	add    $0x10,%esp
   143c7:	80 7d ef 00          	cmpb   $0x0,0xffffffef(%ebp)
   143cb:	78 08                	js     143d5 <_HalpSetPciData@24+0x95>
   143cd:	31 d2                	xor    %edx,%edx
   143cf:	f6 45 10 e0          	testb  $0xe0,0x10(%ebp)
   143d3:	75 8d                	jne    14362 <_HalpSetPciData@24+0x22>
   143d5:	8a 55 10             	mov    0x10(%ebp),%dl
   143d8:	81 e2 ff 00 00 00    	and    $0xff,%edx
   143de:	50                   	push   %eax
   143df:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
   143e2:	50                   	push   %eax
   143e3:	8d 55 f0             	lea    0xfffffff0(%ebp),%edx
   143e6:	8a 45 0c             	mov    0xc(%ebp),%al
   143e9:	52                   	push   %edx
   143ea:	25 ff 00 00 00       	and    $0xff,%eax
   143ef:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
   143f2:	6a 00                	push   $0x0
   143f4:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   143f7:	e8 04 f8 ff ff       	call   13c00 <_ReadPciConfigUlong>
   143fc:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   143ff:	83 c4 10             	add    $0x10,%esp
   14402:	83 f8 ff             	cmp    $0xffffffff,%eax
   14405:	0f 94 c2             	sete   %dl
   14408:	85 c0                	test   %eax,%eax
   1440a:	0f 94 c0             	sete   %al
   1440d:	09 d0                	or     %edx,%eax
   1440f:	31 d2                	xor    %edx,%edx
   14411:	a8 01                	test   $0x1,%al
   14413:	0f 85 49 ff ff ff    	jne    14362 <_HalpSetPciData@24+0x22>
   14419:	8b 45 1c             	mov    0x1c(%ebp),%eax
   1441c:	85 c0                	test   %eax,%eax
   1441e:	0f 95 c0             	setne  %al
   14421:	25 ff 00 00 00       	and    $0xff,%eax
   14426:	85 45 18             	test   %eax,0x18(%ebp)
   14429:	0f 85 f2 00 00 00    	jne    14521 <_HalpSetPciData@24+0x1e1>
   1442f:	89 f2                	mov    %esi,%edx
   14431:	d1 ea                	shr    %edx
   14433:	83 fb 01             	cmp    $0x1,%ebx
   14436:	0f 97 c0             	seta   %al
   14439:	25 ff 00 00 00       	and    $0xff,%eax
   1443e:	85 d0                	test   %edx,%eax
   14440:	0f 85 ac 00 00 00    	jne    144f2 <_HalpSetPciData@24+0x1b2>
   14446:	83 fb 03             	cmp    $0x3,%ebx
   14449:	76 35                	jbe    14480 <_HalpSetPciData@24+0x140>
   1444b:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   1444e:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   14451:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   14454:	89 55 d4             	mov    %edx,0xffffffd4(%ebp)
   14457:	89 f0                	mov    %esi,%eax
   14459:	51                   	push   %ecx
   1445a:	51                   	push   %ecx
   1445b:	8b 17                	mov    (%edi),%edx
   1445d:	25 ff 00 00 00       	and    $0xff,%eax
   14462:	52                   	push   %edx
   14463:	83 eb 04             	sub    $0x4,%ebx
   14466:	50                   	push   %eax
   14467:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   1446a:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   1446d:	83 c7 04             	add    $0x4,%edi
   14470:	e8 4b fb ff ff       	call   13fc0 <_WritePciConfigUlong>
   14475:	83 c6 04             	add    $0x4,%esi
   14478:	83 c4 10             	add    $0x10,%esp
   1447b:	83 fb 03             	cmp    $0x3,%ebx
   1447e:	77 d7                	ja     14457 <_HalpSetPciData@24+0x117>
   14480:	83 fb 01             	cmp    $0x1,%ebx
   14483:	77 3b                	ja     144c0 <_HalpSetPciData@24+0x180>
   14485:	85 db                	test   %ebx,%ebx
   14487:	75 0a                	jne    14493 <_HalpSetPciData@24+0x153>
   14489:	8b 55 1c             	mov    0x1c(%ebp),%edx
   1448c:	29 da                	sub    %ebx,%edx
   1448e:	e9 cf fe ff ff       	jmp    14362 <_HalpSetPciData@24+0x22>
   14493:	31 c9                	xor    %ecx,%ecx
   14495:	50                   	push   %eax
   14496:	50                   	push   %eax
   14497:	8a 0f                	mov    (%edi),%cl
   14499:	31 d2                	xor    %edx,%edx
   1449b:	51                   	push   %ecx
   1449c:	31 c0                	xor    %eax,%eax
   1449e:	89 f1                	mov    %esi,%ecx
   144a0:	8a 55 10             	mov    0x10(%ebp),%dl
   144a3:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   144a9:	8a 45 0c             	mov    0xc(%ebp),%al
   144ac:	51                   	push   %ecx
   144ad:	e8 9e f8 ff ff       	call   13d50 <_WritePciConfigUchar>
   144b2:	4b                   	dec    %ebx
   144b3:	8b 55 1c             	mov    0x1c(%ebp),%edx
   144b6:	83 c4 10             	add    $0x10,%esp
   144b9:	29 da                	sub    %ebx,%edx
   144bb:	e9 a2 fe ff ff       	jmp    14362 <_HalpSetPciData@24+0x22>
   144c0:	50                   	push   %eax
   144c1:	50                   	push   %eax
   144c2:	31 d2                	xor    %edx,%edx
   144c4:	66 8b 0f             	mov    (%edi),%cx
   144c7:	31 c0                	xor    %eax,%eax
   144c9:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
   144cf:	8a 55 10             	mov    0x10(%ebp),%dl
   144d2:	51                   	push   %ecx
   144d3:	89 f1                	mov    %esi,%ecx
   144d5:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   144db:	8a 45 0c             	mov    0xc(%ebp),%al
   144de:	51                   	push   %ecx
   144df:	e8 9c f9 ff ff       	call   13e80 <_WritePciConfigUshort>
   144e4:	83 c7 02             	add    $0x2,%edi
   144e7:	83 c6 02             	add    $0x2,%esi
   144ea:	83 eb 02             	sub    $0x2,%ebx
   144ed:	83 c4 10             	add    $0x10,%esp
   144f0:	eb 93                	jmp    14485 <_HalpSetPciData@24+0x145>
   144f2:	50                   	push   %eax
   144f3:	50                   	push   %eax
   144f4:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
   144f7:	66 8b 07             	mov    (%edi),%ax
   144fa:	83 eb 02             	sub    $0x2,%ebx
   144fd:	25 ff ff 00 00       	and    $0xffff,%eax
   14502:	83 c7 02             	add    $0x2,%edi
   14505:	50                   	push   %eax
   14506:	89 f0                	mov    %esi,%eax
   14508:	25 ff 00 00 00       	and    $0xff,%eax
   1450d:	83 c6 02             	add    $0x2,%esi
   14510:	50                   	push   %eax
   14511:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   14514:	e8 67 f9 ff ff       	call   13e80 <_WritePciConfigUshort>
   14519:	83 c4 10             	add    $0x10,%esp
   1451c:	e9 25 ff ff ff       	jmp    14446 <_HalpSetPciData@24+0x106>
   14521:	8b 55 14             	mov    0x14(%ebp),%edx
   14524:	50                   	push   %eax
   14525:	50                   	push   %eax
   14526:	31 c0                	xor    %eax,%eax
   14528:	8a 02                	mov    (%edx),%al
   1452a:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
   1452d:	50                   	push   %eax
   1452e:	31 c0                	xor    %eax,%eax
   14530:	8a 45 18             	mov    0x18(%ebp),%al
   14533:	50                   	push   %eax
   14534:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   14537:	e8 14 f8 ff ff       	call   13d50 <_WritePciConfigUchar>
   1453c:	8b 7d 14             	mov    0x14(%ebp),%edi
   1453f:	8b 75 18             	mov    0x18(%ebp),%esi
   14542:	8b 5d 1c             	mov    0x1c(%ebp),%ebx
   14545:	47                   	inc    %edi
   14546:	46                   	inc    %esi
   14547:	4b                   	dec    %ebx
   14548:	83 c4 10             	add    $0x10,%esp
   1454b:	e9 df fe ff ff       	jmp    1442f <_HalpSetPciData@24+0xef>

00014550 <_HalpGetPciInterruptVector@24>:
   14550:	55                   	push   %ebp
   14551:	ba 17 00 00 00       	mov    $0x17,%edx
   14556:	89 e5                	mov    %esp,%ebp
   14558:	8b 4d 14             	mov    0x14(%ebp),%ecx
   1455b:	29 ca                	sub    %ecx,%edx
   1455d:	8b 4d 18             	mov    0x18(%ebp),%ecx
   14560:	c1 e2 03             	shl    $0x3,%edx
   14563:	8d 42 30             	lea    0x30(%edx),%eax
   14566:	c1 ea 03             	shr    $0x3,%edx
   14569:	83 c2 04             	add    $0x4,%edx
   1456c:	88 11                	mov    %dl,(%ecx)
   1456e:	8b 55 1c             	mov    0x1c(%ebp),%edx
   14571:	c7 02 ff ff ff ff    	movl   $0xffffffff,(%edx)
   14577:	5d                   	pop    %ebp
   14578:	c2 18 00             	ret    $0x18
   1457b:	90                   	nop    
   1457c:	8d 74 26 00          	lea    0x0(%esi),%esi

00014580 <_HalpTranslatePciAddress@24>:
   14580:	55                   	push   %ebp
   14581:	89 e5                	mov    %esp,%ebp
   14583:	8b 45 18             	mov    0x18(%ebp),%eax
   14586:	8b 00                	mov    (%eax),%eax
   14588:	85 c0                	test   %eax,%eax
   1458a:	74 05                	je     14591 <_HalpTranslatePciAddress@24+0x11>
   1458c:	31 d2                	xor    %edx,%edx
   1458e:	48                   	dec    %eax
   1458f:	75 13                	jne    145a4 <_HalpTranslatePciAddress@24+0x24>
   14591:	8b 4d 1c             	mov    0x1c(%ebp),%ecx
   14594:	8b 55 14             	mov    0x14(%ebp),%edx
   14597:	8b 45 10             	mov    0x10(%ebp),%eax
   1459a:	89 01                	mov    %eax,(%ecx)
   1459c:	89 51 04             	mov    %edx,0x4(%ecx)
   1459f:	ba 01 00 00 00       	mov    $0x1,%edx
   145a4:	89 d0                	mov    %edx,%eax
   145a6:	5d                   	pop    %ebp
   145a7:	c2 18 00             	ret    $0x18
   145aa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

000145b0 <_PciSize@8>:
   145b0:	21 c2                	and    %eax,%edx
   145b2:	55                   	push   %ebp
   145b3:	89 d0                	mov    %edx,%eax
   145b5:	89 e5                	mov    %esp,%ebp
   145b7:	f7 d8                	neg    %eax
   145b9:	21 c2                	and    %eax,%edx
   145bb:	5d                   	pop    %ebp
   145bc:	89 d0                	mov    %edx,%eax
   145be:	c3                   	ret    
   145bf:	90                   	nop    

000145c0 <_HalpAssignPciSlotResources@32>:
   145c0:	55                   	push   %ebp
   145c1:	89 e5                	mov    %esp,%ebp
   145c3:	57                   	push   %edi
   145c4:	56                   	push   %esi
   145c5:	53                   	push   %ebx
   145c6:	81 ec 44 01 00 00    	sub    $0x144,%esp
   145cc:	8d 85 e8 fe ff ff    	lea    0xfffffee8(%ebp),%eax
   145d2:	8b 5d 20             	mov    0x20(%ebp),%ebx
   145d5:	c7 85 c0 fe ff ff 00 	movl   $0x0,0xfffffec0(%ebp)
   145dc:	00 00 00 
   145df:	6a 40                	push   $0x40
   145e1:	6a 00                	push   $0x0
   145e3:	50                   	push   %eax
   145e4:	8b 45 0c             	mov    0xc(%ebp),%eax
   145e7:	53                   	push   %ebx
   145e8:	50                   	push   %eax
   145e9:	8b 45 08             	mov    0x8(%ebp),%eax
   145ec:	50                   	push   %eax
   145ed:	e8 ee fa ff ff       	call   140e0 <_HalpGetPciData@24>
   145f2:	b9 01 00 00 c0       	mov    $0xc0000001,%ecx
   145f7:	5e                   	pop    %esi
   145f8:	83 f8 40             	cmp    $0x40,%eax
   145fb:	5f                   	pop    %edi
   145fc:	0f 85 f0 01 00 00    	jne    147f2 <_HalpAssignPciSlotResources@32+0x232>
   14602:	31 c0                	xor    %eax,%eax
   14604:	31 f6                	xor    %esi,%esi
   14606:	88 d8                	mov    %bl,%al
   14608:	c7 85 c4 fe ff ff 00 	movl   $0x0,0xfffffec4(%ebp)
   1460f:	00 00 00 
   14612:	89 85 bc fe ff ff    	mov    %eax,0xfffffebc(%ebp)
   14618:	8a 45 0c             	mov    0xc(%ebp),%al
   1461b:	25 ff 00 00 00       	and    $0xff,%eax
   14620:	89 85 b8 fe ff ff    	mov    %eax,0xfffffeb8(%ebp)
   14626:	eb 0e                	jmp    14636 <_HalpAssignPciSlotResources@32+0x76>
   14628:	85 c0                	test   %eax,%eax
   1462a:	0f 85 20 01 00 00    	jne    14750 <_HalpAssignPciSlotResources@32+0x190>
   14630:	46                   	inc    %esi
   14631:	83 fe 05             	cmp    $0x5,%esi
   14634:	77 1d                	ja     14653 <_HalpAssignPciSlotResources@32+0x93>
   14636:	8b 84 b5 f8 fe ff ff 	mov    0xfffffef8(%ebp,%esi,4),%eax
   1463d:	83 f8 ff             	cmp    $0xffffffff,%eax
   14640:	75 e6                	jne    14628 <_HalpAssignPciSlotResources@32+0x68>
   14642:	c7 84 b5 f8 fe ff ff 	movl   $0x0,0xfffffef8(%ebp,%esi,4)
   14649:	00 00 00 00 
   1464d:	46                   	inc    %esi
   1464e:	83 fe 05             	cmp    $0x5,%esi
   14651:	76 e3                	jbe    14636 <_HalpAssignPciSlotResources@32+0x76>
   14653:	80 bd 24 ff ff ff 01 	cmpb   $0x1,0xffffff24(%ebp)
   1465a:	83 9d c4 fe ff ff ff 	sbbl   $0xffffffff,0xfffffec4(%ebp)
   14661:	50                   	push   %eax
   14662:	8b 85 c4 fe ff ff    	mov    0xfffffec4(%ebp),%eax
   14668:	68 50 43 49 48       	push   $0x48494350
   1466d:	c1 e0 04             	shl    $0x4,%eax
   14670:	83 c0 14             	add    $0x14,%eax
   14673:	50                   	push   %eax
   14674:	6a 01                	push   $0x1
   14676:	e8 25 62 00 00       	call   1a8a0 <_ExAllocatePoolWithTag@12>
   1467b:	b9 17 00 00 c0       	mov    $0xc0000017,%ecx
   14680:	89 c2                	mov    %eax,%edx
   14682:	8b 45 24             	mov    0x24(%ebp),%eax
   14685:	85 d2                	test   %edx,%edx
   14687:	89 10                	mov    %edx,(%eax)
   14689:	58                   	pop    %eax
   1468a:	0f 84 62 01 00 00    	je     147f2 <_HalpAssignPciSlotResources@32+0x232>
   14690:	8b 45 0c             	mov    0xc(%ebp),%eax
   14693:	8d 5a 14             	lea    0x14(%edx),%ebx
   14696:	89 42 08             	mov    %eax,0x8(%edx)
   14699:	31 f6                	xor    %esi,%esi
   1469b:	8b 85 c4 fe ff ff    	mov    0xfffffec4(%ebp),%eax
   146a1:	c7 02 01 00 00 00    	movl   $0x1,(%edx)
   146a7:	c7 42 04 05 00 00 00 	movl   $0x5,0x4(%edx)
   146ae:	66 c7 42 0c 01 00    	movw   $0x1,0xc(%edx)
   146b4:	66 c7 42 0e 01 00    	movw   $0x1,0xe(%edx)
   146ba:	89 42 10             	mov    %eax,0x10(%edx)
   146bd:	eb 41                	jmp    14700 <_HalpAssignPciSlotResources@32+0x140>
   146bf:	90                   	nop    
   146c0:	c6 03 03             	movb   $0x3,(%ebx)
   146c3:	c6 43 01 01          	movb   $0x1,0x1(%ebx)
   146c7:	66 c7 43 02 00 00    	movw   $0x0,0x2(%ebx)
   146cd:	31 d2                	xor    %edx,%edx
   146cf:	8b 84 b5 f8 fe ff ff 	mov    0xfffffef8(%ebp,%esi,4),%eax
   146d6:	89 53 08             	mov    %edx,0x8(%ebx)
   146d9:	83 e0 f0             	and    $0xfffffff0,%eax
   146dc:	ba f0 ff ff ff       	mov    $0xfffffff0,%edx
   146e1:	89 43 04             	mov    %eax,0x4(%ebx)
   146e4:	8b 84 b5 c8 fe ff ff 	mov    0xfffffec8(%ebp,%esi,4),%eax
   146eb:	e8 c0 fe ff ff       	call   145b0 <_PciSize@8>
   146f0:	89 43 0c             	mov    %eax,0xc(%ebx)
   146f3:	83 c3 10             	add    $0x10,%ebx
   146f6:	46                   	inc    %esi
   146f7:	83 fe 05             	cmp    $0x5,%esi
   146fa:	0f 87 00 01 00 00    	ja     14800 <_HalpAssignPciSlotResources@32+0x240>
   14700:	8b 84 b5 f8 fe ff ff 	mov    0xfffffef8(%ebp,%esi,4),%eax
   14707:	85 c0                	test   %eax,%eax
   14709:	74 eb                	je     146f6 <_HalpAssignPciSlotResources@32+0x136>
   1470b:	a8 01                	test   $0x1,%al
   1470d:	74 b1                	je     146c0 <_HalpAssignPciSlotResources@32+0x100>
   1470f:	a8 01                	test   $0x1,%al
   14711:	0f 84 24 01 00 00    	je     1483b <_HalpAssignPciSlotResources@32+0x27b>
   14717:	c6 03 01             	movb   $0x1,(%ebx)
   1471a:	c6 43 01 01          	movb   $0x1,0x1(%ebx)
   1471e:	66 c7 43 02 01 00    	movw   $0x1,0x2(%ebx)
   14724:	ba fc ff 00 00       	mov    $0xfffc,%edx
   14729:	8b 84 b5 f8 fe ff ff 	mov    0xfffffef8(%ebp,%esi,4),%eax
   14730:	83 e0 fc             	and    $0xfffffffc,%eax
   14733:	89 84 b5 f8 fe ff ff 	mov    %eax,0xfffffef8(%ebp,%esi,4)
   1473a:	89 43 04             	mov    %eax,0x4(%ebx)
   1473d:	c7 43 08 00 00 00 00 	movl   $0x0,0x8(%ebx)
   14744:	8b 84 b5 c8 fe ff ff 	mov    0xfffffec8(%ebp,%esi,4),%eax
   1474b:	eb 9e                	jmp    146eb <_HalpAssignPciSlotResources@32+0x12b>
   1474d:	8d 76 00             	lea    0x0(%esi),%esi
   14750:	8d 3c b5 00 00 00 00 	lea    0x0(,%esi,4),%edi
   14757:	8b 8d c4 fe ff ff    	mov    0xfffffec4(%ebp),%ecx
   1475d:	31 db                	xor    %ebx,%ebx
   1475f:	41                   	inc    %ecx
   14760:	8d 47 10             	lea    0x10(%edi),%eax
   14763:	88 c3                	mov    %al,%bl
   14765:	52                   	push   %edx
   14766:	8b 85 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%eax
   1476c:	52                   	push   %edx
   1476d:	8b 95 bc fe ff ff    	mov    0xfffffebc(%ebp),%edx
   14773:	6a ff                	push   $0xffffffff
   14775:	89 8d c4 fe ff ff    	mov    %ecx,0xfffffec4(%ebp)
   1477b:	53                   	push   %ebx
   1477c:	e8 3f f8 ff ff       	call   13fc0 <_WritePciConfigUlong>
   14781:	83 c4 10             	add    $0x10,%esp
   14784:	85 c0                	test   %eax,%eax
   14786:	89 85 c0 fe ff ff    	mov    %eax,0xfffffec0(%ebp)
   1478c:	0f 88 b0 00 00 00    	js     14842 <_HalpAssignPciSlotResources@32+0x282>
   14792:	50                   	push   %eax
   14793:	50                   	push   %eax
   14794:	8d 84 3d c8 fe ff ff 	lea    0xfffffec8(%ebp,%edi,1),%eax
   1479b:	50                   	push   %eax
   1479c:	8b 95 bc fe ff ff    	mov    0xfffffebc(%ebp),%edx
   147a2:	8b 85 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%eax
   147a8:	53                   	push   %ebx
   147a9:	e8 52 f4 ff ff       	call   13c00 <_ReadPciConfigUlong>
   147ae:	83 c4 10             	add    $0x10,%esp
   147b1:	85 c0                	test   %eax,%eax
   147b3:	89 85 c0 fe ff ff    	mov    %eax,0xfffffec0(%ebp)
   147b9:	0f 88 83 00 00 00    	js     14842 <_HalpAssignPciSlotResources@32+0x282>
   147bf:	50                   	push   %eax
   147c0:	50                   	push   %eax
   147c1:	8b 84 b5 f8 fe ff ff 	mov    0xfffffef8(%ebp,%esi,4),%eax
   147c8:	50                   	push   %eax
   147c9:	8b 95 bc fe ff ff    	mov    0xfffffebc(%ebp),%edx
   147cf:	8b 85 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%eax
   147d5:	53                   	push   %ebx
   147d6:	e8 e5 f7 ff ff       	call   13fc0 <_WritePciConfigUlong>
   147db:	83 c4 10             	add    $0x10,%esp
   147de:	85 c0                	test   %eax,%eax
   147e0:	89 85 c0 fe ff ff    	mov    %eax,0xfffffec0(%ebp)
   147e6:	0f 89 44 fe ff ff    	jns    14630 <_HalpAssignPciSlotResources@32+0x70>
   147ec:	8b 8d c0 fe ff ff    	mov    0xfffffec0(%ebp),%ecx
   147f2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   147f5:	89 c8                	mov    %ecx,%eax
   147f7:	5b                   	pop    %ebx
   147f8:	5e                   	pop    %esi
   147f9:	5f                   	pop    %edi
   147fa:	5d                   	pop    %ebp
   147fb:	c2 20 00             	ret    $0x20
   147fe:	89 f6                	mov    %esi,%esi
   14800:	80 bd 24 ff ff ff 00 	cmpb   $0x0,0xffffff24(%ebp)
   14807:	74 e3                	je     147ec <_HalpAssignPciSlotResources@32+0x22c>
   14809:	c6 03 02             	movb   $0x2,(%ebx)
   1480c:	c6 43 01 03          	movb   $0x3,0x1(%ebx)
   14810:	66 c7 43 02 00 00    	movw   $0x0,0x2(%ebx)
   14816:	31 c0                	xor    %eax,%eax
   14818:	8a 85 24 ff ff ff    	mov    0xffffff24(%ebp),%al
   1481e:	89 43 04             	mov    %eax,0x4(%ebx)
   14821:	31 c0                	xor    %eax,%eax
   14823:	8a 85 24 ff ff ff    	mov    0xffffff24(%ebp),%al
   14829:	c7 43 0c ff ff ff ff 	movl   $0xffffffff,0xc(%ebx)
   14830:	89 43 08             	mov    %eax,0x8(%ebx)
   14833:	8b 8d c0 fe ff ff    	mov    0xfffffec0(%ebp),%ecx
   14839:	eb b7                	jmp    147f2 <_HalpAssignPciSlotResources@32+0x232>
   1483b:	b9 01 00 00 c0       	mov    $0xc0000001,%ecx
   14840:	eb b0                	jmp    147f2 <_HalpAssignPciSlotResources@32+0x232>
   14842:	8b b4 b5 f8 fe ff ff 	mov    0xfffffef8(%ebp,%esi,4),%esi
   14849:	8b 95 bc fe ff ff    	mov    0xfffffebc(%ebp),%edx
   1484f:	8b 85 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%eax
   14855:	57                   	push   %edi
   14856:	57                   	push   %edi
   14857:	56                   	push   %esi
   14858:	53                   	push   %ebx
   14859:	e8 62 f7 ff ff       	call   13fc0 <_WritePciConfigUlong>
   1485e:	eb 8c                	jmp    147ec <_HalpAssignPciSlotResources@32+0x22c>

00014860 <_HalpInitPciBus>:
   14860:	55                   	push   %ebp
   14861:	89 e5                	mov    %esp,%ebp
   14863:	53                   	push   %ebx
   14864:	83 ec 10             	sub    $0x10,%esp
   14867:	68 70 e4 03 00       	push   $0x3e470
   1486c:	e8 5f 5f 00 00       	call   1a7d0 <_KeInitializeSpinLock@4>
   14871:	8d 45 fb             	lea    0xfffffffb(%ebp),%eax
   14874:	89 04 24             	mov    %eax,(%esp)
   14877:	68 70 e4 03 00       	push   $0x3e470
   1487c:	e8 2f 04 00 00       	call   14cb0 <_KeAcquireSpinLock@8>
   14881:	6a 01                	push   $0x1
   14883:	68 fb 0c 00 00       	push   $0xcfb
   14888:	e8 03 03 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1488d:	50                   	push   %eax
   1488e:	68 f8 0c 00 00       	push   $0xcf8
   14893:	e8 88 02 00 00       	call   14b20 <_READ_PORT_ULONG@4>
   14898:	89 c3                	mov    %eax,%ebx
   1489a:	c7 04 24 00 00 00 80 	movl   $0x80000000,(%esp)
   148a1:	68 f8 0c 00 00       	push   $0xcf8
   148a6:	e8 15 03 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   148ab:	50                   	push   %eax
   148ac:	68 f8 0c 00 00       	push   $0xcf8
   148b1:	e8 6a 02 00 00       	call   14b20 <_READ_PORT_ULONG@4>
   148b6:	83 c4 0c             	add    $0xc,%esp
   148b9:	3d 00 00 00 80       	cmp    $0x80000000,%eax
   148be:	0f 84 6d 01 00 00    	je     14a31 <_HalpInitPciBus+0x1d1>
   148c4:	50                   	push   %eax
   148c5:	50                   	push   %eax
   148c6:	53                   	push   %ebx
   148c7:	68 f8 0c 00 00       	push   $0xcf8
   148cc:	e8 ef 02 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   148d1:	6a 00                	push   $0x0
   148d3:	68 fb 0c 00 00       	push   $0xcfb
   148d8:	e8 b3 02 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   148dd:	6a 00                	push   $0x0
   148df:	68 f8 0c 00 00       	push   $0xcf8
   148e4:	e8 a7 02 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   148e9:	6a 00                	push   $0x0
   148eb:	68 fa 0c 00 00       	push   $0xcfa
   148f0:	e8 9b 02 00 00       	call   14b90 <_WRITE_PORT_UCHAR@8>
   148f5:	50                   	push   %eax
   148f6:	68 f8 0c 00 00       	push   $0xcf8
   148fb:	e8 e0 01 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   14900:	83 c4 0c             	add    $0xc,%esp
   14903:	84 c0                	test   %al,%al
   14905:	74 29                	je     14930 <_HalpInitPciBus+0xd0>
   14907:	31 c0                	xor    %eax,%eax
   14909:	51                   	push   %ecx
   1490a:	51                   	push   %ecx
   1490b:	8a 45 fb             	mov    0xfffffffb(%ebp),%al
   1490e:	50                   	push   %eax
   1490f:	68 70 e4 03 00       	push   $0x3e470
   14914:	e8 07 04 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   14919:	58                   	pop    %eax
   1491a:	31 c0                	xor    %eax,%eax
   1491c:	5a                   	pop    %edx
   1491d:	a3 60 e4 03 00       	mov    %eax,0x3e460
   14922:	85 c0                	test   %eax,%eax
   14924:	75 40                	jne    14966 <_HalpInitPciBus+0x106>
   14926:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   14929:	c9                   	leave  
   1492a:	c3                   	ret    
   1492b:	90                   	nop    
   1492c:	8d 74 26 00          	lea    0x0(%esi),%esi
   14930:	83 ec 0c             	sub    $0xc,%esp
   14933:	68 fb 0c 00 00       	push   $0xcfb
   14938:	e8 a3 01 00 00       	call   14ae0 <_READ_PORT_UCHAR@4>
   1493d:	83 c4 0c             	add    $0xc,%esp
   14940:	84 c0                	test   %al,%al
   14942:	75 c3                	jne    14907 <_HalpInitPciBus+0xa7>
   14944:	50                   	push   %eax
   14945:	50                   	push   %eax
   14946:	31 c0                	xor    %eax,%eax
   14948:	8a 45 fb             	mov    0xfffffffb(%ebp),%al
   1494b:	50                   	push   %eax
   1494c:	68 70 e4 03 00       	push   $0x3e470
   14951:	e8 ca 03 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   14956:	5b                   	pop    %ebx
   14957:	58                   	pop    %eax
   14958:	b8 02 00 00 00       	mov    $0x2,%eax
   1495d:	a3 60 e4 03 00       	mov    %eax,0x3e460
   14962:	85 c0                	test   %eax,%eax
   14964:	74 c0                	je     14926 <_HalpInitPciBus+0xc6>
   14966:	53                   	push   %ebx
   14967:	6a 00                	push   $0x0
   14969:	6a 04                	push   $0x4
   1496b:	6a 05                	push   $0x5
   1496d:	e8 ae cf ff ff       	call   11920 <_HalpAllocateBusHandler>
   14972:	8b 15 80 e5 03 00    	mov    0x3e580,%edx
   14978:	83 c4 10             	add    $0x10,%esp
   1497b:	c7 40 18 e0 40 01 00 	movl   $0x140e0,0x18(%eax)
   14982:	c7 40 1c 40 43 01 00 	movl   $0x14340,0x1c(%eax)
   14989:	c7 40 28 50 45 01 00 	movl   $0x14550,0x28(%eax)
   14990:	c7 40 2c 80 45 01 00 	movl   $0x14580,0x2c(%eax)
   14997:	c7 40 24 c0 45 01 00 	movl   $0x145c0,0x24(%eax)
   1499e:	85 d2                	test   %edx,%edx
   149a0:	0f 85 c3 00 00 00    	jne    14a69 <_HalpInitPciBus+0x209>
   149a6:	53                   	push   %ebx
   149a7:	6a 01                	push   $0x1
   149a9:	6a 04                	push   $0x4
   149ab:	6a 05                	push   $0x5
   149ad:	e8 6e cf ff ff       	call   11920 <_HalpAllocateBusHandler>
   149b2:	8b 15 80 e5 03 00    	mov    0x3e580,%edx
   149b8:	83 c4 10             	add    $0x10,%esp
   149bb:	c7 40 18 e0 40 01 00 	movl   $0x140e0,0x18(%eax)
   149c2:	c7 40 1c 40 43 01 00 	movl   $0x14340,0x1c(%eax)
   149c9:	c7 40 28 50 45 01 00 	movl   $0x14550,0x28(%eax)
   149d0:	c7 40 2c 80 45 01 00 	movl   $0x14580,0x2c(%eax)
   149d7:	c7 40 24 c0 45 01 00 	movl   $0x145c0,0x24(%eax)
   149de:	85 d2                	test   %edx,%edx
   149e0:	75 78                	jne    14a5a <_HalpInitPciBus+0x1fa>
   149e2:	53                   	push   %ebx
   149e3:	6a 02                	push   $0x2
   149e5:	6a 04                	push   $0x4
   149e7:	6a 05                	push   $0x5
   149e9:	e8 32 cf ff ff       	call   11920 <_HalpAllocateBusHandler>
   149ee:	8b 15 80 e5 03 00    	mov    0x3e580,%edx
   149f4:	83 c4 10             	add    $0x10,%esp
   149f7:	c7 40 18 e0 40 01 00 	movl   $0x140e0,0x18(%eax)
   149fe:	c7 40 1c 40 43 01 00 	movl   $0x14340,0x1c(%eax)
   14a05:	c7 40 28 50 45 01 00 	movl   $0x14550,0x28(%eax)
   14a0c:	c7 40 2c 80 45 01 00 	movl   $0x14580,0x2c(%eax)
   14a13:	c7 40 24 c0 45 01 00 	movl   $0x145c0,0x24(%eax)
   14a1a:	85 d2                	test   %edx,%edx
   14a1c:	0f 84 04 ff ff ff    	je     14926 <_HalpInitPciBus+0xc6>
   14a22:	51                   	push   %ecx
   14a23:	51                   	push   %ecx
   14a24:	50                   	push   %eax
   14a25:	6a 02                	push   $0x2
   14a27:	ff d2                	call   *%edx
   14a29:	83 c4 10             	add    $0x10,%esp
   14a2c:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   14a2f:	c9                   	leave  
   14a30:	c3                   	ret    
   14a31:	51                   	push   %ecx
   14a32:	51                   	push   %ecx
   14a33:	53                   	push   %ebx
   14a34:	68 f8 0c 00 00       	push   $0xcf8
   14a39:	e8 82 01 00 00       	call   14bc0 <_WRITE_PORT_ULONG@8>
   14a3e:	31 c0                	xor    %eax,%eax
   14a40:	8a 45 fb             	mov    0xfffffffb(%ebp),%al
   14a43:	50                   	push   %eax
   14a44:	68 70 e4 03 00       	push   $0x3e470
   14a49:	e8 d2 02 00 00       	call   14d20 <_KeReleaseSpinLock@8>
   14a4e:	58                   	pop    %eax
   14a4f:	b8 01 00 00 00       	mov    $0x1,%eax
   14a54:	5a                   	pop    %edx
   14a55:	e9 c3 fe ff ff       	jmp    1491d <_HalpInitPciBus+0xbd>
   14a5a:	51                   	push   %ecx
   14a5b:	51                   	push   %ecx
   14a5c:	50                   	push   %eax
   14a5d:	6a 01                	push   $0x1
   14a5f:	ff d2                	call   *%edx
   14a61:	83 c4 10             	add    $0x10,%esp
   14a64:	e9 79 ff ff ff       	jmp    149e2 <_HalpInitPciBus+0x182>
   14a69:	51                   	push   %ecx
   14a6a:	51                   	push   %ecx
   14a6b:	50                   	push   %eax
   14a6c:	6a 00                	push   $0x0
   14a6e:	ff d2                	call   *%edx
   14a70:	83 c4 10             	add    $0x10,%esp
   14a73:	e9 2e ff ff ff       	jmp    149a6 <_HalpInitPciBus+0x146>
   14a78:	90                   	nop    
   14a79:	90                   	nop    
   14a7a:	90                   	nop    
   14a7b:	90                   	nop    
   14a7c:	90                   	nop    
   14a7d:	90                   	nop    
   14a7e:	90                   	nop    
   14a7f:	90                   	nop    

00014a80 <_READ_PORT_BUFFER_UCHAR@12>:
   14a80:	55                   	push   %ebp
   14a81:	89 e5                	mov    %esp,%ebp
   14a83:	57                   	push   %edi
   14a84:	8b 55 08             	mov    0x8(%ebp),%edx
   14a87:	8b 7d 0c             	mov    0xc(%ebp),%edi
   14a8a:	8b 4d 10             	mov    0x10(%ebp),%ecx
   14a8d:	fc                   	cld    
   14a8e:	f3 6c                	repz insb (%dx),%es:(%edi)
   14a90:	5f                   	pop    %edi
   14a91:	5d                   	pop    %ebp
   14a92:	c2 0c 00             	ret    $0xc
   14a95:	8d 74 26 00          	lea    0x0(%esi),%esi
   14a99:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014aa0 <_READ_PORT_BUFFER_USHORT@12>:
   14aa0:	55                   	push   %ebp
   14aa1:	89 e5                	mov    %esp,%ebp
   14aa3:	57                   	push   %edi
   14aa4:	8b 55 08             	mov    0x8(%ebp),%edx
   14aa7:	8b 7d 0c             	mov    0xc(%ebp),%edi
   14aaa:	8b 4d 10             	mov    0x10(%ebp),%ecx
   14aad:	fc                   	cld    
   14aae:	f3 66 6d             	repz insw (%dx),%es:(%edi)
   14ab1:	5f                   	pop    %edi
   14ab2:	5d                   	pop    %ebp
   14ab3:	c2 0c 00             	ret    $0xc
   14ab6:	8d 76 00             	lea    0x0(%esi),%esi
   14ab9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014ac0 <_READ_PORT_BUFFER_ULONG@12>:
   14ac0:	55                   	push   %ebp
   14ac1:	89 e5                	mov    %esp,%ebp
   14ac3:	57                   	push   %edi
   14ac4:	8b 55 08             	mov    0x8(%ebp),%edx
   14ac7:	8b 7d 0c             	mov    0xc(%ebp),%edi
   14aca:	8b 4d 10             	mov    0x10(%ebp),%ecx
   14acd:	fc                   	cld    
   14ace:	f3 6d                	repz insl (%dx),%es:(%edi)
   14ad0:	5f                   	pop    %edi
   14ad1:	5d                   	pop    %ebp
   14ad2:	c2 0c 00             	ret    $0xc
   14ad5:	8d 74 26 00          	lea    0x0(%esi),%esi
   14ad9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014ae0 <_READ_PORT_UCHAR@4>:
   14ae0:	55                   	push   %ebp
   14ae1:	89 e5                	mov    %esp,%ebp
   14ae3:	8b 55 08             	mov    0x8(%ebp),%edx
   14ae6:	ec                   	in     (%dx),%al
   14ae7:	e6 80                	out    %al,$0x80
   14ae9:	25 ff 00 00 00       	and    $0xff,%eax
   14aee:	5d                   	pop    %ebp
   14aef:	c2 04 00             	ret    $0x4
   14af2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   14af9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014b00 <_READ_PORT_USHORT@4>:
   14b00:	55                   	push   %ebp
   14b01:	89 e5                	mov    %esp,%ebp
   14b03:	8b 55 08             	mov    0x8(%ebp),%edx
   14b06:	66 ed                	in     (%dx),%ax
   14b08:	e6 80                	out    %al,$0x80
   14b0a:	25 ff ff 00 00       	and    $0xffff,%eax
   14b0f:	5d                   	pop    %ebp
   14b10:	c2 04 00             	ret    $0x4
   14b13:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   14b19:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014b20 <_READ_PORT_ULONG@4>:
   14b20:	55                   	push   %ebp
   14b21:	89 e5                	mov    %esp,%ebp
   14b23:	8b 55 08             	mov    0x8(%ebp),%edx
   14b26:	ed                   	in     (%dx),%eax
   14b27:	e6 80                	out    %al,$0x80
   14b29:	5d                   	pop    %ebp
   14b2a:	c2 04 00             	ret    $0x4
   14b2d:	8d 76 00             	lea    0x0(%esi),%esi

00014b30 <_WRITE_PORT_BUFFER_UCHAR@12>:
   14b30:	55                   	push   %ebp
   14b31:	89 e5                	mov    %esp,%ebp
   14b33:	56                   	push   %esi
   14b34:	8b 55 08             	mov    0x8(%ebp),%edx
   14b37:	8b 75 0c             	mov    0xc(%ebp),%esi
   14b3a:	8b 4d 10             	mov    0x10(%ebp),%ecx
   14b3d:	fc                   	cld    
   14b3e:	f3 6e                	repz outsb %ds:(%esi),(%dx)
   14b40:	5e                   	pop    %esi
   14b41:	5d                   	pop    %ebp
   14b42:	c2 0c 00             	ret    $0xc
   14b45:	8d 74 26 00          	lea    0x0(%esi),%esi
   14b49:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014b50 <_WRITE_PORT_BUFFER_USHORT@12>:
   14b50:	55                   	push   %ebp
   14b51:	89 e5                	mov    %esp,%ebp
   14b53:	56                   	push   %esi
   14b54:	8b 55 08             	mov    0x8(%ebp),%edx
   14b57:	8b 75 0c             	mov    0xc(%ebp),%esi
   14b5a:	8b 4d 10             	mov    0x10(%ebp),%ecx
   14b5d:	fc                   	cld    
   14b5e:	f3 66 6f             	repz outsw %ds:(%esi),(%dx)
   14b61:	5e                   	pop    %esi
   14b62:	5d                   	pop    %ebp
   14b63:	c2 0c 00             	ret    $0xc
   14b66:	8d 76 00             	lea    0x0(%esi),%esi
   14b69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014b70 <_WRITE_PORT_BUFFER_ULONG@12>:
   14b70:	55                   	push   %ebp
   14b71:	89 e5                	mov    %esp,%ebp
   14b73:	56                   	push   %esi
   14b74:	8b 55 08             	mov    0x8(%ebp),%edx
   14b77:	8b 75 0c             	mov    0xc(%ebp),%esi
   14b7a:	8b 4d 10             	mov    0x10(%ebp),%ecx
   14b7d:	fc                   	cld    
   14b7e:	f3 6f                	repz outsl %ds:(%esi),(%dx)
   14b80:	5e                   	pop    %esi
   14b81:	5d                   	pop    %ebp
   14b82:	c2 0c 00             	ret    $0xc
   14b85:	8d 74 26 00          	lea    0x0(%esi),%esi
   14b89:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014b90 <_WRITE_PORT_UCHAR@8>:
   14b90:	55                   	push   %ebp
   14b91:	89 e5                	mov    %esp,%ebp
   14b93:	8b 55 08             	mov    0x8(%ebp),%edx
   14b96:	8a 45 0c             	mov    0xc(%ebp),%al
   14b99:	ee                   	out    %al,(%dx)
   14b9a:	e6 80                	out    %al,$0x80
   14b9c:	5d                   	pop    %ebp
   14b9d:	c2 08 00             	ret    $0x8

00014ba0 <_WRITE_PORT_USHORT@8>:
   14ba0:	55                   	push   %ebp
   14ba1:	89 e5                	mov    %esp,%ebp
   14ba3:	8b 55 08             	mov    0x8(%ebp),%edx
   14ba6:	8b 45 0c             	mov    0xc(%ebp),%eax
   14ba9:	66 ef                	out    %ax,(%dx)
   14bab:	e6 80                	out    %al,$0x80
   14bad:	5d                   	pop    %ebp
   14bae:	c2 08 00             	ret    $0x8
   14bb1:	eb 0d                	jmp    14bc0 <_WRITE_PORT_ULONG@8>
   14bb3:	90                   	nop    
   14bb4:	90                   	nop    
   14bb5:	90                   	nop    
   14bb6:	90                   	nop    
   14bb7:	90                   	nop    
   14bb8:	90                   	nop    
   14bb9:	90                   	nop    
   14bba:	90                   	nop    
   14bbb:	90                   	nop    
   14bbc:	90                   	nop    
   14bbd:	90                   	nop    
   14bbe:	90                   	nop    
   14bbf:	90                   	nop    

00014bc0 <_WRITE_PORT_ULONG@8>:
   14bc0:	55                   	push   %ebp
   14bc1:	89 e5                	mov    %esp,%ebp
   14bc3:	8b 55 08             	mov    0x8(%ebp),%edx
   14bc6:	8b 45 0c             	mov    0xc(%ebp),%eax
   14bc9:	ef                   	out    %eax,(%dx)
   14bca:	e6 80                	out    %al,$0x80
   14bcc:	5d                   	pop    %ebp
   14bcd:	c2 08 00             	ret    $0x8

00014bd0 <_HalReturnToFirmware@4>:
   14bd0:	55                   	push   %ebp
   14bd1:	89 e5                	mov    %esp,%ebp
   14bd3:	50                   	push   %eax
   14bd4:	50                   	push   %eax
   14bd5:	8b 45 08             	mov    0x8(%ebp),%eax
   14bd8:	83 f8 01             	cmp    $0x1,%eax
   14bdb:	0f 84 86 00 00 00    	je     14c67 <_HalReturnToFirmware@4+0x97>
   14be1:	83 f8 03             	cmp    $0x3,%eax
   14be4:	74 04                	je     14bea <_HalReturnToFirmware@4+0x1a>
   14be6:	c9                   	leave  
   14be7:	c2 04 00             	ret    $0x4
   14bea:	e8 c1 d9 ff ff       	call   125b0 <_HalReleaseDisplayOwnership@0>
   14bef:	a1 00 e4 03 00       	mov    0x3e400,%eax
   14bf4:	c6 80 72 04 00 00 34 	movb   $0x34,0x472(%eax)
   14bfb:	a1 00 e4 03 00       	mov    0x3e400,%eax
   14c00:	c6 80 73 04 00 00 12 	movb   $0x12,0x473(%eax)
   14c07:	fa                   	cli    
   14c08:	50                   	push   %eax
   14c09:	50                   	push   %eax
   14c0a:	6a 0b                	push   $0xb
   14c0c:	6a 70                	push   $0x70
   14c0e:	e8 7d ff ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14c13:	50                   	push   %eax
   14c14:	6a 71                	push   $0x71
   14c16:	e8 c5 fe ff ff       	call   14ae0 <_READ_PORT_UCHAR@4>
   14c1b:	25 bf 00 00 00       	and    $0xbf,%eax
   14c20:	89 04 24             	mov    %eax,(%esp)
   14c23:	6a 71                	push   $0x71
   14c25:	e8 66 ff ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14c2a:	6a 0a                	push   $0xa
   14c2c:	6a 70                	push   $0x70
   14c2e:	e8 5d ff ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14c33:	51                   	push   %ecx
   14c34:	6a 71                	push   $0x71
   14c36:	e8 a5 fe ff ff       	call   14ae0 <_READ_PORT_UCHAR@4>
   14c3b:	83 c8 06             	or     $0x6,%eax
   14c3e:	25 f6 00 00 00       	and    $0xf6,%eax
   14c43:	89 04 24             	mov    %eax,(%esp)
   14c46:	6a 71                	push   $0x71
   14c48:	e8 43 ff ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14c4d:	6a 15                	push   $0x15
   14c4f:	6a 70                	push   $0x70
   14c51:	e8 3a ff ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14c56:	68 fe 00 00 00       	push   $0xfe
   14c5b:	6a 64                	push   $0x64
   14c5d:	e8 2e ff ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14c62:	58                   	pop    %eax
   14c63:	5a                   	pop    %edx
   14c64:	f4                   	hlt    
   14c65:	eb fe                	jmp    14c65 <_HalReturnToFirmware@4+0x95>
   14c67:	83 ec 0c             	sub    $0xc,%esp
   14c6a:	68 c0 c1 01 00       	push   $0x1c1c0
   14c6f:	e8 1c 5c 00 00       	call   1a890 <_DbgPrint>
   14c74:	e8 f7 5c 00 00       	call   1a970 <_DbgBreakPoint@0>
   14c79:	83 c4 10             	add    $0x10,%esp
   14c7c:	c9                   	leave  
   14c7d:	c2 04 00             	ret    $0x4

00014c80 <@KfAcquireSpinLock@4>:
   14c80:	55                   	push   %ebp
   14c81:	89 e5                	mov    %esp,%ebp
   14c83:	56                   	push   %esi
   14c84:	89 ce                	mov    %ecx,%esi
   14c86:	b9 02 00 00 00       	mov    $0x2,%ecx
   14c8b:	53                   	push   %ebx
   14c8c:	e8 9f 53 00 00       	call   1a030 <@KfRaiseIrql@4>
   14c91:	89 f1                	mov    %esi,%ecx
   14c93:	88 c3                	mov    %al,%bl
   14c95:	e8 26 5c 00 00       	call   1a8c0 <@KiAcquireSpinLock@4>
   14c9a:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   14ca0:	89 d8                	mov    %ebx,%eax
   14ca2:	5b                   	pop    %ebx
   14ca3:	5e                   	pop    %esi
   14ca4:	5d                   	pop    %ebp
   14ca5:	c3                   	ret    
   14ca6:	8d 76 00             	lea    0x0(%esi),%esi
   14ca9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014cb0 <_KeAcquireSpinLock@8>:
   14cb0:	55                   	push   %ebp
   14cb1:	89 e5                	mov    %esp,%ebp
   14cb3:	50                   	push   %eax
   14cb4:	50                   	push   %eax
   14cb5:	8b 4d 08             	mov    0x8(%ebp),%ecx
   14cb8:	e8 c3 ff ff ff       	call   14c80 <@KfAcquireSpinLock@4>
   14cbd:	8b 55 0c             	mov    0xc(%ebp),%edx
   14cc0:	88 02                	mov    %al,(%edx)
   14cc2:	c9                   	leave  
   14cc3:	c2 08 00             	ret    $0x8
   14cc6:	8d 76 00             	lea    0x0(%esi),%esi
   14cc9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014cd0 <@KeAcquireSpinLockRaiseToSynch@4>:
   14cd0:	55                   	push   %ebp
   14cd1:	89 e5                	mov    %esp,%ebp
   14cd3:	56                   	push   %esi
   14cd4:	89 ce                	mov    %ecx,%esi
   14cd6:	b9 1c 00 00 00       	mov    $0x1c,%ecx
   14cdb:	53                   	push   %ebx
   14cdc:	e8 4f 53 00 00       	call   1a030 <@KfRaiseIrql@4>
   14ce1:	89 f1                	mov    %esi,%ecx
   14ce3:	88 c3                	mov    %al,%bl
   14ce5:	e8 d6 5b 00 00       	call   1a8c0 <@KiAcquireSpinLock@4>
   14cea:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   14cf0:	89 d8                	mov    %ebx,%eax
   14cf2:	5b                   	pop    %ebx
   14cf3:	5e                   	pop    %esi
   14cf4:	5d                   	pop    %ebp
   14cf5:	c3                   	ret    
   14cf6:	8d 76 00             	lea    0x0(%esi),%esi
   14cf9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014d00 <@KfReleaseSpinLock@8>:
   14d00:	55                   	push   %ebp
   14d01:	89 e5                	mov    %esp,%ebp
   14d03:	53                   	push   %ebx
   14d04:	53                   	push   %ebx
   14d05:	88 d3                	mov    %dl,%bl
   14d07:	e8 d4 5b 00 00       	call   1a8e0 <@KiReleaseSpinLock@4>
   14d0c:	31 c9                	xor    %ecx,%ecx
   14d0e:	5a                   	pop    %edx
   14d0f:	88 d9                	mov    %bl,%cl
   14d11:	5b                   	pop    %ebx
   14d12:	5d                   	pop    %ebp
   14d13:	e9 58 52 00 00       	jmp    19f70 <@KfLowerIrql@4>
   14d18:	90                   	nop    
   14d19:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00014d20 <_KeReleaseSpinLock@8>:
   14d20:	55                   	push   %ebp
   14d21:	89 e5                	mov    %esp,%ebp
   14d23:	31 d2                	xor    %edx,%edx
   14d25:	50                   	push   %eax
   14d26:	50                   	push   %eax
   14d27:	8b 4d 08             	mov    0x8(%ebp),%ecx
   14d2a:	8a 55 0c             	mov    0xc(%ebp),%dl
   14d2d:	e8 ce ff ff ff       	call   14d00 <@KfReleaseSpinLock@8>
   14d32:	c9                   	leave  
   14d33:	c2 08 00             	ret    $0x8
   14d36:	90                   	nop    
   14d37:	90                   	nop    
   14d38:	90                   	nop    
   14d39:	90                   	nop    
   14d3a:	90                   	nop    
   14d3b:	90                   	nop    
   14d3c:	90                   	nop    
   14d3d:	90                   	nop    
   14d3e:	90                   	nop    
   14d3f:	90                   	nop    

00014d40 <_HalpGetSystemInterruptVector@24>:
   14d40:	55                   	push   %ebp
   14d41:	ba 17 00 00 00       	mov    $0x17,%edx
   14d46:	89 e5                	mov    %esp,%ebp
   14d48:	8b 45 14             	mov    0x14(%ebp),%eax
   14d4b:	8b 4d 18             	mov    0x18(%ebp),%ecx
   14d4e:	29 c2                	sub    %eax,%edx
   14d50:	c1 e2 03             	shl    $0x3,%edx
   14d53:	8d 42 30             	lea    0x30(%edx),%eax
   14d56:	c1 ea 03             	shr    $0x3,%edx
   14d59:	83 c2 04             	add    $0x4,%edx
   14d5c:	88 11                	mov    %dl,(%ecx)
   14d5e:	8b 55 1c             	mov    0x1c(%ebp),%edx
   14d61:	c7 02 ff ff ff ff    	movl   $0xffffffff,(%edx)
   14d67:	5d                   	pop    %ebp
   14d68:	c2 18 00             	ret    $0x18
   14d6b:	90                   	nop    
   14d6c:	8d 74 26 00          	lea    0x0(%esi),%esi

00014d70 <_HalpTranslateSystemBusAddress@24>:
   14d70:	55                   	push   %ebp
   14d71:	89 e5                	mov    %esp,%ebp
   14d73:	8b 45 18             	mov    0x18(%ebp),%eax
   14d76:	8b 00                	mov    (%eax),%eax
   14d78:	85 c0                	test   %eax,%eax
   14d7a:	74 05                	je     14d81 <_HalpTranslateSystemBusAddress@24+0x11>
   14d7c:	31 d2                	xor    %edx,%edx
   14d7e:	48                   	dec    %eax
   14d7f:	75 13                	jne    14d94 <_HalpTranslateSystemBusAddress@24+0x24>
   14d81:	8b 4d 1c             	mov    0x1c(%ebp),%ecx
   14d84:	8b 55 14             	mov    0x14(%ebp),%edx
   14d87:	8b 45 10             	mov    0x10(%ebp),%eax
   14d8a:	89 01                	mov    %eax,(%ecx)
   14d8c:	89 51 04             	mov    %edx,0x4(%ecx)
   14d8f:	ba 01 00 00 00       	mov    $0x1,%edx
   14d94:	89 d0                	mov    %edx,%eax
   14d96:	5d                   	pop    %ebp
   14d97:	c2 18 00             	ret    $0x18
   14d9a:	90                   	nop    
   14d9b:	90                   	nop    
   14d9c:	90                   	nop    
   14d9d:	90                   	nop    
   14d9e:	90                   	nop    
   14d9f:	90                   	nop    

00014da0 <_HalpQuerySystemInformation@16>:
   14da0:	55                   	push   %ebp
   14da1:	89 e5                	mov    %esp,%ebp
   14da3:	83 ec 0c             	sub    $0xc,%esp
   14da6:	6a 20                	push   $0x20
   14da8:	68 e0 c1 01 00       	push   $0x1c1e0
   14dad:	68 f5 c1 01 00       	push   $0x1c1f5
   14db2:	e8 d9 5a 00 00       	call   1a890 <_DbgPrint>
   14db7:	c7 04 24 00 c2 01 00 	movl   $0x1c200,(%esp)
   14dbe:	e8 cd 5a 00 00       	call   1a890 <_DbgPrint>
   14dc3:	8b 45 14             	mov    0x14(%ebp),%eax
   14dc6:	83 c4 10             	add    $0x10,%esp
   14dc9:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
   14dcf:	b8 48 01 00 c0       	mov    $0xc0000148,%eax
   14dd4:	c9                   	leave  
   14dd5:	c2 10 00             	ret    $0x10
   14dd8:	90                   	nop    
   14dd9:	90                   	nop    
   14dda:	90                   	nop    
   14ddb:	90                   	nop    
   14ddc:	90                   	nop    
   14ddd:	90                   	nop    
   14dde:	90                   	nop    
   14ddf:	90                   	nop    

00014de0 <_HalpQueryCMOS>:
   14de0:	55                   	push   %ebp
   14de1:	83 c8 80             	or     $0xffffff80,%eax
   14de4:	89 e5                	mov    %esp,%ebp
   14de6:	56                   	push   %esi
   14de7:	53                   	push   %ebx
   14de8:	9c                   	pushf  
   14de9:	5e                   	pop    %esi
   14dea:	fa                   	cli    
   14deb:	25 ff 00 00 00       	and    $0xff,%eax
   14df0:	52                   	push   %edx
   14df1:	52                   	push   %edx
   14df2:	50                   	push   %eax
   14df3:	6a 70                	push   $0x70
   14df5:	e8 96 fd ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14dfa:	50                   	push   %eax
   14dfb:	6a 71                	push   $0x71
   14dfd:	e8 de fc ff ff       	call   14ae0 <_READ_PORT_UCHAR@4>
   14e02:	88 c3                	mov    %al,%bl
   14e04:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   14e0b:	6a 70                	push   $0x70
   14e0d:	e8 7e fd ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14e12:	56                   	push   %esi
   14e13:	9d                   	popf   
   14e14:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   14e1a:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   14e1d:	89 d8                	mov    %ebx,%eax
   14e1f:	5b                   	pop    %ebx
   14e20:	5e                   	pop    %esi
   14e21:	5d                   	pop    %ebp
   14e22:	c3                   	ret    
   14e23:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   14e29:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00014e30 <_HalpSetCMOS>:
   14e30:	55                   	push   %ebp
   14e31:	83 c8 80             	or     $0xffffff80,%eax
   14e34:	89 e5                	mov    %esp,%ebp
   14e36:	56                   	push   %esi
   14e37:	89 d6                	mov    %edx,%esi
   14e39:	53                   	push   %ebx
   14e3a:	9c                   	pushf  
   14e3b:	5b                   	pop    %ebx
   14e3c:	fa                   	cli    
   14e3d:	25 ff 00 00 00       	and    $0xff,%eax
   14e42:	51                   	push   %ecx
   14e43:	51                   	push   %ecx
   14e44:	50                   	push   %eax
   14e45:	6a 70                	push   $0x70
   14e47:	e8 44 fd ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14e4c:	89 f0                	mov    %esi,%eax
   14e4e:	25 ff 00 00 00       	and    $0xff,%eax
   14e53:	50                   	push   %eax
   14e54:	6a 71                	push   $0x71
   14e56:	e8 35 fd ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14e5b:	6a 00                	push   $0x0
   14e5d:	6a 70                	push   $0x70
   14e5f:	e8 2c fd ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   14e64:	53                   	push   %ebx
   14e65:	9d                   	popf   
   14e66:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   14e69:	5b                   	pop    %ebx
   14e6a:	5e                   	pop    %esi
   14e6b:	5d                   	pop    %ebp
   14e6c:	c3                   	ret    
   14e6d:	8d 76 00             	lea    0x0(%esi),%esi

00014e70 <_HalQueryRealTimeClock@4>:
   14e70:	55                   	push   %ebp
   14e71:	89 e5                	mov    %esp,%ebp
   14e73:	56                   	push   %esi
   14e74:	53                   	push   %ebx
   14e75:	83 ec 18             	sub    $0x18,%esp
   14e78:	8d 45 f7             	lea    0xfffffff7(%ebp),%eax
   14e7b:	8b 75 08             	mov    0x8(%ebp),%esi
   14e7e:	50                   	push   %eax
   14e7f:	68 80 e4 03 00       	push   $0x3e480
   14e84:	e8 27 fe ff ff       	call   14cb0 <_KeAcquireSpinLock@8>
   14e89:	58                   	pop    %eax
   14e8a:	5a                   	pop    %edx
   14e8b:	90                   	nop    
   14e8c:	8d 74 26 00          	lea    0x0(%esi),%esi
   14e90:	b8 0a 00 00 00       	mov    $0xa,%eax
   14e95:	e8 46 ff ff ff       	call   14de0 <_HalpQueryCMOS>
   14e9a:	84 c0                	test   %al,%al
   14e9c:	78 f2                	js     14e90 <_HalQueryRealTimeClock@4+0x20>
   14e9e:	31 c0                	xor    %eax,%eax
   14ea0:	e8 3b ff ff ff       	call   14de0 <_HalpQueryCMOS>
   14ea5:	25 f0 00 00 00       	and    $0xf0,%eax
   14eaa:	c1 f8 04             	sar    $0x4,%eax
   14ead:	8d 04 80             	lea    (%eax,%eax,4),%eax
   14eb0:	8d 1c 00             	lea    (%eax,%eax,1),%ebx
   14eb3:	31 c0                	xor    %eax,%eax
   14eb5:	e8 26 ff ff ff       	call   14de0 <_HalpQueryCMOS>
   14eba:	83 e0 0f             	and    $0xf,%eax
   14ebd:	01 d8                	add    %ebx,%eax
   14ebf:	66 89 46 0a          	mov    %ax,0xa(%esi)
   14ec3:	b8 02 00 00 00       	mov    $0x2,%eax
   14ec8:	e8 13 ff ff ff       	call   14de0 <_HalpQueryCMOS>
   14ecd:	25 f0 00 00 00       	and    $0xf0,%eax
   14ed2:	c1 f8 04             	sar    $0x4,%eax
   14ed5:	8d 04 80             	lea    (%eax,%eax,4),%eax
   14ed8:	8d 1c 00             	lea    (%eax,%eax,1),%ebx
   14edb:	b8 02 00 00 00       	mov    $0x2,%eax
   14ee0:	e8 fb fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14ee5:	83 e0 0f             	and    $0xf,%eax
   14ee8:	01 d8                	add    %ebx,%eax
   14eea:	66 89 46 08          	mov    %ax,0x8(%esi)
   14eee:	b8 04 00 00 00       	mov    $0x4,%eax
   14ef3:	e8 e8 fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14ef8:	25 f0 00 00 00       	and    $0xf0,%eax
   14efd:	c1 f8 04             	sar    $0x4,%eax
   14f00:	8d 04 80             	lea    (%eax,%eax,4),%eax
   14f03:	8d 1c 00             	lea    (%eax,%eax,1),%ebx
   14f06:	b8 04 00 00 00       	mov    $0x4,%eax
   14f0b:	e8 d0 fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14f10:	83 e0 0f             	and    $0xf,%eax
   14f13:	01 d8                	add    %ebx,%eax
   14f15:	66 89 46 06          	mov    %ax,0x6(%esi)
   14f19:	b8 06 00 00 00       	mov    $0x6,%eax
   14f1e:	e8 bd fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14f23:	25 f0 00 00 00       	and    $0xf0,%eax
   14f28:	c1 f8 04             	sar    $0x4,%eax
   14f2b:	8d 04 80             	lea    (%eax,%eax,4),%eax
   14f2e:	8d 1c 00             	lea    (%eax,%eax,1),%ebx
   14f31:	b8 06 00 00 00       	mov    $0x6,%eax
   14f36:	e8 a5 fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14f3b:	83 e0 0f             	and    $0xf,%eax
   14f3e:	01 d8                	add    %ebx,%eax
   14f40:	66 89 46 0e          	mov    %ax,0xe(%esi)
   14f44:	b8 07 00 00 00       	mov    $0x7,%eax
   14f49:	e8 92 fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14f4e:	25 f0 00 00 00       	and    $0xf0,%eax
   14f53:	c1 f8 04             	sar    $0x4,%eax
   14f56:	8d 04 80             	lea    (%eax,%eax,4),%eax
   14f59:	8d 1c 00             	lea    (%eax,%eax,1),%ebx
   14f5c:	b8 07 00 00 00       	mov    $0x7,%eax
   14f61:	e8 7a fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14f66:	83 e0 0f             	and    $0xf,%eax
   14f69:	01 d8                	add    %ebx,%eax
   14f6b:	66 89 46 04          	mov    %ax,0x4(%esi)
   14f6f:	b8 08 00 00 00       	mov    $0x8,%eax
   14f74:	e8 67 fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14f79:	25 f0 00 00 00       	and    $0xf0,%eax
   14f7e:	c1 f8 04             	sar    $0x4,%eax
   14f81:	8d 04 80             	lea    (%eax,%eax,4),%eax
   14f84:	8d 1c 00             	lea    (%eax,%eax,1),%ebx
   14f87:	b8 08 00 00 00       	mov    $0x8,%eax
   14f8c:	e8 4f fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14f91:	83 e0 0f             	and    $0xf,%eax
   14f94:	01 d8                	add    %ebx,%eax
   14f96:	66 89 46 02          	mov    %ax,0x2(%esi)
   14f9a:	b8 09 00 00 00       	mov    $0x9,%eax
   14f9f:	e8 3c fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14fa4:	25 f0 00 00 00       	and    $0xf0,%eax
   14fa9:	c1 f8 04             	sar    $0x4,%eax
   14fac:	8d 04 80             	lea    (%eax,%eax,4),%eax
   14faf:	8d 1c 00             	lea    (%eax,%eax,1),%ebx
   14fb2:	b8 09 00 00 00       	mov    $0x9,%eax
   14fb7:	e8 24 fe ff ff       	call   14de0 <_HalpQueryCMOS>
   14fbc:	83 e0 0f             	and    $0xf,%eax
   14fbf:	01 d8                	add    %ebx,%eax
   14fc1:	66 83 f8 50          	cmp    $0x50,%ax
   14fc5:	76 29                	jbe    14ff0 <_HalQueryRealTimeClock@4+0x180>
   14fc7:	05 6c 07 00 00       	add    $0x76c,%eax
   14fcc:	66 89 06             	mov    %ax,(%esi)
   14fcf:	53                   	push   %ebx
   14fd0:	31 c0                	xor    %eax,%eax
   14fd2:	53                   	push   %ebx
   14fd3:	8a 45 f7             	mov    0xfffffff7(%ebp),%al
   14fd6:	50                   	push   %eax
   14fd7:	68 80 e4 03 00       	push   $0x3e480
   14fdc:	e8 3f fd ff ff       	call   14d20 <_KeReleaseSpinLock@8>
   14fe1:	66 c7 46 0c 00 00    	movw   $0x0,0xc(%esi)
   14fe7:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   14fea:	5b                   	pop    %ebx
   14feb:	5e                   	pop    %esi
   14fec:	5d                   	pop    %ebp
   14fed:	c2 04 00             	ret    $0x4
   14ff0:	05 d0 07 00 00       	add    $0x7d0,%eax
   14ff5:	66 89 06             	mov    %ax,(%esi)
   14ff8:	53                   	push   %ebx
   14ff9:	31 c0                	xor    %eax,%eax
   14ffb:	53                   	push   %ebx
   14ffc:	8a 45 f7             	mov    0xfffffff7(%ebp),%al
   14fff:	50                   	push   %eax
   15000:	68 80 e4 03 00       	push   $0x3e480
   15005:	e8 16 fd ff ff       	call   14d20 <_KeReleaseSpinLock@8>
   1500a:	66 c7 46 0c 00 00    	movw   $0x0,0xc(%esi)
   15010:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   15013:	5b                   	pop    %ebx
   15014:	5e                   	pop    %esi
   15015:	5d                   	pop    %ebp
   15016:	c2 04 00             	ret    $0x4
   15019:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00015020 <_HalSetRealTimeClock@4>:
   15020:	55                   	push   %ebp
   15021:	89 e5                	mov    %esp,%ebp
   15023:	57                   	push   %edi
   15024:	56                   	push   %esi
   15025:	53                   	push   %ebx
   15026:	83 ec 14             	sub    $0x14,%esp
   15029:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   1502c:	8b 75 08             	mov    0x8(%ebp),%esi
   1502f:	50                   	push   %eax
   15030:	68 80 e4 03 00       	push   $0x3e480
   15035:	e8 76 fc ff ff       	call   14cb0 <_KeAcquireSpinLock@8>
   1503a:	5b                   	pop    %ebx
   1503b:	5f                   	pop    %edi
   1503c:	8d 74 26 00          	lea    0x0(%esi),%esi
   15040:	b8 0a 00 00 00       	mov    $0xa,%eax
   15045:	e8 96 fd ff ff       	call   14de0 <_HalpQueryCMOS>
   1504a:	84 c0                	test   %al,%al
   1504c:	78 f2                	js     15040 <_HalSetRealTimeClock@4+0x20>
   1504e:	66 8b 5e 0a          	mov    0xa(%esi),%bx
   15052:	bf 0a 00 00 00       	mov    $0xa,%edi
   15057:	89 d9                	mov    %ebx,%ecx
   15059:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
   1505f:	8d 04 49             	lea    (%ecx,%ecx,2),%eax
   15062:	89 c2                	mov    %eax,%edx
   15064:	c1 e2 04             	shl    $0x4,%edx
   15067:	01 d0                	add    %edx,%eax
   15069:	89 c2                	mov    %eax,%edx
   1506b:	c1 e2 08             	shl    $0x8,%edx
   1506e:	01 d0                	add    %edx,%eax
   15070:	8d 04 81             	lea    (%ecx,%eax,4),%eax
   15073:	c1 e8 10             	shr    $0x10,%eax
   15076:	66 c1 e8 03          	shr    $0x3,%ax
   1507a:	88 c2                	mov    %al,%dl
   1507c:	c1 e2 04             	shl    $0x4,%edx
   1507f:	8d 04 80             	lea    (%eax,%eax,4),%eax
   15082:	01 c0                	add    %eax,%eax
   15084:	66 29 c3             	sub    %ax,%bx
   15087:	31 c0                	xor    %eax,%eax
   15089:	01 da                	add    %ebx,%edx
   1508b:	81 e2 ff 00 00 00    	and    $0xff,%edx
   15091:	e8 9a fd ff ff       	call   14e30 <_HalpSetCMOS>
   15096:	66 8b 5e 08          	mov    0x8(%esi),%bx
   1509a:	89 d9                	mov    %ebx,%ecx
   1509c:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
   150a2:	8d 04 49             	lea    (%ecx,%ecx,2),%eax
   150a5:	89 c2                	mov    %eax,%edx
   150a7:	c1 e2 04             	shl    $0x4,%edx
   150aa:	01 d0                	add    %edx,%eax
   150ac:	89 c2                	mov    %eax,%edx
   150ae:	c1 e2 08             	shl    $0x8,%edx
   150b1:	01 d0                	add    %edx,%eax
   150b3:	8d 04 81             	lea    (%ecx,%eax,4),%eax
   150b6:	c1 e8 10             	shr    $0x10,%eax
   150b9:	66 c1 e8 03          	shr    $0x3,%ax
   150bd:	88 c2                	mov    %al,%dl
   150bf:	c1 e2 04             	shl    $0x4,%edx
   150c2:	8d 04 80             	lea    (%eax,%eax,4),%eax
   150c5:	01 c0                	add    %eax,%eax
   150c7:	66 29 c3             	sub    %ax,%bx
   150ca:	b8 02 00 00 00       	mov    $0x2,%eax
   150cf:	01 da                	add    %ebx,%edx
   150d1:	81 e2 ff 00 00 00    	and    $0xff,%edx
   150d7:	e8 54 fd ff ff       	call   14e30 <_HalpSetCMOS>
   150dc:	66 8b 5e 06          	mov    0x6(%esi),%bx
   150e0:	89 d9                	mov    %ebx,%ecx
   150e2:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
   150e8:	8d 04 49             	lea    (%ecx,%ecx,2),%eax
   150eb:	89 c2                	mov    %eax,%edx
   150ed:	c1 e2 04             	shl    $0x4,%edx
   150f0:	01 d0                	add    %edx,%eax
   150f2:	89 c2                	mov    %eax,%edx
   150f4:	c1 e2 08             	shl    $0x8,%edx
   150f7:	01 d0                	add    %edx,%eax
   150f9:	8d 04 81             	lea    (%ecx,%eax,4),%eax
   150fc:	c1 e8 10             	shr    $0x10,%eax
   150ff:	66 c1 e8 03          	shr    $0x3,%ax
   15103:	88 c2                	mov    %al,%dl
   15105:	c1 e2 04             	shl    $0x4,%edx
   15108:	8d 04 80             	lea    (%eax,%eax,4),%eax
   1510b:	01 c0                	add    %eax,%eax
   1510d:	66 29 c3             	sub    %ax,%bx
   15110:	b8 04 00 00 00       	mov    $0x4,%eax
   15115:	01 da                	add    %ebx,%edx
   15117:	81 e2 ff 00 00 00    	and    $0xff,%edx
   1511d:	e8 0e fd ff ff       	call   14e30 <_HalpSetCMOS>
   15122:	66 8b 5e 0e          	mov    0xe(%esi),%bx
   15126:	89 d9                	mov    %ebx,%ecx
   15128:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
   1512e:	8d 04 49             	lea    (%ecx,%ecx,2),%eax
   15131:	89 c2                	mov    %eax,%edx
   15133:	c1 e2 04             	shl    $0x4,%edx
   15136:	01 d0                	add    %edx,%eax
   15138:	89 c2                	mov    %eax,%edx
   1513a:	c1 e2 08             	shl    $0x8,%edx
   1513d:	01 d0                	add    %edx,%eax
   1513f:	8d 04 81             	lea    (%ecx,%eax,4),%eax
   15142:	c1 e8 10             	shr    $0x10,%eax
   15145:	66 c1 e8 03          	shr    $0x3,%ax
   15149:	88 c2                	mov    %al,%dl
   1514b:	c1 e2 04             	shl    $0x4,%edx
   1514e:	8d 04 80             	lea    (%eax,%eax,4),%eax
   15151:	01 c0                	add    %eax,%eax
   15153:	66 29 c3             	sub    %ax,%bx
   15156:	b8 06 00 00 00       	mov    $0x6,%eax
   1515b:	01 da                	add    %ebx,%edx
   1515d:	81 e2 ff 00 00 00    	and    $0xff,%edx
   15163:	e8 c8 fc ff ff       	call   14e30 <_HalpSetCMOS>
   15168:	66 8b 5e 04          	mov    0x4(%esi),%bx
   1516c:	89 d9                	mov    %ebx,%ecx
   1516e:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
   15174:	8d 04 49             	lea    (%ecx,%ecx,2),%eax
   15177:	89 c2                	mov    %eax,%edx
   15179:	c1 e2 04             	shl    $0x4,%edx
   1517c:	01 d0                	add    %edx,%eax
   1517e:	89 c2                	mov    %eax,%edx
   15180:	c1 e2 08             	shl    $0x8,%edx
   15183:	01 d0                	add    %edx,%eax
   15185:	8d 04 81             	lea    (%ecx,%eax,4),%eax
   15188:	c1 e8 10             	shr    $0x10,%eax
   1518b:	66 c1 e8 03          	shr    $0x3,%ax
   1518f:	88 c2                	mov    %al,%dl
   15191:	c1 e2 04             	shl    $0x4,%edx
   15194:	8d 04 80             	lea    (%eax,%eax,4),%eax
   15197:	01 c0                	add    %eax,%eax
   15199:	66 29 c3             	sub    %ax,%bx
   1519c:	b8 07 00 00 00       	mov    $0x7,%eax
   151a1:	01 da                	add    %ebx,%edx
   151a3:	81 e2 ff 00 00 00    	and    $0xff,%edx
   151a9:	e8 82 fc ff ff       	call   14e30 <_HalpSetCMOS>
   151ae:	66 8b 5e 02          	mov    0x2(%esi),%bx
   151b2:	89 d9                	mov    %ebx,%ecx
   151b4:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
   151ba:	8d 04 49             	lea    (%ecx,%ecx,2),%eax
   151bd:	89 c2                	mov    %eax,%edx
   151bf:	c1 e2 04             	shl    $0x4,%edx
   151c2:	01 d0                	add    %edx,%eax
   151c4:	89 c2                	mov    %eax,%edx
   151c6:	c1 e2 08             	shl    $0x8,%edx
   151c9:	01 d0                	add    %edx,%eax
   151cb:	8d 04 81             	lea    (%ecx,%eax,4),%eax
   151ce:	c1 e8 10             	shr    $0x10,%eax
   151d1:	66 c1 e8 03          	shr    $0x3,%ax
   151d5:	88 c2                	mov    %al,%dl
   151d7:	c1 e2 04             	shl    $0x4,%edx
   151da:	8d 04 80             	lea    (%eax,%eax,4),%eax
   151dd:	01 c0                	add    %eax,%eax
   151df:	66 29 c3             	sub    %ax,%bx
   151e2:	b8 08 00 00 00       	mov    $0x8,%eax
   151e7:	01 da                	add    %ebx,%edx
   151e9:	81 e2 ff 00 00 00    	and    $0xff,%edx
   151ef:	e8 3c fc ff ff       	call   14e30 <_HalpSetCMOS>
   151f4:	66 8b 06             	mov    (%esi),%ax
   151f7:	31 f6                	xor    %esi,%esi
   151f9:	b9 64 00 00 00       	mov    $0x64,%ecx
   151fe:	89 f2                	mov    %esi,%edx
   15200:	66 f7 f1             	div    %cx
   15203:	89 d1                	mov    %edx,%ecx
   15205:	89 d3                	mov    %edx,%ebx
   15207:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
   1520d:	8d 14 49             	lea    (%ecx,%ecx,2),%edx
   15210:	89 d0                	mov    %edx,%eax
   15212:	c1 e0 04             	shl    $0x4,%eax
   15215:	01 c2                	add    %eax,%edx
   15217:	89 d0                	mov    %edx,%eax
   15219:	c1 e0 08             	shl    $0x8,%eax
   1521c:	01 c2                	add    %eax,%edx
   1521e:	89 d8                	mov    %ebx,%eax
   15220:	8d 0c 91             	lea    (%ecx,%edx,4),%ecx
   15223:	89 f2                	mov    %esi,%edx
   15225:	66 f7 f7             	div    %di
   15228:	c1 e9 13             	shr    $0x13,%ecx
   1522b:	89 d6                	mov    %edx,%esi
   1522d:	c1 e1 04             	shl    $0x4,%ecx
   15230:	b8 09 00 00 00       	mov    $0x9,%eax
   15235:	8d 14 31             	lea    (%ecx,%esi,1),%edx
   15238:	81 e2 ff 00 00 00    	and    $0xff,%edx
   1523e:	e8 ed fb ff ff       	call   14e30 <_HalpSetCMOS>
   15243:	31 c0                	xor    %eax,%eax
   15245:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   15248:	51                   	push   %ecx
   15249:	51                   	push   %ecx
   1524a:	50                   	push   %eax
   1524b:	68 80 e4 03 00       	push   $0x3e480
   15250:	e8 cb fa ff ff       	call   14d20 <_KeReleaseSpinLock@8>
   15255:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   15258:	5b                   	pop    %ebx
   15259:	5e                   	pop    %esi
   1525a:	5f                   	pop    %edi
   1525b:	5d                   	pop    %ebp
   1525c:	c2 04 00             	ret    $0x4
   1525f:	90                   	nop    

00015260 <_HalGetEnvironmentVariable@12>:
   15260:	55                   	push   %ebp
   15261:	89 e5                	mov    %esp,%ebp
   15263:	56                   	push   %esi
   15264:	53                   	push   %ebx
   15265:	83 ec 18             	sub    $0x18,%esp
   15268:	8b 75 0c             	mov    0xc(%ebp),%esi
   1526b:	8b 5d 10             	mov    0x10(%ebp),%ebx
   1526e:	68 30 c2 01 00       	push   $0x1c230
   15273:	8b 45 08             	mov    0x8(%ebp),%eax
   15276:	50                   	push   %eax
   15277:	e8 14 57 00 00       	call   1a990 <__stricmp>
   1527c:	83 c4 10             	add    $0x10,%esp
   1527f:	31 d2                	xor    %edx,%edx
   15281:	85 c0                	test   %eax,%eax
   15283:	74 0b                	je     15290 <_HalGetEnvironmentVariable@12+0x30>
   15285:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   15288:	89 d0                	mov    %edx,%eax
   1528a:	5b                   	pop    %ebx
   1528b:	5e                   	pop    %esi
   1528c:	5d                   	pop    %ebp
   1528d:	c2 0c 00             	ret    $0xc
   15290:	8d 45 f7             	lea    0xfffffff7(%ebp),%eax
   15293:	51                   	push   %ecx
   15294:	51                   	push   %ecx
   15295:	50                   	push   %eax
   15296:	68 80 e4 03 00       	push   $0x3e480
   1529b:	e8 10 fa ff ff       	call   14cb0 <_KeAcquireSpinLock@8>
   152a0:	58                   	pop    %eax
   152a1:	b8 0b 00 00 00       	mov    $0xb,%eax
   152a6:	5a                   	pop    %edx
   152a7:	e8 34 fb ff ff       	call   14de0 <_HalpQueryCMOS>
   152ac:	a8 01                	test   $0x1,%al
   152ae:	75 36                	jne    152e6 <_HalGetEnvironmentVariable@12+0x86>
   152b0:	89 d8                	mov    %ebx,%eax
   152b2:	25 ff ff 00 00       	and    $0xffff,%eax
   152b7:	51                   	push   %ecx
   152b8:	50                   	push   %eax
   152b9:	68 3e c2 01 00       	push   $0x1c23e
   152be:	56                   	push   %esi
   152bf:	e8 bc 56 00 00       	call   1a980 <_strncpy>
   152c4:	58                   	pop    %eax
   152c5:	31 c0                	xor    %eax,%eax
   152c7:	8a 45 f7             	mov    0xfffffff7(%ebp),%al
   152ca:	5a                   	pop    %edx
   152cb:	50                   	push   %eax
   152cc:	68 80 e4 03 00       	push   $0x3e480
   152d1:	e8 4a fa ff ff       	call   14d20 <_KeReleaseSpinLock@8>
   152d6:	ba 01 00 00 00       	mov    $0x1,%edx
   152db:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   152de:	89 d0                	mov    %edx,%eax
   152e0:	5b                   	pop    %ebx
   152e1:	5e                   	pop    %esi
   152e2:	5d                   	pop    %ebp
   152e3:	c2 0c 00             	ret    $0xc
   152e6:	50                   	push   %eax
   152e7:	89 d8                	mov    %ebx,%eax
   152e9:	25 ff ff 00 00       	and    $0xffff,%eax
   152ee:	50                   	push   %eax
   152ef:	68 43 c2 01 00       	push   $0x1c243
   152f4:	eb c8                	jmp    152be <_HalGetEnvironmentVariable@12+0x5e>
   152f6:	8d 76 00             	lea    0x0(%esi),%esi
   152f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00015300 <_HalSetEnvironmentVariable@8>:
   15300:	55                   	push   %ebp
   15301:	89 e5                	mov    %esp,%ebp
   15303:	57                   	push   %edi
   15304:	56                   	push   %esi
   15305:	53                   	push   %ebx
   15306:	83 ec 14             	sub    $0x14,%esp
   15309:	bf 01 00 00 00       	mov    $0x1,%edi
   1530e:	8b 75 0c             	mov    0xc(%ebp),%esi
   15311:	68 30 c2 01 00       	push   $0x1c230
   15316:	8b 5d 08             	mov    0x8(%ebp),%ebx
   15319:	53                   	push   %ebx
   1531a:	e8 71 56 00 00       	call   1a990 <__stricmp>
   1531f:	83 c4 10             	add    $0x10,%esp
   15322:	31 d2                	xor    %edx,%edx
   15324:	85 c0                	test   %eax,%eax
   15326:	74 0c                	je     15334 <_HalSetEnvironmentVariable@8+0x34>
   15328:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1532b:	89 d0                	mov    %edx,%eax
   1532d:	5b                   	pop    %ebx
   1532e:	5e                   	pop    %esi
   1532f:	5f                   	pop    %edi
   15330:	5d                   	pop    %ebp
   15331:	c2 08 00             	ret    $0x8
   15334:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   15337:	51                   	push   %ecx
   15338:	51                   	push   %ecx
   15339:	50                   	push   %eax
   1533a:	68 80 e4 03 00       	push   $0x3e480
   1533f:	e8 6c f9 ff ff       	call   14cb0 <_KeAcquireSpinLock@8>
   15344:	58                   	pop    %eax
   15345:	b8 0b 00 00 00       	mov    $0xb,%eax
   1534a:	5a                   	pop    %edx
   1534b:	e8 90 fa ff ff       	call   14de0 <_HalpQueryCMOS>
   15350:	88 c3                	mov    %al,%bl
   15352:	50                   	push   %eax
   15353:	50                   	push   %eax
   15354:	68 3e c2 01 00       	push   $0x1c23e
   15359:	56                   	push   %esi
   1535a:	e8 31 56 00 00       	call   1a990 <__stricmp>
   1535f:	83 c4 10             	add    $0x10,%esp
   15362:	85 c0                	test   %eax,%eax
   15364:	74 3c                	je     153a2 <_HalSetEnvironmentVariable@8+0xa2>
   15366:	50                   	push   %eax
   15367:	50                   	push   %eax
   15368:	68 43 c2 01 00       	push   $0x1c243
   1536d:	56                   	push   %esi
   1536e:	e8 1d 56 00 00       	call   1a990 <__stricmp>
   15373:	83 c4 10             	add    $0x10,%esp
   15376:	85 c0                	test   %eax,%eax
   15378:	74 38                	je     153b2 <_HalSetEnvironmentVariable@8+0xb2>
   1537a:	31 ff                	xor    %edi,%edi
   1537c:	50                   	push   %eax
   1537d:	50                   	push   %eax
   1537e:	31 c0                	xor    %eax,%eax
   15380:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   15383:	50                   	push   %eax
   15384:	68 80 e4 03 00       	push   $0x3e480
   15389:	e8 92 f9 ff ff       	call   14d20 <_KeReleaseSpinLock@8>
   1538e:	89 fa                	mov    %edi,%edx
   15390:	81 e2 ff 00 00 00    	and    $0xff,%edx
   15396:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   15399:	89 d0                	mov    %edx,%eax
   1539b:	5b                   	pop    %ebx
   1539c:	5e                   	pop    %esi
   1539d:	5f                   	pop    %edi
   1539e:	5d                   	pop    %ebp
   1539f:	c2 08 00             	ret    $0x8
   153a2:	83 cb 01             	or     $0x1,%ebx
   153a5:	31 d2                	xor    %edx,%edx
   153a7:	88 da                	mov    %bl,%dl
   153a9:	b0 0b                	mov    $0xb,%al
   153ab:	e8 80 fa ff ff       	call   14e30 <_HalpSetCMOS>
   153b0:	eb ca                	jmp    1537c <_HalSetEnvironmentVariable@8+0x7c>
   153b2:	89 da                	mov    %ebx,%edx
   153b4:	81 e2 fe 00 00 00    	and    $0xfe,%edx
   153ba:	eb ed                	jmp    153a9 <_HalSetEnvironmentVariable@8+0xa9>
   153bc:	8d 74 26 00          	lea    0x0(%esi),%esi

000153c0 <_HalpGetCmosData@24>:
   153c0:	55                   	push   %ebp
   153c1:	89 e5                	mov    %esp,%ebp
   153c3:	57                   	push   %edi
   153c4:	56                   	push   %esi
   153c5:	53                   	push   %ebx
   153c6:	83 ec 0c             	sub    $0xc,%esp
   153c9:	8b 45 14             	mov    0x14(%ebp),%eax
   153cc:	8b 75 1c             	mov    0x1c(%ebp),%esi
   153cf:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   153d2:	8b 55 0c             	mov    0xc(%ebp),%edx
   153d5:	31 c0                	xor    %eax,%eax
   153d7:	8b 7d 10             	mov    0x10(%ebp),%edi
   153da:	85 f6                	test   %esi,%esi
   153dc:	74 12                	je     153f0 <_HalpGetCmosData@24+0x30>
   153de:	85 d2                	test   %edx,%edx
   153e0:	74 1e                	je     15400 <_HalpGetCmosData@24+0x40>
   153e2:	4a                   	dec    %edx
   153e3:	74 7e                	je     15463 <_HalpGetCmosData@24+0xa3>
   153e5:	8b 45 1c             	mov    0x1c(%ebp),%eax
   153e8:	29 f0                	sub    %esi,%eax
   153ea:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   153f0:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   153f3:	5b                   	pop    %ebx
   153f4:	5e                   	pop    %esi
   153f5:	5f                   	pop    %edi
   153f6:	5d                   	pop    %ebp
   153f7:	c2 18 00             	ret    $0x18
   153fa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   15400:	50                   	push   %eax
   15401:	50                   	push   %eax
   15402:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   15405:	50                   	push   %eax
   15406:	68 80 e4 03 00       	push   $0x3e480
   1540b:	e8 a0 f8 ff ff       	call   14cb0 <_KeAcquireSpinLock@8>
   15410:	81 ff ff 00 00 00    	cmp    $0xff,%edi
   15416:	5b                   	pop    %ebx
   15417:	58                   	pop    %eax
   15418:	76 1b                	jbe    15435 <_HalpGetCmosData@24+0x75>
   1541a:	50                   	push   %eax
   1541b:	50                   	push   %eax
   1541c:	31 c0                	xor    %eax,%eax
   1541e:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   15421:	50                   	push   %eax
   15422:	68 80 e4 03 00       	push   $0x3e480
   15427:	e8 f4 f8 ff ff       	call   14d20 <_KeReleaseSpinLock@8>
   1542c:	5f                   	pop    %edi
   1542d:	58                   	pop    %eax
   1542e:	8b 45 1c             	mov    0x1c(%ebp),%eax
   15431:	29 f0                	sub    %esi,%eax
   15433:	eb bb                	jmp    153f0 <_HalpGetCmosData@24+0x30>
   15435:	89 f8                	mov    %edi,%eax
   15437:	47                   	inc    %edi
   15438:	25 ff 00 00 00       	and    $0xff,%eax
   1543d:	e8 9e f9 ff ff       	call   14de0 <_HalpQueryCMOS>
   15442:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   15445:	88 02                	mov    %al,(%edx)
   15447:	42                   	inc    %edx
   15448:	4e                   	dec    %esi
   15449:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   1544c:	0f 95 c2             	setne  %dl
   1544f:	81 ff ff 00 00 00    	cmp    $0xff,%edi
   15455:	0f 96 c0             	setbe  %al
   15458:	25 ff 00 00 00       	and    $0xff,%eax
   1545d:	85 c2                	test   %eax,%edx
   1545f:	75 d4                	jne    15435 <_HalpGetCmosData@24+0x75>
   15461:	eb b7                	jmp    1541a <_HalpGetCmosData@24+0x5a>
   15463:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   15466:	51                   	push   %ecx
   15467:	51                   	push   %ecx
   15468:	50                   	push   %eax
   15469:	68 80 e4 03 00       	push   $0x3e480
   1546e:	e8 3d f8 ff ff       	call   14cb0 <_KeAcquireSpinLock@8>
   15473:	81 ff ff 0f 00 00    	cmp    $0xfff,%edi
   15479:	58                   	pop    %eax
   1547a:	5a                   	pop    %edx
   1547b:	77 9d                	ja     1541a <_HalpGetCmosData@24+0x5a>
   1547d:	8d 76 00             	lea    0x0(%esi),%esi
   15480:	89 fb                	mov    %edi,%ebx
   15482:	9c                   	pushf  
   15483:	8f 45 e8             	popl   0xffffffe8(%ebp)
   15486:	fa                   	cli    
   15487:	50                   	push   %eax
   15488:	50                   	push   %eax
   15489:	31 c0                	xor    %eax,%eax
   1548b:	88 d8                	mov    %bl,%al
   1548d:	50                   	push   %eax
   1548e:	6a 74                	push   $0x74
   15490:	e8 fb f6 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   15495:	0f b6 df             	movzbl %bh,%ebx
   15498:	53                   	push   %ebx
   15499:	6a 75                	push   $0x75
   1549b:	e8 f0 f6 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   154a0:	50                   	push   %eax
   154a1:	6a 76                	push   $0x76
   154a3:	e8 38 f6 ff ff       	call   14ae0 <_READ_PORT_UCHAR@4>
   154a8:	83 c4 0c             	add    $0xc,%esp
   154ab:	ff 75 e8             	pushl  0xffffffe8(%ebp)
   154ae:	9d                   	popf   
   154af:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   154b2:	47                   	inc    %edi
   154b3:	88 02                	mov    %al,(%edx)
   154b5:	42                   	inc    %edx
   154b6:	4e                   	dec    %esi
   154b7:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   154ba:	0f 95 c2             	setne  %dl
   154bd:	81 ff ff 0f 00 00    	cmp    $0xfff,%edi
   154c3:	0f 96 c0             	setbe  %al
   154c6:	25 ff 00 00 00       	and    $0xff,%eax
   154cb:	85 c2                	test   %eax,%edx
   154cd:	75 b1                	jne    15480 <_HalpGetCmosData@24+0xc0>
   154cf:	e9 46 ff ff ff       	jmp    1541a <_HalpGetCmosData@24+0x5a>
   154d4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   154da:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

000154e0 <_HalpSetCmosData@24>:
   154e0:	55                   	push   %ebp
   154e1:	89 e5                	mov    %esp,%ebp
   154e3:	57                   	push   %edi
   154e4:	56                   	push   %esi
   154e5:	53                   	push   %ebx
   154e6:	83 ec 1c             	sub    $0x1c,%esp
   154e9:	8b 45 14             	mov    0x14(%ebp),%eax
   154ec:	8b 75 1c             	mov    0x1c(%ebp),%esi
   154ef:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   154f2:	8b 55 0c             	mov    0xc(%ebp),%edx
   154f5:	31 c0                	xor    %eax,%eax
   154f7:	8b 7d 10             	mov    0x10(%ebp),%edi
   154fa:	85 f6                	test   %esi,%esi
   154fc:	74 12                	je     15510 <_HalpSetCmosData@24+0x30>
   154fe:	85 d2                	test   %edx,%edx
   15500:	74 1e                	je     15520 <_HalpSetCmosData@24+0x40>
   15502:	4a                   	dec    %edx
   15503:	0f 84 7f 00 00 00    	je     15588 <_HalpSetCmosData@24+0xa8>
   15509:	8b 45 1c             	mov    0x1c(%ebp),%eax
   1550c:	29 f0                	sub    %esi,%eax
   1550e:	89 f6                	mov    %esi,%esi
   15510:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   15513:	5b                   	pop    %ebx
   15514:	5e                   	pop    %esi
   15515:	5f                   	pop    %edi
   15516:	5d                   	pop    %ebp
   15517:	c2 18 00             	ret    $0x18
   1551a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   15520:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   15523:	51                   	push   %ecx
   15524:	51                   	push   %ecx
   15525:	50                   	push   %eax
   15526:	68 80 e4 03 00       	push   $0x3e480
   1552b:	e8 80 f7 ff ff       	call   14cb0 <_KeAcquireSpinLock@8>
   15530:	81 ff ff 00 00 00    	cmp    $0xff,%edi
   15536:	58                   	pop    %eax
   15537:	5a                   	pop    %edx
   15538:	76 1b                	jbe    15555 <_HalpSetCmosData@24+0x75>
   1553a:	31 c0                	xor    %eax,%eax
   1553c:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   1553f:	51                   	push   %ecx
   15540:	51                   	push   %ecx
   15541:	50                   	push   %eax
   15542:	68 80 e4 03 00       	push   $0x3e480
   15547:	e8 d4 f7 ff ff       	call   14d20 <_KeReleaseSpinLock@8>
   1554c:	58                   	pop    %eax
   1554d:	8b 45 1c             	mov    0x1c(%ebp),%eax
   15550:	5a                   	pop    %edx
   15551:	29 f0                	sub    %esi,%eax
   15553:	eb bb                	jmp    15510 <_HalpSetCmosData@24+0x30>
   15555:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   15558:	31 d2                	xor    %edx,%edx
   1555a:	8a 10                	mov    (%eax),%dl
   1555c:	89 f8                	mov    %edi,%eax
   1555e:	25 ff 00 00 00       	and    $0xff,%eax
   15563:	47                   	inc    %edi
   15564:	e8 c7 f8 ff ff       	call   14e30 <_HalpSetCMOS>
   15569:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1556c:	40                   	inc    %eax
   1556d:	4e                   	dec    %esi
   1556e:	0f 95 c2             	setne  %dl
   15571:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   15574:	81 ff ff 00 00 00    	cmp    $0xff,%edi
   1557a:	0f 96 c0             	setbe  %al
   1557d:	25 ff 00 00 00       	and    $0xff,%eax
   15582:	85 c2                	test   %eax,%edx
   15584:	75 cf                	jne    15555 <_HalpSetCmosData@24+0x75>
   15586:	eb b2                	jmp    1553a <_HalpSetCmosData@24+0x5a>
   15588:	50                   	push   %eax
   15589:	50                   	push   %eax
   1558a:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   1558d:	50                   	push   %eax
   1558e:	68 80 e4 03 00       	push   $0x3e480
   15593:	e8 18 f7 ff ff       	call   14cb0 <_KeAcquireSpinLock@8>
   15598:	81 ff ff 0f 00 00    	cmp    $0xfff,%edi
   1559e:	5b                   	pop    %ebx
   1559f:	58                   	pop    %eax
   155a0:	77 98                	ja     1553a <_HalpSetCmosData@24+0x5a>
   155a2:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   155a5:	89 fb                	mov    %edi,%ebx
   155a7:	8a 00                	mov    (%eax),%al
   155a9:	88 45 eb             	mov    %al,0xffffffeb(%ebp)
   155ac:	9c                   	pushf  
   155ad:	8f 45 e4             	popl   0xffffffe4(%ebp)
   155b0:	fa                   	cli    
   155b1:	31 c0                	xor    %eax,%eax
   155b3:	88 d8                	mov    %bl,%al
   155b5:	51                   	push   %ecx
   155b6:	51                   	push   %ecx
   155b7:	50                   	push   %eax
   155b8:	6a 74                	push   $0x74
   155ba:	e8 d1 f5 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   155bf:	0f b6 df             	movzbl %bh,%ebx
   155c2:	53                   	push   %ebx
   155c3:	6a 75                	push   $0x75
   155c5:	e8 c6 f5 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   155ca:	31 c0                	xor    %eax,%eax
   155cc:	8a 45 eb             	mov    0xffffffeb(%ebp),%al
   155cf:	50                   	push   %eax
   155d0:	6a 76                	push   $0x76
   155d2:	e8 b9 f5 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   155d7:	58                   	pop    %eax
   155d8:	5a                   	pop    %edx
   155d9:	ff 75 e4             	pushl  0xffffffe4(%ebp)
   155dc:	9d                   	popf   
   155dd:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   155e0:	47                   	inc    %edi
   155e1:	43                   	inc    %ebx
   155e2:	4e                   	dec    %esi
   155e3:	0f 95 c2             	setne  %dl
   155e6:	81 ff ff 0f 00 00    	cmp    $0xfff,%edi
   155ec:	89 5d ec             	mov    %ebx,0xffffffec(%ebp)
   155ef:	0f 96 c0             	setbe  %al
   155f2:	25 ff 00 00 00       	and    $0xff,%eax
   155f7:	85 c2                	test   %eax,%edx
   155f9:	75 a7                	jne    155a2 <_HalpSetCmosData@24+0xc2>
   155fb:	e9 3a ff ff ff       	jmp    1553a <_HalpSetCmosData@24+0x5a>

00015600 <___KeStallExecutionProcessor@4>:
   15600:	55                   	push   %ebp
   15601:	89 e5                	mov    %esp,%ebp
   15603:	8b 55 08             	mov    0x8(%ebp),%edx
   15606:	85 d2                	test   %edx,%edx
   15608:	74 05                	je     1560f <ROSL1+0x3>
   1560a:	89 d0                	mov    %edx,%eax

0001560c <ROSL1>:
   1560c:	48                   	dec    %eax
   1560d:	75 fd                	jne    1560c <ROSL1>
   1560f:	5d                   	pop    %ebp
   15610:	c2 04 00             	ret    $0x4
   15613:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   15619:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00015620 <_KeStallExecutionProcessor@4>:
   15620:	55                   	push   %ebp
   15621:	89 e5                	mov    %esp,%ebp
   15623:	57                   	push   %edi
   15624:	56                   	push   %esi
   15625:	53                   	push   %ebx
   15626:	83 ec 14             	sub    $0x14,%esp
   15629:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   15630:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   15637:	8b 4d 08             	mov    0x8(%ebp),%ecx
{
  ULONG value;

#if defined(__GNUC__)
  __asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
   1563a:	64 8b 1d 1c 00 00 00 	mov    %fs:0x1c,%ebx
   15641:	f6 83 d0 08 00 00 10 	testb  $0x10,0x8d0(%ebx)
   15648:	74 30                	je     1567a <_KeStallExecutionProcessor@4+0x5a>
   1564a:	0f 31                	rdtsc  
   1564c:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   1564f:	89 c8                	mov    %ecx,%eax
   15651:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   15654:	f7 a3 cc 08 00 00    	mull   0x8cc(%ebx)
   1565a:	89 c1                	mov    %eax,%ecx
   1565c:	89 d3                	mov    %edx,%ebx
   1565e:	03 4d e8             	add    0xffffffe8(%ebp),%ecx
   15661:	13 5d ec             	adc    0xffffffec(%ebp),%ebx
   15664:	0f 31                	rdtsc  
   15666:	39 da                	cmp    %ebx,%edx
   15668:	7f 06                	jg     15670 <_KeStallExecutionProcessor@4+0x50>
   1566a:	7c f8                	jl     15664 <_KeStallExecutionProcessor@4+0x44>
   1566c:	39 c8                	cmp    %ecx,%eax
   1566e:	72 f4                	jb     15664 <_KeStallExecutionProcessor@4+0x44>
   15670:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   15673:	5b                   	pop    %ebx
   15674:	5e                   	pop    %esi
   15675:	5f                   	pop    %edi
   15676:	5d                   	pop    %ebp
   15677:	c2 04 00             	ret    $0x4
   1567a:	8b 53 4c             	mov    0x4c(%ebx),%edx
   1567d:	b8 d3 4d 62 10       	mov    $0x10624dd3,%eax
   15682:	0f af d1             	imul   %ecx,%edx
   15685:	f7 e2                	mul    %edx
   15687:	c1 ea 06             	shr    $0x6,%edx
   1568a:	89 55 08             	mov    %edx,0x8(%ebp)
   1568d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   15690:	5b                   	pop    %ebx
   15691:	5e                   	pop    %esi
   15692:	5f                   	pop    %edi
   15693:	5d                   	pop    %ebp
   15694:	e9 67 ff ff ff       	jmp    15600 <___KeStallExecutionProcessor@4>
   15699:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000156a0 <_Read8254Timer>:
   156a0:	55                   	push   %ebp
   156a1:	89 e5                	mov    %esp,%ebp
   156a3:	56                   	push   %esi
   156a4:	53                   	push   %ebx
   156a5:	9c                   	pushf  
   156a6:	5e                   	pop    %esi
   156a7:	fa                   	cli    
   156a8:	52                   	push   %edx
   156a9:	52                   	push   %edx
   156aa:	6a 00                	push   $0x0
   156ac:	6a 43                	push   $0x43
   156ae:	e8 dd f4 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   156b3:	50                   	push   %eax
   156b4:	6a 40                	push   $0x40
   156b6:	e8 25 f4 ff ff       	call   14ae0 <_READ_PORT_UCHAR@4>
   156bb:	88 c3                	mov    %al,%bl
   156bd:	6a 40                	push   $0x40
   156bf:	e8 1c f4 ff ff       	call   14ae0 <_READ_PORT_UCHAR@4>
   156c4:	25 ff 00 00 00       	and    $0xff,%eax
   156c9:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   156cf:	c1 e0 08             	shl    $0x8,%eax
   156d2:	09 c3                	or     %eax,%ebx
   156d4:	56                   	push   %esi
   156d5:	9d                   	popf   
   156d6:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   156d9:	89 d8                	mov    %ebx,%eax
   156db:	5b                   	pop    %ebx
   156dc:	5e                   	pop    %esi
   156dd:	5d                   	pop    %ebp
   156de:	c3                   	ret    
   156df:	90                   	nop    

000156e0 <_WaitFor8254Wraparound>:
   156e0:	55                   	push   %ebp
   156e1:	89 e5                	mov    %esp,%ebp
   156e3:	53                   	push   %ebx
   156e4:	53                   	push   %ebx
   156e5:	e8 b6 ff ff ff       	call   156a0 <_Read8254Timer>
   156ea:	89 c2                	mov    %eax,%edx
   156ec:	8d 74 26 00          	lea    0x0(%esi),%esi
   156f0:	89 d3                	mov    %edx,%ebx
   156f2:	e8 a9 ff ff ff       	call   156a0 <_Read8254Timer>
   156f7:	89 c2                	mov    %eax,%edx
   156f9:	29 d8                	sub    %ebx,%eax
   156fb:	3d 2b 01 00 00       	cmp    $0x12b,%eax
   15700:	7e ee                	jle    156f0 <_WaitFor8254Wraparound+0x10>
   15702:	59                   	pop    %ecx
   15703:	5b                   	pop    %ebx
   15704:	5d                   	pop    %ebp
   15705:	c3                   	ret    
   15706:	8d 76 00             	lea    0x0(%esi),%esi
   15709:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00015710 <_HalpCalibrateStallExecution>:
   15710:	55                   	push   %ebp
   15711:	89 e5                	mov    %esp,%ebp
   15713:	57                   	push   %edi
   15714:	56                   	push   %esi
   15715:	53                   	push   %ebx
   15716:	83 ec 0c             	sub    $0xc,%esp
   15719:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   15720:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   15727:	80 3d 90 e4 03 00 00 	cmpb   $0x0,0x3e490
   1572e:	74 08                	je     15738 <_HalpCalibrateStallExecution+0x28>
   15730:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   15733:	5b                   	pop    %ebx
   15734:	5e                   	pop    %esi
   15735:	5f                   	pop    %edi
   15736:	5d                   	pop    %ebp
   15737:	c3                   	ret    
   15738:	c6 05 90 e4 03 00 01 	movb   $0x1,0x3e490
{
  ULONG value;

#if defined(__GNUC__)
  __asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
   1573f:	64 8b 1d 1c 00 00 00 	mov    %fs:0x1c,%ebx
   15746:	51                   	push   %ecx
   15747:	51                   	push   %ecx
   15748:	6a 34                	push   $0x34
   1574a:	6a 43                	push   $0x43
   1574c:	e8 3f f4 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   15751:	68 9b 00 00 00       	push   $0x9b
   15756:	6a 40                	push   $0x40
   15758:	e8 33 f4 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1575d:	6a 2e                	push   $0x2e
   1575f:	6a 40                	push   $0x40
   15761:	e8 2a f4 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   15766:	f6 83 d0 08 00 00 10 	testb  $0x10,0x8d0(%ebx)
   1576d:	58                   	pop    %eax
   1576e:	5a                   	pop    %edx
   1576f:	0f 85 eb 00 00 00    	jne    15860 <_HalpCalibrateStallExecution+0x150>
   15775:	83 ec 0c             	sub    $0xc,%esp
   15778:	68 50 c2 01 00       	push   $0x1c250
   1577d:	e8 0e 51 00 00       	call   1a890 <_DbgPrint>
   15782:	e8 59 ff ff ff       	call   156e0 <_WaitFor8254Wraparound>
   15787:	c7 43 4c 01 00 00 00 	movl   $0x1,0x4c(%ebx)
   1578e:	83 c4 10             	add    $0x10,%esp
   15791:	8b 73 4c             	mov    0x4c(%ebx),%esi
   15794:	01 f6                	add    %esi,%esi
   15796:	89 73 4c             	mov    %esi,0x4c(%ebx)
   15799:	e8 42 ff ff ff       	call   156e0 <_WaitFor8254Wraparound>
   1579e:	8b 4b 4c             	mov    0x4c(%ebx),%ecx
   157a1:	51                   	push   %ecx
   157a2:	e8 59 fe ff ff       	call   15600 <___KeStallExecutionProcessor@4>
   157a7:	e8 f4 fe ff ff       	call   156a0 <_Read8254Timer>
   157ac:	3d 4d 17 00 00       	cmp    $0x174d,%eax
   157b1:	77 de                	ja     15791 <_HalpCalibrateStallExecution+0x81>
   157b3:	8b 43 4c             	mov    0x4c(%ebx),%eax
   157b6:	d1 e8                	shr    %eax
   157b8:	31 ff                	xor    %edi,%edi
   157ba:	89 43 4c             	mov    %eax,0x4c(%ebx)
   157bd:	52                   	push   %edx
   157be:	52                   	push   %edx
   157bf:	50                   	push   %eax
   157c0:	68 6c c2 01 00       	push   $0x1c26c
   157c5:	e8 c6 50 00 00       	call   1a890 <_DbgPrint>
   157ca:	8b 43 4c             	mov    0x4c(%ebx),%eax
   157cd:	83 c4 10             	add    $0x10,%esp
   157d0:	89 c6                	mov    %eax,%esi
   157d2:	eb 03                	jmp    157d7 <_HalpCalibrateStallExecution+0xc7>
   157d4:	8b 43 4c             	mov    0x4c(%ebx),%eax
   157d7:	d1 ee                	shr    %esi
   157d9:	74 35                	je     15810 <_HalpCalibrateStallExecution+0x100>
   157db:	09 f0                	or     %esi,%eax
   157dd:	89 43 4c             	mov    %eax,0x4c(%ebx)
   157e0:	e8 fb fe ff ff       	call   156e0 <_WaitFor8254Wraparound>
   157e5:	8b 43 4c             	mov    0x4c(%ebx),%eax
   157e8:	50                   	push   %eax
   157e9:	e8 12 fe ff ff       	call   15600 <___KeStallExecutionProcessor@4>
   157ee:	e8 ad fe ff ff       	call   156a0 <_Read8254Timer>
   157f3:	3d 4d 17 00 00       	cmp    $0x174d,%eax
   157f8:	77 0d                	ja     15807 <_HalpCalibrateStallExecution+0xf7>
   157fa:	89 f0                	mov    %esi,%eax
   157fc:	8b 4b 4c             	mov    0x4c(%ebx),%ecx
   157ff:	83 f0 ff             	xor    $0xffffffff,%eax
   15802:	21 c1                	and    %eax,%ecx
   15804:	89 4b 4c             	mov    %ecx,0x4c(%ebx)
   15807:	47                   	inc    %edi
   15808:	83 ff 07             	cmp    $0x7,%edi
   1580b:	76 c7                	jbe    157d4 <_HalpCalibrateStallExecution+0xc4>
   1580d:	8b 43 4c             	mov    0x4c(%ebx),%eax
   15810:	ba cd cc cc cc       	mov    $0xcccccccd,%edx
   15815:	83 ec 0c             	sub    $0xc,%esp
   15818:	f7 e2                	mul    %edx
   1581a:	c1 ea 02             	shr    $0x2,%edx
   1581d:	89 53 4c             	mov    %edx,0x4c(%ebx)
   15820:	68 7c c2 01 00       	push   $0x1c27c
   15825:	e8 66 50 00 00       	call   1a890 <_DbgPrint>
   1582a:	58                   	pop    %eax
   1582b:	8b 43 4c             	mov    0x4c(%ebx),%eax
   1582e:	5a                   	pop    %edx
   1582f:	50                   	push   %eax
   15830:	68 7f c2 01 00       	push   $0x1c27f
   15835:	e8 56 50 00 00       	call   1a890 <_DbgPrint>
   1583a:	b8 d3 4d 62 10       	mov    $0x10624dd3,%eax
   1583f:	f7 63 4c             	mull   0x4c(%ebx)
   15842:	c1 ea 04             	shr    $0x4,%edx
   15845:	5e                   	pop    %esi
   15846:	5f                   	pop    %edi
   15847:	52                   	push   %edx
   15848:	68 90 c2 01 00       	push   $0x1c290
   1584d:	e8 3e 50 00 00       	call   1a890 <_DbgPrint>
   15852:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   15855:	5b                   	pop    %ebx
   15856:	5e                   	pop    %esi
   15857:	5f                   	pop    %edi
   15858:	5d                   	pop    %ebp
   15859:	c3                   	ret    
   1585a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   15860:	e8 7b fe ff ff       	call   156e0 <_WaitFor8254Wraparound>
   15865:	0f 31                	rdtsc  
   15867:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   1586a:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   1586d:	e8 6e fe ff ff       	call   156e0 <_WaitFor8254Wraparound>
   15872:	0f 31                	rdtsc  
   15874:	8b 7d e8             	mov    0xffffffe8(%ebp),%edi
   15877:	89 c2                	mov    %eax,%edx
   15879:	29 fa                	sub    %edi,%edx
   1587b:	b8 59 17 b7 d1       	mov    $0xd1b71759,%eax
   15880:	f7 e2                	mul    %edx
   15882:	c1 ea 0d             	shr    $0xd,%edx
   15885:	89 93 cc 08 00 00    	mov    %edx,0x8cc(%ebx)
   1588b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1588e:	5b                   	pop    %ebx
   1588f:	5e                   	pop    %esi
   15890:	5f                   	pop    %edi
   15891:	5d                   	pop    %ebp
   15892:	c3                   	ret    
   15893:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   15899:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000158a0 <_HalCalibratePerformanceCounter@4>:
   158a0:	55                   	push   %ebp
   158a1:	89 e5                	mov    %esp,%ebp
   158a3:	53                   	push   %ebx
   158a4:	9c                   	pushf  
   158a5:	5b                   	pop    %ebx
   158a6:	fa                   	cli    
   158a7:	8b 45 08             	mov    0x8(%ebp),%eax
   158aa:	50                   	push   %eax
   158ab:	e8 50 fd ff ff       	call   15600 <___KeStallExecutionProcessor@4>
   158b0:	53                   	push   %ebx
   158b1:	9d                   	popf   
   158b2:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   158b5:	c9                   	leave  
   158b6:	c2 04 00             	ret    $0x4
   158b9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000158c0 <_KeQueryPerformanceCounter@4>:
   158c0:	55                   	push   %ebp
   158c1:	89 e5                	mov    %esp,%ebp
   158c3:	57                   	push   %edi
   158c4:	56                   	push   %esi
   158c5:	53                   	push   %ebx
   158c6:	83 ec 1c             	sub    $0x1c,%esp
   158c9:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
   158d0:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   158d7:	8b 4d 08             	mov    0x8(%ebp),%ecx
   158da:	9c                   	pushf  
   158db:	58                   	pop    %eax
   158dc:	fa                   	cli    
{
  ULONG value;

#if defined(__GNUC__)
  __asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
   158dd:	64 8b 15 1c 00 00 00 	mov    %fs:0x1c,%edx
   158e4:	f6 82 d0 08 00 00 10 	testb  $0x10,0x8d0(%edx)
   158eb:	74 33                	je     15920 <_KeQueryPerformanceCounter@4+0x60>
   158ed:	50                   	push   %eax
   158ee:	9d                   	popf   
   158ef:	85 c9                	test   %ecx,%ecx
   158f1:	74 10                	je     15903 <_KeQueryPerformanceCounter@4+0x43>
   158f3:	b8 40 42 0f 00       	mov    $0xf4240,%eax
   158f8:	f7 a2 cc 08 00 00    	mull   0x8cc(%edx)
   158fe:	89 01                	mov    %eax,(%ecx)
   15900:	89 51 04             	mov    %edx,0x4(%ecx)
   15903:	0f 31                	rdtsc  
   15905:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   15908:	89 55 dc             	mov    %edx,0xffffffdc(%ebp)
   1590b:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   1590e:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   15911:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   15914:	5b                   	pop    %ebx
   15915:	5e                   	pop    %esi
   15916:	5f                   	pop    %edi
   15917:	5d                   	pop    %ebp
   15918:	c2 04 00             	ret    $0x4
   1591b:	90                   	nop    
   1591c:	8d 74 26 00          	lea    0x0(%esi),%esi
   15920:	50                   	push   %eax
   15921:	9d                   	popf   
   15922:	85 c9                	test   %ecx,%ecx
   15924:	74 0d                	je     15933 <_KeQueryPerformanceCounter@4+0x73>
   15926:	c7 01 de 34 12 00    	movl   $0x1234de,(%ecx)
   1592c:	c7 41 04 00 00 00 00 	movl   $0x0,0x4(%ecx)
   15933:	8d 7d e0             	lea    0xffffffe0(%ebp),%edi
   15936:	83 ec 0c             	sub    $0xc,%esp
   15939:	8d 55 e8             	lea    0xffffffe8(%ebp),%edx
   1593c:	52                   	push   %edx
   1593d:	e8 5e 50 00 00       	call   1a9a0 <_KeQueryTickCount@4>
   15942:	83 c4 0c             	add    $0xc,%esp
   15945:	e8 56 fd ff ff       	call   156a0 <_Read8254Timer>
   1594a:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   1594d:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   15950:	0f a4 d1 03          	shld   $0x3,%edx,%ecx
   15954:	c1 e2 03             	shl    $0x3,%edx
   15957:	03 55 e8             	add    0xffffffe8(%ebp),%edx
   1595a:	13 4d ec             	adc    0xffffffec(%ebp),%ecx
   1595d:	0f a4 d1 02          	shld   $0x2,%edx,%ecx
   15961:	c1 e2 02             	shl    $0x2,%edx
   15964:	03 55 e8             	add    0xffffffe8(%ebp),%edx
   15967:	13 4d ec             	adc    0xffffffec(%ebp),%ecx
   1596a:	0f a4 d1 02          	shld   $0x2,%edx,%ecx
   1596e:	c1 e2 02             	shl    $0x2,%edx
   15971:	03 55 e8             	add    0xffffffe8(%ebp),%edx
   15974:	13 4d ec             	adc    0xffffffec(%ebp),%ecx
   15977:	0f a4 d1 03          	shld   $0x3,%edx,%ecx
   1597b:	c1 e2 03             	shl    $0x3,%edx
   1597e:	03 55 e8             	add    0xffffffe8(%ebp),%edx
   15981:	13 4d ec             	adc    0xffffffec(%ebp),%ecx
   15984:	89 d3                	mov    %edx,%ebx
   15986:	c1 e3 02             	shl    $0x2,%ebx
   15989:	89 ce                	mov    %ecx,%esi
   1598b:	89 5d d8             	mov    %ebx,0xffffffd8(%ebp)
   1598e:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   15991:	0f a4 d6 02          	shld   $0x2,%edx,%esi
   15995:	01 55 d8             	add    %edx,0xffffffd8(%ebp)
   15998:	89 75 dc             	mov    %esi,0xffffffdc(%ebp)
   1599b:	11 4d dc             	adc    %ecx,0xffffffdc(%ebp)
   1599e:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   159a1:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx
   159a4:	0f a4 d1 01          	shld   $0x1,%edx,%ecx
   159a8:	01 d2                	add    %edx,%edx
   159aa:	89 4d dc             	mov    %ecx,0xffffffdc(%ebp)
   159ad:	89 55 d8             	mov    %edx,0xffffffd8(%ebp)
   159b0:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   159b3:	01 4d d8             	add    %ecx,0xffffffd8(%ebp)
   159b6:	ba 9b 2e 00 00       	mov    $0x2e9b,%edx
   159bb:	11 5d dc             	adc    %ebx,0xffffffdc(%ebp)
   159be:	29 c2                	sub    %eax,%edx
   159c0:	89 d0                	mov    %edx,%eax
   159c2:	31 d2                	xor    %edx,%edx
   159c4:	01 45 d8             	add    %eax,0xffffffd8(%ebp)
   159c7:	11 55 dc             	adc    %edx,0xffffffdc(%ebp)
   159ca:	83 ec 0c             	sub    $0xc,%esp
   159cd:	57                   	push   %edi
   159ce:	e8 cd 4f 00 00       	call   1a9a0 <_KeQueryTickCount@4>
   159d3:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   159d6:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   159d9:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   159dc:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   159df:	89 de                	mov    %ebx,%esi
   159e1:	31 c8                	xor    %ecx,%eax
   159e3:	31 d6                	xor    %edx,%esi
   159e5:	83 c4 0c             	add    $0xc,%esp
   159e8:	09 c6                	or     %eax,%esi
   159ea:	0f 85 46 ff ff ff    	jne    15936 <_KeQueryPerformanceCounter@4+0x76>
   159f0:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   159f3:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   159f6:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   159f9:	5b                   	pop    %ebx
   159fa:	5e                   	pop    %esi
   159fb:	5f                   	pop    %edi
   159fc:	5d                   	pop    %ebp
   159fd:	c2 04 00             	ret    $0x4

00015a00 <_DisableSMPMode>:
}

/* Disable symetric I/O mode ie. go to PIC mode */
inline VOID DisableSMPMode(VOID)
{
   15a00:	55                   	push   %ebp
   15a01:	89 e5                	mov    %esp,%ebp
   15a03:	83 ec 10             	sub    $0x10,%esp
   /*
    * Put the board back into PIC mode (has an effect
    * only on certain older boards).  Note that APIC
    * interrupts, including IPIs, won't work beyond
    * this point!  The only exception are INIT IPIs.
    */
   WRITE_PORT_UCHAR((PUCHAR)0x22, 0x70);
   15a06:	6a 70                	push   $0x70
   15a08:	6a 22                	push   $0x22
   15a0a:	e8 81 f1 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   WRITE_PORT_UCHAR((PUCHAR)0x23, 0x00);
   15a0f:	6a 00                	push   $0x0
   15a11:	6a 23                	push   $0x23
   15a13:	e8 78 f1 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   15a18:	c9                   	leave  
   15a19:	c3                   	ret    
   15a1a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00015a20 <__APICRead>:
}

VOID DumpESR(VOID)
{
  ULONG tmp;

  if (APICGetMaxLVT() > 3)
  {
    APICWrite(APIC_ESR, 0);
  }
  tmp = APICRead(APIC_ESR);
  DbgPrint("ESR %08x\n", tmp);
}


VOID APICDisable(VOID)
{
  ULONG tmp;

  APICClear();

  /*
   * Disable APIC (implies clearing of registers for 82489DX!).
   */
  tmp = APICRead(APIC_SIVR);
  tmp &= ~APIC_SIVR_ENABLE;
  APICWrite(APIC_SIVR, tmp);
}


inline ULONG _APICRead(ULONG Offset)
{
   15a20:	55                   	push   %ebp
   PULONG p;

   p = (PULONG)((ULONG)APICBase + Offset);
   15a21:	a1 10 b0 01 00       	mov    0x1b010,%eax
   15a26:	89 e5                	mov    %esp,%ebp
   15a28:	8b 55 08             	mov    0x8(%ebp),%edx
   return *p;
}
   15a2b:	5d                   	pop    %ebp
   15a2c:	01 d0                	add    %edx,%eax
   15a2e:	8b 00                	mov    (%eax),%eax
   15a30:	c3                   	ret    
   15a31:	eb 0d                	jmp    15a40 <_APICRead>
   15a33:	90                   	nop    
   15a34:	90                   	nop    
   15a35:	90                   	nop    
   15a36:	90                   	nop    
   15a37:	90                   	nop    
   15a38:	90                   	nop    
   15a39:	90                   	nop    
   15a3a:	90                   	nop    
   15a3b:	90                   	nop    
   15a3c:	90                   	nop    
   15a3d:	90                   	nop    
   15a3e:	90                   	nop    
   15a3f:	90                   	nop    

00015a40 <_APICRead>:

#if 0
inline VOID APICWrite(ULONG Offset,
		      ULONG Value)
{
   PULONG p;

   p = (PULONG)((ULONG)APICBase + Offset);

   *p = Value;
}
#else
inline VOID APICWrite(ULONG Offset,
		      ULONG Value)
{
   PULONG p;
   ULONG CPU = (_APICRead(APIC_ID) & APIC_ID_MASK) >> 24;

   lastregw[CPU] = Offset;
   lastvalw[CPU] = Value;

   p = (PULONG)((ULONG)APICBase + Offset);

   *p = Value;
}
#endif


#if 0
inline ULONG APICRead(ULONG Offset)
{
   PULONG p;

   p = (PULONG)((ULONG)APICBase + Offset);
   return *p;
}
#else
inline ULONG APICRead(ULONG Offset)
{
   15a40:	55                   	push   %ebp
   15a41:	a1 10 b0 01 00       	mov    0x1b010,%eax
   15a46:	89 e5                	mov    %esp,%ebp
   15a48:	53                   	push   %ebx
   15a49:	8b 50 20             	mov    0x20(%eax),%edx
   PULONG p;
   ULONG CPU = (_APICRead(APIC_ID) & APIC_ID_MASK) >> 24;

   lastregr[CPU] = Offset;
   lastvalr[CPU] = 0;
   15a4c:	b9 d0 e8 03 00       	mov    $0x3e8d0,%ecx
   15a51:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   15a57:	8b 5d 08             	mov    0x8(%ebp),%ebx
   15a5a:	c1 ea 18             	shr    $0x18,%edx
   15a5d:	c7 04 91 00 00 00 00 	movl   $0x0,(%ecx,%edx,4)
   15a64:	89 1c 95 b0 e5 03 00 	mov    %ebx,0x3e5b0(,%edx,4)

   p = (PULONG)((ULONG)APICBase + Offset);

   lastvalr[CPU] = *p;
   15a6b:	8b 04 18             	mov    (%eax,%ebx,1),%eax
   15a6e:	89 04 91             	mov    %eax,(%ecx,%edx,4)
   return lastvalr[CPU];
}
   15a71:	5b                   	pop    %ebx
   15a72:	5d                   	pop    %ebp
   15a73:	c3                   	ret    
   15a74:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   15a7a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00015a80 <_APICGetMaxLVT>:
   15a80:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   15a86:	55                   	push   %ebp
   15a87:	89 e5                	mov    %esp,%ebp
   15a89:	8b 42 20             	mov    0x20(%edx),%eax
   15a8c:	25 00 00 00 0f       	and    $0xf000000,%eax
   15a91:	c1 e8 18             	shr    $0x18,%eax
   15a94:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   15a9b:	00 00 00 00 
   15a9f:	c7 04 85 b0 e5 03 00 	movl   $0x30,0x3e5b0(,%eax,4)
   15aa6:	30 00 00 00 
   15aaa:	8b 52 30             	mov    0x30(%edx),%edx
   15aad:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   15ab4:	b8 02 00 00 00       	mov    $0x2,%eax
   15ab9:	f6 c2 f0             	test   $0xf0,%dl
   15abc:	74 06                	je     15ac4 <_APICGetMaxLVT+0x44>
   15abe:	c1 ea 10             	shr    $0x10,%edx
   15ac1:	0f b6 c2             	movzbl %dl,%eax
   15ac4:	5d                   	pop    %ebp
   15ac5:	c3                   	ret    
   15ac6:	8d 76 00             	lea    0x0(%esi),%esi
   15ac9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00015ad0 <_APICWrite>:
   15ad0:	55                   	push   %ebp
   15ad1:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   15ad7:	89 e5                	mov    %esp,%ebp
   15ad9:	53                   	push   %ebx
   15ada:	8b 42 20             	mov    0x20(%edx),%eax
   15add:	25 00 00 00 0f       	and    $0xf000000,%eax
   15ae2:	8b 5d 08             	mov    0x8(%ebp),%ebx
   15ae5:	c1 e8 18             	shr    $0x18,%eax
   15ae8:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   15aeb:	89 1c 85 40 e8 03 00 	mov    %ebx,0x3e840(,%eax,4)
   15af2:	89 0c 85 70 e9 03 00 	mov    %ecx,0x3e970(,%eax,4)
   15af9:	89 0c 1a             	mov    %ecx,(%edx,%ebx,1)
   15afc:	5b                   	pop    %ebx
   15afd:	5d                   	pop    %ebp
   15afe:	c3                   	ret    
   15aff:	90                   	nop    

00015b00 <_DumpESR>:
   15b00:	55                   	push   %ebp
   15b01:	89 e5                	mov    %esp,%ebp
   15b03:	50                   	push   %eax
   15b04:	50                   	push   %eax
   15b05:	e8 76 ff ff ff       	call   15a80 <_APICGetMaxLVT>
   15b0a:	83 f8 03             	cmp    $0x3,%eax
   15b0d:	76 71                	jbe    15b80 <_DumpESR+0x80>
   15b0f:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   15b15:	8b 42 20             	mov    0x20(%edx),%eax
   15b18:	25 00 00 00 0f       	and    $0xf000000,%eax
   15b1d:	c1 e8 18             	shr    $0x18,%eax
   15b20:	c7 04 85 40 e8 03 00 	movl   $0x280,0x3e840(,%eax,4)
   15b27:	80 02 00 00 
   15b2b:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   15b32:	00 00 00 00 
   15b36:	c7 82 80 02 00 00 00 	movl   $0x0,0x280(%edx)
   15b3d:	00 00 00 
   15b40:	8b 42 20             	mov    0x20(%edx),%eax
   15b43:	25 00 00 00 0f       	and    $0xf000000,%eax
   15b48:	c1 e8 18             	shr    $0x18,%eax
   15b4b:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   15b52:	00 00 00 00 
   15b56:	c7 04 85 b0 e5 03 00 	movl   $0x280,0x3e5b0(,%eax,4)
   15b5d:	80 02 00 00 
   15b61:	8b 92 80 02 00 00    	mov    0x280(%edx),%edx
   15b67:	51                   	push   %ecx
   15b68:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   15b6f:	51                   	push   %ecx
   15b70:	52                   	push   %edx
   15b71:	68 a0 c2 01 00       	push   $0x1c2a0
   15b76:	e8 15 4d 00 00       	call   1a890 <_DbgPrint>
   15b7b:	c9                   	leave  
   15b7c:	c3                   	ret    
   15b7d:	8d 76 00             	lea    0x0(%esi),%esi
   15b80:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   15b86:	eb b8                	jmp    15b40 <_DumpESR+0x40>
   15b88:	90                   	nop    
   15b89:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00015b90 <_APICClear>:
   15b90:	55                   	push   %ebp
   15b91:	89 e5                	mov    %esp,%ebp
   15b93:	53                   	push   %ebx
   15b94:	e8 e7 fe ff ff       	call   15a80 <_APICGetMaxLVT>
   15b99:	89 c3                	mov    %eax,%ebx
   15b9b:	83 f8 02             	cmp    $0x2,%eax
   15b9e:	0f 86 7c 02 00 00    	jbe    15e20 <_APICClear+0x290>
   15ba4:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   15baa:	8b 41 20             	mov    0x20(%ecx),%eax
   15bad:	25 00 00 00 0f       	and    $0xf000000,%eax
   15bb2:	c1 e8 18             	shr    $0x18,%eax
   15bb5:	c7 04 85 40 e8 03 00 	movl   $0x370,0x3e840(,%eax,4)
   15bbc:	70 03 00 00 
   15bc0:	c7 04 85 70 e9 03 00 	movl   $0x100fe,0x3e970(,%eax,4)
   15bc7:	fe 00 01 00 
   15bcb:	c7 81 70 03 00 00 fe 	movl   $0x100fe,0x370(%ecx)
   15bd2:	00 01 00 
   15bd5:	8b 41 20             	mov    0x20(%ecx),%eax
   15bd8:	25 00 00 00 0f       	and    $0xf000000,%eax
   15bdd:	c1 e8 18             	shr    $0x18,%eax
   15be0:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   15be7:	00 00 00 00 
   15beb:	c7 04 85 b0 e5 03 00 	movl   $0x320,0x3e5b0(,%eax,4)
   15bf2:	20 03 00 00 
   15bf6:	8b 91 20 03 00 00    	mov    0x320(%ecx),%edx
   15bfc:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   15c03:	81 ca 00 00 01 00    	or     $0x10000,%edx
   15c09:	8b 41 20             	mov    0x20(%ecx),%eax
   15c0c:	25 00 00 00 0f       	and    $0xf000000,%eax
   15c11:	c1 e8 18             	shr    $0x18,%eax
   15c14:	c7 04 85 40 e8 03 00 	movl   $0x320,0x3e840(,%eax,4)
   15c1b:	20 03 00 00 
   15c1f:	89 14 85 70 e9 03 00 	mov    %edx,0x3e970(,%eax,4)
   15c26:	8b 41 20             	mov    0x20(%ecx),%eax
   15c29:	89 91 20 03 00 00    	mov    %edx,0x320(%ecx)
   15c2f:	25 00 00 00 0f       	and    $0xf000000,%eax
   15c34:	c1 e8 18             	shr    $0x18,%eax
   15c37:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   15c3e:	00 00 00 00 
   15c42:	c7 04 85 b0 e5 03 00 	movl   $0x350,0x3e5b0(,%eax,4)
   15c49:	50 03 00 00 
   15c4d:	8b 91 50 03 00 00    	mov    0x350(%ecx),%edx
   15c53:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   15c5a:	81 ca 00 00 01 00    	or     $0x10000,%edx
   15c60:	8b 41 20             	mov    0x20(%ecx),%eax
   15c63:	25 00 00 00 0f       	and    $0xf000000,%eax
   15c68:	c1 e8 18             	shr    $0x18,%eax
   15c6b:	c7 04 85 40 e8 03 00 	movl   $0x350,0x3e840(,%eax,4)
   15c72:	50 03 00 00 
   15c76:	89 14 85 70 e9 03 00 	mov    %edx,0x3e970(,%eax,4)
   15c7d:	8b 41 20             	mov    0x20(%ecx),%eax
   15c80:	89 91 50 03 00 00    	mov    %edx,0x350(%ecx)
   15c86:	25 00 00 00 0f       	and    $0xf000000,%eax
   15c8b:	c1 e8 18             	shr    $0x18,%eax
   15c8e:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   15c95:	00 00 00 00 
   15c99:	c7 04 85 b0 e5 03 00 	movl   $0x360,0x3e5b0(,%eax,4)
   15ca0:	60 03 00 00 
   15ca4:	8b 91 60 03 00 00    	mov    0x360(%ecx),%edx
   15caa:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   15cb1:	81 ca 00 00 01 00    	or     $0x10000,%edx
   15cb7:	8b 41 20             	mov    0x20(%ecx),%eax
   15cba:	25 00 00 00 0f       	and    $0xf000000,%eax
   15cbf:	c1 e8 18             	shr    $0x18,%eax
   15cc2:	83 fb 03             	cmp    $0x3,%ebx
   15cc5:	c7 04 85 40 e8 03 00 	movl   $0x360,0x3e840(,%eax,4)
   15ccc:	60 03 00 00 
   15cd0:	89 14 85 70 e9 03 00 	mov    %edx,0x3e970(,%eax,4)
   15cd7:	89 91 60 03 00 00    	mov    %edx,0x360(%ecx)
   15cdd:	76 57                	jbe    15d36 <_APICClear+0x1a6>
   15cdf:	8b 41 20             	mov    0x20(%ecx),%eax
   15ce2:	25 00 00 00 0f       	and    $0xf000000,%eax
   15ce7:	c1 e8 18             	shr    $0x18,%eax
   15cea:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   15cf1:	00 00 00 00 
   15cf5:	c7 04 85 b0 e5 03 00 	movl   $0x340,0x3e5b0(,%eax,4)
   15cfc:	40 03 00 00 
   15d00:	8b 91 40 03 00 00    	mov    0x340(%ecx),%edx
   15d06:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   15d0d:	81 ca 00 00 01 00    	or     $0x10000,%edx
   15d13:	8b 41 20             	mov    0x20(%ecx),%eax
   15d16:	25 00 00 00 0f       	and    $0xf000000,%eax
   15d1b:	c1 e8 18             	shr    $0x18,%eax
   15d1e:	c7 04 85 40 e8 03 00 	movl   $0x340,0x3e840(,%eax,4)
   15d25:	40 03 00 00 
   15d29:	89 14 85 70 e9 03 00 	mov    %edx,0x3e970(,%eax,4)
   15d30:	89 91 40 03 00 00    	mov    %edx,0x340(%ecx)
   15d36:	8b 41 20             	mov    0x20(%ecx),%eax
   15d39:	25 00 00 00 0f       	and    $0xf000000,%eax
   15d3e:	c1 e8 18             	shr    $0x18,%eax
   15d41:	c7 04 85 40 e8 03 00 	movl   $0x320,0x3e840(,%eax,4)
   15d48:	20 03 00 00 
   15d4c:	c7 04 85 70 e9 03 00 	movl   $0x10000,0x3e970(,%eax,4)
   15d53:	00 00 01 00 
   15d57:	8b 41 20             	mov    0x20(%ecx),%eax
   15d5a:	c7 81 20 03 00 00 00 	movl   $0x10000,0x320(%ecx)
   15d61:	00 01 00 
   15d64:	25 00 00 00 0f       	and    $0xf000000,%eax
   15d69:	c1 e8 18             	shr    $0x18,%eax
   15d6c:	c7 04 85 40 e8 03 00 	movl   $0x350,0x3e840(,%eax,4)
   15d73:	50 03 00 00 
   15d77:	c7 04 85 70 e9 03 00 	movl   $0x10000,0x3e970(,%eax,4)
   15d7e:	00 00 01 00 
   15d82:	8b 41 20             	mov    0x20(%ecx),%eax
   15d85:	c7 81 50 03 00 00 00 	movl   $0x10000,0x350(%ecx)
   15d8c:	00 01 00 
   15d8f:	25 00 00 00 0f       	and    $0xf000000,%eax
   15d94:	c1 e8 18             	shr    $0x18,%eax
   15d97:	83 fb 02             	cmp    $0x2,%ebx
   15d9a:	c7 04 85 40 e8 03 00 	movl   $0x360,0x3e840(,%eax,4)
   15da1:	60 03 00 00 
   15da5:	c7 04 85 70 e9 03 00 	movl   $0x10000,0x3e970(,%eax,4)
   15dac:	00 00 01 00 
   15db0:	c7 81 60 03 00 00 00 	movl   $0x10000,0x360(%ecx)
   15db7:	00 01 00 
   15dba:	76 2b                	jbe    15de7 <_APICClear+0x257>
   15dbc:	8b 41 20             	mov    0x20(%ecx),%eax
   15dbf:	25 00 00 00 0f       	and    $0xf000000,%eax
   15dc4:	c1 e8 18             	shr    $0x18,%eax
   15dc7:	c7 04 85 40 e8 03 00 	movl   $0x370,0x3e840(,%eax,4)
   15dce:	70 03 00 00 
   15dd2:	c7 04 85 70 e9 03 00 	movl   $0x10000,0x3e970(,%eax,4)
   15dd9:	00 00 01 00 
   15ddd:	c7 81 70 03 00 00 00 	movl   $0x10000,0x370(%ecx)
   15de4:	00 01 00 
   15de7:	83 fb 03             	cmp    $0x3,%ebx
   15dea:	76 2b                	jbe    15e17 <_APICClear+0x287>
   15dec:	8b 41 20             	mov    0x20(%ecx),%eax
   15def:	25 00 00 00 0f       	and    $0xf000000,%eax
   15df4:	c1 e8 18             	shr    $0x18,%eax
   15df7:	c7 04 85 40 e8 03 00 	movl   $0x340,0x3e840(,%eax,4)
   15dfe:	40 03 00 00 
   15e02:	c7 04 85 70 e9 03 00 	movl   $0x10000,0x3e970(,%eax,4)
   15e09:	00 00 01 00 
   15e0d:	c7 81 40 03 00 00 00 	movl   $0x10000,0x340(%ecx)
   15e14:	00 01 00 
   15e17:	5b                   	pop    %ebx
   15e18:	5d                   	pop    %ebp
   15e19:	c3                   	ret    
   15e1a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   15e20:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   15e26:	e9 aa fd ff ff       	jmp    15bd5 <_APICClear+0x45>
   15e2b:	90                   	nop    
   15e2c:	8d 74 26 00          	lea    0x0(%esi),%esi

00015e30 <_APICDisable>:
   15e30:	55                   	push   %ebp
   15e31:	89 e5                	mov    %esp,%ebp
   15e33:	53                   	push   %ebx
   15e34:	e8 57 fd ff ff       	call   15b90 <_APICClear>
   15e39:	8b 1d 10 b0 01 00    	mov    0x1b010,%ebx
   15e3f:	8b 43 20             	mov    0x20(%ebx),%eax
   15e42:	b9 d0 e8 03 00       	mov    $0x3e8d0,%ecx
   15e47:	25 00 00 00 0f       	and    $0xf000000,%eax
   15e4c:	c1 e8 18             	shr    $0x18,%eax
   15e4f:	c7 04 81 00 00 00 00 	movl   $0x0,(%ecx,%eax,4)
   15e56:	c7 04 85 b0 e5 03 00 	movl   $0xf0,0x3e5b0(,%eax,4)
   15e5d:	f0 00 00 00 
   15e61:	8b 93 f0 00 00 00    	mov    0xf0(%ebx),%edx
   15e67:	89 14 81             	mov    %edx,(%ecx,%eax,4)
   15e6a:	80 e6 fe             	and    $0xfe,%dh
   15e6d:	8b 43 20             	mov    0x20(%ebx),%eax
   15e70:	25 00 00 00 0f       	and    $0xf000000,%eax
   15e75:	c1 e8 18             	shr    $0x18,%eax
   15e78:	c7 04 85 40 e8 03 00 	movl   $0xf0,0x3e840(,%eax,4)
   15e7f:	f0 00 00 00 
   15e83:	89 14 85 70 e9 03 00 	mov    %edx,0x3e970(,%eax,4)
   15e8a:	89 93 f0 00 00 00    	mov    %edx,0xf0(%ebx)
   15e90:	5b                   	pop    %ebx
   15e91:	5d                   	pop    %ebp
   15e92:	c3                   	ret    
   15e93:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   15e99:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00015ea0 <_EnableApicMode>:
   15ea0:	55                   	push   %ebp
   15ea1:	89 e5                	mov    %esp,%ebp
   15ea3:	50                   	push   %eax
   15ea4:	50                   	push   %eax
   15ea5:	e8 e6 fc ff ff       	call   15b90 <_APICClear>
   15eaa:	50                   	push   %eax
   15eab:	50                   	push   %eax
   15eac:	6a 70                	push   $0x70
   15eae:	6a 22                	push   $0x22
   15eb0:	e8 db ec ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   15eb5:	6a 01                	push   $0x1
   15eb7:	6a 23                	push   $0x23
   15eb9:	e8 d2 ec ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   15ebe:	c9                   	leave  
   15ebf:	c3                   	ret    

00015ec0 <_APICSendEOI>:
   15ec0:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
#endif

inline VOID APICSendEOI(VOID)
{
   15ec6:	55                   	push   %ebp
   15ec7:	89 e5                	mov    %esp,%ebp
   15ec9:	8b 42 20             	mov    0x20(%edx),%eax
   15ecc:	25 00 00 00 0f       	and    $0xf000000,%eax
   15ed1:	c1 e8 18             	shr    $0x18,%eax
   15ed4:	c7 04 85 40 e8 03 00 	movl   $0xb0,0x3e840(,%eax,4)
   15edb:	b0 00 00 00 
   15edf:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   15ee6:	00 00 00 00 
   15eea:	c7 82 b0 00 00 00 00 	movl   $0x0,0xb0(%edx)
   15ef1:	00 00 00 
   15ef4:	5d                   	pop    %ebp
   15ef5:	c3                   	ret    
   15ef6:	8d 76 00             	lea    0x0(%esi),%esi
   15ef9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00015f00 <_APICDumpBit>:
  // Send the EOI
  APICWrite(APIC_EOI, 0);
}

static VOID APICDumpBit(ULONG base)
{
   15f00:	55                   	push   %ebp
   15f01:	89 e5                	mov    %esp,%ebp
   15f03:	57                   	push   %edi
   15f04:	56                   	push   %esi
   15f05:	53                   	push   %ebx
   15f06:	83 ec 18             	sub    $0x18,%esp
   15f09:	89 c3                	mov    %eax,%ebx
   15f0b:	89 df                	mov    %ebx,%edi
	ULONG v, i, j;

	DbgPrint("0123456789abcdef0123456789abcdef\n");
   15f0d:	68 ac c2 01 00       	push   $0x1c2ac
   15f12:	e8 79 49 00 00       	call   1a890 <_DbgPrint>
	for (i = 0; i < 8; i++) 
   15f17:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   15f1e:	83 c4 10             	add    $0x10,%esp
   15f21:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
	{
		v = APICRead(base + i*0x10);
		for (j = 0; j < 32; j++) 
   15f27:	31 db                	xor    %ebx,%ebx
   15f29:	8b 42 20             	mov    0x20(%edx),%eax
   15f2c:	25 00 00 00 0f       	and    $0xf000000,%eax
   15f31:	c1 e8 18             	shr    $0x18,%eax
   15f34:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   15f3b:	00 00 00 00 
   15f3f:	89 3c 85 b0 e5 03 00 	mov    %edi,0x3e5b0(,%eax,4)
   15f46:	8b 34 3a             	mov    (%edx,%edi,1),%esi
   15f49:	89 34 85 d0 e8 03 00 	mov    %esi,0x3e8d0(,%eax,4)
   15f50:	eb 16                	jmp    15f68 <_APICDumpBit+0x68>
		{
			if (v & (1<<j))
				DbgPrint("1");
   15f52:	83 ec 0c             	sub    $0xc,%esp
   15f55:	43                   	inc    %ebx
   15f56:	68 ce c2 01 00       	push   $0x1c2ce
			else
				DbgPrint("0");
   15f5b:	e8 30 49 00 00       	call   1a890 <_DbgPrint>
   15f60:	83 c4 10             	add    $0x10,%esp
   15f63:	83 fb 1f             	cmp    $0x1f,%ebx
   15f66:	77 23                	ja     15f8b <_APICDumpBit+0x8b>
   15f68:	b8 01 00 00 00       	mov    $0x1,%eax
   15f6d:	88 d9                	mov    %bl,%cl
   15f6f:	d3 e0                	shl    %cl,%eax
   15f71:	85 c6                	test   %eax,%esi
   15f73:	75 dd                	jne    15f52 <_APICDumpBit+0x52>
   15f75:	83 ec 0c             	sub    $0xc,%esp
   15f78:	43                   	inc    %ebx
   15f79:	68 d0 c2 01 00       	push   $0x1c2d0
   15f7e:	e8 0d 49 00 00       	call   1a890 <_DbgPrint>
   15f83:	83 c4 10             	add    $0x10,%esp
   15f86:	83 fb 1f             	cmp    $0x1f,%ebx
   15f89:	76 dd                	jbe    15f68 <_APICDumpBit+0x68>
		}
		DbgPrint("\n");
   15f8b:	83 ec 0c             	sub    $0xc,%esp
   15f8e:	83 c7 10             	add    $0x10,%edi
   15f91:	68 d2 c2 01 00       	push   $0x1c2d2
   15f96:	e8 f5 48 00 00       	call   1a890 <_DbgPrint>
   15f9b:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   15f9e:	83 c4 10             	add    $0x10,%esp
   15fa1:	40                   	inc    %eax
   15fa2:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   15fa5:	83 7d f0 07          	cmpl   $0x7,0xfffffff0(%ebp)
   15fa9:	0f 86 72 ff ff ff    	jbe    15f21 <_APICDumpBit+0x21>
   15faf:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   15fb2:	5b                   	pop    %ebx
   15fb3:	5e                   	pop    %esi
   15fb4:	5f                   	pop    %edi
   15fb5:	5d                   	pop    %ebp
   15fb6:	c3                   	ret    
   15fb7:	89 f6                	mov    %esi,%esi
   15fb9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00015fc0 <_APICDump>:
	}
}


VOID APICDump(VOID)
/*
 * Dump the contents of the local APIC registers
 */
{
   15fc0:	55                   	push   %ebp
   15fc1:	89 e5                	mov    %esp,%ebp
   15fc3:	57                   	push   %edi
   15fc4:	56                   	push   %esi
   15fc5:	53                   	push   %ebx
   15fc6:	83 ec 14             	sub    $0x14,%esp
   15fc9:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   15fcf:	8b 51 20             	mov    0x20(%ecx),%edx
   15fd2:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   15fd8:	c1 ea 18             	shr    $0x18,%edx
   15fdb:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   15fe2:	00 00 00 00 
   15fe6:	c7 04 95 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%edx,4)
   15fed:	20 00 00 00 
   15ff1:	8b 41 20             	mov    0x20(%ecx),%eax
   15ff4:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   15ffb:	25 00 00 00 0f       	and    $0xf000000,%eax
   16000:	c1 e8 18             	shr    $0x18,%eax
  ULONG v, ver, maxlvt;
  ULONG r1, r2, w1, w2;
  ULONG CPU = ThisCPU();;



  r1 = lastregr[CPU];
  r2 = lastvalr[CPU];
   16003:	8b 14 85 d0 e8 03 00 	mov    0x3e8d0(,%eax,4),%edx
   1600a:	8b 3c 85 b0 e5 03 00 	mov    0x3e5b0(,%eax,4),%edi
   16011:	89 55 f0             	mov    %edx,0xfffffff0(%ebp)
  w1 = lastregw[CPU];
   16014:	8b 14 85 40 e8 03 00 	mov    0x3e840(,%eax,4),%edx
   1601b:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   1601e:	8b 51 20             	mov    0x20(%ecx),%edx
   16021:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
  w2 = lastvalw[CPU];
   16027:	8b 04 85 70 e9 03 00 	mov    0x3e970(,%eax,4),%eax
   1602e:	c1 ea 18             	shr    $0x18,%edx
   16031:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   16034:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   1603b:	00 00 00 00 
   1603f:	c7 04 95 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%edx,4)
   16046:	20 00 00 00 
   1604a:	8b 41 20             	mov    0x20(%ecx),%eax
   1604d:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   16054:	25 00 00 00 0f       	and    $0xf000000,%eax
   16059:	c1 e8 18             	shr    $0x18,%eax
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   1605c:	50                   	push   %eax
   1605d:	68 d4 c2 01 00       	push   $0x1c2d4
   16062:	e8 29 48 00 00       	call   1a890 <_DbgPrint>
   16067:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   1606d:	8b 42 20             	mov    0x20(%edx),%eax
   16070:	83 c4 0c             	add    $0xc,%esp
   16073:	25 00 00 00 0f       	and    $0xf000000,%eax
   16078:	c1 e8 18             	shr    $0x18,%eax
   1607b:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16082:	00 00 00 00 
   16086:	c7 04 85 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%eax,4)
   1608d:	20 00 00 00 
   16091:	8b 52 20             	mov    0x20(%edx),%edx
   16094:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)

  DbgPrint("\nPrinting local APIC contents on CPU(%d):\n", ThisCPU());
  v = APICRead(APIC_ID);
  DbgPrint("... ID     : %08x (%01x) ", v, GET_APIC_ID(v));
   1609b:	89 d0                	mov    %edx,%eax
   1609d:	25 00 00 00 0f       	and    $0xf000000,%eax
   160a2:	c1 e8 18             	shr    $0x18,%eax
   160a5:	50                   	push   %eax
   160a6:	52                   	push   %edx
   160a7:	68 ff c2 01 00       	push   $0x1c2ff
   160ac:	e8 df 47 00 00       	call   1a890 <_DbgPrint>
   160b1:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   160b7:	5b                   	pop    %ebx
   160b8:	5e                   	pop    %esi
   160b9:	8b 42 20             	mov    0x20(%edx),%eax
   160bc:	25 00 00 00 0f       	and    $0xf000000,%eax
   160c1:	c1 e8 18             	shr    $0x18,%eax
   160c4:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   160cb:	00 00 00 00 
   160cf:	c7 04 85 b0 e5 03 00 	movl   $0x30,0x3e5b0(,%eax,4)
   160d6:	30 00 00 00 
   160da:	8b 5a 30             	mov    0x30(%edx),%ebx
  v = APICRead(APIC_VER);
  DbgPrint("... VERSION: %08x\n", v);
   160dd:	53                   	push   %ebx
   160de:	89 1c 85 d0 e8 03 00 	mov    %ebx,0x3e8d0(,%eax,4)
   160e5:	68 19 c3 01 00       	push   $0x1c319
   160ea:	e8 a1 47 00 00       	call   1a890 <_DbgPrint>
  ver = GET_APIC_VERSION(v);
  maxlvt = APICGetMaxLVT();
   160ef:	e8 8c f9 ff ff       	call   15a80 <_APICGetMaxLVT>
   160f4:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   160fa:	89 c6                	mov    %eax,%esi
   160fc:	8b 42 20             	mov    0x20(%edx),%eax
   160ff:	25 00 00 00 0f       	and    $0xf000000,%eax
   16104:	83 c4 0c             	add    $0xc,%esp
   16107:	c1 e8 18             	shr    $0x18,%eax
   1610a:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   16110:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16117:	00 00 00 00 
   1611b:	c7 04 85 b0 e5 03 00 	movl   $0x80,0x3e5b0(,%eax,4)
   16122:	80 00 00 00 
   16126:	8b 92 80 00 00 00    	mov    0x80(%edx),%edx

  v = APICRead(APIC_TPR);
  DbgPrint("... TPR    : %08x (%02x)", v, v & ~0);
   1612c:	52                   	push   %edx
   1612d:	52                   	push   %edx
   1612e:	68 2c c3 01 00       	push   $0x1c32c
   16133:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   1613a:	e8 51 47 00 00       	call   1a890 <_DbgPrint>

  if (APIC_INTEGRATED(ver)) 
   1613f:	83 c4 10             	add    $0x10,%esp
   16142:	81 e3 f0 00 00 00    	and    $0xf0,%ebx
   16148:	0f 85 12 04 00 00    	jne    16560 <_APICDump+0x5a0>
   1614e:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16154:	8b 42 20             	mov    0x20(%edx),%eax
   16157:	25 00 00 00 0f       	and    $0xf000000,%eax
   1615c:	c1 e8 18             	shr    $0x18,%eax
   1615f:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16166:	00 00 00 00 
   1616a:	c7 04 85 b0 e5 03 00 	movl   $0xb0,0x3e5b0(,%eax,4)
   16171:	b0 00 00 00 
   16175:	8b 92 b0 00 00 00    	mov    0xb0(%edx),%edx
  {
     /* !82489DX */
     v = APICRead(APIC_APR);
     DbgPrint("... APR    : %08x (%02x)\n", v, v & ~0);
     v = APICRead(APIC_PPR);
     DbgPrint("... PPR    : %08x\n", v);
  }

  v = APICRead(APIC_EOI);
  DbgPrint("... EOI    : %08x  !  ", v);
   1617b:	51                   	push   %ecx
   1617c:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   16183:	51                   	push   %ecx
   16184:	52                   	push   %edx
   16185:	68 45 c3 01 00       	push   $0x1c345
   1618a:	e8 01 47 00 00       	call   1a890 <_DbgPrint>
   1618f:	58                   	pop    %eax
   16190:	5a                   	pop    %edx
   16191:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16197:	8b 42 20             	mov    0x20(%edx),%eax
   1619a:	25 00 00 00 0f       	and    $0xf000000,%eax
   1619f:	c1 e8 18             	shr    $0x18,%eax
   161a2:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   161a9:	00 00 00 00 
   161ad:	c7 04 85 b0 e5 03 00 	movl   $0xd0,0x3e5b0(,%eax,4)
   161b4:	d0 00 00 00 
   161b8:	8b 92 d0 00 00 00    	mov    0xd0(%edx),%edx
  v = APICRead(APIC_LDR);
  DbgPrint("... LDR    : %08x\n", v);
   161be:	52                   	push   %edx
   161bf:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   161c6:	68 5c c3 01 00       	push   $0x1c35c
   161cb:	e8 c0 46 00 00       	call   1a890 <_DbgPrint>
   161d0:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   161d6:	59                   	pop    %ecx
   161d7:	58                   	pop    %eax
   161d8:	8b 42 20             	mov    0x20(%edx),%eax
   161db:	25 00 00 00 0f       	and    $0xf000000,%eax
   161e0:	c1 e8 18             	shr    $0x18,%eax
   161e3:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   161ea:	00 00 00 00 
   161ee:	c7 04 85 b0 e5 03 00 	movl   $0xe0,0x3e5b0(,%eax,4)
   161f5:	e0 00 00 00 
   161f9:	8b 92 e0 00 00 00    	mov    0xe0(%edx),%edx
  v = APICRead(APIC_DFR);
  DbgPrint("... DFR    : %08x  !  ", v);
   161ff:	52                   	push   %edx
   16200:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   16207:	68 6f c3 01 00       	push   $0x1c36f
   1620c:	e8 7f 46 00 00       	call   1a890 <_DbgPrint>
   16211:	58                   	pop    %eax
   16212:	5a                   	pop    %edx
   16213:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16219:	8b 42 20             	mov    0x20(%edx),%eax
   1621c:	25 00 00 00 0f       	and    $0xf000000,%eax
   16221:	c1 e8 18             	shr    $0x18,%eax
   16224:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   1622b:	00 00 00 00 
   1622f:	c7 04 85 b0 e5 03 00 	movl   $0xf0,0x3e5b0(,%eax,4)
   16236:	f0 00 00 00 
   1623a:	8b 92 f0 00 00 00    	mov    0xf0(%edx),%edx
  v = APICRead(APIC_SIVR);
  DbgPrint("... SIVR   : %08x\n", v);
   16240:	52                   	push   %edx
   16241:	68 86 c3 01 00       	push   $0x1c386
   16246:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   1624d:	e8 3e 46 00 00       	call   1a890 <_DbgPrint>

  if (0)
   16252:	83 c4 10             	add    $0x10,%esp
  {
  	DbgPrint("... ISR field:\n");
  	APICDumpBit(APIC_ISR);
  	DbgPrint("... TMR field:\n");
  	APICDumpBit(APIC_TMR);
  	DbgPrint("... IRR field:\n");
  	APICDumpBit(APIC_IRR);
  }

  if (APIC_INTEGRATED(ver)) 
   16255:	84 db                	test   %bl,%bl
   16257:	74 4d                	je     162a6 <_APICDump+0x2e6>
  {
     /* !82489DX */
     if (maxlvt > 3)		
   16259:	83 fe 03             	cmp    $0x3,%esi
   1625c:	0f 87 c1 02 00 00    	ja     16523 <_APICDump+0x563>
   16262:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16268:	8b 42 20             	mov    0x20(%edx),%eax
   1626b:	25 00 00 00 0f       	and    $0xf000000,%eax
   16270:	c1 e8 18             	shr    $0x18,%eax
   16273:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   1627a:	00 00 00 00 
   1627e:	c7 04 85 b0 e5 03 00 	movl   $0x280,0x3e5b0(,%eax,4)
   16285:	80 02 00 00 
   16289:	8b 92 80 02 00 00    	mov    0x280(%edx),%edx
   1628f:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
     {
	/* Due to the Pentium erratum 3AP. */
	APICWrite(APIC_ESR, 0);
     }
     v = APICRead(APIC_ESR);
     DbgPrint("... ESR    : %08x\n", v);
   16296:	50                   	push   %eax
   16297:	50                   	push   %eax
   16298:	52                   	push   %edx
   16299:	68 99 c3 01 00       	push   $0x1c399
   1629e:	e8 ed 45 00 00       	call   1a890 <_DbgPrint>
   162a3:	83 c4 10             	add    $0x10,%esp
   162a6:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   162ac:	8b 42 20             	mov    0x20(%edx),%eax
   162af:	25 00 00 00 0f       	and    $0xf000000,%eax
   162b4:	c1 e8 18             	shr    $0x18,%eax
   162b7:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   162be:	00 00 00 00 
   162c2:	c7 04 85 b0 e5 03 00 	movl   $0x300,0x3e5b0(,%eax,4)
   162c9:	00 03 00 00 
   162cd:	8b 92 00 03 00 00    	mov    0x300(%edx),%edx
   162d3:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
  }
 
  v = APICRead(APIC_ICR0);
  DbgPrint("... ICR0   : %08x  !  ", v);
   162da:	50                   	push   %eax
   162db:	50                   	push   %eax
   162dc:	52                   	push   %edx
   162dd:	68 ac c3 01 00       	push   $0x1c3ac
   162e2:	e8 a9 45 00 00       	call   1a890 <_DbgPrint>
   162e7:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   162ed:	8b 42 20             	mov    0x20(%edx),%eax
   162f0:	59                   	pop    %ecx
   162f1:	25 00 00 00 0f       	and    $0xf000000,%eax
   162f6:	5b                   	pop    %ebx
   162f7:	c1 e8 18             	shr    $0x18,%eax
   162fa:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16301:	00 00 00 00 
   16305:	c7 04 85 b0 e5 03 00 	movl   $0x310,0x3e5b0(,%eax,4)
   1630c:	10 03 00 00 
   16310:	8b 92 10 03 00 00    	mov    0x310(%edx),%edx
  v = APICRead(APIC_ICR1);
  DbgPrint("... ICR1   : %08x  !  ", v);
   16316:	52                   	push   %edx
   16317:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   1631e:	68 c3 c3 01 00       	push   $0x1c3c3
   16323:	e8 68 45 00 00       	call   1a890 <_DbgPrint>
   16328:	58                   	pop    %eax
   16329:	5a                   	pop    %edx
   1632a:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16330:	8b 42 20             	mov    0x20(%edx),%eax
   16333:	25 00 00 00 0f       	and    $0xf000000,%eax
   16338:	c1 e8 18             	shr    $0x18,%eax
   1633b:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16342:	00 00 00 00 
   16346:	c7 04 85 b0 e5 03 00 	movl   $0x320,0x3e5b0(,%eax,4)
   1634d:	20 03 00 00 
   16351:	8b 92 20 03 00 00    	mov    0x320(%edx),%edx

  v = APICRead(APIC_LVTT);
  DbgPrint("... LVTT   : %08x\n", v);
   16357:	52                   	push   %edx
   16358:	68 da c3 01 00       	push   $0x1c3da
   1635d:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   16364:	e8 27 45 00 00       	call   1a890 <_DbgPrint>

  if (maxlvt > 3) 
   16369:	83 c4 10             	add    $0x10,%esp
   1636c:	83 fe 03             	cmp    $0x3,%esi
   1636f:	0f 87 cb 02 00 00    	ja     16640 <_APICDump+0x680>
   16375:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   1637b:	8b 42 20             	mov    0x20(%edx),%eax
   1637e:	25 00 00 00 0f       	and    $0xf000000,%eax
   16383:	c1 e8 18             	shr    $0x18,%eax
   16386:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   1638d:	00 00 00 00 
   16391:	c7 04 85 b0 e5 03 00 	movl   $0x350,0x3e5b0(,%eax,4)
   16398:	50 03 00 00 
   1639c:	8b 92 50 03 00 00    	mov    0x350(%edx),%edx
  {
     /* PC is LVT#4. */
     v = APICRead(APIC_LVTPC);
     DbgPrint("... LVTPC  : %08x  !  ", v);
  }
  v = APICRead(APIC_LINT0);
  DbgPrint("... LINT0  : %08x  !  ", v);
   163a2:	51                   	push   %ecx
   163a3:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   163aa:	51                   	push   %ecx
   163ab:	52                   	push   %edx
   163ac:	68 ed c3 01 00       	push   $0x1c3ed
   163b1:	e8 da 44 00 00       	call   1a890 <_DbgPrint>
   163b6:	58                   	pop    %eax
   163b7:	5a                   	pop    %edx
   163b8:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   163be:	8b 42 20             	mov    0x20(%edx),%eax
   163c1:	25 00 00 00 0f       	and    $0xf000000,%eax
   163c6:	c1 e8 18             	shr    $0x18,%eax
   163c9:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   163d0:	00 00 00 00 
   163d4:	c7 04 85 b0 e5 03 00 	movl   $0x360,0x3e5b0(,%eax,4)
   163db:	60 03 00 00 
   163df:	8b 92 60 03 00 00    	mov    0x360(%edx),%edx
  v = APICRead(APIC_LINT1);
  DbgPrint("... LINT1  : %08x\n", v);
   163e5:	52                   	push   %edx
   163e6:	68 04 c4 01 00       	push   $0x1c404
   163eb:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   163f2:	e8 99 44 00 00       	call   1a890 <_DbgPrint>

  if (maxlvt > 2) 
   163f7:	83 c4 10             	add    $0x10,%esp
   163fa:	83 fe 02             	cmp    $0x2,%esi
   163fd:	0f 87 ed 01 00 00    	ja     165f0 <_APICDump+0x630>
   16403:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16409:	8b 42 20             	mov    0x20(%edx),%eax
   1640c:	25 00 00 00 0f       	and    $0xf000000,%eax
   16411:	c1 e8 18             	shr    $0x18,%eax
   16414:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   1641b:	00 00 00 00 
   1641f:	c7 04 85 b0 e5 03 00 	movl   $0x380,0x3e5b0(,%eax,4)
   16426:	80 03 00 00 
   1642a:	8b 92 80 03 00 00    	mov    0x380(%edx),%edx
  {
     v = APICRead(APIC_LVT3);
     DbgPrint("... LVT3   : %08x\n", v);
  }

  v = APICRead(APIC_ICRT);
  DbgPrint("... ICRT   : %08x  !  ", v);
   16430:	51                   	push   %ecx
   16431:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   16438:	51                   	push   %ecx
   16439:	52                   	push   %edx
   1643a:	68 17 c4 01 00       	push   $0x1c417
   1643f:	e8 4c 44 00 00       	call   1a890 <_DbgPrint>
   16444:	58                   	pop    %eax
   16445:	5a                   	pop    %edx
   16446:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   1644c:	8b 42 20             	mov    0x20(%edx),%eax
   1644f:	25 00 00 00 0f       	and    $0xf000000,%eax
   16454:	c1 e8 18             	shr    $0x18,%eax
   16457:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   1645e:	00 00 00 00 
   16462:	c7 04 85 b0 e5 03 00 	movl   $0x390,0x3e5b0(,%eax,4)
   16469:	90 03 00 00 
   1646d:	8b 92 90 03 00 00    	mov    0x390(%edx),%edx
  v = APICRead(APIC_CCRT);
  DbgPrint("... CCCT   : %08x  !  ", v);
   16473:	52                   	push   %edx
   16474:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   1647b:	68 2e c4 01 00       	push   $0x1c42e
   16480:	e8 0b 44 00 00       	call   1a890 <_DbgPrint>
   16485:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   1648b:	5e                   	pop    %esi
   1648c:	58                   	pop    %eax
   1648d:	8b 42 20             	mov    0x20(%edx),%eax
   16490:	25 00 00 00 0f       	and    $0xf000000,%eax
   16495:	c1 e8 18             	shr    $0x18,%eax
   16498:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   1649f:	00 00 00 00 
   164a3:	c7 04 85 b0 e5 03 00 	movl   $0x3e0,0x3e5b0(,%eax,4)
   164aa:	e0 03 00 00 
   164ae:	8b 92 e0 03 00 00    	mov    0x3e0(%edx),%edx
  v = APICRead(APIC_TDCR);
  DbgPrint("... TDCR   : %08x\n", v);
   164b4:	52                   	push   %edx
   164b5:	68 45 c4 01 00       	push   $0x1c445
   164ba:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   164c1:	e8 ca 43 00 00       	call   1a890 <_DbgPrint>
  DbgPrint("\n");
   164c6:	c7 04 24 d2 c2 01 00 	movl   $0x1c2d2,(%esp)
   164cd:	e8 be 43 00 00       	call   1a890 <_DbgPrint>
  DbgPrint("Last register read (offset): 0x%08X\n", r1);
   164d2:	59                   	pop    %ecx
   164d3:	5b                   	pop    %ebx
   164d4:	57                   	push   %edi
   164d5:	68 58 c4 01 00       	push   $0x1c458
   164da:	e8 b1 43 00 00       	call   1a890 <_DbgPrint>
  DbgPrint("Last register read (value): 0x%08X\n", r2);
   164df:	8b 7d f0             	mov    0xfffffff0(%ebp),%edi
   164e2:	58                   	pop    %eax
   164e3:	5a                   	pop    %edx
   164e4:	57                   	push   %edi
   164e5:	68 80 c4 01 00       	push   $0x1c480
   164ea:	e8 a1 43 00 00       	call   1a890 <_DbgPrint>
  DbgPrint("Last register written (offset): 0x%08X\n", w1);
   164ef:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   164f2:	5b                   	pop    %ebx
   164f3:	5e                   	pop    %esi
   164f4:	51                   	push   %ecx
   164f5:	68 a4 c4 01 00       	push   $0x1c4a4
   164fa:	e8 91 43 00 00       	call   1a890 <_DbgPrint>
  DbgPrint("Last register written (value): 0x%08X\n", w2);
   164ff:	58                   	pop    %eax
   16500:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   16503:	5a                   	pop    %edx
   16504:	50                   	push   %eax
   16505:	68 cc c4 01 00       	push   $0x1c4cc
   1650a:	e8 81 43 00 00       	call   1a890 <_DbgPrint>
  DbgPrint("\n");
   1650f:	c7 04 24 d2 c2 01 00 	movl   $0x1c2d2,(%esp)
   16516:	e8 75 43 00 00       	call   1a890 <_DbgPrint>
   1651b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1651e:	5b                   	pop    %ebx
   1651f:	5e                   	pop    %esi
   16520:	5f                   	pop    %edi
   16521:	5d                   	pop    %ebp
   16522:	c3                   	ret    
   16523:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16529:	8b 42 20             	mov    0x20(%edx),%eax
   1652c:	25 00 00 00 0f       	and    $0xf000000,%eax
   16531:	c1 e8 18             	shr    $0x18,%eax
   16534:	c7 04 85 40 e8 03 00 	movl   $0x280,0x3e840(,%eax,4)
   1653b:	80 02 00 00 
   1653f:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   16546:	00 00 00 00 
   1654a:	c7 82 80 02 00 00 00 	movl   $0x0,0x280(%edx)
   16551:	00 00 00 
   16554:	e9 0f fd ff ff       	jmp    16268 <_APICDump+0x2a8>
   16559:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   16560:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16566:	8b 42 20             	mov    0x20(%edx),%eax
   16569:	25 00 00 00 0f       	and    $0xf000000,%eax
   1656e:	c1 e8 18             	shr    $0x18,%eax
   16571:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16578:	00 00 00 00 
   1657c:	c7 04 85 b0 e5 03 00 	movl   $0x90,0x3e5b0(,%eax,4)
   16583:	90 00 00 00 
   16587:	8b 92 90 00 00 00    	mov    0x90(%edx),%edx
   1658d:	51                   	push   %ecx
   1658e:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   16595:	52                   	push   %edx
   16596:	52                   	push   %edx
   16597:	68 f3 c4 01 00       	push   $0x1c4f3
   1659c:	e8 ef 42 00 00       	call   1a890 <_DbgPrint>
   165a1:	58                   	pop    %eax
   165a2:	5a                   	pop    %edx
   165a3:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   165a9:	8b 42 20             	mov    0x20(%edx),%eax
   165ac:	25 00 00 00 0f       	and    $0xf000000,%eax
   165b1:	c1 e8 18             	shr    $0x18,%eax
   165b4:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   165bb:	00 00 00 00 
   165bf:	c7 04 85 b0 e5 03 00 	movl   $0xa0,0x3e5b0(,%eax,4)
   165c6:	a0 00 00 00 
   165ca:	8b 92 a0 00 00 00    	mov    0xa0(%edx),%edx
   165d0:	52                   	push   %edx
   165d1:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   165d8:	68 0d c5 01 00       	push   $0x1c50d
   165dd:	e8 ae 42 00 00       	call   1a890 <_DbgPrint>
   165e2:	83 c4 10             	add    $0x10,%esp
   165e5:	e9 64 fb ff ff       	jmp    1614e <_APICDump+0x18e>
   165ea:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   165f0:	a1 10 b0 01 00       	mov    0x1b010,%eax
   165f5:	8b 50 20             	mov    0x20(%eax),%edx
   165f8:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   165fe:	c1 ea 18             	shr    $0x18,%edx
   16601:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   16608:	00 00 00 00 
   1660c:	c7 04 95 b0 e5 03 00 	movl   $0x370,0x3e5b0(,%edx,4)
   16613:	70 03 00 00 
   16617:	8b 80 70 03 00 00    	mov    0x370(%eax),%eax
   1661d:	53                   	push   %ebx
   1661e:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   16625:	53                   	push   %ebx
   16626:	50                   	push   %eax
   16627:	68 20 c5 01 00       	push   $0x1c520
   1662c:	e8 5f 42 00 00       	call   1a890 <_DbgPrint>
   16631:	83 c4 10             	add    $0x10,%esp
   16634:	e9 ca fd ff ff       	jmp    16403 <_APICDump+0x443>
   16639:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   16640:	a1 10 b0 01 00       	mov    0x1b010,%eax
   16645:	8b 50 20             	mov    0x20(%eax),%edx
   16648:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   1664e:	c1 ea 18             	shr    $0x18,%edx
   16651:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   16658:	00 00 00 00 
   1665c:	c7 04 95 b0 e5 03 00 	movl   $0x340,0x3e5b0(,%edx,4)
   16663:	40 03 00 00 
   16667:	8b 80 40 03 00 00    	mov    0x340(%eax),%eax
   1666d:	53                   	push   %ebx
   1666e:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   16675:	53                   	push   %ebx
   16676:	50                   	push   %eax
   16677:	68 33 c5 01 00       	push   $0x1c533
   1667c:	e8 0f 42 00 00       	call   1a890 <_DbgPrint>
   16681:	83 c4 10             	add    $0x10,%esp
   16684:	e9 ec fc ff ff       	jmp    16375 <_APICDump+0x3b5>
   16689:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00016690 <_VerifyLocalAPIC>:
}

BOOLEAN VerifyLocalAPIC(VOID)
{
   16690:	55                   	push   %ebp
   16691:	89 e5                	mov    %esp,%ebp
   16693:	57                   	push   %edi
   16694:	56                   	push   %esi
   16695:	53                   	push   %ebx
   16696:	83 ec 10             	sub    $0x10,%esp
   16699:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   1669f:	8b 42 20             	mov    0x20(%edx),%eax
   166a2:	25 00 00 00 0f       	and    $0xf000000,%eax
   166a7:	c1 e8 18             	shr    $0x18,%eax
   166aa:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   166b1:	00 00 00 00 
   166b5:	c7 04 85 b0 e5 03 00 	movl   $0x30,0x3e5b0(,%eax,4)
   166bc:	30 00 00 00 
   166c0:	8b 5a 30             	mov    0x30(%edx),%ebx
   UINT reg0, reg1;
   /* The version register is read-only in a real APIC */
   reg0 = APICRead(APIC_VER);
   DPRINT1("Getting VERSION: %x\n", reg0);
   166c3:	68 aa 01 00 00       	push   $0x1aa
   166c8:	89 1c 85 d0 e8 03 00 	mov    %ebx,0x3e8d0(,%eax,4)
   166cf:	68 4a c5 01 00       	push   $0x1c54a
   166d4:	68 51 c5 01 00       	push   $0x1c551
   166d9:	e8 b2 41 00 00       	call   1a890 <_DbgPrint>
   166de:	58                   	pop    %eax
   166df:	5a                   	pop    %edx
   166e0:	53                   	push   %ebx
   166e1:	68 5a c5 01 00       	push   $0x1c55a
   166e6:	e8 a5 41 00 00       	call   1a890 <_DbgPrint>
   166eb:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   166f1:	8b 42 20             	mov    0x20(%edx),%eax
   166f4:	89 d9                	mov    %ebx,%ecx
   166f6:	25 00 00 00 0f       	and    $0xf000000,%eax
   166fb:	81 f1 ff 00 ff 00    	xor    $0xff00ff,%ecx
   16701:	c1 e8 18             	shr    $0x18,%eax
   16704:	83 c4 0c             	add    $0xc,%esp
   16707:	89 0c 85 70 e9 03 00 	mov    %ecx,0x3e970(,%eax,4)
   1670e:	c7 04 85 40 e8 03 00 	movl   $0x30,0x3e840(,%eax,4)
   16715:	30 00 00 00 
   16719:	8b 42 20             	mov    0x20(%edx),%eax
   1671c:	89 4a 30             	mov    %ecx,0x30(%edx)
   1671f:	25 00 00 00 0f       	and    $0xf000000,%eax
   16724:	c1 e8 18             	shr    $0x18,%eax
   16727:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   1672e:	00 00 00 00 
   16732:	c7 04 85 b0 e5 03 00 	movl   $0x30,0x3e5b0(,%eax,4)
   16739:	30 00 00 00 
   1673d:	8b 52 30             	mov    0x30(%edx),%edx
   APICWrite(APIC_VER, reg0 ^ APIC_VER_MASK);
   reg1 = APICRead(APIC_VER);
   DPRINT1("Getting VERSION: %x\n", reg1);
   16740:	68 ad 01 00 00       	push   $0x1ad
   16745:	89 d6                	mov    %edx,%esi
   16747:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   1674e:	68 4a c5 01 00       	push   $0x1c54a
   16753:	68 51 c5 01 00       	push   $0x1c551
   16758:	e8 33 41 00 00       	call   1a890 <_DbgPrint>
   1675d:	5f                   	pop    %edi
   1675e:	58                   	pop    %eax
   1675f:	56                   	push   %esi
   16760:	68 5a c5 01 00       	push   $0x1c55a
   16765:	e8 26 41 00 00       	call   1a890 <_DbgPrint>
   1676a:	83 c4 10             	add    $0x10,%esp

   /*
    * The two version reads above should print the same
    * numbers.  If the second one is different, then we
    * poke at a non-APIC.
    */

   if (reg1 != reg0)
   {
      return FALSE;
   1676d:	31 d2                	xor    %edx,%edx
   1676f:	39 de                	cmp    %ebx,%esi
   16771:	74 0d                	je     16780 <_VerifyLocalAPIC+0xf0>
   }

   /*
    * Check if the version looks reasonably.
    */
   reg1 = GET_APIC_VERSION(reg0);
   if (reg1 == 0x00 || reg1 == 0xff)
   {
      return FALSE;
   }
   reg1 = APICGetMaxLVT();
   if (reg1 < 0x02 || reg1 == 0xff)
   {
      return FALSE;
   }

   /*
    * The ID register is read/write in a real APIC.
    */
   reg0 = APICRead(APIC_ID);
   DPRINT1("Getting ID: %x\n", reg0);
   APICWrite(APIC_ID, reg0 ^ APIC_ID_MASK);
   reg1 = APICRead(APIC_ID);
   DPRINT1("Getting ID: %x\n", reg1);
   APICWrite(APIC_ID, reg0);
   if (reg1 != (reg0 ^ APIC_ID_MASK))
   {
      return FALSE;
   }

   ULONG l, h;
   Ki386Rdmsr(0x1b /*MSR_IA32_APICBASE*/, l, h);

   if (!(l & /*MSR_IA32_APICBASE_ENABLE*/(1<<11))) 
   {
      DPRINT1("Local APIC disabled by BIOS -- reenabling.\n");
      l &= ~/*MSR_IA32_APICBASE_BASE*/(1<<11);
      l |= /*MSR_IA32_APICBASE_ENABLE | APIC_DEFAULT_PHYS_BASE*/(1<<11)|0xfee00000;
      Ki386Wrmsr(0x1b/*MSR_IA32_APICBASE*/, l, h);
   }

    

   return TRUE;
}
   16773:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   16776:	89 d0                	mov    %edx,%eax
   16778:	5b                   	pop    %ebx
   16779:	5e                   	pop    %esi
   1677a:	5f                   	pop    %edi
   1677b:	5d                   	pop    %ebp
   1677c:	c3                   	ret    
   1677d:	8d 76 00             	lea    0x0(%esi),%esi
   16780:	81 e6 ff 00 00 00    	and    $0xff,%esi
   16786:	0f 94 c2             	sete   %dl
   16789:	81 fe ff 00 00 00    	cmp    $0xff,%esi
   1678f:	0f 94 c0             	sete   %al
   16792:	09 d0                	or     %edx,%eax
   16794:	31 d2                	xor    %edx,%edx
   16796:	a8 01                	test   $0x1,%al
   16798:	75 d9                	jne    16773 <_VerifyLocalAPIC+0xe3>
   1679a:	e8 e1 f2 ff ff       	call   15a80 <_APICGetMaxLVT>
   1679f:	83 f8 01             	cmp    $0x1,%eax
   167a2:	0f 96 c2             	setbe  %dl
   167a5:	3d ff 00 00 00       	cmp    $0xff,%eax
   167aa:	0f 94 c0             	sete   %al
   167ad:	09 d0                	or     %edx,%eax
   167af:	31 d2                	xor    %edx,%edx
   167b1:	a8 01                	test   $0x1,%al
   167b3:	75 be                	jne    16773 <_VerifyLocalAPIC+0xe3>
   167b5:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   167bb:	8b 42 20             	mov    0x20(%edx),%eax
   167be:	25 00 00 00 0f       	and    $0xf000000,%eax
   167c3:	c1 e8 18             	shr    $0x18,%eax
   167c6:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   167cd:	00 00 00 00 
   167d1:	c7 04 85 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%eax,4)
   167d8:	20 00 00 00 
   167dc:	8b 7a 20             	mov    0x20(%edx),%edi
   167df:	56                   	push   %esi
   167e0:	89 3c 85 d0 e8 03 00 	mov    %edi,0x3e8d0(,%eax,4)
   167e7:	68 cc 01 00 00       	push   $0x1cc
   167ec:	68 4a c5 01 00       	push   $0x1c54a
   167f1:	68 51 c5 01 00       	push   $0x1c551
   167f6:	e8 95 40 00 00       	call   1a890 <_DbgPrint>
   167fb:	59                   	pop    %ecx
   167fc:	5b                   	pop    %ebx
   167fd:	89 fe                	mov    %edi,%esi
   167ff:	57                   	push   %edi
   16800:	68 6f c5 01 00       	push   $0x1c56f
   16805:	e8 86 40 00 00       	call   1a890 <_DbgPrint>
   1680a:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16810:	8b 42 20             	mov    0x20(%edx),%eax
   16813:	81 f6 00 00 00 0f    	xor    $0xf000000,%esi
   16819:	25 00 00 00 0f       	and    $0xf000000,%eax
   1681e:	83 c4 0c             	add    $0xc,%esp
   16821:	c1 e8 18             	shr    $0x18,%eax
   16824:	c7 04 85 40 e8 03 00 	movl   $0x20,0x3e840(,%eax,4)
   1682b:	20 00 00 00 
   1682f:	89 34 85 70 e9 03 00 	mov    %esi,0x3e970(,%eax,4)
   16836:	89 f0                	mov    %esi,%eax
   16838:	89 72 20             	mov    %esi,0x20(%edx)
   1683b:	25 00 00 00 0f       	and    $0xf000000,%eax
   16840:	c1 e8 18             	shr    $0x18,%eax
   16843:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   1684a:	00 00 00 00 
   1684e:	c7 04 85 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%eax,4)
   16855:	20 00 00 00 
   16859:	8b 5a 20             	mov    0x20(%edx),%ebx
   1685c:	68 cf 01 00 00       	push   $0x1cf
   16861:	89 1c 85 d0 e8 03 00 	mov    %ebx,0x3e8d0(,%eax,4)
   16868:	68 4a c5 01 00       	push   $0x1c54a
   1686d:	68 51 c5 01 00       	push   $0x1c551
   16872:	e8 19 40 00 00       	call   1a890 <_DbgPrint>
   16877:	58                   	pop    %eax
   16878:	5a                   	pop    %edx
   16879:	53                   	push   %ebx
   1687a:	68 6f c5 01 00       	push   $0x1c56f
   1687f:	e8 0c 40 00 00       	call   1a890 <_DbgPrint>
   16884:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   1688a:	8b 42 20             	mov    0x20(%edx),%eax
   1688d:	83 c4 10             	add    $0x10,%esp
   16890:	25 00 00 00 0f       	and    $0xf000000,%eax
   16895:	c1 e8 18             	shr    $0x18,%eax
   16898:	c7 04 85 40 e8 03 00 	movl   $0x20,0x3e840(,%eax,4)
   1689f:	20 00 00 00 
   168a3:	89 3c 85 70 e9 03 00 	mov    %edi,0x3e970(,%eax,4)
   168aa:	89 7a 20             	mov    %edi,0x20(%edx)
   168ad:	31 d2                	xor    %edx,%edx
   168af:	39 de                	cmp    %ebx,%esi
   168b1:	0f 85 bc fe ff ff    	jne    16773 <_VerifyLocalAPIC+0xe3>
   168b7:	be 1b 00 00 00       	mov    $0x1b,%esi
   168bc:	89 f1                	mov    %esi,%ecx
   168be:	0f 32                	rdmsr  
   168c0:	89 55 f0             	mov    %edx,0xfffffff0(%ebp)
   168c3:	89 c3                	mov    %eax,%ebx
   168c5:	f6 c4 08             	test   $0x8,%ah
   168c8:	74 0a                	je     168d4 <_VerifyLocalAPIC+0x244>
   168ca:	ba 01 00 00 00       	mov    $0x1,%edx
   168cf:	e9 9f fe ff ff       	jmp    16773 <_VerifyLocalAPIC+0xe3>
   168d4:	81 cb 00 08 e0 fe    	or     $0xfee00800,%ebx
   168da:	57                   	push   %edi
   168db:	68 db 01 00 00       	push   $0x1db
   168e0:	68 4a c5 01 00       	push   $0x1c54a
   168e5:	68 51 c5 01 00       	push   $0x1c551
   168ea:	e8 a1 3f 00 00       	call   1a890 <_DbgPrint>
   168ef:	c7 04 24 80 c5 01 00 	movl   $0x1c580,(%esp)
   168f6:	e8 95 3f 00 00       	call   1a890 <_DbgPrint>
   168fb:	83 c4 10             	add    $0x10,%esp
   168fe:	89 f1                	mov    %esi,%ecx
   16900:	89 d8                	mov    %ebx,%eax
   16902:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   16905:	0f 30                	wrmsr  
   16907:	ba 01 00 00 00       	mov    $0x1,%edx
   1690c:	e9 62 fe ff ff       	jmp    16773 <_VerifyLocalAPIC+0xe3>
   16911:	eb 0d                	jmp    16920 <_APICSendIPI>
   16913:	90                   	nop    
   16914:	90                   	nop    
   16915:	90                   	nop    
   16916:	90                   	nop    
   16917:	90                   	nop    
   16918:	90                   	nop    
   16919:	90                   	nop    
   1691a:	90                   	nop    
   1691b:	90                   	nop    
   1691c:	90                   	nop    
   1691d:	90                   	nop    
   1691e:	90                   	nop    
   1691f:	90                   	nop    

00016920 <_APICSendIPI>:

#ifdef CONFIG_SMP
VOID APICSendIPI(ULONG Target, ULONG Mode)
{
   16920:	55                   	push   %ebp
   16921:	89 e5                	mov    %esp,%ebp
   16923:	57                   	push   %edi
   16924:	56                   	push   %esi
   16925:	53                   	push   %ebx
   16926:	83 ec 0c             	sub    $0xc,%esp
   16929:	8b 7d 08             	mov    0x8(%ebp),%edi
   1692c:	8b 75 0c             	mov    0xc(%ebp),%esi
   ULONG tmp, i, flags;

   /* save flags and disable interrupts */
   Ki386SaveFlags(flags);
   1692f:	9c                   	pushf  
   16930:	8f 45 f0             	popl   0xfffffff0(%ebp)
   Ki386DisableInterrupts();
   16933:	fa                   	cli    

   /* Wait up to 100ms for the APIC to become ready */
   for (i = 0; i < 10000; i++) 
   16934:	31 db                	xor    %ebx,%ebx
   16936:	eb 16                	jmp    1694e <_APICSendIPI+0x2e>
   {
      tmp = APICRead(APIC_ICR0);
      /* Check Delivery Status */
      if ((tmp & APIC_ICR0_DS) == 0)
         break;
      KeStallExecutionProcessor(10);
   16938:	83 ec 0c             	sub    $0xc,%esp
   1693b:	43                   	inc    %ebx
   1693c:	6a 0a                	push   $0xa
   1693e:	e8 dd ec ff ff       	call   15620 <_KeStallExecutionProcessor@4>
   16943:	83 c4 0c             	add    $0xc,%esp
   16946:	81 fb 0f 27 00 00    	cmp    $0x270f,%ebx
   1694c:	77 39                	ja     16987 <_APICSendIPI+0x67>
   1694e:	a1 10 b0 01 00       	mov    0x1b010,%eax
   16953:	8b 50 20             	mov    0x20(%eax),%edx
   16956:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   1695c:	c1 ea 18             	shr    $0x18,%edx
   1695f:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   16966:	00 00 00 00 
   1696a:	c7 04 95 b0 e5 03 00 	movl   $0x300,0x3e5b0(,%edx,4)
   16971:	00 03 00 00 
   16975:	8b 80 00 03 00 00    	mov    0x300(%eax),%eax
   1697b:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   16982:	f6 c4 10             	test   $0x10,%ah
   16985:	75 b1                	jne    16938 <_APICSendIPI+0x18>
   }

   if (i == 10000) 
   16987:	81 fb 10 27 00 00    	cmp    $0x2710,%ebx
   1698d:	0f 84 fa 00 00 00    	je     16a8d <_APICSendIPI+0x16d>
   16993:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   16999:	89 fa                	mov    %edi,%edx
   1699b:	c1 e2 18             	shl    $0x18,%edx
   1699e:	8b 41 20             	mov    0x20(%ecx),%eax
   169a1:	25 00 00 00 0f       	and    $0xf000000,%eax
   169a6:	c1 e8 18             	shr    $0x18,%eax
   {
      DPRINT1("CPU(%d) Previous IPI was not delivered after 100ms.\n", ThisCPU());
   }

   /* Setup the APIC to deliver the IPI */
   DPRINT("%08x %x\n", SET_APIC_DEST_FIELD(Target), Target);
   APICWrite(APIC_ICR1, SET_APIC_DEST_FIELD(Target));

   if (Target == APIC_TARGET_SELF) 
   169a9:	81 ff 00 01 00 00    	cmp    $0x100,%edi
   169af:	c7 04 85 40 e8 03 00 	movl   $0x310,0x3e840(,%eax,4)
   169b6:	10 03 00 00 
   169ba:	89 14 85 70 e9 03 00 	mov    %edx,0x3e970(,%eax,4)
   169c1:	89 91 10 03 00 00    	mov    %edx,0x310(%ecx)
   169c7:	0f 84 aa 00 00 00    	je     16a77 <_APICSendIPI+0x157>
   {
      Mode |= APIC_ICR0_DESTS_SELF;
   } 
   else if (Target == APIC_TARGET_ALL) 
   169cd:	81 ff 00 02 00 00    	cmp    $0x200,%edi
   169d3:	0f 84 a9 00 00 00    	je     16a82 <_APICSendIPI+0x162>
   {
      Mode |= APIC_ICR0_DESTS_ALL;
   } 
   else if (Target == APIC_TARGET_ALL_BUT_SELF) 
   169d9:	81 ff 00 03 00 00    	cmp    $0x300,%edi
   169df:	0f 84 6e 01 00 00    	je     16b53 <_APICSendIPI+0x233>
   169e5:	8b 41 20             	mov    0x20(%ecx),%eax
   {
      Mode |= APIC_ICR0_DESTS_ALL_BUT_SELF;
   } 
   else 
   {
      Mode |= APIC_ICR0_DESTS_FIELD;
   }

   /* Now, fire off the IPI */
   APICWrite(APIC_ICR0, Mode);

   /* Wait up to 100ms for the APIC to become ready */
   for (i = 0; i < 10000; i++) 
   169e8:	31 db                	xor    %ebx,%ebx
   169ea:	25 00 00 00 0f       	and    $0xf000000,%eax
   169ef:	c1 e8 18             	shr    $0x18,%eax
   169f2:	c7 04 85 40 e8 03 00 	movl   $0x300,0x3e840(,%eax,4)
   169f9:	00 03 00 00 
   169fd:	89 34 85 70 e9 03 00 	mov    %esi,0x3e970(,%eax,4)
   16a04:	89 b1 00 03 00 00    	mov    %esi,0x300(%ecx)
   16a0a:	eb 20                	jmp    16a2c <_APICSendIPI+0x10c>
   16a0c:	8d 74 26 00          	lea    0x0(%esi),%esi
   {
      tmp = APICRead(APIC_ICR0);
      /* Check Delivery Status */
      if ((tmp & APIC_ICR0_DS) == 0)
         break;
      KeStallExecutionProcessor(10);
   16a10:	83 ec 0c             	sub    $0xc,%esp
   16a13:	43                   	inc    %ebx
   16a14:	6a 0a                	push   $0xa
   16a16:	e8 05 ec ff ff       	call   15620 <_KeStallExecutionProcessor@4>
   16a1b:	83 c4 0c             	add    $0xc,%esp
   16a1e:	81 fb 0f 27 00 00    	cmp    $0x270f,%ebx
   16a24:	77 39                	ja     16a5f <_APICSendIPI+0x13f>
   16a26:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   16a2c:	8b 41 20             	mov    0x20(%ecx),%eax
   16a2f:	25 00 00 00 0f       	and    $0xf000000,%eax
   16a34:	c1 e8 18             	shr    $0x18,%eax
   16a37:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16a3e:	00 00 00 00 
   16a42:	c7 04 85 b0 e5 03 00 	movl   $0x300,0x3e5b0(,%eax,4)
   16a49:	00 03 00 00 
   16a4d:	8b 91 00 03 00 00    	mov    0x300(%ecx),%edx
   16a53:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   16a5a:	80 e6 10             	and    $0x10,%dh
   16a5d:	75 b1                	jne    16a10 <_APICSendIPI+0xf0>
   }

   if (i == 10000) 
   16a5f:	81 fb 10 27 00 00    	cmp    $0x2710,%ebx
   16a65:	0f 84 85 00 00 00    	je     16af0 <_APICSendIPI+0x1d0>
   {
      DPRINT1("CPU(%d) Current IPI was not delivered after 100ms.\n", ThisCPU());
   }
   Ki386RestoreFlags(flags);
   16a6b:	ff 75 f0             	pushl  0xfffffff0(%ebp)
   16a6e:	9d                   	popf   
   16a6f:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   16a72:	5b                   	pop    %ebx
   16a73:	5e                   	pop    %esi
   16a74:	5f                   	pop    %edi
   16a75:	5d                   	pop    %ebp
   16a76:	c3                   	ret    
   16a77:	81 ce 00 00 04 00    	or     $0x40000,%esi
   16a7d:	e9 63 ff ff ff       	jmp    169e5 <_APICSendIPI+0xc5>
   16a82:	81 ce 00 00 08 00    	or     $0x80000,%esi
   16a88:	e9 58 ff ff ff       	jmp    169e5 <_APICSendIPI+0xc5>
   16a8d:	51                   	push   %ecx
   16a8e:	68 fb 01 00 00       	push   $0x1fb
   16a93:	68 4a c5 01 00       	push   $0x1c54a
   16a98:	68 51 c5 01 00       	push   $0x1c551
   16a9d:	e8 ee 3d 00 00       	call   1a890 <_DbgPrint>
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   16aa2:	58                   	pop    %eax
   16aa3:	a1 10 b0 01 00       	mov    0x1b010,%eax
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   16aa8:	5a                   	pop    %edx
   16aa9:	8b 50 20             	mov    0x20(%eax),%edx
   16aac:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   16ab2:	c1 ea 18             	shr    $0x18,%edx
   16ab5:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   16abc:	00 00 00 00 
   16ac0:	c7 04 95 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%edx,4)
   16ac7:	20 00 00 00 
   16acb:	8b 40 20             	mov    0x20(%eax),%eax
   16ace:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   16ad5:	25 00 00 00 0f       	and    $0xf000000,%eax
   16ada:	c1 e8 18             	shr    $0x18,%eax
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   16add:	50                   	push   %eax
   16ade:	68 ac c5 01 00       	push   $0x1c5ac
   16ae3:	e8 a8 3d 00 00       	call   1a890 <_DbgPrint>
   16ae8:	83 c4 10             	add    $0x10,%esp
   16aeb:	e9 a3 fe ff ff       	jmp    16993 <_APICSendIPI+0x73>
   16af0:	56                   	push   %esi
   16af1:	68 22 02 00 00       	push   $0x222
   16af6:	68 4a c5 01 00       	push   $0x1c54a
   16afb:	68 51 c5 01 00       	push   $0x1c551
   16b00:	e8 8b 3d 00 00       	call   1a890 <_DbgPrint>
   16b05:	a1 10 b0 01 00       	mov    0x1b010,%eax
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   16b0a:	59                   	pop    %ecx
   16b0b:	5b                   	pop    %ebx
   16b0c:	8b 50 20             	mov    0x20(%eax),%edx
   16b0f:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   16b15:	c1 ea 18             	shr    $0x18,%edx
   16b18:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   16b1f:	00 00 00 00 
   16b23:	c7 04 95 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%edx,4)
   16b2a:	20 00 00 00 
   16b2e:	8b 40 20             	mov    0x20(%eax),%eax
   16b31:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   16b38:	25 00 00 00 0f       	and    $0xf000000,%eax
   16b3d:	c1 e8 18             	shr    $0x18,%eax
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   16b40:	50                   	push   %eax
   16b41:	68 e4 c5 01 00       	push   $0x1c5e4
   16b46:	e8 45 3d 00 00       	call   1a890 <_DbgPrint>
   16b4b:	83 c4 10             	add    $0x10,%esp
   16b4e:	e9 18 ff ff ff       	jmp    16a6b <_APICSendIPI+0x14b>
   16b53:	81 ce 00 00 0c 00    	or     $0xc0000,%esi
   16b59:	e9 87 fe ff ff       	jmp    169e5 <_APICSendIPI+0xc5>
   16b5e:	89 f6                	mov    %esi,%esi

00016b60 <_APICSetup>:
}
#endif

VOID APICSetup(VOID)
{
   16b60:	55                   	push   %ebp
   16b61:	89 e5                	mov    %esp,%ebp
   16b63:	57                   	push   %edi
   16b64:	56                   	push   %esi
   16b65:	53                   	push   %ebx
   16b66:	83 ec 10             	sub    $0x10,%esp
   16b69:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16b6f:	8b 42 20             	mov    0x20(%edx),%eax
   16b72:	25 00 00 00 0f       	and    $0xf000000,%eax
   16b77:	c1 e8 18             	shr    $0x18,%eax
   16b7a:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16b81:	00 00 00 00 
   16b85:	c7 04 85 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%eax,4)
   16b8c:	20 00 00 00 
   16b90:	8b 52 20             	mov    0x20(%edx),%edx
   16b93:	89 d7                	mov    %edx,%edi
   16b95:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   16b9c:	81 e7 00 00 00 0f    	and    $0xf000000,%edi
   ULONG CPU, tmp;

   CPU = ThisCPU();

//   APICDump();
  
   DPRINT1("CPU%d:\n", CPU);
   16ba2:	68 30 02 00 00       	push   $0x230
   16ba7:	c1 ef 18             	shr    $0x18,%edi
   16baa:	68 4a c5 01 00       	push   $0x1c54a
   16baf:	68 51 c5 01 00       	push   $0x1c551
   16bb4:	e8 d7 3c 00 00       	call   1a890 <_DbgPrint>
   16bb9:	5e                   	pop    %esi
   16bba:	58                   	pop    %eax
   16bbb:	57                   	push   %edi
   16bbc:	68 18 c6 01 00       	push   $0x1c618
   16bc1:	e8 ca 3c 00 00       	call   1a890 <_DbgPrint>
   16bc6:	83 c4 0c             	add    $0xc,%esp
   DPRINT1("  Physical APIC id: %d\n", GET_APIC_ID(APICRead(APIC_ID)));
   16bc9:	68 31 02 00 00       	push   $0x231
   16bce:	68 4a c5 01 00       	push   $0x1c54a
   16bd3:	68 51 c5 01 00       	push   $0x1c551
   16bd8:	e8 b3 3c 00 00       	call   1a890 <_DbgPrint>
   16bdd:	a1 10 b0 01 00       	mov    0x1b010,%eax
   16be2:	59                   	pop    %ecx
   16be3:	5b                   	pop    %ebx
   16be4:	8b 50 20             	mov    0x20(%eax),%edx
   16be7:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   16bed:	c1 ea 18             	shr    $0x18,%edx
   16bf0:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   16bf7:	00 00 00 00 
   16bfb:	c7 04 95 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%edx,4)
   16c02:	20 00 00 00 
   16c06:	8b 40 20             	mov    0x20(%eax),%eax
   16c09:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   16c10:	25 00 00 00 0f       	and    $0xf000000,%eax
   16c15:	c1 e8 18             	shr    $0x18,%eax
   16c18:	50                   	push   %eax
   16c19:	68 20 c6 01 00       	push   $0x1c620
   16c1e:	e8 6d 3c 00 00       	call   1a890 <_DbgPrint>
   16c23:	83 c4 0c             	add    $0xc,%esp
   DPRINT1("  Logical APIC id:  %d\n", GET_APIC_LOGICAL_ID(APICRead(APIC_LDR)));
   16c26:	68 32 02 00 00       	push   $0x232
   16c2b:	68 4a c5 01 00       	push   $0x1c54a
   16c30:	68 51 c5 01 00       	push   $0x1c551
   16c35:	e8 56 3c 00 00       	call   1a890 <_DbgPrint>
   16c3a:	58                   	pop    %eax
   16c3b:	a1 10 b0 01 00       	mov    0x1b010,%eax
   16c40:	5a                   	pop    %edx
   16c41:	8b 50 20             	mov    0x20(%eax),%edx
   16c44:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   16c4a:	c1 ea 18             	shr    $0x18,%edx
   16c4d:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   16c54:	00 00 00 00 
   16c58:	c7 04 95 b0 e5 03 00 	movl   $0xd0,0x3e5b0(,%edx,4)
   16c5f:	d0 00 00 00 
   16c63:	8b 80 d0 00 00 00    	mov    0xd0(%eax),%eax
   16c69:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   16c70:	c1 e8 18             	shr    $0x18,%eax
   16c73:	50                   	push   %eax
   16c74:	68 38 c6 01 00       	push   $0x1c638
   16c79:	e8 12 3c 00 00       	call   1a890 <_DbgPrint>
   16c7e:	83 c4 0c             	add    $0xc,%esp
   DPRINT1("%08x %08x %08x\n", APICRead(APIC_ID), APICRead(APIC_LDR), APICRead(APIC_DFR));
   16c81:	68 33 02 00 00       	push   $0x233
   16c86:	68 4a c5 01 00       	push   $0x1c54a
   16c8b:	68 51 c5 01 00       	push   $0x1c551
   16c90:	e8 fb 3b 00 00       	call   1a890 <_DbgPrint>
   16c95:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16c9b:	83 c4 10             	add    $0x10,%esp
   16c9e:	8b 42 20             	mov    0x20(%edx),%eax
   16ca1:	25 00 00 00 0f       	and    $0xf000000,%eax
   16ca6:	c1 e8 18             	shr    $0x18,%eax
   16ca9:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16cb0:	00 00 00 00 
   16cb4:	c7 04 85 b0 e5 03 00 	movl   $0xe0,0x3e5b0(,%eax,4)
   16cbb:	e0 00 00 00 
   16cbf:	8b 9a e0 00 00 00    	mov    0xe0(%edx),%ebx
   16cc5:	89 1c 85 d0 e8 03 00 	mov    %ebx,0x3e8d0(,%eax,4)
   16ccc:	8b 42 20             	mov    0x20(%edx),%eax
   16ccf:	25 00 00 00 0f       	and    $0xf000000,%eax
   16cd4:	c1 e8 18             	shr    $0x18,%eax
   16cd7:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16cde:	00 00 00 00 
   16ce2:	c7 04 85 b0 e5 03 00 	movl   $0xd0,0x3e5b0(,%eax,4)
   16ce9:	d0 00 00 00 
   16ced:	8b 8a d0 00 00 00    	mov    0xd0(%edx),%ecx
   16cf3:	89 0c 85 d0 e8 03 00 	mov    %ecx,0x3e8d0(,%eax,4)
   16cfa:	8b 42 20             	mov    0x20(%edx),%eax
   16cfd:	25 00 00 00 0f       	and    $0xf000000,%eax
   16d02:	c1 e8 18             	shr    $0x18,%eax
   16d05:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16d0c:	00 00 00 00 
   16d10:	c7 04 85 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%eax,4)
   16d17:	20 00 00 00 
   16d1b:	8b 52 20             	mov    0x20(%edx),%edx
   16d1e:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   16d25:	53                   	push   %ebx
   16d26:	51                   	push   %ecx
   16d27:	52                   	push   %edx
   16d28:	68 50 c6 01 00       	push   $0x1c650
   16d2d:	e8 5e 3b 00 00       	call   1a890 <_DbgPrint>
   16d32:	8b 1d 10 b0 01 00    	mov    0x1b010,%ebx
   16d38:	83 c4 0c             	add    $0xc,%esp
   16d3b:	8b 43 20             	mov    0x20(%ebx),%eax
   16d3e:	25 00 00 00 0f       	and    $0xf000000,%eax
   16d43:	c1 e8 18             	shr    $0x18,%eax
   16d46:	c7 04 85 40 e8 03 00 	movl   $0xe0,0x3e840(,%eax,4)
   16d4d:	e0 00 00 00 
   16d51:	c7 04 85 70 e9 03 00 	movl   $0xffffffff,0x3e970(,%eax,4)
   16d58:	ff ff ff ff 
   16d5c:	8b 43 20             	mov    0x20(%ebx),%eax
   16d5f:	c7 83 e0 00 00 00 ff 	movl   $0xffffffff,0xe0(%ebx)
   16d66:	ff ff ff 
   16d69:	25 00 00 00 0f       	and    $0xf000000,%eax
   16d6e:	c1 e8 18             	shr    $0x18,%eax
   16d71:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16d78:	00 00 00 00 
   16d7c:	c7 04 85 b0 e5 03 00 	movl   $0xd0,0x3e5b0(,%eax,4)
   16d83:	d0 00 00 00 
   16d87:	8b 93 d0 00 00 00    	mov    0xd0(%ebx),%edx

   /*
    * Intel recommends to set DFR, LDR and TPR before enabling
    * an APIC.  See e.g. "AP-388 82489DX User's Manual" (Intel
    * document number 292116).  So here it goes...
    */

   /*
    * Put the APIC into flat delivery mode.
    * Must be "all ones" explicitly for 82489DX.
    */
   APICWrite(APIC_DFR, 0xFFFFFFFF);

   /*
    * Set up the logical destination ID.
    */
   tmp = APICRead(APIC_LDR);
   tmp &= ~APIC_LDR_MASK;
   16d8d:	89 d6                	mov    %edx,%esi
   16d8f:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   16d96:	81 e6 ff ff ff 00    	and    $0xffffff,%esi
{
  ULONG value;

#if defined(__GNUC__)
  __asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
   16d9c:	64 a1 1c 00 00 00    	mov    %fs:0x1c,%eax
   16da2:	31 c9                	xor    %ecx,%ecx
   16da4:	8a 48 51             	mov    0x51(%eax),%cl
   16da7:	b8 01 00 00 00       	mov    $0x1,%eax
   16dac:	83 c1 18             	add    $0x18,%ecx
   16daf:	d3 e0                	shl    %cl,%eax
   16db1:	09 c6                	or     %eax,%esi
   16db3:	8b 43 20             	mov    0x20(%ebx),%eax
   16db6:	25 00 00 00 0f       	and    $0xf000000,%eax
   16dbb:	c1 e8 18             	shr    $0x18,%eax
   16dbe:	89 34 85 70 e9 03 00 	mov    %esi,0x3e970(,%eax,4)
   16dc5:	c7 04 85 40 e8 03 00 	movl   $0xd0,0x3e840(,%eax,4)
   16dcc:	d0 00 00 00 
   16dd0:	89 b3 d0 00 00 00    	mov    %esi,0xd0(%ebx)
   /* 
    * FIXME:
    *   This works only up to 8 CPU's
    */
   tmp |= (1 << (KeGetCurrentProcessorNumber() + 24));
   APICWrite(APIC_LDR, tmp);


   DPRINT1("CPU%d:\n", CPU);
   16dd6:	68 4e 02 00 00       	push   $0x24e
   16ddb:	68 4a c5 01 00       	push   $0x1c54a
   16de0:	68 51 c5 01 00       	push   $0x1c551
   16de5:	e8 a6 3a 00 00       	call   1a890 <_DbgPrint>
   16dea:	5e                   	pop    %esi
   16deb:	58                   	pop    %eax
   16dec:	57                   	push   %edi
   16ded:	68 18 c6 01 00       	push   $0x1c618
   16df2:	e8 99 3a 00 00       	call   1a890 <_DbgPrint>
   16df7:	83 c4 0c             	add    $0xc,%esp
   DPRINT1("  Physical APIC id: %d\n", GET_APIC_ID(APICRead(APIC_ID)));
   16dfa:	68 4f 02 00 00       	push   $0x24f
   16dff:	68 4a c5 01 00       	push   $0x1c54a
   16e04:	68 51 c5 01 00       	push   $0x1c551
   16e09:	e8 82 3a 00 00       	call   1a890 <_DbgPrint>
   16e0e:	a1 10 b0 01 00       	mov    0x1b010,%eax
   16e13:	59                   	pop    %ecx
   16e14:	5b                   	pop    %ebx
   16e15:	8b 50 20             	mov    0x20(%eax),%edx
   16e18:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   16e1e:	c1 ea 18             	shr    $0x18,%edx
   16e21:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   16e28:	00 00 00 00 
   16e2c:	c7 04 95 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%edx,4)
   16e33:	20 00 00 00 
   16e37:	8b 40 20             	mov    0x20(%eax),%eax
   16e3a:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   16e41:	25 00 00 00 0f       	and    $0xf000000,%eax
   16e46:	c1 e8 18             	shr    $0x18,%eax
   16e49:	50                   	push   %eax
   16e4a:	68 20 c6 01 00       	push   $0x1c620
   16e4f:	e8 3c 3a 00 00       	call   1a890 <_DbgPrint>
   16e54:	83 c4 0c             	add    $0xc,%esp
   DPRINT1("  Logical APIC id:  %d\n", GET_APIC_LOGICAL_ID(APICRead(APIC_LDR)));
   16e57:	68 50 02 00 00       	push   $0x250
   16e5c:	68 4a c5 01 00       	push   $0x1c54a
   16e61:	68 51 c5 01 00       	push   $0x1c551
   16e66:	e8 25 3a 00 00       	call   1a890 <_DbgPrint>
   16e6b:	58                   	pop    %eax
   16e6c:	a1 10 b0 01 00       	mov    0x1b010,%eax
   16e71:	5a                   	pop    %edx
   16e72:	8b 50 20             	mov    0x20(%eax),%edx
   16e75:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   16e7b:	c1 ea 18             	shr    $0x18,%edx
   16e7e:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   16e85:	00 00 00 00 
   16e89:	c7 04 95 b0 e5 03 00 	movl   $0xd0,0x3e5b0(,%edx,4)
   16e90:	d0 00 00 00 
   16e94:	8b 80 d0 00 00 00    	mov    0xd0(%eax),%eax
   16e9a:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   16ea1:	c1 e8 18             	shr    $0x18,%eax
   16ea4:	50                   	push   %eax
   16ea5:	68 38 c6 01 00       	push   $0x1c638
   16eaa:	e8 e1 39 00 00       	call   1a890 <_DbgPrint>
   16eaf:	83 c4 0c             	add    $0xc,%esp
   DPRINT1("%08x %08x %08x\n", APICRead(APIC_ID), APICRead(APIC_LDR), APICRead(APIC_DFR));
   16eb2:	68 51 02 00 00       	push   $0x251
   16eb7:	68 4a c5 01 00       	push   $0x1c54a
   16ebc:	68 51 c5 01 00       	push   $0x1c551
   16ec1:	e8 ca 39 00 00       	call   1a890 <_DbgPrint>
   16ec6:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   16ecc:	83 c4 10             	add    $0x10,%esp
   16ecf:	8b 42 20             	mov    0x20(%edx),%eax
   16ed2:	25 00 00 00 0f       	and    $0xf000000,%eax
   16ed7:	c1 e8 18             	shr    $0x18,%eax
   16eda:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16ee1:	00 00 00 00 
   16ee5:	c7 04 85 b0 e5 03 00 	movl   $0xe0,0x3e5b0(,%eax,4)
   16eec:	e0 00 00 00 
   16ef0:	8b 9a e0 00 00 00    	mov    0xe0(%edx),%ebx
   16ef6:	89 1c 85 d0 e8 03 00 	mov    %ebx,0x3e8d0(,%eax,4)
   16efd:	8b 42 20             	mov    0x20(%edx),%eax
   16f00:	25 00 00 00 0f       	and    $0xf000000,%eax
   16f05:	c1 e8 18             	shr    $0x18,%eax
   16f08:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16f0f:	00 00 00 00 
   16f13:	c7 04 85 b0 e5 03 00 	movl   $0xd0,0x3e5b0(,%eax,4)
   16f1a:	d0 00 00 00 
   16f1e:	8b 8a d0 00 00 00    	mov    0xd0(%edx),%ecx
   16f24:	89 0c 85 d0 e8 03 00 	mov    %ecx,0x3e8d0(,%eax,4)
   16f2b:	8b 42 20             	mov    0x20(%edx),%eax
   16f2e:	25 00 00 00 0f       	and    $0xf000000,%eax
   16f33:	c1 e8 18             	shr    $0x18,%eax
   16f36:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16f3d:	00 00 00 00 
   16f41:	c7 04 85 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%eax,4)
   16f48:	20 00 00 00 
   16f4c:	8b 52 20             	mov    0x20(%edx),%edx
   16f4f:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   16f56:	53                   	push   %ebx
   16f57:	51                   	push   %ecx
   16f58:	52                   	push   %edx
   16f59:	68 50 c6 01 00       	push   $0x1c650
   16f5e:	e8 2d 39 00 00       	call   1a890 <_DbgPrint>
   16f63:	83 c4 0c             	add    $0xc,%esp
   DPRINT1("%d\n", CPUMap[CPU].APICId);
   16f66:	68 52 02 00 00       	push   $0x252
   16f6b:	68 4a c5 01 00       	push   $0x1c54a
   16f70:	68 51 c5 01 00       	push   $0x1c551
   16f75:	e8 16 39 00 00       	call   1a890 <_DbgPrint>
   16f7a:	5e                   	pop    %esi
   16f7b:	58                   	pop    %eax
   16f7c:	89 f8                	mov    %edi,%eax
   16f7e:	c1 e0 04             	shl    $0x4,%eax
   16f81:	8a 80 31 e6 03 00    	mov    0x3e631(%eax),%al
   16f87:	25 ff 00 00 00       	and    $0xff,%eax
   16f8c:	50                   	push   %eax
   16f8d:	68 60 c6 01 00       	push   $0x1c660
   16f92:	e8 f9 38 00 00       	call   1a890 <_DbgPrint>
   16f97:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   16f9d:	8b 41 20             	mov    0x20(%ecx),%eax
   16fa0:	83 c4 10             	add    $0x10,%esp
   16fa3:	25 00 00 00 0f       	and    $0xf000000,%eax
   16fa8:	c1 e8 18             	shr    $0x18,%eax
   16fab:	c7 04 85 40 e8 03 00 	movl   $0x80,0x3e840(,%eax,4)
   16fb2:	80 00 00 00 
   16fb6:	c7 04 85 70 e9 03 00 	movl   $0xef,0x3e970(,%eax,4)
   16fbd:	ef 00 00 00 
   16fc1:	8b 41 20             	mov    0x20(%ecx),%eax
   16fc4:	c7 81 80 00 00 00 ef 	movl   $0xef,0x80(%ecx)
   16fcb:	00 00 00 
   16fce:	25 00 00 00 0f       	and    $0xf000000,%eax
   16fd3:	c1 e8 18             	shr    $0x18,%eax
   16fd6:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   16fdd:	00 00 00 00 
   16fe1:	c7 04 85 b0 e5 03 00 	movl   $0xf0,0x3e5b0(,%eax,4)
   16fe8:	f0 00 00 00 
   16fec:	8b 91 f0 00 00 00    	mov    0xf0(%ecx),%edx
   16ff2:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)

   /* Accept only higher interrupts */
   APICWrite(APIC_TPR, 0xef);

   /* Enable local APIC */
   tmp = APICRead(APIC_SIVR);
   tmp &= ~0xff;
   tmp |= APIC_SIVR_ENABLE;

#if 0
   tmp &= ~APIC_SIVR_FOCUS;
#else
   tmp |= APIC_SIVR_FOCUS;
#endif

  /* Set spurious interrupt vector */
  tmp |= SPURIOUS_VECTOR;
   16ff9:	89 d6                	mov    %edx,%esi
   16ffb:	8b 41 20             	mov    0x20(%ecx),%eax
   16ffe:	81 ce ff 03 00 00    	or     $0x3ff,%esi
   17004:	25 00 00 00 0f       	and    $0xf000000,%eax
   17009:	c1 e8 18             	shr    $0x18,%eax
   1700c:	89 34 85 70 e9 03 00 	mov    %esi,0x3e970(,%eax,4)
   17013:	c7 04 85 40 e8 03 00 	movl   $0xf0,0x3e840(,%eax,4)
   1701a:	f0 00 00 00 
   1701e:	8b 41 20             	mov    0x20(%ecx),%eax
   17021:	89 b1 f0 00 00 00    	mov    %esi,0xf0(%ecx)
   17027:	25 00 00 00 0f       	and    $0xf000000,%eax
   1702c:	c1 e8 18             	shr    $0x18,%eax
   1702f:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   17036:	00 00 00 00 
   1703a:	c7 04 85 b0 e5 03 00 	movl   $0x350,0x3e5b0(,%eax,4)
   17041:	50 03 00 00 
   17045:	8b 91 50 03 00 00    	mov    0x350(%ecx),%edx
   1704b:	89 d6                	mov    %edx,%esi
   1704d:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   17054:	81 e6 00 00 01 00    	and    $0x10000,%esi
  APICWrite(APIC_SIVR, tmp);

  /*
   * Set up LVT0, LVT1:
   *
   * set up through-local-APIC on the BP's LINT0. This is not
   * strictly necessery in pure symmetric-IO mode, but sometimes
   * we delegate interrupts to the 8259A.
   */
  tmp = APICRead(APIC_LINT0) & APIC_LVT_MASKED;
  if (CPU == BootCPU && (APICMode == amPIC || !tmp)) 
   1705a:	3b 3d 50 e9 03 00    	cmp    0x3e950,%edi
   17060:	0f 84 ba 00 00 00    	je     17120 <_APICSetup+0x5c0>
  {
     tmp = APIC_DM_EXTINT;
     DPRINT1("enabled ExtINT on CPU#%d\n", CPU);
  } 
  else 
  {
     tmp = APIC_DM_EXTINT | APIC_LVT_MASKED;
     DPRINT1("masked ExtINT on CPU#%d\n", CPU);
   17066:	50                   	push   %eax
   17067:	68 76 02 00 00       	push   $0x276
   1706c:	68 4a c5 01 00       	push   $0x1c54a
   17071:	68 51 c5 01 00       	push   $0x1c551
   17076:	e8 15 38 00 00       	call   1a890 <_DbgPrint>
   1707b:	5b                   	pop    %ebx
   1707c:	58                   	pop    %eax
   1707d:	57                   	push   %edi
   1707e:	be 00 07 01 00       	mov    $0x10700,%esi
   17083:	68 64 c6 01 00       	push   $0x1c664
   17088:	e8 03 38 00 00       	call   1a890 <_DbgPrint>
   1708d:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   17093:	8b 41 20             	mov    0x20(%ecx),%eax
   17096:	83 c4 10             	add    $0x10,%esp
   17099:	25 00 00 00 0f       	and    $0xf000000,%eax
  }
  APICWrite(APIC_LINT0, tmp);

  /*
   * Only the BSP should see the LINT1 NMI signal, obviously.
   */
  if (CPU == BootCPU)
  {
     tmp = APIC_DM_NMI;
  }
  else
  {
     tmp = APIC_DM_NMI | APIC_LVT_MASKED;
  }
  if (!APIC_INTEGRATED(CPUMap[CPU].APICVersion)) 
   1709e:	89 fa                	mov    %edi,%edx
   170a0:	c1 e8 18             	shr    $0x18,%eax
   170a3:	89 34 85 70 e9 03 00 	mov    %esi,0x3e970(,%eax,4)
   170aa:	c7 04 85 40 e8 03 00 	movl   $0x350,0x3e840(,%eax,4)
   170b1:	50 03 00 00 
   170b5:	89 b1 50 03 00 00    	mov    %esi,0x350(%ecx)
   170bb:	3b 3d 50 e9 03 00    	cmp    0x3e950,%edi
   170c1:	0f 95 c0             	setne  %al
   170c4:	c1 e2 04             	shl    $0x4,%edx
   170c7:	25 ff 00 00 00       	and    $0xff,%eax
   170cc:	89 c6                	mov    %eax,%esi
   170ce:	4e                   	dec    %esi
   170cf:	81 e6 00 00 ff ff    	and    $0xffff0000,%esi
   170d5:	81 c6 00 04 01 00    	add    $0x10400,%esi
   170db:	f6 82 32 e6 03 00 f0 	testb  $0xf0,0x3e632(%edx)
   170e2:	75 06                	jne    170ea <_APICSetup+0x58a>
  {
     /* 82489DX */
     tmp |= APIC_LVT_LEVEL_TRIGGER;
   170e4:	81 ce 00 80 00 00    	or     $0x8000,%esi
   170ea:	8b 41 20             	mov    0x20(%ecx),%eax
   170ed:	25 00 00 00 0f       	and    $0xf000000,%eax
   170f2:	c1 e8 18             	shr    $0x18,%eax
   170f5:	c7 04 85 40 e8 03 00 	movl   $0x360,0x3e840(,%eax,4)
   170fc:	60 03 00 00 
   17100:	89 34 85 70 e9 03 00 	mov    %esi,0x3e970(,%eax,4)
   17107:	89 b1 60 03 00 00    	mov    %esi,0x360(%ecx)
  }
  APICWrite(APIC_LINT1, tmp);

  if (APIC_INTEGRATED(CPUMap[CPU].APICVersion)) 
   1710d:	f6 82 32 e6 03 00 f0 	testb  $0xf0,0x3e632(%edx)
   17114:	75 4b                	jne    17161 <_APICSetup+0x601>
  {	
     /* !82489DX */
     if (APICGetMaxLVT() > 3) 
     {
	/* Due to the Pentium erratum 3AP */
	APICWrite(APIC_ESR, 0);
     }

     tmp = APICRead(APIC_ESR);
     DPRINT("ESR value before enabling vector: 0x%X\n", tmp);

     /* Enable sending errors */
     tmp = ERROR_VECTOR;
     APICWrite(APIC_LVT3, tmp);

     /*
      * Spec says clear errors after enabling vector
      */
     if (APICGetMaxLVT() > 3)
     {
        APICWrite(APIC_ESR, 0);
     }
     tmp = APICRead(APIC_ESR);
     DPRINT("ESR value after enabling vector: 0x%X\n", tmp);
  }
}
   17116:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   17119:	5b                   	pop    %ebx
   1711a:	5e                   	pop    %esi
   1711b:	5f                   	pop    %edi
   1711c:	5d                   	pop    %ebp
   1711d:	c3                   	ret    
   1711e:	89 f6                	mov    %esi,%esi
   17120:	8b 1d 60 e9 03 00    	mov    0x3e960,%ebx
   17126:	85 db                	test   %ebx,%ebx
   17128:	0f 94 c2             	sete   %dl
   1712b:	85 f6                	test   %esi,%esi
   1712d:	0f 94 c0             	sete   %al
   17130:	09 d0                	or     %edx,%eax
   17132:	a8 01                	test   $0x1,%al
   17134:	0f 84 2c ff ff ff    	je     17066 <_APICSetup+0x506>
   1713a:	51                   	push   %ecx
   1713b:	68 71 02 00 00       	push   $0x271
   17140:	68 4a c5 01 00       	push   $0x1c54a
   17145:	68 51 c5 01 00       	push   $0x1c551
   1714a:	e8 41 37 00 00       	call   1a890 <_DbgPrint>
   1714f:	58                   	pop    %eax
   17150:	5a                   	pop    %edx
   17151:	57                   	push   %edi
   17152:	be 00 07 00 00       	mov    $0x700,%esi
   17157:	68 7d c6 01 00       	push   $0x1c67d
   1715c:	e9 27 ff ff ff       	jmp    17088 <_APICSetup+0x528>
   17161:	e8 1a e9 ff ff       	call   15a80 <_APICGetMaxLVT>
   17166:	83 f8 03             	cmp    $0x3,%eax
   17169:	0f 87 d4 00 00 00    	ja     17243 <_APICSetup+0x6e3>
   1716f:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   17175:	8b 41 20             	mov    0x20(%ecx),%eax
   17178:	25 00 00 00 0f       	and    $0xf000000,%eax
   1717d:	c1 e8 18             	shr    $0x18,%eax
   17180:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   17187:	00 00 00 00 
   1718b:	c7 04 85 b0 e5 03 00 	movl   $0x280,0x3e5b0(,%eax,4)
   17192:	80 02 00 00 
   17196:	8b 91 80 02 00 00    	mov    0x280(%ecx),%edx
   1719c:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   171a3:	8b 41 20             	mov    0x20(%ecx),%eax
   171a6:	25 00 00 00 0f       	and    $0xf000000,%eax
   171ab:	c1 e8 18             	shr    $0x18,%eax
   171ae:	c7 04 85 40 e8 03 00 	movl   $0x370,0x3e840(,%eax,4)
   171b5:	70 03 00 00 
   171b9:	c7 04 85 70 e9 03 00 	movl   $0xfe,0x3e970(,%eax,4)
   171c0:	fe 00 00 00 
   171c4:	c7 81 70 03 00 00 fe 	movl   $0xfe,0x370(%ecx)
   171cb:	00 00 00 
   171ce:	e8 ad e8 ff ff       	call   15a80 <_APICGetMaxLVT>
   171d3:	83 f8 03             	cmp    $0x3,%eax
   171d6:	0f 86 a4 00 00 00    	jbe    17280 <_APICSetup+0x720>
   171dc:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   171e2:	8b 41 20             	mov    0x20(%ecx),%eax
   171e5:	25 00 00 00 0f       	and    $0xf000000,%eax
   171ea:	c1 e8 18             	shr    $0x18,%eax
   171ed:	c7 04 85 40 e8 03 00 	movl   $0x280,0x3e840(,%eax,4)
   171f4:	80 02 00 00 
   171f8:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   171ff:	00 00 00 00 
   17203:	c7 81 80 02 00 00 00 	movl   $0x0,0x280(%ecx)
   1720a:	00 00 00 
   1720d:	8b 41 20             	mov    0x20(%ecx),%eax
   17210:	25 00 00 00 0f       	and    $0xf000000,%eax
   17215:	c1 e8 18             	shr    $0x18,%eax
   17218:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   1721f:	00 00 00 00 
   17223:	c7 04 85 b0 e5 03 00 	movl   $0x280,0x3e5b0(,%eax,4)
   1722a:	80 02 00 00 
   1722e:	8b 91 80 02 00 00    	mov    0x280(%ecx),%edx
   17234:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   1723b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1723e:	5b                   	pop    %ebx
   1723f:	5e                   	pop    %esi
   17240:	5f                   	pop    %edi
   17241:	5d                   	pop    %ebp
   17242:	c3                   	ret    
   17243:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   17249:	8b 41 20             	mov    0x20(%ecx),%eax
   1724c:	25 00 00 00 0f       	and    $0xf000000,%eax
   17251:	c1 e8 18             	shr    $0x18,%eax
   17254:	c7 04 85 40 e8 03 00 	movl   $0x280,0x3e840(,%eax,4)
   1725b:	80 02 00 00 
   1725f:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   17266:	00 00 00 00 
   1726a:	c7 81 80 02 00 00 00 	movl   $0x0,0x280(%ecx)
   17271:	00 00 00 
   17274:	e9 fc fe ff ff       	jmp    17175 <_APICSetup+0x615>
   17279:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   17280:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   17286:	eb 85                	jmp    1720d <_APICSetup+0x6ad>
   17288:	90                   	nop    
   17289:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00017290 <_APICSyncArbIDs>:
#ifdef CONFIG_SMP
VOID APICSyncArbIDs(VOID)
{
   17290:	55                   	push   %ebp
   17291:	89 e5                	mov    %esp,%ebp
   17293:	53                   	push   %ebx
   ULONG i, tmp;

   /* Wait up to 100ms for the APIC to become ready */
   for (i = 0; i < 10000; i++) 
   17294:	31 db                	xor    %ebx,%ebx
   17296:	50                   	push   %eax
   17297:	eb 1d                	jmp    172b6 <_APICSyncArbIDs+0x26>
   17299:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   {
      tmp = APICRead(APIC_ICR0);
      /* Check Delivery Status */
      if ((tmp & APIC_ICR0_DS) == 0)
         break;
      KeStallExecutionProcessor(10);
   172a0:	83 ec 0c             	sub    $0xc,%esp
   172a3:	43                   	inc    %ebx
   172a4:	6a 0a                	push   $0xa
   172a6:	e8 75 e3 ff ff       	call   15620 <_KeStallExecutionProcessor@4>
   172ab:	83 c4 0c             	add    $0xc,%esp
   172ae:	81 fb 0f 27 00 00    	cmp    $0x270f,%ebx
   172b4:	77 69                	ja     1731f <_APICSyncArbIDs+0x8f>
   172b6:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   172bc:	8b 41 20             	mov    0x20(%ecx),%eax
   172bf:	25 00 00 00 0f       	and    $0xf000000,%eax
   172c4:	c1 e8 18             	shr    $0x18,%eax
   172c7:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   172ce:	00 00 00 00 
   172d2:	c7 04 85 b0 e5 03 00 	movl   $0x300,0x3e5b0(,%eax,4)
   172d9:	00 03 00 00 
   172dd:	8b 91 00 03 00 00    	mov    0x300(%ecx),%edx
   172e3:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   172ea:	80 e6 10             	and    $0x10,%dh
   172ed:	75 b1                	jne    172a0 <_APICSyncArbIDs+0x10>
   172ef:	8b 41 20             	mov    0x20(%ecx),%eax
   172f2:	25 00 00 00 0f       	and    $0xf000000,%eax
   172f7:	c1 e8 18             	shr    $0x18,%eax
   172fa:	c7 04 85 40 e8 03 00 	movl   $0x300,0x3e840(,%eax,4)
   17301:	00 03 00 00 
   17305:	c7 04 85 70 e9 03 00 	movl   $0x84500,0x3e970(,%eax,4)
   1730c:	00 45 08 00 
   17310:	c7 81 00 03 00 00 00 	movl   $0x84500,0x300(%ecx)
   17317:	45 08 00 
   1731a:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1731d:	c9                   	leave  
   1731e:	c3                   	ret    
   1731f:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   17325:	eb c8                	jmp    172ef <_APICSyncArbIDs+0x5f>
   17327:	89 f6                	mov    %esi,%esi
   17329:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00017330 <_MpsErrorHandler>:
   }

   if (i == 10000) 
   {
      DPRINT("CPU(%d) APIC busy for 100ms.\n", ThisCPU());
   }

   DPRINT("Synchronizing Arb IDs.\n");
   APICWrite(APIC_ICR0, APIC_ICR0_DESTS_ALL | APIC_ICR0_LEVEL | APIC_DM_INIT);
}
#endif

VOID MpsErrorHandler(VOID)
{
   17330:	55                   	push   %ebp
   17331:	89 e5                	mov    %esp,%ebp
   17333:	56                   	push   %esi
   17334:	53                   	push   %ebx
  ULONG tmp1, tmp2;

  APICDump();
   17335:	e8 86 ec ff ff       	call   15fc0 <_APICDump>
   1733a:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   17340:	8b 42 20             	mov    0x20(%edx),%eax
   17343:	25 00 00 00 0f       	and    $0xf000000,%eax
   17348:	c1 e8 18             	shr    $0x18,%eax
   1734b:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   17352:	00 00 00 00 
   17356:	c7 04 85 b0 e5 03 00 	movl   $0x280,0x3e5b0(,%eax,4)
   1735d:	80 02 00 00 
   17361:	8b 9a 80 02 00 00    	mov    0x280(%edx),%ebx
   17367:	89 1c 85 d0 e8 03 00 	mov    %ebx,0x3e8d0(,%eax,4)
   1736e:	8b 42 20             	mov    0x20(%edx),%eax
   17371:	25 00 00 00 0f       	and    $0xf000000,%eax
   17376:	c1 e8 18             	shr    $0x18,%eax
   17379:	c7 04 85 40 e8 03 00 	movl   $0x280,0x3e840(,%eax,4)
   17380:	80 02 00 00 
   17384:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   1738b:	00 00 00 00 
   1738f:	8b 42 20             	mov    0x20(%edx),%eax
   17392:	c7 82 80 02 00 00 00 	movl   $0x0,0x280(%edx)
   17399:	00 00 00 
   1739c:	25 00 00 00 0f       	and    $0xf000000,%eax
   173a1:	c1 e8 18             	shr    $0x18,%eax
   173a4:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   173ab:	00 00 00 00 
   173af:	c7 04 85 b0 e5 03 00 	movl   $0x280,0x3e5b0(,%eax,4)
   173b6:	80 02 00 00 
   173ba:	8b b2 80 02 00 00    	mov    0x280(%edx),%esi
   173c0:	89 34 85 d0 e8 03 00 	mov    %esi,0x3e8d0(,%eax,4)

  tmp1 = APICRead(APIC_ESR);
  APICWrite(APIC_ESR, 0);
  tmp2 = APICRead(APIC_ESR);
  DPRINT1("APIC error on CPU(%d) ESR(%x)(%x)\n", ThisCPU(), tmp1, tmp2);
   173c7:	50                   	push   %eax
   173c8:	68 c9 02 00 00       	push   $0x2c9
   173cd:	68 4a c5 01 00       	push   $0x1c54a
   173d2:	68 51 c5 01 00       	push   $0x1c551
   173d7:	e8 b4 34 00 00       	call   1a890 <_DbgPrint>
   173dc:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   173e2:	8b 42 20             	mov    0x20(%edx),%eax
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   173e5:	83 c4 10             	add    $0x10,%esp
   173e8:	25 00 00 00 0f       	and    $0xf000000,%eax
   173ed:	c1 e8 18             	shr    $0x18,%eax
   173f0:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   173f7:	00 00 00 00 
   173fb:	c7 04 85 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%eax,4)
   17402:	20 00 00 00 
   17406:	8b 52 20             	mov    0x20(%edx),%edx
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   17409:	56                   	push   %esi
   1740a:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   17411:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   17417:	c1 ea 18             	shr    $0x18,%edx
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   1741a:	53                   	push   %ebx
   1741b:	52                   	push   %edx
   1741c:	68 98 c6 01 00       	push   $0x1c698
   17421:	e8 6a 34 00 00       	call   1a890 <_DbgPrint>
   17426:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   1742c:	8b 42 20             	mov    0x20(%edx),%eax
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   1742f:	83 c4 0c             	add    $0xc,%esp
   17432:	25 00 00 00 0f       	and    $0xf000000,%eax
   17437:	c1 e8 18             	shr    $0x18,%eax
   1743a:	c7 04 85 40 e8 03 00 	movl   $0xb0,0x3e840(,%eax,4)
   17441:	b0 00 00 00 
   17445:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   1744c:	00 00 00 00 
   17450:	c7 82 b0 00 00 00 00 	movl   $0x0,0xb0(%edx)
   17457:	00 00 00 

  /*
   * Acknowledge the interrupt
   */
  APICSendEOI();

  /* Here is what the APIC error bits mean:
   *   0: Send CS error
   *   1: Receive CS error
   *   2: Send accept error
   *   3: Receive accept error
   *   4: Reserved
   *   5: Send illegal vector
   *   6: Received illegal vector
   *   7: Illegal register address
   */
  DPRINT1("APIC error on CPU(%d) ESR(%x)(%x)\n", ThisCPU(), tmp1, tmp2);
   1745a:	68 da 02 00 00       	push   $0x2da
   1745f:	68 4a c5 01 00       	push   $0x1c54a
   17464:	68 51 c5 01 00       	push   $0x1c551
   17469:	e8 22 34 00 00       	call   1a890 <_DbgPrint>
   1746e:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   17474:	8b 42 20             	mov    0x20(%edx),%eax
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   17477:	83 c4 10             	add    $0x10,%esp
   1747a:	25 00 00 00 0f       	and    $0xf000000,%eax
   1747f:	c1 e8 18             	shr    $0x18,%eax
   17482:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   17489:	00 00 00 00 
   1748d:	c7 04 85 b0 e5 03 00 	movl   $0x20,0x3e5b0(,%eax,4)
   17494:	20 00 00 00 
   17498:	8b 52 20             	mov    0x20(%edx),%edx
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   1749b:	56                   	push   %esi
   1749c:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   174a3:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   174a9:	c1 ea 18             	shr    $0x18,%edx
VOID APICCalibrateTimer(ULONG CPU);
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
   174ac:	53                   	push   %ebx
   174ad:	52                   	push   %edx
   174ae:	68 98 c6 01 00       	push   $0x1c698
   174b3:	e8 d8 33 00 00       	call   1a890 <_DbgPrint>
   174b8:	83 c4 10             	add    $0x10,%esp
   174bb:	eb fe                	jmp    174bb <_MpsErrorHandler+0x18b>
   174bd:	8d 76 00             	lea    0x0(%esi),%esi

000174c0 <_MpsSpuriousHandler>:
   174c0:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
  for (;;);
}

VOID MpsSpuriousHandler(VOID)
{
   174c6:	55                   	push   %ebp
   174c7:	89 e5                	mov    %esp,%ebp
   174c9:	8b 41 20             	mov    0x20(%ecx),%eax
   174cc:	25 00 00 00 0f       	and    $0xf000000,%eax
   174d1:	c1 e8 18             	shr    $0x18,%eax
   174d4:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   174db:	00 00 00 00 
   174df:	c7 04 85 b0 e5 03 00 	movl   $0x170,0x3e5b0(,%eax,4)
   174e6:	70 01 00 00 
   174ea:	8b 91 70 01 00 00    	mov    0x170(%ecx),%edx
   174f0:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
  ULONG tmp;

  DPRINT("Spurious interrupt on CPU(%d)\n", ThisCPU());
  
  tmp = APICRead(APIC_ISR + ((SPURIOUS_VECTOR & ~0x1f) >> 1));
  if (tmp & (1 << (SPURIOUS_VECTOR & 0x1f)))
   174f7:	85 d2                	test   %edx,%edx
   174f9:	78 05                	js     17500 <_MpsSpuriousHandler+0x40>
  {
      APICSendEOI();
      return;
  }
#if 0
  /* No need to send EOI here */
  APICDump();
#endif
}
   174fb:	5d                   	pop    %ebp
   174fc:	c3                   	ret    
   174fd:	8d 76 00             	lea    0x0(%esi),%esi
   17500:	8b 41 20             	mov    0x20(%ecx),%eax
   17503:	25 00 00 00 0f       	and    $0xf000000,%eax
   17508:	c1 e8 18             	shr    $0x18,%eax
   1750b:	c7 04 85 40 e8 03 00 	movl   $0xb0,0x3e840(,%eax,4)
   17512:	b0 00 00 00 
   17516:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   1751d:	00 00 00 00 
   17521:	c7 81 b0 00 00 00 00 	movl   $0x0,0xb0(%ecx)
   17528:	00 00 00 
   1752b:	5d                   	pop    %ebp
   1752c:	c3                   	ret    
   1752d:	8d 76 00             	lea    0x0(%esi),%esi

00017530 <_MpsIpiHandler>:

#ifdef CONFIG_SMP
VOID MpsIpiHandler(VOID)
{
   17530:	55                   	push   %ebp
   17531:	89 e5                	mov    %esp,%ebp
   17533:	83 ec 0c             	sub    $0xc,%esp
   KIRQL oldIrql;

   HalBeginSystemInterrupt(IPI_VECTOR, 
   17536:	8d 45 ff             	lea    0xffffffff(%ebp),%eax
   17539:	50                   	push   %eax
   1753a:	6a 1d                	push   $0x1d
   1753c:	68 fb 00 00 00       	push   $0xfb
   17541:	e8 3a 2c 00 00       	call   1a180 <_HalBeginSystemInterrupt@12>
                           IPI_LEVEL, 
			   &oldIrql);
   Ki386EnableInterrupts();
   17546:	fb                   	sti    
#if 0
   DbgPrint("(%s:%d) MpsIpiHandler on CPU%d, current irql is %d\n", 
            __FILE__,__LINE__, KeGetCurrentProcessorNumber(), KeGetCurrentIrql());
#endif   

   KiIpiServiceRoutine(NULL, NULL);
   17547:	50                   	push   %eax
   17548:	6a 00                	push   $0x0
   1754a:	6a 00                	push   $0x0
   1754c:	e8 5f 34 00 00       	call   1a9b0 <_KiIpiServiceRoutine@8>

#if 0
   DbgPrint("(%s:%d) MpsIpiHandler on CPU%d done\n", __FILE__,__LINE__, KeGetCurrentProcessorNumber());
#endif

   Ki386DisableInterrupts();
   17551:	fa                   	cli    
   HalEndSystemInterrupt(oldIrql, 0);
   17552:	31 c0                	xor    %eax,%eax
   17554:	6a 00                	push   $0x0
   17556:	8a 45 ff             	mov    0xffffffff(%ebp),%al
   17559:	50                   	push   %eax
   1755a:	e8 51 2d 00 00       	call   1a2b0 <_HalEndSystemInterrupt@8>
   1755f:	c9                   	leave  
   17560:	c3                   	ret    
   17561:	eb 0d                	jmp    17570 <_MpsIRQTrapFrameToTrapFrame>
   17563:	90                   	nop    
   17564:	90                   	nop    
   17565:	90                   	nop    
   17566:	90                   	nop    
   17567:	90                   	nop    
   17568:	90                   	nop    
   17569:	90                   	nop    
   1756a:	90                   	nop    
   1756b:	90                   	nop    
   1756c:	90                   	nop    
   1756d:	90                   	nop    
   1756e:	90                   	nop    
   1756f:	90                   	nop    

00017570 <_MpsIRQTrapFrameToTrapFrame>:
}
#endif

VOID
MpsIRQTrapFrameToTrapFrame(PKIRQ_TRAPFRAME IrqTrapFrame,
			   PKTRAP_FRAME TrapFrame)
{
   17570:	55                   	push   %ebp
   17571:	89 e5                	mov    %esp,%ebp
   17573:	8b 45 08             	mov    0x8(%ebp),%eax
   17576:	8b 55 0c             	mov    0xc(%ebp),%edx
   TrapFrame->Gs     = (USHORT)IrqTrapFrame->Gs;
   17579:	8b 48 04             	mov    0x4(%eax),%ecx
   1757c:	66 89 4a 30          	mov    %cx,0x30(%edx)
   TrapFrame->Fs     = (USHORT)IrqTrapFrame->Fs;
   17580:	8b 48 08             	mov    0x8(%eax),%ecx
   17583:	66 89 4a 50          	mov    %cx,0x50(%edx)
   TrapFrame->Es     = (USHORT)IrqTrapFrame->Es;
   17587:	8b 48 0c             	mov    0xc(%eax),%ecx
   1758a:	66 89 4a 34          	mov    %cx,0x34(%edx)
   TrapFrame->Ds     = (USHORT)IrqTrapFrame->Ds;
   1758e:	8b 48 10             	mov    0x10(%eax),%ecx
   17591:	66 89 4a 38          	mov    %cx,0x38(%edx)
   TrapFrame->Eax    = IrqTrapFrame->Eax;
   17595:	8b 48 14             	mov    0x14(%eax),%ecx
   17598:	89 4a 44             	mov    %ecx,0x44(%edx)
   TrapFrame->Ecx    = IrqTrapFrame->Ecx;
   1759b:	8b 48 18             	mov    0x18(%eax),%ecx
   1759e:	89 4a 40             	mov    %ecx,0x40(%edx)
   TrapFrame->Edx    = IrqTrapFrame->Edx;
   175a1:	8b 48 1c             	mov    0x1c(%eax),%ecx
   175a4:	89 4a 3c             	mov    %ecx,0x3c(%edx)
   TrapFrame->Ebx    = IrqTrapFrame->Ebx;
   175a7:	8b 48 20             	mov    0x20(%eax),%ecx
   175aa:	89 4a 5c             	mov    %ecx,0x5c(%edx)
   TrapFrame->Esp    = IrqTrapFrame->Esp;
   175ad:	8b 48 24             	mov    0x24(%eax),%ecx
   175b0:	89 4a 74             	mov    %ecx,0x74(%edx)
   TrapFrame->Ebp    = IrqTrapFrame->Ebp;
   175b3:	8b 48 28             	mov    0x28(%eax),%ecx
   175b6:	89 4a 60             	mov    %ecx,0x60(%edx)
   TrapFrame->Esi    = IrqTrapFrame->Esi;
   175b9:	8b 48 2c             	mov    0x2c(%eax),%ecx
   175bc:	89 4a 58             	mov    %ecx,0x58(%edx)
   TrapFrame->Edi    = IrqTrapFrame->Edi;
   175bf:	8b 48 30             	mov    0x30(%eax),%ecx
   175c2:	89 4a 54             	mov    %ecx,0x54(%edx)
   TrapFrame->Eip    = IrqTrapFrame->Eip;
   175c5:	8b 48 34             	mov    0x34(%eax),%ecx
   175c8:	89 4a 68             	mov    %ecx,0x68(%edx)
   TrapFrame->Cs     = IrqTrapFrame->Cs;
   175cb:	8b 48 38             	mov    0x38(%eax),%ecx
   175ce:	89 4a 6c             	mov    %ecx,0x6c(%edx)
   TrapFrame->Eflags = IrqTrapFrame->Eflags;
   175d1:	8b 40 3c             	mov    0x3c(%eax),%eax
   175d4:	89 42 70             	mov    %eax,0x70(%edx)
   175d7:	5d                   	pop    %ebp
   175d8:	c3                   	ret    
   175d9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000175e0 <_MpsTimerHandler>:
}

VOID
MpsTimerHandler(ULONG Vector, PKIRQ_TRAPFRAME Trapframe)
{
   175e0:	55                   	push   %ebp
   175e1:	89 e5                	mov    %esp,%ebp
   175e3:	53                   	push   %ebx
   175e4:	81 ec a8 00 00 00    	sub    $0xa8,%esp
   KIRQL oldIrql;
   KTRAP_FRAME KernelTrapFrame;
#if 0
   ULONG CPU;
   static ULONG Count[MAX_CPU] = {0,};
#endif
   HalBeginSystemInterrupt(LOCAL_TIMER_VECTOR, 
   175ea:	8d 85 67 ff ff ff    	lea    0xffffff67(%ebp),%eax
   175f0:	50                   	push   %eax
   175f1:	6a 1b                	push   $0x1b
   175f3:	68 ef 00 00 00       	push   $0xef
   175f8:	e8 83 2b 00 00       	call   1a180 <_HalBeginSystemInterrupt@12>
                           PROFILE_LEVEL, 
			   &oldIrql);
   Ki386EnableInterrupts();
   175fd:	fb                   	sti    

#if 0
   CPU = ThisCPU();
   if ((Count[CPU] % 100) == 0)
   {
     DbgPrint("(%s:%d) MpsTimerHandler on CPU%d, irql = %d, epi = %x, KPCR = %x\n", __FILE__, __LINE__, CPU, oldIrql,Trapframe->Eip, KeGetCurrentKPCR());
   }
   Count[CPU]++;
#endif

   MpsIRQTrapFrameToTrapFrame(Trapframe, &KernelTrapFrame);
   175fe:	8b 55 0c             	mov    0xc(%ebp),%edx
   17601:	8d 9d 68 ff ff ff    	lea    0xffffff68(%ebp),%ebx
   17607:	53                   	push   %ebx
   17608:	52                   	push   %edx
   17609:	e8 62 ff ff ff       	call   17570 <_MpsIRQTrapFrameToTrapFrame>

#ifdef CONFIG_SMP

static inline PKPCR KeGetCurrentKPCR(VOID)
{
   1760e:	83 c4 0c             	add    $0xc,%esp
  ULONG value;

#if defined(__GNUC__)
  __asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
   17611:	64 a1 1c 00 00 00    	mov    %fs:0x1c,%eax
   17617:	80 78 51 00          	cmpb   $0x0,0x51(%eax)
   1761b:	75 27                	jne    17644 <_MpsTimerHandler+0x64>
   if (KeGetCurrentProcessorNumber() == 0)
   {
      KeUpdateSystemTime(&KernelTrapFrame, oldIrql);
   1761d:	50                   	push   %eax
   1761e:	50                   	push   %eax
   1761f:	31 c0                	xor    %eax,%eax
   17621:	8a 85 67 ff ff ff    	mov    0xffffff67(%ebp),%al
   17627:	50                   	push   %eax
   17628:	53                   	push   %ebx
   17629:	e8 92 33 00 00       	call   1a9c0 <_KeUpdateSystemTime@8>
   }
   else
   {
      KeUpdateRunTime(&KernelTrapFrame, oldIrql);
   }

   Ki386DisableInterrupts();
   1762e:	fa                   	cli    
   HalEndSystemInterrupt (oldIrql, 0);
   1762f:	31 c0                	xor    %eax,%eax
   17631:	6a 00                	push   $0x0
   17633:	8a 85 67 ff ff ff    	mov    0xffffff67(%ebp),%al
   17639:	50                   	push   %eax
   1763a:	e8 71 2c 00 00       	call   1a2b0 <_HalEndSystemInterrupt@8>
   1763f:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   17642:	c9                   	leave  
   17643:	c3                   	ret    
   17644:	50                   	push   %eax
   17645:	50                   	push   %eax
   17646:	31 c0                	xor    %eax,%eax
   17648:	8a 85 67 ff ff ff    	mov    0xffffff67(%ebp),%al
   1764e:	50                   	push   %eax
   1764f:	53                   	push   %ebx
   17650:	e8 7b 33 00 00       	call   1a9d0 <_KeUpdateRunTime@8>
   17655:	eb d7                	jmp    1762e <_MpsTimerHandler+0x4e>
   17657:	89 f6                	mov    %esi,%esi
   17659:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00017660 <_APICSetupLVTT>:
}

VOID APICSetupLVTT(ULONG ClockTicks)
{
   17660:	55                   	push   %ebp
   17661:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   17667:	89 e5                	mov    %esp,%ebp
   17669:	53                   	push   %ebx
   1766a:	8b 51 20             	mov    0x20(%ecx),%edx
   1766d:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   17673:	8b 5d 08             	mov    0x8(%ebp),%ebx
   17676:	c1 ea 18             	shr    $0x18,%edx
   17679:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   17680:	00 00 00 00 
   17684:	c7 04 95 b0 e5 03 00 	movl   $0x30,0x3e5b0(,%edx,4)
   1768b:	30 00 00 00 
   1768f:	8b 41 30             	mov    0x30(%ecx),%eax
   17692:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   ULONG tmp;

   tmp = GET_APIC_VERSION(APICRead(APIC_VER));
   if (!APIC_INTEGRATED(tmp))
   17699:	83 e0 f0             	and    $0xfffffff0,%eax
   {
      tmp = SET_APIC_TIMER_BASE(APIC_TIMER_BASE_DIV) | APIC_LVT_PERIODIC | LOCAL_TIMER_VECTOR;;
   1769c:	3c 01                	cmp    $0x1,%al
   1769e:	8b 41 20             	mov    0x20(%ecx),%eax
   176a1:	19 d2                	sbb    %edx,%edx
   176a3:	25 00 00 00 0f       	and    $0xf000000,%eax
   176a8:	c1 e8 18             	shr    $0x18,%eax
   176ab:	81 e2 00 00 08 00    	and    $0x80000,%edx
   176b1:	c1 eb 04             	shr    $0x4,%ebx
   176b4:	81 c2 ef 00 02 00    	add    $0x200ef,%edx
   176ba:	c7 04 85 40 e8 03 00 	movl   $0x320,0x3e840(,%eax,4)
   176c1:	20 03 00 00 
   176c5:	89 14 85 70 e9 03 00 	mov    %edx,0x3e970(,%eax,4)
   176cc:	8b 41 20             	mov    0x20(%ecx),%eax
   176cf:	89 91 20 03 00 00    	mov    %edx,0x320(%ecx)
   176d5:	25 00 00 00 0f       	and    $0xf000000,%eax
   176da:	c1 e8 18             	shr    $0x18,%eax
   176dd:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   176e4:	00 00 00 00 
   176e8:	c7 04 85 b0 e5 03 00 	movl   $0x3e0,0x3e5b0(,%eax,4)
   176ef:	e0 03 00 00 
   176f3:	8b 91 e0 03 00 00    	mov    0x3e0(%ecx),%edx
   176f9:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   }
   else
   {
      /* Periodic timer */
      tmp = APIC_LVT_PERIODIC | LOCAL_TIMER_VECTOR;;
   }
   APICWrite(APIC_LVTT, tmp);

   tmp = APICRead(APIC_TDCR);
   tmp &= ~(APIC_TDCR_1 | APIC_TIMER_BASE_DIV);
   17700:	83 e2 f4             	and    $0xfffffff4,%edx
   17703:	8b 41 20             	mov    0x20(%ecx),%eax
   tmp |= APIC_TDCR_16;
   17706:	83 ca 03             	or     $0x3,%edx
   17709:	25 00 00 00 0f       	and    $0xf000000,%eax
   1770e:	c1 e8 18             	shr    $0x18,%eax
   17711:	c7 04 85 40 e8 03 00 	movl   $0x3e0,0x3e840(,%eax,4)
   17718:	e0 03 00 00 
   1771c:	89 14 85 70 e9 03 00 	mov    %edx,0x3e970(,%eax,4)
   17723:	8b 41 20             	mov    0x20(%ecx),%eax
   17726:	89 91 e0 03 00 00    	mov    %edx,0x3e0(%ecx)
   1772c:	25 00 00 00 0f       	and    $0xf000000,%eax
   17731:	c1 e8 18             	shr    $0x18,%eax
   17734:	89 1c 85 70 e9 03 00 	mov    %ebx,0x3e970(,%eax,4)
   1773b:	c7 04 85 40 e8 03 00 	movl   $0x380,0x3e840(,%eax,4)
   17742:	80 03 00 00 
   17746:	89 99 80 03 00 00    	mov    %ebx,0x380(%ecx)
   1774c:	5b                   	pop    %ebx
   1774d:	5d                   	pop    %ebp
   1774e:	c3                   	ret    
   1774f:	90                   	nop    

00017750 <_APICCalibrateTimer>:
   APICWrite(APIC_TDCR, tmp);
   APICWrite(APIC_ICRT, ClockTicks / APIC_DIVISOR);
}

VOID 
APICCalibrateTimer(ULONG CPU)
{
   17750:	55                   	push   %ebp
   17751:	89 e5                	mov    %esp,%ebp
   17753:	57                   	push   %edi
   17754:	56                   	push   %esi
   17755:	53                   	push   %ebx
   17756:	83 ec 2c             	sub    $0x2c,%esp
   17759:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
   17760:	8b 45 08             	mov    0x8(%ebp),%eax
   17763:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
   1776a:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
   17771:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   17778:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   ULARGE_INTEGER t1, t2;
   LONG tt1, tt2;
   BOOLEAN TSCPresent;

   DPRINT("Calibrating APIC timer for CPU %d\n", CPU);

   APICSetupLVTT(1000000000);
   1777b:	68 00 ca 9a 3b       	push   $0x3b9aca00
   17780:	e8 db fe ff ff       	call   17660 <_APICSetupLVTT>

#ifdef CONFIG_SMP

static inline PKPCR KeGetCurrentKPCR(VOID)
{
   17785:	5e                   	pop    %esi
  ULONG value;

#if defined(__GNUC__)
  __asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
   17786:	64 a1 1c 00 00 00    	mov    %fs:0x1c,%eax
   1778c:	8b 80 d0 08 00 00    	mov    0x8d0(%eax),%eax
   17792:	c1 e8 04             	shr    $0x4,%eax
   17795:	88 c3                	mov    %al,%bl

   TSCPresent = KeGetCurrentKPCR()->PrcbData.FeatureBits & X86_FEATURE_TSC ? TRUE : FALSE;

   /*
    * The timer chip counts down to zero. Let's wait
    * for a wraparound to start exact measurement:
    * (the current tick might have been already half done)
    */
   WaitFor8254Wraparound();
   17797:	e8 44 df ff ff       	call   156e0 <_WaitFor8254Wraparound>

#ifdef CONFIG_SMP

static inline PKPCR KeGetCurrentKPCR(VOID)
{
   1779c:	83 e3 01             	and    $0x1,%ebx

   /*
    * We wrapped around just now. Let's start
    */
   if (TSCPresent)
   1779f:	84 db                	test   %bl,%bl
   177a1:	74 08                	je     177ab <_APICCalibrateTimer+0x5b>
   {
      Ki386RdTSC(t1);
   177a3:	0f 31                	rdtsc  
   177a5:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   177a8:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   177ab:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   177b1:	8b 42 20             	mov    0x20(%edx),%eax
   177b4:	25 00 00 00 0f       	and    $0xf000000,%eax
   177b9:	c1 e8 18             	shr    $0x18,%eax
   177bc:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   177c3:	00 00 00 00 
   177c7:	c7 04 85 b0 e5 03 00 	movl   $0x390,0x3e5b0(,%eax,4)
   177ce:	90 03 00 00 
   177d2:	8b ba 90 03 00 00    	mov    0x390(%edx),%edi
   177d8:	89 3c 85 d0 e8 03 00 	mov    %edi,0x3e8d0(,%eax,4)
   }
   tt1 = APICRead(APIC_CCRT);

   WaitFor8254Wraparound();
   177df:	e8 fc de ff ff       	call   156e0 <_WaitFor8254Wraparound>
   177e4:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   177ea:	8b 42 20             	mov    0x20(%edx),%eax
   177ed:	25 00 00 00 0f       	and    $0xf000000,%eax
   177f2:	c1 e8 18             	shr    $0x18,%eax


   tt2 = APICRead(APIC_CCRT);
   if (TSCPresent)
   177f5:	84 db                	test   %bl,%bl
   177f7:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   177fe:	00 00 00 00 
   17802:	c7 04 85 b0 e5 03 00 	movl   $0x390,0x3e5b0(,%eax,4)
   17809:	90 03 00 00 
   1780d:	8b 92 90 03 00 00    	mov    0x390(%edx),%edx
   17813:	89 55 d4             	mov    %edx,0xffffffd4(%ebp)
   17816:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   1781d:	74 42                	je     17861 <_APICCalibrateTimer+0x111>
   {
      Ki386RdTSC(t2);
   1781f:	0f 31                	rdtsc  
   17821:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
      CPUMap[CPU].CoreSpeed = (HZ * (t2.QuadPart - t1.QuadPart));
   17824:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
   17827:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
   1782a:	89 55 dc             	mov    %edx,0xffffffdc(%ebp)
   1782d:	c1 e6 04             	shl    $0x4,%esi
   17830:	2b 4d e0             	sub    0xffffffe0(%ebp),%ecx
   17833:	89 c8                	mov    %ecx,%eax
   17835:	c1 e0 02             	shl    $0x2,%eax
   17838:	01 c8                	add    %ecx,%eax
   1783a:	89 c1                	mov    %eax,%ecx
   1783c:	c1 e1 02             	shl    $0x2,%ecx
   1783f:	01 c1                	add    %eax,%ecx
   17841:	c1 e1 02             	shl    $0x2,%ecx
   17844:	89 8e 38 e6 03 00    	mov    %ecx,0x3e638(%esi)
{
  ULONG value;

#if defined(__GNUC__)
  __asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
   1784a:	64 8b 35 1c 00 00 00 	mov    %fs:0x1c,%esi
   17851:	b8 83 de 1b 43       	mov    $0x431bde83,%eax
   17856:	f7 e1                	mul    %ecx
   17858:	c1 ea 12             	shr    $0x12,%edx
   1785b:	89 96 cc 08 00 00    	mov    %edx,0x8cc(%esi)
      DPRINT("CPU clock speed is %ld.%04ld MHz.\n",
	     CPUMap[CPU].CoreSpeed/1000000,
	     CPUMap[CPU].CoreSpeed%1000000);
      KeGetCurrentKPCR()->PrcbData.MHz = CPUMap[CPU].CoreSpeed/1000000;
   }

   CPUMap[CPU].BusSpeed = (HZ * (long)(tt1 - tt2) * APIC_DIVISOR);
   17861:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
   17864:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   17867:	c1 e3 04             	shl    $0x4,%ebx
   1786a:	29 cf                	sub    %ecx,%edi
   1786c:	89 5d ec             	mov    %ebx,0xffffffec(%ebp)
   1786f:	8d 14 bf             	lea    (%edi,%edi,4),%edx
   17872:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   17875:	8d 14 92             	lea    (%edx,%edx,4),%edx
   17878:	c1 e2 06             	shl    $0x6,%edx
   1787b:	89 90 34 e6 03 00    	mov    %edx,0x3e634(%eax)

   /* Setup timer for normal operation */
// APICSetupLVTT((CPUMap[CPU].BusSpeed / 1000000) * 100);    // 100ns
   APICSetupLVTT((CPUMap[CPU].BusSpeed / 1000000) * 10000);  // 10ms
   17881:	b8 83 de 1b 43       	mov    $0x431bde83,%eax
   17886:	f7 e2                	mul    %edx
   17888:	c1 ea 12             	shr    $0x12,%edx
   1788b:	8d 14 92             	lea    (%edx,%edx,4),%edx
   1788e:	8d 14 92             	lea    (%edx,%edx,4),%edx
   17891:	8d 14 92             	lea    (%edx,%edx,4),%edx
   17894:	8d 14 92             	lea    (%edx,%edx,4),%edx
   17897:	c1 e2 04             	shl    $0x4,%edx
   1789a:	89 55 08             	mov    %edx,0x8(%ebp)
   1789d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   178a0:	5b                   	pop    %ebx
   178a1:	5e                   	pop    %esi
   178a2:	5f                   	pop    %edi
   178a3:	5d                   	pop    %ebp
   178a4:	e9 b7 fd ff ff       	jmp    17660 <_APICSetupLVTT>
   178a9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000178b0 <_SetInterruptGate>:
// APICSetupLVTT((CPUMap[CPU].BusSpeed / 1000000) * 100000); // 100ms

   DPRINT("Host bus clock speed is %ld.%04ld MHz.\n",
	  CPUMap[CPU].BusSpeed/1000000,
	  CPUMap[CPU].BusSpeed%1000000);
}

VOID 
SetInterruptGate(ULONG index, ULONG address)
{
   178b0:	55                   	push   %ebp
   178b1:	89 e5                	mov    %esp,%ebp
   178b3:	8b 4d 0c             	mov    0xc(%ebp),%ecx
{
  ULONG value;

#if defined(__GNUC__)
  __asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
   178b6:	64 a1 1c 00 00 00    	mov    %fs:0x1c,%eax
   178bc:	8b 55 08             	mov    0x8(%ebp),%edx
   178bf:	8b 40 38             	mov    0x38(%eax),%eax
   178c2:	8d 14 d0             	lea    (%eax,%edx,8),%edx
  IDT_DESCRIPTOR *idt;

  idt = (IDT_DESCRIPTOR*)((ULONG)KeGetCurrentKPCR()->IDT + index * sizeof(IDT_DESCRIPTOR));
  idt->a = (((ULONG)address)&0xffff) + (KERNEL_CS << 16);
   178c5:	0f b7 c1             	movzwl %cx,%eax
  idt->b = 0x8e00 + (((ULONG)address)&0xffff0000);
   178c8:	81 e1 00 00 ff ff    	and    $0xffff0000,%ecx
   178ce:	05 00 00 08 00       	add    $0x80000,%eax
   178d3:	81 c1 00 8e 00 00    	add    $0x8e00,%ecx
   178d9:	89 02                	mov    %eax,(%edx)
   178db:	89 4a 04             	mov    %ecx,0x4(%edx)
   178de:	5d                   	pop    %ebp
   178df:	c3                   	ret    

000178e0 <_HaliInitBSP>:
}

VOID HaliInitBSP(VOID)
{
   178e0:	55                   	push   %ebp
   178e1:	89 e5                	mov    %esp,%ebp
   178e3:	50                   	push   %eax
   178e4:	50                   	push   %eax
#ifdef CONFIG_SMP
   PUSHORT ps;
#endif

   static BOOLEAN BSPInitialized = FALSE;

   /* Only initialize the BSP once */
   if (BSPInitialized)
   178e5:	80 3d a0 e4 03 00 00 	cmpb   $0x0,0x3e4a0
   178ec:	74 23                	je     17911 <_HaliInitBSP+0x31>
   {
      KEBUGCHECK(0);
   178ee:	50                   	push   %eax
   178ef:	68 a6 03 00 00       	push   $0x3a6
   178f4:	68 4a c5 01 00       	push   $0x1c54a
   178f9:	68 bb c6 01 00       	push   $0x1c6bb
   178fe:	e8 8d 2f 00 00       	call   1a890 <_DbgPrint>
   17903:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1790a:	e8 61 2f 00 00       	call   1a870 <_KeBugCheck@4>
      return;
   }

   BSPInitialized = TRUE;

   /* Setup interrupt handlers */
   SetInterruptGate(LOCAL_TIMER_VECTOR, (ULONG)MpsTimerInterrupt);
   SetInterruptGate(ERROR_VECTOR, (ULONG)MpsErrorInterrupt);
   SetInterruptGate(SPURIOUS_VECTOR, (ULONG)MpsSpuriousInterrupt);
#ifdef CONFIG_SMP
   SetInterruptGate(IPI_VECTOR, (ULONG)MpsIpiInterrupt);
#endif
   DPRINT("APIC is mapped at 0x%X\n", APICBase);

   if (VerifyLocalAPIC()) 
   {
      DPRINT("APIC found\n");
   } 
   else 
   {
      DPRINT("No APIC found\n");
      KEBUGCHECK(0);
   }

   if (APICMode == amPIC) 
   {
      EnableApicMode();
   }

   APICSetup();

#ifdef CONFIG_SMP
   /* BIOS data segment */
   BIOSBase = (PULONG)BIOS_AREA;
   
   /* Area for communicating with the APs */
   CommonBase = (PULONG)COMMON_AREA;
 
   /* Copy bootstrap code to common area */
   memcpy((PVOID)((ULONG)CommonBase + PAGE_SIZE),
	  &APstart,
	  (ULONG)&APend - (ULONG)&APstart + 1);

   /* Set shutdown code */
   CMOS_WRITE(0xF, 0xA);

   /* Set warm reset vector */
   ps = (PUSHORT)((ULONG)BIOSBase + 0x467);
   *ps = (COMMON_AREA + PAGE_SIZE) & 0xF;
 
   ps = (PUSHORT)((ULONG)BIOSBase + 0x469);
   *ps = (COMMON_AREA + PAGE_SIZE) >> 4;
#endif

   /* Calibrate APIC timer */
   APICCalibrateTimer(BootCPU);
}
   1790f:	c9                   	leave  
   17910:	c3                   	ret    
   17911:	c6 05 a0 e4 03 00 01 	movb   $0x1,0x3e4a0
   17918:	68 55 a5 01 00       	push   $0x1a555
   1791d:	68 ef 00 00 00       	push   $0xef
   17922:	e8 89 ff ff ff       	call   178b0 <_SetInterruptGate>
   17927:	68 07 a5 01 00       	push   $0x1a507
   1792c:	68 fe 00 00 00       	push   $0xfe
   17931:	e8 7a ff ff ff       	call   178b0 <_SetInterruptGate>
   17936:	68 2e a5 01 00       	push   $0x1a52e
   1793b:	68 ff 00 00 00       	push   $0xff
   17940:	e8 6b ff ff ff       	call   178b0 <_SetInterruptGate>
   17945:	68 e0 a4 01 00       	push   $0x1a4e0
   1794a:	68 fb 00 00 00       	push   $0xfb
   1794f:	e8 5c ff ff ff       	call   178b0 <_SetInterruptGate>
   17954:	83 c4 20             	add    $0x20,%esp
   17957:	e8 34 ed ff ff       	call   16690 <_VerifyLocalAPIC>
   1795c:	84 c0                	test   %al,%al
   1795e:	0f 84 7c 00 00 00    	je     179e0 <_HaliInitBSP+0x100>
   17964:	a1 60 e9 03 00       	mov    0x3e960,%eax
   17969:	85 c0                	test   %eax,%eax
   1796b:	0f 84 a0 00 00 00    	je     17a11 <_HaliInitBSP+0x131>
   17971:	e8 ea f1 ff ff       	call   16b60 <_APICSetup>
   17976:	b8 d8 a4 01 00       	mov    $0x1a4d8,%eax
   1797b:	2d 50 a4 01 00       	sub    $0x1a450,%eax
   17980:	c7 05 30 e8 03 00 00 	movl   $0x0,0x3e830
   17987:	00 00 00 
   1798a:	c7 05 a0 e5 03 00 00 	movl   $0x2000,0x3e5a0
   17991:	20 00 00 
   17994:	51                   	push   %ecx
   17995:	50                   	push   %eax
   17996:	68 50 a4 01 00       	push   $0x1a450
   1799b:	68 00 30 00 00       	push   $0x3000
   179a0:	e8 db 2e 00 00       	call   1a880 <_memcpy>
   179a5:	58                   	pop    %eax
   179a6:	5a                   	pop    %edx
   179a7:	6a 0f                	push   $0xf
   179a9:	6a 70                	push   $0x70
   179ab:	e8 e0 d1 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   179b0:	6a 0a                	push   $0xa
   179b2:	6a 71                	push   $0x71
   179b4:	e8 d7 d1 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   179b9:	50                   	push   %eax
   179ba:	a1 30 e8 03 00       	mov    0x3e830,%eax
   179bf:	66 c7 80 67 04 00 00 	movw   $0x0,0x467(%eax)
   179c6:	00 00 
   179c8:	66 c7 80 69 04 00 00 	movw   $0x300,0x469(%eax)
   179cf:	00 03 
   179d1:	a1 50 e9 03 00       	mov    0x3e950,%eax
   179d6:	50                   	push   %eax
   179d7:	e8 74 fd ff ff       	call   17750 <_APICCalibrateTimer>
   179dc:	c9                   	leave  
   179dd:	c3                   	ret    
   179de:	89 f6                	mov    %esi,%esi
   179e0:	50                   	push   %eax
   179e1:	68 bc 03 00 00       	push   $0x3bc
   179e6:	68 4a c5 01 00       	push   $0x1c54a
   179eb:	68 bb c6 01 00       	push   $0x1c6bb
   179f0:	e8 9b 2e 00 00       	call   1a890 <_DbgPrint>
   179f5:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   179fc:	e8 6f 2e 00 00       	call   1a870 <_KeBugCheck@4>
   17a01:	a1 60 e9 03 00       	mov    0x3e960,%eax
   17a06:	83 c4 0c             	add    $0xc,%esp
   17a09:	85 c0                	test   %eax,%eax
   17a0b:	0f 85 60 ff ff ff    	jne    17971 <_HaliInitBSP+0x91>
   17a11:	e8 8a e4 ff ff       	call   15ea0 <_EnableApicMode>
   17a16:	e9 56 ff ff ff       	jmp    17971 <_HaliInitBSP+0x91>
   17a1b:	90                   	nop    
   17a1c:	8d 74 26 00          	lea    0x0(%esi),%esi

00017a20 <_HaliStartApplicationProcessor>:

#ifdef CONFIG_SMP
VOID
HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack)
{
   17a20:	55                   	push   %ebp
   17a21:	89 e5                	mov    %esp,%ebp
   17a23:	57                   	push   %edi
   17a24:	56                   	push   %esi
   17a25:	53                   	push   %ebx
   17a26:	83 ec 1c             	sub    $0x1c,%esp
   ULONG tmp, maxlvt;
   PCOMMON_AREA_INFO Common;
   ULONG StartupCount;
   ULONG i, j;
   ULONG DeliveryStatus = 0;
   17a29:	31 f6                	xor    %esi,%esi
   17a2b:	8b 45 08             	mov    0x8(%ebp),%eax
   17a2e:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   17a31:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   17a34:	89 4d ec             	mov    %ecx,0xffffffec(%ebp)
   ULONG AcceptStatus = 0;
   17a37:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)

   if (Cpu >= MAX_CPU ||
   17a3e:	83 f8 1f             	cmp    $0x1f,%eax
   17a41:	77 0c                	ja     17a4f <_HaliStartApplicationProcessor+0x2f>
   17a43:	3b 05 c0 e8 03 00    	cmp    0x3e8c0,%eax
   17a49:	0f 82 70 03 00 00    	jb     17dbf <_HaliStartApplicationProcessor+0x39f>
       Cpu >= CPUCount ||
       OnlineCPUs & (1 << Cpu))
   {
     KEBUGCHECK(0);
   17a4f:	50                   	push   %eax
   17a50:	68 f0 03 00 00       	push   $0x3f0
   17a55:	68 4a c5 01 00       	push   $0x1c54a
   17a5a:	68 bb c6 01 00       	push   $0x1c6bb
   17a5f:	e8 2c 2e 00 00       	call   1a890 <_DbgPrint>
   17a64:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   17a6b:	e8 00 2e 00 00       	call   1a870 <_KeBugCheck@4>
   17a70:	83 c4 0c             	add    $0xc,%esp
   }
   DPRINT1("Attempting to boot CPU %d\n", Cpu);
   17a73:	50                   	push   %eax
   17a74:	68 f2 03 00 00       	push   $0x3f2
   17a79:	68 4a c5 01 00       	push   $0x1c54a
   17a7e:	68 51 c5 01 00       	push   $0x1c551
   17a83:	e8 08 2e 00 00       	call   1a890 <_DbgPrint>
   17a88:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   17a8b:	5b                   	pop    %ebx
   17a8c:	5f                   	pop    %edi
   17a8d:	51                   	push   %ecx
   17a8e:	68 d0 c6 01 00       	push   $0x1c6d0
   17a93:	e8 f8 2d 00 00       	call   1a890 <_DbgPrint>
   17a98:	58                   	pop    %eax
   17a99:	5a                   	pop    %edx

   /* Send INIT IPI */

   APICSendIPI(Cpu, APIC_DM_INIT|APIC_ICR0_LEVEL_ASSERT);
   17a9a:	68 00 45 00 00       	push   $0x4500
   17a9f:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   17aa2:	50                   	push   %eax
   17aa3:	e8 78 ee ff ff       	call   16920 <_APICSendIPI>
 
   KeStallExecutionProcessor(200);
   17aa8:	c7 04 24 c8 00 00 00 	movl   $0xc8,(%esp)
   17aaf:	e8 6c db ff ff       	call   15620 <_KeStallExecutionProcessor@4>

   /* Deassert INIT */

   APICSendIPI(Cpu, APIC_DM_INIT|APIC_ICR0_LEVEL_DEASSERT);
   17ab4:	c7 04 24 00 05 00 00 	movl   $0x500,(%esp)
   17abb:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   17abe:	50                   	push   %eax
   17abf:	e8 5c ee ff ff       	call   16920 <_APICSendIPI>

   if (APIC_INTEGRATED(CPUMap[Cpu].APICVersion)) 
   17ac4:	8b 7d f0             	mov    0xfffffff0(%ebp),%edi
   17ac7:	83 c4 10             	add    $0x10,%esp
   17aca:	c1 e7 04             	shl    $0x4,%edi
   17acd:	f6 87 32 e6 03 00 f0 	testb  $0xf0,0x3e632(%edi)
   17ad4:	74 5f                	je     17b35 <_HaliStartApplicationProcessor+0x115>
   17ad6:	8b 15 10 b0 01 00    	mov    0x1b010,%edx
   17adc:	8b 42 20             	mov    0x20(%edx),%eax
   17adf:	25 00 00 00 0f       	and    $0xf000000,%eax
   17ae4:	c1 e8 18             	shr    $0x18,%eax
   17ae7:	c7 04 85 40 e8 03 00 	movl   $0x280,0x3e840(,%eax,4)
   17aee:	80 02 00 00 
   17af2:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   17af9:	00 00 00 00 
   17afd:	8b 42 20             	mov    0x20(%edx),%eax
   17b00:	c7 82 80 02 00 00 00 	movl   $0x0,0x280(%edx)
   17b07:	00 00 00 
   17b0a:	25 00 00 00 0f       	and    $0xf000000,%eax
   17b0f:	c1 e8 18             	shr    $0x18,%eax
   17b12:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   17b19:	00 00 00 00 
   17b1d:	c7 04 85 b0 e5 03 00 	movl   $0x280,0x3e5b0(,%eax,4)
   17b24:	80 02 00 00 
   17b28:	8b 92 80 02 00 00    	mov    0x280(%edx),%edx
   17b2e:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   {
      /* Clear APIC errors */
      APICWrite(APIC_ESR, 0);
      tmp = (APICRead(APIC_ESR) & APIC_ESR_MASK);
   }

   Common = (PCOMMON_AREA_INFO)CommonBase;
   17b35:	8b 1d a0 e5 03 00    	mov    0x3e5a0,%ebx

   /* Write the location of the AP stack */
   Common->Stack = (ULONG)Stack;
   17b3b:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   /* Write the page directory page */
   Ke386GetPageTableDirectory(Common->PageDirectory);
   17b3e:	0f 20 da             	mov    %cr3,%edx
   17b41:	89 03                	mov    %eax,(%ebx)
   17b43:	89 53 04             	mov    %edx,0x4(%ebx)
   /* Write the kernel entry point */
   Common->NtProcessStartup = (ULONG_PTR)RtlImageNtHeader(MmSystemRangeStart)->OptionalHeader.AddressOfEntryPoint + (ULONG_PTR)MmSystemRangeStart;
   17b46:	a1 68 11 04 00       	mov    0x41168,%eax
   17b4b:	83 ec 0c             	sub    $0xc,%esp
   17b4e:	8b 00                	mov    (%eax),%eax
   17b50:	50                   	push   %eax
   17b51:	e8 8a 2e 00 00       	call   1a9e0 <_RtlImageNtHeader@4>
   17b56:	8b 15 68 11 04 00    	mov    0x41168,%edx
   17b5c:	8b 48 28             	mov    0x28(%eax),%ecx
   17b5f:	8b 12                	mov    (%edx),%edx
   17b61:	01 ca                	add    %ecx,%edx
   17b63:	89 53 08             	mov    %edx,0x8(%ebx)
   /* Write the state of the mae mode */
   Common->PaeModeEnabled = Ke386GetCr4() & X86_CR4_PAE ? 1 : 0;
   17b66:	58                   	pop    %eax
   17b67:	5a                   	pop    %edx
   17b68:	0f 20 e0             	mov    %cr4,%eax
   17b6b:	c1 e8 05             	shr    $0x5,%eax
   17b6e:	83 e0 01             	and    $0x1,%eax
   17b71:	89 43 0c             	mov    %eax,0xc(%ebx)

   DPRINT1("%x %x %x %x\n", Common->Stack, Common->PageDirectory, Common->NtProcessStartup, Common->PaeModeEnabled);
   17b74:	68 10 04 00 00       	push   $0x410
   17b79:	68 4a c5 01 00       	push   $0x1c54a
   17b7e:	68 51 c5 01 00       	push   $0x1c551
   17b83:	e8 08 2d 00 00       	call   1a890 <_DbgPrint>
   17b88:	58                   	pop    %eax
   17b89:	8b 43 0c             	mov    0xc(%ebx),%eax
   17b8c:	50                   	push   %eax
   17b8d:	8b 43 08             	mov    0x8(%ebx),%eax
   17b90:	50                   	push   %eax
   17b91:	8b 43 04             	mov    0x4(%ebx),%eax
   17b94:	50                   	push   %eax
   17b95:	8b 0b                	mov    (%ebx),%ecx
   17b97:	51                   	push   %ecx
   17b98:	68 eb c6 01 00       	push   $0x1c6eb
   17b9d:	e8 ee 2c 00 00       	call   1a890 <_DbgPrint>
   17ba2:	83 c4 20             	add    $0x20,%esp

   DPRINT("Cpu %d got stack at 0x%X\n", Cpu, Common->Stack);
#if 0
   for (j = 0; j < 16; j++) 
   {
      Common->Debug[j] = 0;
   }
#endif

   maxlvt = APICGetMaxLVT();
   17ba5:	e8 d6 de ff ff       	call   15a80 <_APICGetMaxLVT>
   17baa:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)

   /* Is this a local APIC or an 82489DX? */
   StartupCount = (APIC_INTEGRATED(CPUMap[Cpu].APICVersion)) ? 2 : 0;
   17bad:	8a 87 32 e6 03 00    	mov    0x3e632(%edi),%al

   for (i = 1; i <= StartupCount; i++)
   17bb3:	c7 45 e4 01 00 00 00 	movl   $0x1,0xffffffe4(%ebp)
   17bba:	83 e0 f0             	and    $0xfffffff0,%eax
   17bbd:	3c 01                	cmp    $0x1,%al
   17bbf:	19 ff                	sbb    %edi,%edi
   17bc1:	83 f7 ff             	xor    $0xffffffff,%edi
   17bc4:	83 e7 02             	and    $0x2,%edi
   17bc7:	39 7d e4             	cmp    %edi,0xffffffe4(%ebp)
   17bca:	0f 87 99 01 00 00    	ja     17d69 <_HaliStartApplicationProcessor+0x349>
   17bd0:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   17bd6:	8b 41 20             	mov    0x20(%ecx),%eax
   {
      /* It's a local APIC, so send STARTUP IPI */
      DPRINT("Sending startup signal %d\n", i);
      /* Clear errors */
      APICWrite(APIC_ESR, 0);
      APICRead(APIC_ESR);

      APICSendIPI(Cpu, APIC_DM_STARTUP | ((COMMON_AREA + PAGE_SIZE) >> 12)|APIC_ICR0_LEVEL_DEASSERT);

      /* Wait up to 10ms for IPI to be delivered */
      j = 0;
   17bd9:	31 db                	xor    %ebx,%ebx
   17bdb:	25 00 00 00 0f       	and    $0xf000000,%eax
   17be0:	c1 e8 18             	shr    $0x18,%eax
   17be3:	c7 04 85 40 e8 03 00 	movl   $0x280,0x3e840(,%eax,4)
   17bea:	80 02 00 00 
   17bee:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   17bf5:	00 00 00 00 
   17bf9:	8b 41 20             	mov    0x20(%ecx),%eax
   17bfc:	c7 81 80 02 00 00 00 	movl   $0x0,0x280(%ecx)
   17c03:	00 00 00 
   17c06:	25 00 00 00 0f       	and    $0xf000000,%eax
   17c0b:	c1 e8 18             	shr    $0x18,%eax
   17c0e:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   17c15:	00 00 00 00 
   17c19:	c7 04 85 b0 e5 03 00 	movl   $0x280,0x3e5b0(,%eax,4)
   17c20:	80 02 00 00 
   17c24:	8b 91 80 02 00 00    	mov    0x280(%ecx),%edx
   17c2a:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   17c31:	52                   	push   %edx
   17c32:	52                   	push   %edx
   17c33:	68 03 06 00 00       	push   $0x603
   17c38:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   17c3b:	50                   	push   %eax
   17c3c:	e8 df ec ff ff       	call   16920 <_APICSendIPI>
      do 
   17c41:	83 c4 10             	add    $0x10,%esp
      {
         KeStallExecutionProcessor(10);
   17c44:	83 ec 0c             	sub    $0xc,%esp

         /* Check Delivery Status */
         DeliveryStatus = APICRead(APIC_ICR0) & APIC_ICR0_DS;

         j++;
   17c47:	43                   	inc    %ebx
   17c48:	6a 0a                	push   $0xa
   17c4a:	e8 d1 d9 ff ff       	call   15620 <_KeStallExecutionProcessor@4>
   17c4f:	a1 10 b0 01 00       	mov    0x1b010,%eax
   17c54:	83 c4 0c             	add    $0xc,%esp
   17c57:	8b 50 20             	mov    0x20(%eax),%edx
   17c5a:	81 e2 00 00 00 0f    	and    $0xf000000,%edx
   17c60:	c1 ea 18             	shr    $0x18,%edx
   17c63:	c7 04 95 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%edx,4)
   17c6a:	00 00 00 00 
   17c6e:	c7 04 95 b0 e5 03 00 	movl   $0x300,0x3e5b0(,%edx,4)
   17c75:	00 03 00 00 
   17c79:	8b 80 00 03 00 00    	mov    0x300(%eax),%eax
      } while ((DeliveryStatus) && (j < 1000));
   17c7f:	89 c6                	mov    %eax,%esi
   17c81:	89 04 95 d0 e8 03 00 	mov    %eax,0x3e8d0(,%edx,4)
   17c88:	81 e6 00 10 00 00    	and    $0x1000,%esi
   17c8e:	0f 95 c2             	setne  %dl
   17c91:	81 fb e7 03 00 00    	cmp    $0x3e7,%ebx
   17c97:	0f 96 c0             	setbe  %al
   17c9a:	25 ff 00 00 00       	and    $0xff,%eax
   17c9f:	85 c2                	test   %eax,%edx
   17ca1:	75 a1                	jne    17c44 <_HaliStartApplicationProcessor+0x224>

      KeStallExecutionProcessor(200);
   17ca3:	83 ec 0c             	sub    $0xc,%esp
   17ca6:	68 c8 00 00 00       	push   $0xc8
   17cab:	e8 70 d9 ff ff       	call   15620 <_KeStallExecutionProcessor@4>

      /*
       * Due to the Pentium erratum 3AP.
       */
      if (maxlvt > 3) 
   17cb0:	83 c4 0c             	add    $0xc,%esp
   17cb3:	83 7d e8 03          	cmpl   $0x3,0xffffffe8(%ebp)
   17cb7:	0f 86 36 01 00 00    	jbe    17df3 <_HaliStartApplicationProcessor+0x3d3>
   17cbd:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   17cc3:	8b 41 20             	mov    0x20(%ecx),%eax
   17cc6:	25 00 00 00 0f       	and    $0xf000000,%eax
   17ccb:	c1 e8 18             	shr    $0x18,%eax
   17cce:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   17cd5:	00 00 00 00 
   17cd9:	c7 04 85 b0 e5 03 00 	movl   $0xf0,0x3e5b0(,%eax,4)
   17ce0:	f0 00 00 00 
   17ce4:	8b 91 f0 00 00 00    	mov    0xf0(%ecx),%edx
   17cea:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   17cf1:	8b 41 20             	mov    0x20(%ecx),%eax
   17cf4:	25 00 00 00 0f       	and    $0xf000000,%eax
   17cf9:	c1 e8 18             	shr    $0x18,%eax
   17cfc:	c7 04 85 40 e8 03 00 	movl   $0x280,0x3e840(,%eax,4)
   17d03:	80 02 00 00 
   17d07:	c7 04 85 70 e9 03 00 	movl   $0x0,0x3e970(,%eax,4)
   17d0e:	00 00 00 00 
   17d12:	c7 81 80 02 00 00 00 	movl   $0x0,0x280(%ecx)
   17d19:	00 00 00 
   17d1c:	8b 41 20             	mov    0x20(%ecx),%eax
   17d1f:	25 00 00 00 0f       	and    $0xf000000,%eax
   17d24:	c1 e8 18             	shr    $0x18,%eax
   17d27:	c7 04 85 d0 e8 03 00 	movl   $0x0,0x3e8d0(,%eax,4)
   17d2e:	00 00 00 00 
   17d32:	c7 04 85 b0 e5 03 00 	movl   $0x280,0x3e5b0(,%eax,4)
   17d39:	80 02 00 00 
   17d3d:	8b 91 80 02 00 00    	mov    0x280(%ecx),%edx
   17d43:	89 14 85 d0 e8 03 00 	mov    %edx,0x3e8d0(,%eax,4)
   17d4a:	81 e2 fe 00 00 00    	and    $0xfe,%edx
      {
        APICRead(APIC_SIVR);
        APICWrite(APIC_ESR, 0);
      }

      AcceptStatus = APICRead(APIC_ESR) & APIC_ESR_MASK;

      if (DeliveryStatus || AcceptStatus) 
   17d50:	89 d0                	mov    %edx,%eax
   17d52:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
   17d55:	09 f0                	or     %esi,%eax
   17d57:	75 10                	jne    17d69 <_HaliStartApplicationProcessor+0x349>
   17d59:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   17d5c:	40                   	inc    %eax
   17d5d:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   17d60:	39 7d e4             	cmp    %edi,0xffffffe4(%ebp)
   17d63:	0f 86 6d fe ff ff    	jbe    17bd6 <_HaliStartApplicationProcessor+0x1b6>
      {
         break;
      }
   }

   if (DeliveryStatus) 
   {
      DPRINT("STARTUP IPI for CPU %d was never delivered.\n", Cpu);
   }

   if (AcceptStatus) 
   {
      DPRINT("STARTUP IPI for CPU %d was never accepted.\n", Cpu);
   }

   if (!(DeliveryStatus || AcceptStatus)) 
   17d69:	0b 75 e0             	or     0xffffffe0(%ebp),%esi
   17d6c:	75 29                	jne    17d97 <_HaliStartApplicationProcessor+0x377>
   17d6e:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
   {

      /* Wait no more than 5 seconds for processor to boot */
      DPRINT("Waiting for 5 seconds for CPU %d to boot\n", Cpu);

      /* Wait no more than 5 seconds */
      for (j = 0; j < 50000; j++) 
   17d71:	31 db                	xor    %ebx,%ebx
   17d73:	c1 e6 04             	shl    $0x4,%esi
   17d76:	eb 16                	jmp    17d8e <_HaliStartApplicationProcessor+0x36e>
      {
         if (CPUMap[Cpu].Flags & CPU_ENABLED)
	 {
            break;
	 }
         KeStallExecutionProcessor(100);
   17d78:	83 ec 0c             	sub    $0xc,%esp
   17d7b:	43                   	inc    %ebx
   17d7c:	6a 64                	push   $0x64
   17d7e:	e8 9d d8 ff ff       	call   15620 <_KeStallExecutionProcessor@4>
   17d83:	83 c4 0c             	add    $0xc,%esp
   17d86:	81 fb 4f c3 00 00    	cmp    $0xc34f,%ebx
   17d8c:	77 09                	ja     17d97 <_HaliStartApplicationProcessor+0x377>
   17d8e:	f6 86 30 e6 03 00 02 	testb  $0x2,0x3e630(%esi)
   17d95:	74 e1                	je     17d78 <_HaliStartApplicationProcessor+0x358>
      }
   }

   if (CPUMap[Cpu].Flags & CPU_ENABLED) 
   17d97:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   17d9a:	c1 e0 04             	shl    $0x4,%eax
   17d9d:	f6 80 30 e6 03 00 02 	testb  $0x2,0x3e630(%eax)
   17da4:	74 34                	je     17dda <_HaliStartApplicationProcessor+0x3ba>
   {
      DbgPrint("CPU %d is now running\n", Cpu);
   17da6:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   17da9:	c7 45 08 f8 c6 01 00 	movl   $0x1c6f8,0x8(%ebp)
   17db0:	89 4d 0c             	mov    %ecx,0xc(%ebp)
   } 
   else 
   {
      DbgPrint("Initialization of CPU %d failed\n", Cpu);
   }

#if 0
   DPRINT("Debug bytes are:\n");

   for (j = 0; j < 4; j++) 
   {
      DPRINT("0x%08X 0x%08X 0x%08X 0x%08X.\n",
             Common->Debug[j*4+0],
             Common->Debug[j*4+1],
             Common->Debug[j*4+2],
             Common->Debug[j*4+3]);
   }

#endif
}
   17db3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   17db6:	5b                   	pop    %ebx
   17db7:	5e                   	pop    %esi
   17db8:	5f                   	pop    %edi
   17db9:	5d                   	pop    %ebp
   17dba:	e9 d1 2a 00 00       	jmp    1a890 <_DbgPrint>
   17dbf:	b8 01 00 00 00       	mov    $0x1,%eax
   17dc4:	8a 4d f0             	mov    0xfffffff0(%ebp),%cl
   17dc7:	d3 e0                	shl    %cl,%eax
   17dc9:	85 05 90 e5 03 00    	test   %eax,0x3e590
   17dcf:	0f 84 9e fc ff ff    	je     17a73 <_HaliStartApplicationProcessor+0x53>
   17dd5:	e9 75 fc ff ff       	jmp    17a4f <_HaliStartApplicationProcessor+0x2f>
   17dda:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   17ddd:	c7 45 08 10 c7 01 00 	movl   $0x1c710,0x8(%ebp)
   17de4:	89 45 0c             	mov    %eax,0xc(%ebp)
   17de7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   17dea:	5b                   	pop    %ebx
   17deb:	5e                   	pop    %esi
   17dec:	5f                   	pop    %edi
   17ded:	5d                   	pop    %ebp
   17dee:	e9 9d 2a 00 00       	jmp    1a890 <_DbgPrint>
   17df3:	8b 0d 10 b0 01 00    	mov    0x1b010,%ecx
   17df9:	e9 1e ff ff ff       	jmp    17d1c <_HaliStartApplicationProcessor+0x2fc>
   17dfe:	90                   	nop    
   17dff:	90                   	nop    

00017e00 <_HalpInitPhase0>:
/***************************************************************************/
VOID
HalpInitPhase0(VOID)

{
   17e00:	55                   	push   %ebp
   17e01:	89 e5                	mov    %esp,%ebp
   17e03:	51                   	push   %ecx
   17e04:	51                   	push   %ecx
   static BOOLEAN MPSInitialized = FALSE;


   /* Only initialize MP system once. Once called the first time,
      each subsequent call is part of the initialization sequence
			for an application processor. */

   DPRINT("HalpInitPhase0()\n");


   if (MPSInitialized) 
   17e05:	80 3d b0 e4 03 00 00 	cmpb   $0x0,0x3e4b0
   17e0c:	75 35                	jne    17e43 <_HalpInitPhase0+0x43>
   {
      KEBUGCHECK(0);
   }

   MPSInitialized = TRUE;
   17e0e:	c6 05 b0 e4 03 00 01 	movb   $0x1,0x3e4b0

   if (!HaliFindSmpConfig())
   17e15:	e8 26 19 00 00       	call   19740 <_HaliFindSmpConfig>
   17e1a:	84 c0                	test   %al,%al
   17e1c:	74 02                	je     17e20 <_HalpInitPhase0+0x20>
   {
      KEBUGCHECK(0);
   }
}
   17e1e:	c9                   	leave  
   17e1f:	c3                   	ret    
   17e20:	50                   	push   %eax
   17e21:	6a 31                	push   $0x31
   17e23:	68 40 c7 01 00       	push   $0x1c740
   17e28:	68 4d c7 01 00       	push   $0x1c74d
   17e2d:	e8 5e 2a 00 00       	call   1a890 <_DbgPrint>
   17e32:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   17e39:	e8 32 2a 00 00       	call   1a870 <_KeBugCheck@4>
   17e3e:	83 c4 0c             	add    $0xc,%esp
   17e41:	c9                   	leave  
   17e42:	c3                   	ret    
   17e43:	52                   	push   %edx
   17e44:	6a 2a                	push   $0x2a
   17e46:	68 40 c7 01 00       	push   $0x1c740
   17e4b:	68 4d c7 01 00       	push   $0x1c74d
   17e50:	e8 3b 2a 00 00       	call   1a890 <_DbgPrint>
   17e55:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   17e5c:	e8 0f 2a 00 00       	call   1a870 <_KeBugCheck@4>
   17e61:	83 c4 0c             	add    $0xc,%esp
   17e64:	eb a8                	jmp    17e0e <_HalpInitPhase0+0xe>
   17e66:	90                   	nop    
   17e67:	90                   	nop    
   17e68:	90                   	nop    
   17e69:	90                   	nop    
   17e6a:	90                   	nop    
   17e6b:	90                   	nop    
   17e6c:	90                   	nop    
   17e6d:	90                   	nop    
   17e6e:	90                   	nop    
   17e6f:	90                   	nop    

00017e70 <_IOAPICWrite>:

/* EOF */
   17e70:	55                   	push   %ebp
   17e71:	89 e5                	mov    %esp,%ebp
   17e73:	8b 45 08             	mov    0x8(%ebp),%eax
   17e76:	c1 e0 04             	shl    $0x4,%eax
   17e79:	8b 90 18 ee 03 00    	mov    0x3ee18(%eax),%edx
   17e7f:	8b 45 0c             	mov    0xc(%ebp),%eax
   17e82:	89 02                	mov    %eax,(%edx)
   17e84:	8b 45 10             	mov    0x10(%ebp),%eax
   17e87:	89 42 10             	mov    %eax,0x10(%edx)
   17e8a:	5d                   	pop    %ebp
   17e8b:	c3                   	ret    
   17e8c:	8d 74 26 00          	lea    0x0(%esi),%esi

00017e90 <_IOAPICRead>:
   17e90:	55                   	push   %ebp
   17e91:	89 e5                	mov    %esp,%ebp
   17e93:	8b 45 08             	mov    0x8(%ebp),%eax
   17e96:	c1 e0 04             	shl    $0x4,%eax
   17e99:	8b 90 18 ee 03 00    	mov    0x3ee18(%eax),%edx
   17e9f:	8b 45 0c             	mov    0xc(%ebp),%eax
   17ea2:	89 02                	mov    %eax,(%edx)
   17ea4:	8b 42 10             	mov    0x10(%edx),%eax
   17ea7:	5d                   	pop    %ebp
   17ea8:	c3                   	ret    
   17ea9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00017eb0 <_IOAPICEnable>:
   17eb0:	55                   	push   %ebp
   17eb1:	89 e5                	mov    %esp,%ebp
   17eb3:	57                   	push   %edi
   17eb4:	56                   	push   %esi
   17eb5:	53                   	push   %ebx
   17eb6:	83 ec 20             	sub    $0x20,%esp
   17eb9:	31 db                	xor    %ebx,%ebx
   17ebb:	68 00 02 00 00       	push   $0x200
   17ec0:	6a 00                	push   $0x0
   17ec2:	68 f0 eb 03 00       	push   $0x3ebf0
   17ec7:	e8 24 2b 00 00       	call   1a9f0 <_memset>
   17ecc:	a1 50 ee 03 00       	mov    0x3ee50,%eax
   17ed1:	83 c4 10             	add    $0x10,%esp
   17ed4:	39 c3                	cmp    %eax,%ebx
   17ed6:	73 28                	jae    17f00 <_IOAPICEnable+0x50>
   17ed8:	6a 01                	push   $0x1
   17eda:	53                   	push   %ebx
   17edb:	e8 b0 ff ff ff       	call   17e90 <_IOAPICRead>
   17ee0:	89 da                	mov    %ebx,%edx
   17ee2:	25 00 00 ff 00       	and    $0xff0000,%eax
   17ee7:	43                   	inc    %ebx
   17ee8:	c1 e2 04             	shl    $0x4,%edx
   17eeb:	c1 e8 10             	shr    $0x10,%eax
   17eee:	40                   	inc    %eax
   17eef:	89 82 1c ee 03 00    	mov    %eax,0x3ee1c(%edx)
   17ef5:	58                   	pop    %eax
   17ef6:	5a                   	pop    %edx
   17ef7:	a1 50 ee 03 00       	mov    0x3ee50,%eax
   17efc:	39 c3                	cmp    %eax,%ebx
   17efe:	72 d8                	jb     17ed8 <_IOAPICEnable+0x28>
   17f00:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
   17f07:	39 45 e4             	cmp    %eax,0xffffffe4(%ebp)
   17f0a:	73 5a                	jae    17f66 <_IOAPICEnable+0xb6>
   17f0c:	8d 7d e8             	lea    0xffffffe8(%ebp),%edi
   17f0f:	31 f6                	xor    %esi,%esi
   17f11:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   17f18:	8d 1c 36             	lea    (%esi,%esi,1),%ebx
   17f1b:	80 4f 02 01          	orb    $0x1,0x2(%edi)
   17f1f:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   17f22:	c7 47 04 00 00 00 00 	movl   $0x0,0x4(%edi)
   17f29:	50                   	push   %eax
   17f2a:	8d 43 10             	lea    0x10(%ebx),%eax
   17f2d:	50                   	push   %eax
   17f2e:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   17f31:	50                   	push   %eax
   17f32:	e8 39 ff ff ff       	call   17e70 <_IOAPICWrite>
   17f37:	83 c4 0c             	add    $0xc,%esp
   17f3a:	8b 4f 04             	mov    0x4(%edi),%ecx
   17f3d:	83 c3 11             	add    $0x11,%ebx
   17f40:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   17f43:	51                   	push   %ecx
   17f44:	46                   	inc    %esi
   17f45:	53                   	push   %ebx
   17f46:	52                   	push   %edx
   17f47:	e8 24 ff ff ff       	call   17e70 <_IOAPICWrite>
   17f4c:	83 c4 0c             	add    $0xc,%esp
   17f4f:	83 fe 17             	cmp    $0x17,%esi
   17f52:	76 bd                	jbe    17f11 <_IOAPICEnable+0x61>
   17f54:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   17f57:	40                   	inc    %eax
   17f58:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   17f5b:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   17f5e:	3b 05 50 ee 03 00    	cmp    0x3ee50,%eax
   17f64:	72 a9                	jb     17f0f <_IOAPICEnable+0x5f>
   17f66:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   17f69:	5b                   	pop    %ebx
   17f6a:	5e                   	pop    %esi
   17f6b:	5f                   	pop    %edi
   17f6c:	5d                   	pop    %ebp
   17f6d:	c3                   	ret    
   17f6e:	89 f6                	mov    %esi,%esi

00017f70 <_IOAPICSetupIds>:
   17f70:	55                   	push   %ebp
   17f71:	31 c0                	xor    %eax,%eax
   17f73:	89 e5                	mov    %esp,%ebp
   17f75:	57                   	push   %edi
   17f76:	56                   	push   %esi
   17f77:	53                   	push   %ebx
   17f78:	83 ec 0c             	sub    $0xc,%esp
   17f7b:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   17f82:	3b 05 50 ee 03 00    	cmp    0x3ee50,%eax
   17f88:	0f 83 00 01 00 00    	jae    1808e <_IOAPICSetupIds+0x11e>
   17f8e:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   17f95:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
   17f98:	6a 00                	push   $0x0
   17f9a:	53                   	push   %ebx
   17f9b:	e8 f0 fe ff ff       	call   17e90 <_IOAPICRead>
   17fa0:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   17fa3:	89 c6                	mov    %eax,%esi
   17fa5:	58                   	pop    %eax
   17fa6:	59                   	pop    %ecx
   17fa7:	8b 93 10 ee 03 00    	mov    0x3ee10(%ebx),%edx
   17fad:	89 d7                	mov    %edx,%edi
   17faf:	83 fa 0e             	cmp    $0xe,%edx
   17fb2:	0f 87 f4 00 00 00    	ja     180ac <_IOAPICSetupIds+0x13c>
   17fb8:	89 f8                	mov    %edi,%eax
   17fba:	25 ff 00 00 00       	and    $0xff,%eax
   17fbf:	39 d0                	cmp    %edx,%eax
   17fc1:	74 21                	je     17fe4 <_IOAPICSetupIds+0x74>
   17fc3:	31 d2                	xor    %edx,%edx
   17fc5:	8b 0d c0 e4 03 00    	mov    0x3e4c0,%ecx
   17fcb:	39 ca                	cmp    %ecx,%edx
   17fcd:	73 15                	jae    17fe4 <_IOAPICSetupIds+0x74>
   17fcf:	90                   	nop    
   17fd0:	89 fb                	mov    %edi,%ebx
   17fd2:	38 1c d5 66 ee 03 00 	cmp    %bl,0x3ee66(,%edx,8)
   17fd9:	0f 84 b7 00 00 00    	je     18096 <_IOAPICSetupIds+0x126>
   17fdf:	42                   	inc    %edx
   17fe0:	39 ca                	cmp    %ecx,%edx
   17fe2:	72 ec                	jb     17fd0 <_IOAPICSetupIds+0x60>
   17fe4:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   17fe7:	81 e6 ff ff ff f0    	and    $0xf0ffffff,%esi
   17fed:	8b 82 10 ee 03 00    	mov    0x3ee10(%edx),%eax
   17ff3:	c1 e0 18             	shl    $0x18,%eax
   17ff6:	09 f0                	or     %esi,%eax
   17ff8:	50                   	push   %eax
   17ff9:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   17ffc:	6a 00                	push   $0x0
   17ffe:	50                   	push   %eax
   17fff:	e8 6c fe ff ff       	call   17e70 <_IOAPICWrite>
   18004:	8b 7d f0             	mov    0xfffffff0(%ebp),%edi
   18007:	6a 00                	push   $0x0
   18009:	57                   	push   %edi
   1800a:	e8 81 fe ff ff       	call   17e90 <_IOAPICRead>
   1800f:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   18012:	89 c6                	mov    %eax,%esi
   18014:	83 c4 14             	add    $0x14,%esp
   18017:	81 e6 00 00 00 0f    	and    $0xf000000,%esi
   1801d:	c1 ee 18             	shr    $0x18,%esi
   18020:	3b b3 10 ee 03 00    	cmp    0x3ee10(%ebx),%esi
   18026:	74 47                	je     1806f <_IOAPICSetupIds+0xff>
   18028:	56                   	push   %esi
   18029:	68 f7 01 00 00       	push   $0x1f7
   1802e:	68 70 c7 01 00       	push   $0x1c770
   18033:	68 79 c7 01 00       	push   $0x1c779
   18038:	e8 53 28 00 00       	call   1a890 <_DbgPrint>
   1803d:	c7 04 24 82 c7 01 00 	movl   $0x1c782,(%esp)
   18044:	e8 47 28 00 00       	call   1a890 <_DbgPrint>
   18049:	83 c4 0c             	add    $0xc,%esp
   1804c:	68 f8 01 00 00       	push   $0x1f8
   18051:	68 70 c7 01 00       	push   $0x1c770
   18056:	68 9e c7 01 00       	push   $0x1c79e
   1805b:	e8 30 28 00 00       	call   1a890 <_DbgPrint>
   18060:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   18067:	e8 04 28 00 00       	call   1a870 <_KeBugCheck@4>
   1806c:	83 c4 0c             	add    $0xc,%esp
   1806f:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
   18072:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   18075:	43                   	inc    %ebx
   18076:	83 c1 10             	add    $0x10,%ecx
   18079:	89 5d f0             	mov    %ebx,0xfffffff0(%ebp)
   1807c:	89 4d ec             	mov    %ecx,0xffffffec(%ebp)
   1807f:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   18082:	3b 05 50 ee 03 00    	cmp    0x3ee50,%eax
   18088:	0f 82 07 ff ff ff    	jb     17f95 <_IOAPICSetupIds+0x25>
   1808e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   18091:	5b                   	pop    %ebx
   18092:	5e                   	pop    %esi
   18093:	5f                   	pop    %edi
   18094:	5d                   	pop    %ebp
   18095:	c3                   	ret    
   18096:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   18099:	8b 83 10 ee 03 00    	mov    0x3ee10(%ebx),%eax
   1809f:	88 04 d5 66 ee 03 00 	mov    %al,0x3ee66(,%edx,8)
   180a6:	42                   	inc    %edx
   180a7:	e9 34 ff ff ff       	jmp    17fe0 <_IOAPICSetupIds+0x70>
   180ac:	50                   	push   %eax
   180ad:	68 d0 01 00 00       	push   $0x1d0
   180b2:	68 70 c7 01 00       	push   $0x1c770
   180b7:	68 79 c7 01 00       	push   $0x1c779
   180bc:	e8 cf 27 00 00       	call   1a890 <_DbgPrint>
   180c1:	83 c4 0c             	add    $0xc,%esp
   180c4:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   180c7:	8b 9b 10 ee 03 00    	mov    0x3ee10(%ebx),%ebx
   180cd:	53                   	push   %ebx
   180ce:	51                   	push   %ecx
   180cf:	68 b4 c7 01 00       	push   $0x1c7b4
   180d4:	89 f3                	mov    %esi,%ebx
   180d6:	e8 b5 27 00 00       	call   1a890 <_DbgPrint>
   180db:	83 c4 0c             	add    $0xc,%esp
   180de:	81 e3 00 00 00 0f    	and    $0xf000000,%ebx
   180e4:	68 d2 01 00 00       	push   $0x1d2
   180e9:	c1 eb 18             	shr    $0x18,%ebx
   180ec:	68 70 c7 01 00       	push   $0x1c770
   180f1:	68 79 c7 01 00       	push   $0x1c779
   180f6:	e8 95 27 00 00       	call   1a890 <_DbgPrint>
   180fb:	58                   	pop    %eax
   180fc:	5a                   	pop    %edx
   180fd:	53                   	push   %ebx
   180fe:	68 e8 c7 01 00       	push   $0x1c7e8
   18103:	e8 88 27 00 00       	call   1a890 <_DbgPrint>
   18108:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1810b:	83 c4 10             	add    $0x10,%esp
   1810e:	89 da                	mov    %ebx,%edx
   18110:	89 98 10 ee 03 00    	mov    %ebx,0x3ee10(%eax)
   18116:	e9 9d fe ff ff       	jmp    17fb8 <_IOAPICSetupIds+0x48>
   1811b:	90                   	nop    
   1811c:	8d 74 26 00          	lea    0x0(%esi),%esi

00018120 <_IOAPICMaskIrq>:
   18120:	55                   	push   %ebp
   18121:	89 e5                	mov    %esp,%ebp
   18123:	57                   	push   %edi
   18124:	56                   	push   %esi
   18125:	53                   	push   %ebx
   18126:	83 ec 0c             	sub    $0xc,%esp
   18129:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1812c:	8b 34 9d f0 e9 03 00 	mov    0x3e9f0(,%ebx,4),%esi
   18133:	01 db                	add    %ebx,%ebx
   18135:	8d 7b 10             	lea    0x10(%ebx),%edi
   18138:	83 c3 11             	add    $0x11,%ebx
   1813b:	57                   	push   %edi
   1813c:	56                   	push   %esi
   1813d:	e8 4e fd ff ff       	call   17e90 <_IOAPICRead>
   18142:	53                   	push   %ebx
   18143:	56                   	push   %esi
   18144:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   18147:	e8 44 fd ff ff       	call   17e90 <_IOAPICRead>

#ifdef CONFIG_SMP

static inline PKPCR KeGetCurrentKPCR(VOID)
{
   1814c:	83 c4 10             	add    $0x10,%esp
#define default_ISA_polarity(idx)	(0)

/* PCI interrupts are always polarity one level triggered,
 * when listed as conforming in the MP table. */

#define default_PCI_trigger(idx)	(1)
#define default_PCI_polarity(idx)	(1)

/* MCA interrupts are always polarity zero level triggered,
 * when listed as conforming in the MP table. */

#define default_MCA_trigger(idx)	(1)
#define default_MCA_polarity(idx)	(0)

/***************************************************************************/

extern VOID Disable8259AIrq(ULONG irq);
ULONG IOAPICRead(ULONG Apic, ULONG Offset);
VOID IOAPICWrite(ULONG Apic, ULONG Offset, ULONG Value);

/* FUNCTIONS ***************************************************************/

/*
 * EISA Edge/Level control register, ELCR
 */
static ULONG EISA_ELCR(ULONG irq)
{
   if (irq < 16) 
   {
      PUCHAR port = (PUCHAR)(0x4d0 + (irq >> 3));
      return (READ_PORT_UCHAR(port) >> (irq & 7)) & 1;
   }
   DPRINT("Broken MPtable reports ISA irq %d\n", irq);
   return 0;
}

static ULONG 
IRQPolarity(ULONG idx)
{
   ULONG bus = IRQMap[idx].SrcBusId;
   ULONG polarity;

   /*
    * Determine IRQ line polarity (high active or low active):
    */
   switch (IRQMap[idx].IrqFlag & 3)
   {
      case 0: /* conforms, ie. bus-type dependent polarity */
         {
            switch (BUSMap[bus])
	    {
	       case MP_BUS_ISA: /* ISA pin */
		  polarity = default_ISA_polarity(idx);
		  break;
		  
	       case MP_BUS_EISA: /* EISA pin */
		  polarity = default_EISA_polarity(idx);
		  break;
		
	       case MP_BUS_PCI: /* PCI pin */
		  polarity = default_PCI_polarity(idx);
		  break;

	       case MP_BUS_MCA: /* MCA pin */
                  polarity = default_MCA_polarity(idx);
		  break;
		
	       default:
		  DPRINT("Broken BIOS!!\n");
		  polarity = 1;
	    }
	 }
	 break;

      case 1: /* high active */
	 polarity = 0;
	 break;

      case 2: /* reserved */
	 DPRINT("Broken BIOS!!\n");
	 polarity = 1;
	 break;

      case 3: /* low active */
         polarity = 1;
	 break;

      default: /* invalid */
	 DPRINT("Broken BIOS!!\n");
	 polarity = 1;
   }
   return polarity;
}

static ULONG 
IRQTrigger(ULONG idx)
{
   ULONG bus = IRQMap[idx].SrcBusId;
   ULONG trigger;

   /*
    * Determine IRQ trigger mode (edge or level sensitive):
    */
   switch ((IRQMap[idx].IrqFlag >> 2) & 3)
   {
      case 0: /* conforms, ie. bus-type dependent */
	 {
            switch (BUSMap[bus])
	    {
	       case MP_BUS_ISA: /* ISA pin */
	          trigger = default_ISA_trigger(idx);
		  break;

	       case MP_BUS_EISA: /* EISA pin */
		  trigger = default_EISA_trigger(idx);
		  break;
		
	       case MP_BUS_PCI: /* PCI pin */
		  trigger = default_PCI_trigger(idx);
		  break;

               case MP_BUS_MCA: /* MCA pin */
		  trigger = default_MCA_trigger(idx);
		  break;
		
               default:
                  DPRINT("Broken BIOS!!\n");
		  trigger = 1;
	    }
	 }
	 break;

      case 1: /* edge */
	 trigger = 0;
	 break;

      case 2: /* reserved */
	 DPRINT("Broken BIOS!!\n");
	 trigger = 1;
	 break;

      case 3: /* level */
 	 trigger = 1;
	 break;
	
      default: /* invalid */
	 DPRINT("Broken BIOS!!\n");
	 trigger = 0;					
   }
   return trigger;
}

static ULONG 
Pin2Irq(ULONG idx,
	ULONG apic,
	ULONG pin)
{
   ULONG irq, i;
   ULONG bus = IRQMap[idx].SrcBusId;

   /*
    * Debugging check, we are in big trouble if this message pops up!
    */
   if (IRQMap[idx].DstApicInt != pin) 
   {
      DPRINT("broken BIOS or MPTABLE parser, ayiee!!\n");
   }

   switch (BUSMap[bus])
   {
      case MP_BUS_ISA: /* ISA pin */
      case MP_BUS_EISA:
      case MP_BUS_MCA:
	irq = IRQMap[idx].SrcBusIrq;
	break;

      case MP_BUS_PCI: /* PCI pin */
	 /*
	  * PCI IRQs are mapped in order
	  */
	 i = irq = 0;
	 while (i < apic)
	 {
	    irq += IOAPICMap[i++].EntryCount;
	 }
	 irq += pin;
	 break;
	
      default:
	 DPRINT("Unknown bus type %d.\n",bus);
	 irq = 0;
   }
   return irq;
}

static ULONG 
AssignIrqVector(ULONG irq)
{
#if 0
   static ULONG current_vector = FIRST_DEVICE_VECTOR, vector_offset = 0;
#endif
   ULONG vector;
   /* There may already have been assigned a vector for this IRQ */
   vector = IRQVectorMap[irq];
   if (vector > 0)
   {
      return vector;
   }
#if 0
   if (current_vector > FIRST_SYSTEM_VECTOR) 
   {
      vector_offset++;
      current_vector = FIRST_DEVICE_VECTOR + vector_offset;
   } 
   else if (current_vector == FIRST_SYSTEM_VECTOR) 
   {
      DPRINT1("Ran out of interrupt sources!");
      KEBUGCHECK(0);
   }

   vector = current_vector;
   IRQVectorMap[irq] = vector;
   current_vector += 8;
   return vector;
#else
   vector = IRQ2VECTOR(irq);
   IRQVectorMap[irq] = vector;
   return vector;
#endif
}

/*
 * Find the IRQ entry number of a certain pin.
 */
static ULONG 
IOAPICGetIrqEntry(ULONG apic,
		  ULONG pin,
		  ULONG type)
{
   ULONG i;

   for (i = 0; i < IRQCount; i++)
   {
      if (IRQMap[i].IrqType == type &&
	  (IRQMap[i].DstApicId == IOAPICMap[apic].ApicId || IRQMap[i].DstApicId == MP_APIC_ALL) &&
	  IRQMap[i].DstApicInt == pin)
      {
         return i;
      }
   }
   return -1;
}


VOID 
IOAPICSetupIrqs(VOID)
{
   IOAPIC_ROUTE_ENTRY entry;
   ULONG apic, pin, idx, irq, first_notcon = 1, vector, trigger;

   DPRINT("Init IO_APIC IRQs\n");

   /* Setup IRQ to vector translation map */
   memset(&IRQVectorMap, 0, sizeof(IRQVectorMap));

   for (apic = 0; apic < IOAPICCount; apic++) 
   {
      for (pin = 0; pin < IOAPICMap[apic].EntryCount; pin++) 
      {
         /*
	  * add it to the IO-APIC irq-routing table
	  */
	 memset(&entry,0,sizeof(entry));

	 entry.delivery_mode = (APIC_DM_LOWEST >> 8);
	 entry.dest_mode = 1;  /* logical delivery */
	 entry.mask = 1;       /* disable IRQ */
         entry.dest.logical.logical_dest = 0;

	 idx = IOAPICGetIrqEntry(apic,pin,INT_VECTORED);
	 if (idx == -1) 
	 {
	    if (first_notcon) 
	    {
	       DPRINT(" IO-APIC (apicid-pin) %d-%d\n", IOAPICMap[apic].ApicId, pin);
	       first_notcon = 0;
	    } 
	    else 
	    {
	       DPRINT(", %d-%d\n", IOAPICMap[apic].ApicId, pin);
            }
	    continue;
	 }

         trigger = IRQTrigger(idx);
	 entry.polarity = IRQPolarity(idx);

	 if (trigger) 
	 {
	    entry.trigger = 1;
	 }

	 irq = Pin2Irq(idx, apic, pin);

  	 vector = AssignIrqVector(irq);
	 entry.vector = vector;

	 DPRINT("vector 0x%.08x assigned to irq 0x%.02x\n", vector, irq);

         if (irq == 0)
         {
            /* Mask timer IRQ */
            entry.mask = 1;
         }

         if ((apic == 0) && (irq < 16))
	 {
	    Disable8259AIrq(irq);
	 }
         IOAPICWrite(apic, IOAPIC_REDTBL+2*pin+1, *(((PULONG)&entry)+1));
	 IOAPICWrite(apic, IOAPIC_REDTBL+2*pin, *(((PULONG)&entry)+0));

	 IrqApicMap[irq] = apic;

	 DPRINT("Vector %x, Pin %x, Irq %x\n", vector, pin, irq);
      }
   }
}

static VOID 
IOAPICClearPin(ULONG Apic, ULONG Pin)
{
   IOAPIC_ROUTE_ENTRY Entry;

   DPRINT("IOAPICClearPin(Apic %d, Pin %d\n", Apic, Pin);
   /*
    * Disable it in the IO-APIC irq-routing table
    */
   memset(&Entry, 0, sizeof(Entry));
   Entry.mask = 1;

   IOAPICWrite(Apic, IOAPIC_REDTBL + 2 * Pin, *(((PULONG)&Entry) + 0));
   IOAPICWrite(Apic, IOAPIC_REDTBL + 1 + 2 * Pin, *(((PULONG)&Entry) + 1));
}

static VOID 
IOAPICClear(ULONG Apic)
{
   ULONG Pin;

   for (Pin = 0; Pin < /*IOAPICMap[Apic].EntryCount*/24; Pin++)
   {
     IOAPICClearPin(Apic, Pin);
   }
}

static VOID 
IOAPICClearAll(VOID)
{
   ULONG Apic;

   for (Apic = 0; Apic < IOAPICCount; Apic++)
   {
      IOAPICClear(Apic);
   }
}

VOID 
IOAPICEnable(VOID)
{
   ULONG i, tmp;

   /* Setup IRQ to vector translation map */
   memset(&IRQVectorMap, 0, sizeof(IRQVectorMap));

   /*
    * The number of IO-APIC IRQ registers (== #pins):
    */
   for (i = 0; i < IOAPICCount; i++) 
   {
      tmp = IOAPICRead(i, IOAPIC_VER);
      IOAPICMap[i].EntryCount = GET_IOAPIC_MRE(tmp) + 1;
   }

   /*
    * Do not trust the IO-APIC being empty at bootup
    */
   IOAPICClearAll();
}

VOID 
IOAPICSetupIds(VOID)
{
  ULONG tmp, apic, i;
  UCHAR old_id;
  
  /*
   * Set the IOAPIC ID to the value stored in the MPC table.
   */
  for (apic = 0; apic < IOAPICCount; apic++) 
  {
    
    /* Read the register 0 value */
    tmp = IOAPICRead(apic, IOAPIC_ID);
    
    old_id = IOAPICMap[apic].ApicId;
    
    if (IOAPICMap[apic].ApicId >= 0xf) 
    {
      DPRINT1("BIOS bug, IO-APIC#%d ID is %d in the MPC table!...\n",
	      apic, IOAPICMap[apic].ApicId);
      DPRINT1("... fixing up to %d. (tell your hw vendor)\n", 
	      GET_IOAPIC_ID(tmp));
      IOAPICMap[apic].ApicId = GET_IOAPIC_ID(tmp);
    }
    
    /*
     * We need to adjust the IRQ routing table
     * if the ID changed.
     */
    if (old_id != IOAPICMap[apic].ApicId)
    {
      for (i = 0; i < IRQCount; i++)
      {
	if (IRQMap[i].DstApicId == old_id)
	{
	  IRQMap[i].DstApicId = IOAPICMap[apic].ApicId;
	}
      }
    }
    
    /*
     * Read the right value from the MPC table and
     * write it into the ID register.
     */
    DPRINT("Changing IO-APIC physical APIC ID to %d\n",
	   IOAPICMap[apic].ApicId);
    
    tmp &= ~IOAPIC_ID_MASK;
    tmp |= SET_IOAPIC_ID(IOAPICMap[apic].ApicId);

    IOAPICWrite(apic, IOAPIC_ID, tmp);
    
    /*
     * Sanity check
     */
    tmp = IOAPICRead(apic, 0);
    if (GET_IOAPIC_ID(tmp) != IOAPICMap[apic].ApicId) 
    {
      DPRINT1("Could not set I/O APIC ID!\n");
      KEBUGCHECK(0);
    }
  }
}

/* This is performance critical and should probably be done in assembler */
VOID IOAPICMaskIrq(ULONG Irq)
{
   IOAPIC_ROUTE_ENTRY Entry;
   ULONG Apic = IrqApicMap[Irq];

   *(((PULONG)&Entry)+0) = IOAPICRead(Apic, IOAPIC_REDTBL+2*Irq);
   *(((PULONG)&Entry)+1) = IOAPICRead(Apic, IOAPIC_REDTBL+2*Irq+1);
   1814f:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
{
  ULONG value;

#if defined(__GNUC__)
  __asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
   18152:	64 a1 1c 00 00 00    	mov    %fs:0x1c,%eax
   18158:	31 c9                	xor    %ecx,%ecx
   1815a:	8a 48 51             	mov    0x51(%eax),%cl
   1815d:	b8 fe ff ff ff       	mov    $0xfffffffe,%eax
   18162:	d3 c0                	rol    %cl,%eax
   18164:	22 45 ef             	and    0xffffffef(%ebp),%al
   18167:	88 45 ef             	mov    %al,0xffffffef(%ebp)
   Entry.dest.logical.logical_dest &= ~(1 << KeGetCurrentProcessorNumber());
   if (Entry.dest.logical.logical_dest == 0)
   1816a:	84 c0                	test   %al,%al
   1816c:	75 04                	jne    18172 <_IOAPICMaskIrq+0x52>
   {
      Entry.mask = 1;
   1816e:	80 4d ea 01          	orb    $0x1,0xffffffea(%ebp)
   }
   IOAPICWrite(Apic, IOAPIC_REDTBL+2*Irq+1, *(((PULONG)&Entry)+1));
   18172:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   18175:	50                   	push   %eax
   18176:	53                   	push   %ebx
   18177:	56                   	push   %esi
   18178:	e8 f3 fc ff ff       	call   17e70 <_IOAPICWrite>
   IOAPICWrite(Apic, IOAPIC_REDTBL+2*Irq, *(((PULONG)&Entry)+0));
   1817d:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   18180:	50                   	push   %eax
   18181:	57                   	push   %edi
   18182:	56                   	push   %esi
   18183:	e8 e8 fc ff ff       	call   17e70 <_IOAPICWrite>
   18188:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1818b:	5b                   	pop    %ebx
   1818c:	5e                   	pop    %esi
   1818d:	5f                   	pop    %edi
   1818e:	5d                   	pop    %ebp
   1818f:	c3                   	ret    

00018190 <_IOAPICUnmaskIrq>:
}

/* This is performance critical and should probably be done in assembler */
VOID IOAPICUnmaskIrq(ULONG Irq)
{
   18190:	55                   	push   %ebp
   18191:	89 e5                	mov    %esp,%ebp
   18193:	57                   	push   %edi
   18194:	56                   	push   %esi
   18195:	53                   	push   %ebx
   18196:	83 ec 0c             	sub    $0xc,%esp
   18199:	8b 5d 08             	mov    0x8(%ebp),%ebx
   IOAPIC_ROUTE_ENTRY Entry;
   ULONG Apic = IrqApicMap[Irq];
   1819c:	8b 34 9d f0 e9 03 00 	mov    0x3e9f0(,%ebx,4),%esi

   *(((PULONG)&Entry)+0) = IOAPICRead(Apic, IOAPIC_REDTBL+2*Irq);
   181a3:	01 db                	add    %ebx,%ebx
   181a5:	8d 7b 10             	lea    0x10(%ebx),%edi
   *(((PULONG)&Entry)+1) = IOAPICRead(Apic, IOAPIC_REDTBL+2*Irq+1);
   181a8:	83 c3 11             	add    $0x11,%ebx
   181ab:	57                   	push   %edi
   181ac:	56                   	push   %esi
   181ad:	e8 de fc ff ff       	call   17e90 <_IOAPICRead>
   181b2:	53                   	push   %ebx
   181b3:	56                   	push   %esi
   181b4:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   181b7:	e8 d4 fc ff ff       	call   17e90 <_IOAPICRead>

#ifdef CONFIG_SMP

static inline PKPCR KeGetCurrentKPCR(VOID)
{
   181bc:	83 c4 10             	add    $0x10,%esp
   181bf:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
{
  ULONG value;

#if defined(__GNUC__)
  __asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
   181c2:	64 a1 1c 00 00 00    	mov    %fs:0x1c,%eax
   181c8:	31 c9                	xor    %ecx,%ecx
   181ca:	8a 48 51             	mov    0x51(%eax),%cl
   181cd:	b8 01 00 00 00       	mov    $0x1,%eax
   181d2:	d3 e0                	shl    %cl,%eax
   181d4:	08 45 ef             	or     %al,0xffffffef(%ebp)
   Entry.dest.logical.logical_dest |= 1 << KeGetCurrentProcessorNumber();
   Entry.mask = 0;
   IOAPICWrite(Apic, IOAPIC_REDTBL+2*Irq+1, *(((PULONG)&Entry)+1));
   181d7:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   181da:	50                   	push   %eax
   181db:	53                   	push   %ebx
   181dc:	80 65 ea fe          	andb   $0xfe,0xffffffea(%ebp)
   181e0:	56                   	push   %esi
   181e1:	e8 8a fc ff ff       	call   17e70 <_IOAPICWrite>
   IOAPICWrite(Apic, IOAPIC_REDTBL+2*Irq, *(((PULONG)&Entry)+0));
   181e6:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   181e9:	50                   	push   %eax
   181ea:	57                   	push   %edi
   181eb:	56                   	push   %esi
   181ec:	e8 7f fc ff ff       	call   17e70 <_IOAPICWrite>
   181f1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   181f4:	5b                   	pop    %ebx
   181f5:	5e                   	pop    %esi
   181f6:	5f                   	pop    %edi
   181f7:	5d                   	pop    %ebp
   181f8:	c3                   	ret    
   181f9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00018200 <_IOAPICDump>:
}

VOID IOAPICDump(VOID)
{
   18200:	55                   	push   %ebp
   18201:	89 e5                	mov    %esp,%ebp
   18203:	57                   	push   %edi
   18204:	56                   	push   %esi
   18205:	53                   	push   %ebx
   18206:	83 ec 24             	sub    $0x24,%esp
   ULONG apic, i;
   ULONG reg0, reg1, reg2=0;

   DbgPrint("Number of MP IRQ sources: %d.\n", IRQCount);
   for (i = 0; i < IOAPICCount; i++) 
   18209:	31 f6                	xor    %esi,%esi
   1820b:	8b 1d c0 e4 03 00    	mov    0x3e4c0,%ebx
   18211:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
   18218:	53                   	push   %ebx
   18219:	68 14 c8 01 00       	push   $0x1c814
   1821e:	e8 6d 26 00 00       	call   1a890 <_DbgPrint>
   18223:	83 c4 10             	add    $0x10,%esp
   18226:	3b 35 50 ee 03 00    	cmp    0x3ee50,%esi
   1822c:	73 2a                	jae    18258 <_IOAPICDump+0x58>
   {
      DbgPrint("Number of IO-APIC #%d registers: %d.\n",
   1822e:	89 f0                	mov    %esi,%eax
   18230:	c1 e0 04             	shl    $0x4,%eax
   18233:	51                   	push   %ecx
   18234:	46                   	inc    %esi
   18235:	8b 90 1c ee 03 00    	mov    0x3ee1c(%eax),%edx
   1823b:	8b 80 10 ee 03 00    	mov    0x3ee10(%eax),%eax
   18241:	52                   	push   %edx
   18242:	50                   	push   %eax
   18243:	68 34 c8 01 00       	push   $0x1c834
   18248:	e8 43 26 00 00       	call   1a890 <_DbgPrint>
   1824d:	83 c4 10             	add    $0x10,%esp
   18250:	3b 35 50 ee 03 00    	cmp    0x3ee50,%esi
   18256:	72 d6                	jb     1822e <_IOAPICDump+0x2e>
	       IOAPICMap[i].ApicId,
               IOAPICMap[i].EntryCount);
   }

   /*
    * We are a bit conservative about what we expect.  We have to
    * know about every hardware change ASAP.
    */
   DbgPrint("Testing the IO APIC.......................\n");
   18258:	83 ec 0c             	sub    $0xc,%esp
   1825b:	68 5c c8 01 00       	push   $0x1c85c
   18260:	e8 2b 26 00 00       	call   1a890 <_DbgPrint>

   for (apic = 0; apic < IOAPICCount; apic++) 
   18265:	31 c0                	xor    %eax,%eax
   18267:	83 c4 10             	add    $0x10,%esp
   1826a:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
   18271:	3b 05 50 ee 03 00    	cmp    0x3ee50,%eax
   18277:	0f 83 60 02 00 00    	jae    184dd <_IOAPICDump+0x2dd>
   {
      reg0 = IOAPICRead(apic, IOAPIC_ID);
   1827d:	8b 7d e4             	mov    0xffffffe4(%ebp),%edi
   18280:	6a 00                	push   $0x0
   18282:	57                   	push   %edi
   18283:	e8 08 fc ff ff       	call   17e90 <_IOAPICRead>
      reg1 = IOAPICRead(apic, IOAPIC_VER);
   18288:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
   1828b:	6a 01                	push   $0x1
   1828d:	89 c3                	mov    %eax,%ebx
   1828f:	56                   	push   %esi
   18290:	e8 fb fb ff ff       	call   17e90 <_IOAPICRead>
      if (GET_IOAPIC_VERSION(reg1) >= 0x10) 
   18295:	83 c4 10             	add    $0x10,%esp
   18298:	89 c7                	mov    %eax,%edi
   1829a:	3c 0f                	cmp    $0xf,%al
   1829c:	0f 87 50 02 00 00    	ja     184f2 <_IOAPICDump+0x2f2>
      {
         reg2 = IOAPICRead(apic, IOAPIC_ARB);
      }

      DbgPrint("\n");
   182a2:	83 ec 0c             	sub    $0xc,%esp
   182a5:	68 88 c8 01 00       	push   $0x1c888
   182aa:	e8 e1 25 00 00       	call   1a890 <_DbgPrint>
      DbgPrint("IO APIC #%d......\n", IOAPICMap[apic].ApicId);
   182af:	5e                   	pop    %esi
   182b0:	58                   	pop    %eax
   182b1:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   182b4:	c1 e0 04             	shl    $0x4,%eax
   182b7:	8b 88 10 ee 03 00    	mov    0x3ee10(%eax),%ecx
   182bd:	51                   	push   %ecx
   182be:	68 8a c8 01 00       	push   $0x1c88a
   182c3:	e8 c8 25 00 00       	call   1a890 <_DbgPrint>
      DbgPrint(".... register #00: %08X\n", reg0);
   182c8:	58                   	pop    %eax
   182c9:	5a                   	pop    %edx
   182ca:	53                   	push   %ebx
   182cb:	68 9d c8 01 00       	push   $0x1c89d
   182d0:	e8 bb 25 00 00       	call   1a890 <_DbgPrint>
      DbgPrint(".......    : physical APIC id: %02X\n", GET_IOAPIC_ID(reg0));
   182d5:	5e                   	pop    %esi
   182d6:	58                   	pop    %eax
   182d7:	89 d8                	mov    %ebx,%eax
   182d9:	25 00 00 00 0f       	and    $0xf000000,%eax
   182de:	c1 e8 18             	shr    $0x18,%eax
   182e1:	50                   	push   %eax
   182e2:	68 b8 c8 01 00       	push   $0x1c8b8
   182e7:	e8 a4 25 00 00       	call   1a890 <_DbgPrint>
      if (reg0 & 0xF0FFFFFF) 
   182ec:	83 c4 10             	add    $0x10,%esp
   182ef:	81 e3 ff ff ff f0    	and    $0xf0ffffff,%ebx
   182f5:	0f 85 0c 02 00 00    	jne    18507 <_IOAPICDump+0x307>
      {
         DbgPrint("  WARNING: Unexpected IO-APIC\n");
      }

      DbgPrint(".... register #01: %08X\n", reg1);
      i = GET_IOAPIC_MRE(reg1);
   182fb:	89 fe                	mov    %edi,%esi
   182fd:	81 e6 00 00 ff 00    	and    $0xff0000,%esi
   18303:	51                   	push   %ecx
   18304:	c1 ee 10             	shr    $0x10,%esi
   18307:	51                   	push   %ecx
   18308:	57                   	push   %edi
   18309:	68 dd c8 01 00       	push   $0x1c8dd
   1830e:	e8 7d 25 00 00       	call   1a890 <_DbgPrint>

      DbgPrint(".......     : max redirection entries: %04X\n", i);
   18313:	58                   	pop    %eax
   18314:	5a                   	pop    %edx
   18315:	56                   	push   %esi
   18316:	68 f8 c8 01 00       	push   $0x1c8f8
   1831b:	e8 70 25 00 00       	call   1a890 <_DbgPrint>
      if ((i != 0x0f) &&    /* older (Neptune) boards */
   18320:	83 c4 10             	add    $0x10,%esp
   18323:	83 fe 0f             	cmp    $0xf,%esi
   18326:	0f 95 c2             	setne  %dl
   18329:	83 fe 17             	cmp    $0x17,%esi
   1832c:	0f 95 c0             	setne  %al
   1832f:	25 ff 00 00 00       	and    $0xff,%eax
   18334:	85 c2                	test   %eax,%edx
   18336:	74 3f                	je     18377 <_IOAPICDump+0x177>
   18338:	83 fe 1b             	cmp    $0x1b,%esi
   1833b:	0f 95 c2             	setne  %dl
   1833e:	83 fe 1f             	cmp    $0x1f,%esi
   18341:	0f 95 c0             	setne  %al
   18344:	25 ff 00 00 00       	and    $0xff,%eax
   18349:	85 c2                	test   %eax,%edx
   1834b:	74 2a                	je     18377 <_IOAPICDump+0x177>
   1834d:	83 fe 22             	cmp    $0x22,%esi
   18350:	0f 95 c2             	setne  %dl
   18353:	83 fe 2e             	cmp    $0x2e,%esi
   18356:	0f 95 c0             	setne  %al
   18359:	25 ff 00 00 00       	and    $0xff,%eax
   1835e:	85 c2                	test   %eax,%edx
   18360:	74 15                	je     18377 <_IOAPICDump+0x177>
   18362:	83 fe 3f             	cmp    $0x3f,%esi
   18365:	74 10                	je     18377 <_IOAPICDump+0x177>
	  (i != 0x17) &&    /* typical ISA+PCI boards */
	  (i != 0x1b) &&    /* Compaq Proliant boards */
	  (i != 0x1f) &&    /* dual Xeon boards */
          (i != 0x22) &&   /* bigger Xeon boards */
	  (i != 0x2E) &&
	  (i != 0x3F)) 
      {
         DbgPrint("  WARNING: Unexpected IO-APIC\n");
   18367:	83 ec 0c             	sub    $0xc,%esp
   1836a:	68 28 c9 01 00       	push   $0x1c928
   1836f:	e8 1c 25 00 00       	call   1a890 <_DbgPrint>
   18374:	83 c4 10             	add    $0x10,%esp
      }

      i = GET_IOAPIC_VERSION(reg1);
   18377:	89 fe                	mov    %edi,%esi
   18379:	81 e6 ff 00 00 00    	and    $0xff,%esi
      DbgPrint(".......     : IO APIC version: %04X\n", i);
   1837f:	50                   	push   %eax
   18380:	50                   	push   %eax
   18381:	56                   	push   %esi
   18382:	68 48 c9 01 00       	push   $0x1c948
   18387:	e8 04 25 00 00       	call   1a890 <_DbgPrint>
      if ((i != 0x01) &&    /* 82489DX IO-APICs */
   1838c:	83 c4 10             	add    $0x10,%esp
   1838f:	83 fe 01             	cmp    $0x1,%esi
   18392:	0f 95 c2             	setne  %dl
   18395:	83 fe 10             	cmp    $0x10,%esi
   18398:	0f 95 c0             	setne  %al
   1839b:	25 ff 00 00 00       	and    $0xff,%eax
   183a0:	85 c2                	test   %eax,%edx
   183a2:	74 19                	je     183bd <_IOAPICDump+0x1bd>
   183a4:	83 fe 11             	cmp    $0x11,%esi
   183a7:	0f 95 c2             	setne  %dl
   183aa:	83 fe 13             	cmp    $0x13,%esi
   183ad:	0f 95 c0             	setne  %al
   183b0:	25 ff 00 00 00       	and    $0xff,%eax
   183b5:	85 c2                	test   %eax,%edx
   183b7:	0f 85 c1 01 00 00    	jne    1857e <_IOAPICDump+0x37e>
	  (i != 0x10) &&    /* oldest IO-APICs */
	  (i != 0x11) &&    /* Pentium/Pro IO-APICs */
	  (i != 0x13))	    /* Xeon IO-APICs */
      {
         DbgPrint("  WARNING: Unexpected IO-APIC\n");
      }

      if (reg1 & 0xFF00FF00) 
   183bd:	f7 c7 00 ff 00 ff    	test   $0xff00ff00,%edi
   183c3:	0f 85 a0 01 00 00    	jne    18569 <_IOAPICDump+0x369>
      {
         DbgPrint("  WARNING: Unexpected IO-APIC\n");
      }

      if (GET_IOAPIC_VERSION(reg1) >= 0x10) 
   183c9:	89 f8                	mov    %edi,%eax
   183cb:	3c 0f                	cmp    $0xf,%al
   183cd:	0f 87 49 01 00 00    	ja     1851c <_IOAPICDump+0x31c>
      {
	 DbgPrint(".... register #02: %08X\n", reg2);
	 DbgPrint(".......     : arbitration: %02X\n",
	          GET_IOAPIC_ARB(reg2));
  	 if (reg2 & 0xF0FFFFFF) 
	 {
            DbgPrint("  WARNING: Unexpected IO-APIC\n");
         }
      }

      DbgPrint(".... IRQ redirection table:\n");
   183d3:	83 ec 0c             	sub    $0xc,%esp
      DbgPrint(" NR Log Phy Mask Trig IRR Pol"
	       " Stat Dest Deli Vect:   \n");

      for (i = 0; i <= GET_IOAPIC_MRE(reg1); i++) 
   183d6:	31 f6                	xor    %esi,%esi
   183d8:	68 6d c9 01 00       	push   $0x1c96d
   183dd:	e8 ae 24 00 00       	call   1a890 <_DbgPrint>
   183e2:	c7 04 24 8c c9 01 00 	movl   $0x1c98c,(%esp)
   183e9:	e8 a2 24 00 00       	call   1a890 <_DbgPrint>
   183ee:	83 c4 10             	add    $0x10,%esp
      {
         IOAPIC_ROUTE_ENTRY entry;

	 *(((PULONG)&entry)+0) = IOAPICRead(apic, 0x10+i*2);
   183f1:	8d 1c 36             	lea    (%esi,%esi,1),%ebx
   183f4:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   183f7:	8d 43 10             	lea    0x10(%ebx),%eax
	 *(((PULONG)&entry)+1) = IOAPICRead(apic, 0x11+i*2);
   183fa:	83 c3 11             	add    $0x11,%ebx
   183fd:	50                   	push   %eax
   183fe:	52                   	push   %edx
   183ff:	e8 8c fa ff ff       	call   17e90 <_IOAPICRead>
   18404:	53                   	push   %ebx
   18405:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   18408:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   1840b:	50                   	push   %eax
   1840c:	e8 7f fa ff ff       	call   17e90 <_IOAPICRead>

	 DbgPrint(" %02x %03X %02X  ",
   18411:	31 d2                	xor    %edx,%edx
   18413:	8a 55 ef             	mov    0xffffffef(%ebp),%dl
   18416:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   18419:	89 d0                	mov    %edx,%eax
   1841b:	83 e0 0f             	and    $0xf,%eax
   1841e:	50                   	push   %eax
   1841f:	52                   	push   %edx
   18420:	56                   	push   %esi
   18421:	68 c3 c9 01 00       	push   $0x1c9c3
   18426:	e8 65 24 00 00       	call   1a890 <_DbgPrint>
		  i,
		  entry.dest.logical.logical_dest,
		  entry.dest.physical.physical_dest);

         DbgPrint("%C    %C    %1d  %C    %C    %C     %03X    %02X\n",
   1842b:	83 c4 14             	add    $0x14,%esp
   1842e:	31 c0                	xor    %eax,%eax
   18430:	8a 55 e9             	mov    0xffffffe9(%ebp),%dl
   18433:	8a 45 e8             	mov    0xffffffe8(%ebp),%al
   18436:	50                   	push   %eax
   18437:	89 d0                	mov    %edx,%eax
   18439:	c0 ea 03             	shr    $0x3,%dl
   1843c:	83 e0 07             	and    $0x7,%eax
   1843f:	50                   	push   %eax
   18440:	89 d0                	mov    %edx,%eax
   18442:	83 e0 01             	and    $0x1,%eax
   18445:	83 f8 01             	cmp    $0x1,%eax
   18448:	19 c0                	sbb    %eax,%eax
   1844a:	d0 ea                	shr    %dl
   1844c:	83 e0 04             	and    $0x4,%eax
   1844f:	83 c0 4c             	add    $0x4c,%eax
   18452:	50                   	push   %eax
   18453:	89 d0                	mov    %edx,%eax
   18455:	83 e0 01             	and    $0x1,%eax
   18458:	83 f8 01             	cmp    $0x1,%eax
   1845b:	19 c0                	sbb    %eax,%eax
   1845d:	d0 ea                	shr    %dl
   1845f:	83 e0 f6             	and    $0xfffffff6,%eax
   18462:	83 c0 53             	add    $0x53,%eax
   18465:	50                   	push   %eax
   18466:	89 d0                	mov    %edx,%eax
   18468:	83 e0 01             	and    $0x1,%eax
   1846b:	83 f8 01             	cmp    $0x1,%eax
   1846e:	19 c0                	sbb    %eax,%eax
   18470:	d0 ea                	shr    %dl
   18472:	83 e0 fc             	and    $0xfffffffc,%eax
   18475:	83 c0 4c             	add    $0x4c,%eax
   18478:	50                   	push   %eax
   18479:	89 d0                	mov    %edx,%eax
   1847b:	d0 ea                	shr    %dl
   1847d:	83 e0 01             	and    $0x1,%eax
   18480:	81 e2 ff 00 00 00    	and    $0xff,%edx
   18486:	50                   	push   %eax
   18487:	83 fa 01             	cmp    $0x1,%edx
   1848a:	19 c0                	sbb    %eax,%eax
   1848c:	83 e0 f9             	and    $0xfffffff9,%eax
   1848f:	83 c0 4c             	add    $0x4c,%eax
   18492:	50                   	push   %eax
   18493:	31 c0                	xor    %eax,%eax
   18495:	8a 45 ea             	mov    0xffffffea(%ebp),%al
   18498:	83 e0 01             	and    $0x1,%eax
   1849b:	83 f8 01             	cmp    $0x1,%eax
   1849e:	19 c0                	sbb    %eax,%eax
   184a0:	46                   	inc    %esi
   184a1:	83 e0 08             	and    $0x8,%eax
   184a4:	83 c0 4d             	add    $0x4d,%eax
   184a7:	50                   	push   %eax
   184a8:	68 d8 c9 01 00       	push   $0x1c9d8
   184ad:	e8 de 23 00 00       	call   1a890 <_DbgPrint>
   184b2:	89 f8                	mov    %edi,%eax
   184b4:	25 00 00 ff 00       	and    $0xff0000,%eax
   184b9:	83 c4 30             	add    $0x30,%esp
   184bc:	c1 e8 10             	shr    $0x10,%eax
   184bf:	39 f0                	cmp    %esi,%eax
   184c1:	0f 83 2a ff ff ff    	jae    183f1 <_IOAPICDump+0x1f1>
   184c7:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   184ca:	40                   	inc    %eax
   184cb:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   184ce:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   184d1:	3b 05 50 ee 03 00    	cmp    0x3ee50,%eax
   184d7:	0f 82 a0 fd ff ff    	jb     1827d <_IOAPICDump+0x7d>
		  (entry.mask == 0) ? 'U' : 'M',            // Unmasked/masked
		  (entry.trigger == 0) ? 'E' : 'L',         // Edge/level sensitive
		  entry.irr,
		  (entry.polarity == 0) ? 'H' : 'L',        // Active high/active low
		  (entry.delivery_status == 0) ? 'I' : 'S', // Idle / send pending
		  (entry.dest_mode == 0) ? 'P' : 'L',       // Physical logical
		  entry.delivery_mode,
		  entry.vector);
      }
   }

   DbgPrint(".................................... done.\n");
   184dd:	83 ec 0c             	sub    $0xc,%esp
   184e0:	68 0c ca 01 00       	push   $0x1ca0c
   184e5:	e8 a6 23 00 00       	call   1a890 <_DbgPrint>
   184ea:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   184ed:	5b                   	pop    %ebx
   184ee:	5e                   	pop    %esi
   184ef:	5f                   	pop    %edi
   184f0:	5d                   	pop    %ebp
   184f1:	c3                   	ret    
   184f2:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   184f5:	6a 02                	push   $0x2
   184f7:	51                   	push   %ecx
   184f8:	e8 93 f9 ff ff       	call   17e90 <_IOAPICRead>
   184fd:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   18500:	58                   	pop    %eax
   18501:	5a                   	pop    %edx
   18502:	e9 9b fd ff ff       	jmp    182a2 <_IOAPICDump+0xa2>
   18507:	83 ec 0c             	sub    $0xc,%esp
   1850a:	68 28 c9 01 00       	push   $0x1c928
   1850f:	e8 7c 23 00 00       	call   1a890 <_DbgPrint>
   18514:	83 c4 10             	add    $0x10,%esp
   18517:	e9 df fd ff ff       	jmp    182fb <_IOAPICDump+0xfb>
   1851c:	8b 75 e0             	mov    0xffffffe0(%ebp),%esi
   1851f:	50                   	push   %eax
   18520:	50                   	push   %eax
   18521:	56                   	push   %esi
   18522:	68 38 ca 01 00       	push   $0x1ca38
   18527:	e8 64 23 00 00       	call   1a890 <_DbgPrint>
   1852c:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   1852f:	25 00 00 00 0f       	and    $0xf000000,%eax
   18534:	59                   	pop    %ecx
   18535:	c1 e8 18             	shr    $0x18,%eax
   18538:	5b                   	pop    %ebx
   18539:	50                   	push   %eax
   1853a:	68 54 ca 01 00       	push   $0x1ca54
   1853f:	e8 4c 23 00 00       	call   1a890 <_DbgPrint>
   18544:	83 c4 10             	add    $0x10,%esp
   18547:	f7 45 e0 ff ff ff f0 	testl  $0xf0ffffff,0xffffffe0(%ebp)
   1854e:	0f 84 7f fe ff ff    	je     183d3 <_IOAPICDump+0x1d3>
   18554:	83 ec 0c             	sub    $0xc,%esp
   18557:	68 28 c9 01 00       	push   $0x1c928
   1855c:	e8 2f 23 00 00       	call   1a890 <_DbgPrint>
   18561:	83 c4 10             	add    $0x10,%esp
   18564:	e9 6a fe ff ff       	jmp    183d3 <_IOAPICDump+0x1d3>
   18569:	83 ec 0c             	sub    $0xc,%esp
   1856c:	68 28 c9 01 00       	push   $0x1c928
   18571:	e8 1a 23 00 00       	call   1a890 <_DbgPrint>
   18576:	83 c4 10             	add    $0x10,%esp
   18579:	e9 4b fe ff ff       	jmp    183c9 <_IOAPICDump+0x1c9>
   1857e:	83 ec 0c             	sub    $0xc,%esp
   18581:	68 28 c9 01 00       	push   $0x1c928
   18586:	e8 05 23 00 00       	call   1a890 <_DbgPrint>
   1858b:	83 c4 10             	add    $0x10,%esp
   1858e:	e9 2a fe ff ff       	jmp    183bd <_IOAPICDump+0x1bd>
   18593:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   18599:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000185a0 <_HaliReconfigurePciInterrupts>:
}

VOID
HaliReconfigurePciInterrupts(VOID)
{
   185a0:	55                   	push   %ebp
   ULONG i;

   for (i = 0; i < IRQCount; i++)
   185a1:	a1 c0 e4 03 00       	mov    0x3e4c0,%eax
   185a6:	89 e5                	mov    %esp,%ebp
   185a8:	56                   	push   %esi
   185a9:	53                   	push   %ebx
   185aa:	31 db                	xor    %ebx,%ebx
   185ac:	39 c3                	cmp    %eax,%ebx
   185ae:	73 50                	jae    18600 <_HaliReconfigurePciInterrupts+0x60>
   185b0:	be 67 ee 03 00       	mov    $0x3ee67,%esi
   185b5:	eb 08                	jmp    185bf <_HaliReconfigurePciInterrupts+0x1f>
   185b7:	43                   	inc    %ebx
   185b8:	83 c6 08             	add    $0x8,%esi
   185bb:	39 c3                	cmp    %eax,%ebx
   185bd:	73 41                	jae    18600 <_HaliReconfigurePciInterrupts+0x60>
   {
      if (BUSMap[IRQMap[i].SrcBusId] == MP_BUS_PCI)
   185bf:	31 d2                	xor    %edx,%edx
   185c1:	8a 14 dd 64 ee 03 00 	mov    0x3ee64(,%ebx,8),%dl
   185c8:	80 ba f0 ed 03 00 03 	cmpb   $0x3,0x3edf0(%edx)
   185cf:	75 e6                	jne    185b7 <_HaliReconfigurePciInterrupts+0x17>
      {
         DPRINT("%02x: IrqType %02x, IrqFlag %02x, SrcBusId %02x, SrcBusIrq %02x"
	        ", DstApicId %02x, DstApicInt %02x\n",
	        i, IRQMap[i].IrqType, IRQMap[i].IrqFlag, IRQMap[i].SrcBusId, 
	        IRQMap[i].SrcBusIrq, IRQMap[i].DstApicId, IRQMap[i].DstApicInt);

	 if(1 != HalSetBusDataByOffset(PCIConfiguration, 
   185d1:	8a 04 dd 65 ee 03 00 	mov    0x3ee65(,%ebx,8),%al
   185d8:	c0 e8 02             	shr    $0x2,%al
   185db:	51                   	push   %ecx
   185dc:	83 e0 1f             	and    $0x1f,%eax
   185df:	51                   	push   %ecx
   185e0:	6a 01                	push   $0x1
   185e2:	6a 3c                	push   $0x3c
   185e4:	56                   	push   %esi
   185e5:	50                   	push   %eax
   185e6:	52                   	push   %edx
   185e7:	6a 04                	push   $0x4
   185e9:	e8 62 98 ff ff       	call   11e50 <_HalSetBusDataByOffset@24>
   185ee:	43                   	inc    %ebx
   185ef:	58                   	pop    %eax
   185f0:	a1 c0 e4 03 00       	mov    0x3e4c0,%eax
   185f5:	83 c6 08             	add    $0x8,%esi
   185f8:	5a                   	pop    %edx
   185f9:	39 c3                	cmp    %eax,%ebx
   185fb:	72 c2                	jb     185bf <_HaliReconfigurePciInterrupts+0x1f>
   185fd:	8d 76 00             	lea    0x0(%esi),%esi
   18600:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   18603:	5b                   	pop    %ebx
   18604:	5e                   	pop    %esi
   18605:	5d                   	pop    %ebp
   18606:	c3                   	ret    
   18607:	89 f6                	mov    %esi,%esi
   18609:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00018610 <_Disable8259AIrq>:
	                               IRQMap[i].SrcBusId, 
				       (IRQMap[i].SrcBusIrq >> 2) & 0x1f, 
				       &IRQMap[i].DstApicInt, 
				       0x3c /*PCI_INTERRUPT_LINE*/, 
				       1))
	 {
	    CHECKPOINT;
	 }
      }
   }
}

VOID Disable8259AIrq(ULONG irq)
{
   18610:	55                   	push   %ebp
   18611:	89 e5                	mov    %esp,%ebp
   18613:	51                   	push   %ecx
   18614:	51                   	push   %ecx
    ULONG tmp;

    if (irq >= 8) 
   18615:	83 7d 08 07          	cmpl   $0x7,0x8(%ebp)
   18619:	76 35                	jbe    18650 <_Disable8259AIrq+0x40>
    {
       tmp = READ_PORT_UCHAR((PUCHAR)0xA1);
   1861b:	83 ec 0c             	sub    $0xc,%esp
   1861e:	68 a1 00 00 00       	push   $0xa1
   18623:	e8 b8 c4 ff ff       	call   14ae0 <_READ_PORT_UCHAR@4>
       tmp |= (1 << (irq - 8));
   18628:	8b 4d 08             	mov    0x8(%ebp),%ecx
   1862b:	31 d2                	xor    %edx,%edx
   1862d:	88 c2                	mov    %al,%dl
   1862f:	83 e9 08             	sub    $0x8,%ecx
   18632:	b8 01 00 00 00       	mov    $0x1,%eax
   18637:	d3 e0                	shl    %cl,%eax
   18639:	09 c2                	or     %eax,%edx
       WRITE_PORT_UCHAR((PUCHAR)0xA1, tmp);
   1863b:	31 c0                	xor    %eax,%eax
   1863d:	88 d0                	mov    %dl,%al
   1863f:	89 04 24             	mov    %eax,(%esp)
   18642:	68 a1 00 00 00       	push   $0xa1
    } 
    else 
    {
       tmp = READ_PORT_UCHAR((PUCHAR)0x21);
       tmp |= (1 << irq);
       WRITE_PORT_UCHAR((PUCHAR)0x21, tmp);
   18647:	e8 44 c5 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   1864c:	58                   	pop    %eax
   1864d:	5a                   	pop    %edx
    }
}
   1864e:	c9                   	leave  
   1864f:	c3                   	ret    
   18650:	83 ec 0c             	sub    $0xc,%esp
   18653:	6a 21                	push   $0x21
   18655:	e8 86 c4 ff ff       	call   14ae0 <_READ_PORT_UCHAR@4>
   1865a:	31 d2                	xor    %edx,%edx
   1865c:	8a 4d 08             	mov    0x8(%ebp),%cl
   1865f:	88 c2                	mov    %al,%dl
   18661:	b8 01 00 00 00       	mov    $0x1,%eax
   18666:	d3 e0                	shl    %cl,%eax
   18668:	09 c2                	or     %eax,%edx
   1866a:	31 c0                	xor    %eax,%eax
   1866c:	88 d0                	mov    %dl,%al
   1866e:	89 04 24             	mov    %eax,(%esp)
   18671:	6a 21                	push   $0x21
   18673:	e8 18 c5 ff ff       	call   14b90 <_WRITE_PORT_UCHAR@8>
   18678:	58                   	pop    %eax
   18679:	5a                   	pop    %edx
   1867a:	c9                   	leave  
   1867b:	c3                   	ret    
   1867c:	8d 74 26 00          	lea    0x0(%esi),%esi

00018680 <_IOAPICSetupIrqs>:
   18680:	55                   	push   %ebp
   18681:	89 e5                	mov    %esp,%ebp
   18683:	57                   	push   %edi
   18684:	56                   	push   %esi
   18685:	53                   	push   %ebx
   18686:	83 ec 30             	sub    $0x30,%esp
   18689:	c7 45 dc 01 00 00 00 	movl   $0x1,0xffffffdc(%ebp)
   18690:	68 00 02 00 00       	push   $0x200
   18695:	6a 00                	push   $0x0
   18697:	68 f0 eb 03 00       	push   $0x3ebf0
   1869c:	e8 4f 23 00 00       	call   1a9f0 <_memset>
   186a1:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
   186a8:	8b 15 50 ee 03 00    	mov    0x3ee50,%edx
   186ae:	83 c4 10             	add    $0x10,%esp
   186b1:	39 55 e4             	cmp    %edx,0xffffffe4(%ebp)
   186b4:	0f 83 bb 00 00 00    	jae    18775 <_IOAPICSetupIrqs+0xf5>
   186ba:	8d 75 e8             	lea    0xffffffe8(%ebp),%esi
   186bd:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   186c0:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
   186c7:	c1 e0 04             	shl    $0x4,%eax
   186ca:	8b b8 1c ee 03 00    	mov    0x3ee1c(%eax),%edi
   186d0:	85 ff                	test   %edi,%edi
   186d2:	0f 84 8d 00 00 00    	je     18765 <_IOAPICSetupIrqs+0xe5>
   186d8:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   186db:	90                   	nop    
   186dc:	8d 74 26 00          	lea    0x0(%esi),%esi
   186e0:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   186e7:	c7 46 04 00 00 00 00 	movl   $0x0,0x4(%esi)
   186ee:	8a 46 01             	mov    0x1(%esi),%al
   186f1:	c6 46 07 00          	movb   $0x0,0x7(%esi)
   186f5:	83 e0 f8             	and    $0xfffffff8,%eax
   186f8:	31 d2                	xor    %edx,%edx
   186fa:	80 4e 02 01          	orb    $0x1,0x2(%esi)
   186fe:	83 c8 09             	or     $0x9,%eax
   18701:	88 46 01             	mov    %al,0x1(%esi)
   18704:	8b 1d c0 e4 03 00    	mov    0x3e4c0,%ebx
   1870a:	39 da                	cmp    %ebx,%edx
   1870c:	73 2b                	jae    18739 <_IOAPICSetupIrqs+0xb9>
   1870e:	89 f6                	mov    %esi,%esi
   18710:	80 3c d5 61 ee 03 00 	cmpb   $0x0,0x3ee61(,%edx,8)
   18717:	00 
   18718:	75 1a                	jne    18734 <_IOAPICSetupIrqs+0xb4>
   1871a:	31 c0                	xor    %eax,%eax
   1871c:	8a 0c d5 66 ee 03 00 	mov    0x3ee66(,%edx,8),%cl
   18723:	8b 7d d4             	mov    0xffffffd4(%ebp),%edi
   18726:	88 c8                	mov    %cl,%al
   18728:	3b 87 10 ee 03 00    	cmp    0x3ee10(%edi),%eax
   1872e:	74 50                	je     18780 <_IOAPICSetupIrqs+0x100>
   18730:	fe c1                	inc    %cl
   18732:	74 4c                	je     18780 <_IOAPICSetupIrqs+0x100>
   18734:	42                   	inc    %edx
   18735:	39 da                	cmp    %ebx,%edx
   18737:	72 d7                	jb     18710 <_IOAPICSetupIrqs+0x90>
   18739:	8b 5d dc             	mov    0xffffffdc(%ebp),%ebx
   1873c:	85 db                	test   %ebx,%ebx
   1873e:	74 07                	je     18747 <_IOAPICSetupIrqs+0xc7>
   18740:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   18747:	8b 7d e0             	mov    0xffffffe0(%ebp),%edi
   1874a:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   1874d:	c1 e0 04             	shl    $0x4,%eax
   18750:	47                   	inc    %edi
   18751:	89 7d e0             	mov    %edi,0xffffffe0(%ebp)
   18754:	8b 7d e0             	mov    0xffffffe0(%ebp),%edi
   18757:	39 b8 1c ee 03 00    	cmp    %edi,0x3ee1c(%eax)
   1875d:	77 81                	ja     186e0 <_IOAPICSetupIrqs+0x60>
   1875f:	8b 15 50 ee 03 00    	mov    0x3ee50,%edx
   18765:	8b 5d e4             	mov    0xffffffe4(%ebp),%ebx
   18768:	43                   	inc    %ebx
   18769:	89 5d e4             	mov    %ebx,0xffffffe4(%ebp)
   1876c:	39 55 e4             	cmp    %edx,0xffffffe4(%ebp)
   1876f:	0f 82 48 ff ff ff    	jb     186bd <_IOAPICSetupIrqs+0x3d>
   18775:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   18778:	5b                   	pop    %ebx
   18779:	5e                   	pop    %esi
   1877a:	5f                   	pop    %edi
   1877b:	5d                   	pop    %ebp
   1877c:	c3                   	ret    
   1877d:	8d 76 00             	lea    0x0(%esi),%esi
   18780:	31 c0                	xor    %eax,%eax
   18782:	8a 04 d5 67 ee 03 00 	mov    0x3ee67(,%edx,8),%al
   18789:	3b 45 e0             	cmp    0xffffffe0(%ebp),%eax
   1878c:	75 a6                	jne    18734 <_IOAPICSetupIrqs+0xb4>
   1878e:	89 d3                	mov    %edx,%ebx
   18790:	83 fa ff             	cmp    $0xffffffff,%edx
   18793:	74 a4                	je     18739 <_IOAPICSetupIrqs+0xb9>
   18795:	8a 04 d5 64 ee 03 00 	mov    0x3ee64(,%edx,8),%al
   1879c:	31 c9                	xor    %ecx,%ecx
   1879e:	66 8b 14 d5 62 ee 03 	mov    0x3ee62(,%edx,8),%dx
   187a5:	00 
   187a6:	88 45 db             	mov    %al,0xffffffdb(%ebp)
   187a9:	88 c1                	mov    %al,%cl
   187ab:	89 d0                	mov    %edx,%eax
   187ad:	66 c1 e8 02          	shr    $0x2,%ax
   187b1:	31 ff                	xor    %edi,%edi
   187b3:	83 e0 03             	and    $0x3,%eax
   187b6:	83 f8 01             	cmp    $0x1,%eax
   187b9:	74 17                	je     187d2 <_IOAPICSetupIrqs+0x152>
   187bb:	0f 8e 67 01 00 00    	jle    18928 <_IOAPICSetupIrqs+0x2a8>
   187c1:	bf 01 00 00 00       	mov    $0x1,%edi
   187c6:	83 f8 02             	cmp    $0x2,%eax
   187c9:	74 07                	je     187d2 <_IOAPICSetupIrqs+0x152>
   187cb:	83 f8 03             	cmp    $0x3,%eax
   187ce:	74 02                	je     187d2 <_IOAPICSetupIrqs+0x152>
   187d0:	31 ff                	xor    %edi,%edi
   187d2:	89 d0                	mov    %edx,%eax
   187d4:	31 c9                	xor    %ecx,%ecx
   187d6:	83 e0 03             	and    $0x3,%eax
   187d9:	31 d2                	xor    %edx,%edx
   187db:	8a 4d db             	mov    0xffffffdb(%ebp),%cl
   187de:	83 f8 01             	cmp    $0x1,%eax
   187e1:	74 1a                	je     187fd <_IOAPICSetupIrqs+0x17d>
   187e3:	0f 8e 1c 01 00 00    	jle    18905 <_IOAPICSetupIrqs+0x285>
   187e9:	ba 01 00 00 00       	mov    $0x1,%edx
   187ee:	83 f8 02             	cmp    $0x2,%eax
   187f1:	74 0a                	je     187fd <_IOAPICSetupIrqs+0x17d>
   187f3:	83 f8 03             	cmp    $0x3,%eax
   187f6:	74 05                	je     187fd <_IOAPICSetupIrqs+0x17d>
   187f8:	ba 01 00 00 00       	mov    $0x1,%edx
   187fd:	88 d0                	mov    %dl,%al
   187ff:	8a 56 01             	mov    0x1(%esi),%dl
   18802:	c1 e0 05             	shl    $0x5,%eax
   18805:	83 e2 df             	and    $0xffffffdf,%edx
   18808:	09 c2                	or     %eax,%edx
   1880a:	85 ff                	test   %edi,%edi
   1880c:	74 03                	je     18811 <_IOAPICSetupIrqs+0x191>
   1880e:	83 ca 80             	or     $0xffffff80,%edx
   18811:	88 56 01             	mov    %dl,0x1(%esi)
   18814:	31 c0                	xor    %eax,%eax
   18816:	8a 45 db             	mov    0xffffffdb(%ebp),%al
   18819:	8a 80 f0 ed 03 00    	mov    0x3edf0(%eax),%al
   1881f:	25 ff 00 00 00       	and    $0xff,%eax
   18824:	83 f8 03             	cmp    $0x3,%eax
   18827:	0f 84 a4 00 00 00    	je     188d1 <_IOAPICSetupIrqs+0x251>
   1882d:	0f 8f 8e 00 00 00    	jg     188c1 <_IOAPICSetupIrqs+0x241>
   18833:	48                   	dec    %eax
   18834:	0f 8c 90 00 00 00    	jl     188ca <_IOAPICSetupIrqs+0x24a>
   1883a:	8a 1c dd 65 ee 03 00 	mov    0x3ee65(,%ebx,8),%bl
   18841:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   18847:	89 df                	mov    %ebx,%edi
   18849:	8b 04 bd f0 eb 03 00 	mov    0x3ebf0(,%edi,4),%eax
   18850:	85 c0                	test   %eax,%eax
   18852:	75 12                	jne    18866 <_IOAPICSetupIrqs+0x1e6>
   18854:	b0 17                	mov    $0x17,%al
   18856:	29 f8                	sub    %edi,%eax
   18858:	8d 04 c5 30 00 00 00 	lea    0x30(,%eax,8),%eax
   1885f:	89 04 bd f0 eb 03 00 	mov    %eax,0x3ebf0(,%edi,4)
   18866:	88 45 e8             	mov    %al,0xffffffe8(%ebp)
   18869:	85 ff                	test   %edi,%edi
   1886b:	75 04                	jne    18871 <_IOAPICSetupIrqs+0x1f1>
   1886d:	80 4e 02 01          	orb    $0x1,0x2(%esi)
   18871:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   18874:	85 c0                	test   %eax,%eax
   18876:	0f 94 c2             	sete   %dl
   18879:	83 ff 0f             	cmp    $0xf,%edi
   1887c:	0f 96 c0             	setbe  %al
   1887f:	25 ff 00 00 00       	and    $0xff,%eax
   18884:	85 c2                	test   %eax,%edx
   18886:	75 6f                	jne    188f7 <_IOAPICSetupIrqs+0x277>
   18888:	8b 5d e0             	mov    0xffffffe0(%ebp),%ebx
   1888b:	8b 46 04             	mov    0x4(%esi),%eax
   1888e:	01 db                	add    %ebx,%ebx
   18890:	50                   	push   %eax
   18891:	8d 43 11             	lea    0x11(%ebx),%eax
   18894:	83 c3 10             	add    $0x10,%ebx
   18897:	50                   	push   %eax
   18898:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   1889b:	50                   	push   %eax
   1889c:	e8 cf f5 ff ff       	call   17e70 <_IOAPICWrite>
   188a1:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   188a4:	50                   	push   %eax
   188a5:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   188a8:	53                   	push   %ebx
   188a9:	50                   	push   %eax
   188aa:	e8 c1 f5 ff ff       	call   17e70 <_IOAPICWrite>
   188af:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   188b2:	83 c4 18             	add    $0x18,%esp
   188b5:	89 0c bd f0 e9 03 00 	mov    %ecx,0x3e9f0(,%edi,4)
   188bc:	e9 86 fe ff ff       	jmp    18747 <_IOAPICSetupIrqs+0xc7>
   188c1:	83 f8 04             	cmp    $0x4,%eax
   188c4:	0f 84 70 ff ff ff    	je     1883a <_IOAPICSetupIrqs+0x1ba>
   188ca:	31 ff                	xor    %edi,%edi
   188cc:	e9 78 ff ff ff       	jmp    18849 <_IOAPICSetupIrqs+0x1c9>
   188d1:	31 ff                	xor    %edi,%edi
   188d3:	31 d2                	xor    %edx,%edx
   188d5:	3b 7d e4             	cmp    0xffffffe4(%ebp),%edi
   188d8:	eb 11                	jmp    188eb <_IOAPICSetupIrqs+0x26b>
   188da:	89 d0                	mov    %edx,%eax
   188dc:	42                   	inc    %edx
   188dd:	c1 e0 04             	shl    $0x4,%eax
   188e0:	8b 88 1c ee 03 00    	mov    0x3ee1c(%eax),%ecx
   188e6:	01 cf                	add    %ecx,%edi
   188e8:	3b 55 e4             	cmp    0xffffffe4(%ebp),%edx
   188eb:	72 ed                	jb     188da <_IOAPICSetupIrqs+0x25a>
   188ed:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   188f0:	01 c7                	add    %eax,%edi
   188f2:	e9 52 ff ff ff       	jmp    18849 <_IOAPICSetupIrqs+0x1c9>
   188f7:	83 ec 0c             	sub    $0xc,%esp
   188fa:	57                   	push   %edi
   188fb:	e8 10 fd ff ff       	call   18610 <_Disable8259AIrq>
   18900:	83 c4 10             	add    $0x10,%esp
   18903:	eb 83                	jmp    18888 <_IOAPICSetupIrqs+0x208>
   18905:	85 c0                	test   %eax,%eax
   18907:	0f 85 eb fe ff ff    	jne    187f8 <_IOAPICSetupIrqs+0x178>
   1890d:	31 c0                	xor    %eax,%eax
   1890f:	31 d2                	xor    %edx,%edx
   18911:	8a 81 f0 ed 03 00    	mov    0x3edf0(%ecx),%al
   18917:	83 f8 02             	cmp    $0x2,%eax
   1891a:	0f 84 dd fe ff ff    	je     187fd <_IOAPICSetupIrqs+0x17d>
   18920:	7f 30                	jg     18952 <_IOAPICSetupIrqs+0x2d2>
   18922:	48                   	dec    %eax
   18923:	e9 ce fe ff ff       	jmp    187f6 <_IOAPICSetupIrqs+0x176>
   18928:	85 c0                	test   %eax,%eax
   1892a:	0f 85 a0 fe ff ff    	jne    187d0 <_IOAPICSetupIrqs+0x150>
   18930:	31 c0                	xor    %eax,%eax
   18932:	8a 81 f0 ed 03 00    	mov    0x3edf0(%ecx),%al
   18938:	83 f8 02             	cmp    $0x2,%eax
   1893b:	74 40                	je     1897d <_IOAPICSetupIrqs+0x2fd>
   1893d:	7f 2b                	jg     1896a <_IOAPICSetupIrqs+0x2ea>
   1893f:	31 ff                	xor    %edi,%edi
   18941:	48                   	dec    %eax
   18942:	0f 84 8a fe ff ff    	je     187d2 <_IOAPICSetupIrqs+0x152>
   18948:	bf 01 00 00 00       	mov    $0x1,%edi
   1894d:	e9 80 fe ff ff       	jmp    187d2 <_IOAPICSetupIrqs+0x152>
   18952:	ba 01 00 00 00       	mov    $0x1,%edx
   18957:	83 f8 03             	cmp    $0x3,%eax
   1895a:	0f 84 9d fe ff ff    	je     187fd <_IOAPICSetupIrqs+0x17d>
   18960:	30 d2                	xor    %dl,%dl
   18962:	83 f8 04             	cmp    $0x4,%eax
   18965:	e9 8c fe ff ff       	jmp    187f6 <_IOAPICSetupIrqs+0x176>
   1896a:	bf 01 00 00 00       	mov    $0x1,%edi
   1896f:	83 f8 03             	cmp    $0x3,%eax
   18972:	0f 84 5a fe ff ff    	je     187d2 <_IOAPICSetupIrqs+0x152>
   18978:	83 f8 04             	cmp    $0x4,%eax
   1897b:	eb c5                	jmp    18942 <_IOAPICSetupIrqs+0x2c2>
   1897d:	8a 0c dd 65 ee 03 00 	mov    0x3ee65(,%ebx,8),%cl
   18984:	31 c0                	xor    %eax,%eax
   18986:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   1898c:	89 cf                	mov    %ecx,%edi
   1898e:	83 f9 0f             	cmp    $0xf,%ecx
   18991:	76 07                	jbe    1899a <_IOAPICSetupIrqs+0x31a>
   18993:	89 c7                	mov    %eax,%edi
   18995:	e9 38 fe ff ff       	jmp    187d2 <_IOAPICSetupIrqs+0x152>
   1899a:	89 c8                	mov    %ecx,%eax
   1899c:	83 ec 0c             	sub    $0xc,%esp
   1899f:	c1 e8 03             	shr    $0x3,%eax
   189a2:	83 e7 07             	and    $0x7,%edi
   189a5:	05 d0 04 00 00       	add    $0x4d0,%eax
   189aa:	50                   	push   %eax
   189ab:	e8 30 c1 ff ff       	call   14ae0 <_READ_PORT_UCHAR@4>
   189b0:	89 f9                	mov    %edi,%ecx
   189b2:	25 ff 00 00 00       	and    $0xff,%eax
   189b7:	d3 f8                	sar    %cl,%eax
   189b9:	8a 14 dd 64 ee 03 00 	mov    0x3ee64(,%ebx,8),%dl
   189c0:	83 e0 01             	and    $0x1,%eax
   189c3:	88 55 db             	mov    %dl,0xffffffdb(%ebp)
   189c6:	83 c4 0c             	add    $0xc,%esp
   189c9:	66 8b 14 dd 62 ee 03 	mov    0x3ee62(,%ebx,8),%dx
   189d0:	00 
   189d1:	89 c7                	mov    %eax,%edi
   189d3:	e9 fa fd ff ff       	jmp    187d2 <_IOAPICSetupIrqs+0x152>
   189d8:	90                   	nop    
   189d9:	90                   	nop    
   189da:	90                   	nop    
   189db:	90                   	nop    
   189dc:	90                   	nop    
   189dd:	90                   	nop    
   189de:	90                   	nop    
   189df:	90                   	nop    

000189e0 <_HalRequestIpi@4>:
   189e0:	55                   	push   %ebp
   189e1:	b8 01 00 00 00       	mov    $0x1,%eax
   189e6:	89 e5                	mov    %esp,%ebp
   189e8:	83 ec 10             	sub    $0x10,%esp
   189eb:	8b 4d 08             	mov    0x8(%ebp),%ecx
   189ee:	68 fb 08 00 00       	push   $0x8fb
   189f3:	d3 e0                	shl    %cl,%eax
   189f5:	50                   	push   %eax
   189f6:	e8 25 df ff ff       	call   16920 <_APICSendIPI>
   189fb:	c9                   	leave  
   189fc:	c2 04 00             	ret    $0x4
   189ff:	90                   	nop    

00018a00 <_MPChecksum>:
   18a00:	55                   	push   %ebp
   18a01:	31 c9                	xor    %ecx,%ecx
   18a03:	89 e5                	mov    %esp,%ebp
   18a05:	eb 03                	jmp    18a0a <_MPChecksum+0xa>
   18a07:	02 08                	add    (%eax),%cl
   18a09:	40                   	inc    %eax
   18a0a:	4a                   	dec    %edx
   18a0b:	83 fa ff             	cmp    $0xffffffff,%edx
   18a0e:	75 f7                	jne    18a07 <_MPChecksum+0x7>
   18a10:	31 c0                	xor    %eax,%eax
   18a12:	5d                   	pop    %ebp
   18a13:	88 c8                	mov    %cl,%al
   18a15:	c3                   	ret    
   18a16:	8d 76 00             	lea    0x0(%esi),%esi
   18a19:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00018a20 <_HaliMPIntSrcInfo>:
   18a20:	55                   	push   %ebp
   18a21:	89 e5                	mov    %esp,%ebp
   18a23:	53                   	push   %ebx
   18a24:	89 c3                	mov    %eax,%ebx
   18a26:	52                   	push   %edx
   18a27:	52                   	push   %edx
   18a28:	6a 32                	push   $0x32
   18a2a:	68 80 ca 01 00       	push   $0x1ca80
   18a2f:	68 8b ca 01 00       	push   $0x1ca8b
   18a34:	e8 57 1e 00 00       	call   1a890 <_DbgPrint>
   18a39:	31 c0                	xor    %eax,%eax
   18a3b:	8a 43 07             	mov    0x7(%ebx),%al
   18a3e:	50                   	push   %eax
   18a3f:	31 c0                	xor    %eax,%eax
   18a41:	8a 43 06             	mov    0x6(%ebx),%al
   18a44:	50                   	push   %eax
   18a45:	31 c0                	xor    %eax,%eax
   18a47:	8a 43 05             	mov    0x5(%ebx),%al
   18a4a:	50                   	push   %eax
   18a4b:	31 c0                	xor    %eax,%eax
   18a4d:	8a 43 04             	mov    0x4(%ebx),%al
   18a50:	50                   	push   %eax
   18a51:	66 8b 53 02          	mov    0x2(%ebx),%dx
   18a55:	89 d0                	mov    %edx,%eax
   18a57:	83 e2 03             	and    $0x3,%edx
   18a5a:	66 c1 e8 02          	shr    $0x2,%ax
   18a5e:	83 e0 03             	and    $0x3,%eax
   18a61:	50                   	push   %eax
   18a62:	31 c0                	xor    %eax,%eax
   18a64:	52                   	push   %edx
   18a65:	8a 43 01             	mov    0x1(%ebx),%al
   18a68:	50                   	push   %eax
   18a69:	68 94 ca 01 00       	push   $0x1ca94
   18a6e:	e8 1d 1e 00 00       	call   1a890 <_DbgPrint>
   18a73:	8b 0d c0 e4 03 00    	mov    0x3e4c0,%ecx
   18a79:	83 c4 30             	add    $0x30,%esp
   18a7c:	81 f9 80 00 00 00    	cmp    $0x80,%ecx
   18a82:	77 20                	ja     18aa4 <_HaliMPIntSrcInfo+0x84>
   18a84:	8b 03                	mov    (%ebx),%eax
   18a86:	8b 53 04             	mov    0x4(%ebx),%edx
   18a89:	89 04 cd 60 ee 03 00 	mov    %eax,0x3ee60(,%ecx,8)
   18a90:	8d 41 01             	lea    0x1(%ecx),%eax
   18a93:	89 14 cd 64 ee 03 00 	mov    %edx,0x3ee64(,%ecx,8)
   18a9a:	a3 c0 e4 03 00       	mov    %eax,0x3e4c0
   18a9f:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   18aa2:	c9                   	leave  
   18aa3:	c3                   	ret    
   18aa4:	50                   	push   %eax
   18aa5:	6a 35                	push   $0x35
   18aa7:	68 80 ca 01 00       	push   $0x1ca80
   18aac:	68 8b ca 01 00       	push   $0x1ca8b
   18ab1:	e8 da 1d 00 00       	call   1a890 <_DbgPrint>
   18ab6:	c7 04 24 e0 ca 01 00 	movl   $0x1cae0,(%esp)
   18abd:	e8 ce 1d 00 00       	call   1a890 <_DbgPrint>
   18ac2:	83 c4 0c             	add    $0xc,%esp
   18ac5:	6a 36                	push   $0x36
   18ac7:	68 80 ca 01 00       	push   $0x1ca80
   18acc:	68 01 cb 01 00       	push   $0x1cb01
   18ad1:	e8 ba 1d 00 00       	call   1a890 <_DbgPrint>
   18ad6:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   18add:	e8 8e 1d 00 00       	call   1a870 <_KeBugCheck@4>
   18ae2:	8b 0d c0 e4 03 00    	mov    0x3e4c0,%ecx
   18ae8:	8b 03                	mov    (%ebx),%eax
   18aea:	8b 53 04             	mov    0x4(%ebx),%edx
   18aed:	89 04 cd 60 ee 03 00 	mov    %eax,0x3ee60(,%ecx,8)
   18af4:	8d 41 01             	lea    0x1(%ecx),%eax
   18af7:	89 14 cd 64 ee 03 00 	mov    %edx,0x3ee64(,%ecx,8)
   18afe:	a3 c0 e4 03 00       	mov    %eax,0x3e4c0
   18b03:	83 c4 0c             	add    $0xc,%esp
   18b06:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   18b09:	c9                   	leave  
   18b0a:	c3                   	ret    
   18b0b:	90                   	nop    
   18b0c:	8d 74 26 00          	lea    0x0(%esi),%esi

00018b10 <_HaliMPProcessorInfo>:
   18b10:	55                   	push   %ebp
   18b11:	89 e5                	mov    %esp,%ebp
   18b13:	57                   	push   %edi
   18b14:	56                   	push   %esi
   18b15:	53                   	push   %ebx
   18b16:	83 ec 0c             	sub    $0xc,%esp
   18b19:	89 c6                	mov    %eax,%esi
   18b1b:	f6 40 03 01          	testb  $0x1,0x3(%eax)
   18b1f:	75 0f                	jne    18b30 <_HaliMPProcessorInfo+0x20>
   18b21:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   18b24:	5b                   	pop    %ebx
   18b25:	5e                   	pop    %esi
   18b26:	5f                   	pop    %edi
   18b27:	5d                   	pop    %ebp
   18b28:	c3                   	ret    
   18b29:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   18b30:	50                   	push   %eax
   18b31:	6a 65                	push   $0x65
   18b33:	68 80 ca 01 00       	push   $0x1ca80
   18b38:	68 8b ca 01 00       	push   $0x1ca8b
   18b3d:	e8 4e 1d 00 00       	call   1a890 <_DbgPrint>
   18b42:	8b 46 08             	mov    0x8(%esi),%eax
   18b45:	83 c4 10             	add    $0x10,%esp
   18b48:	89 c1                	mov    %eax,%ecx
   18b4a:	89 c3                	mov    %eax,%ebx
   18b4c:	81 e1 00 0f 00 00    	and    $0xf00,%ecx
   18b52:	81 e3 f0 00 00 00    	and    $0xf0,%ebx
   18b58:	c1 e9 08             	shr    $0x8,%ecx
   18b5b:	ba 60 cb 01 00       	mov    $0x1cb60,%edx
   18b60:	c1 eb 04             	shr    $0x4,%ebx
   18b63:	83 f9 06             	cmp    $0x6,%ecx
   18b66:	74 38                	je     18ba0 <_HaliMPProcessorInfo+0x90>
   18b68:	ba 70 cb 01 00       	mov    $0x1cb70,%edx
   18b6d:	83 f9 05             	cmp    $0x5,%ecx
   18b70:	74 2e                	je     18ba0 <_HaliMPProcessorInfo+0x90>
   18b72:	83 f9 0f             	cmp    $0xf,%ecx
   18b75:	ba 7c cb 01 00       	mov    $0x1cb7c,%edx
   18b7a:	0f 94 c0             	sete   %al
   18b7d:	25 ff 00 00 00       	and    $0xff,%eax
   18b82:	83 fb 0f             	cmp    $0xf,%ebx
   18b85:	89 c7                	mov    %eax,%edi
   18b87:	0f 94 c0             	sete   %al
   18b8a:	85 f8                	test   %edi,%eax
   18b8c:	75 12                	jne    18ba0 <_HaliMPProcessorInfo+0x90>
   18b8e:	85 db                	test   %ebx,%ebx
   18b90:	ba 8f cb 01 00       	mov    $0x1cb8f,%edx
   18b95:	0f 94 c0             	sete   %al
   18b98:	85 f8                	test   %edi,%eax
   18b9a:	0f 84 6e 05 00 00    	je     1910e <_HaliMPProcessorInfo+0x5fe>
   18ba0:	31 c0                	xor    %eax,%eax
   18ba2:	8a 46 02             	mov    0x2(%esi),%al
   18ba5:	50                   	push   %eax
   18ba6:	31 c0                	xor    %eax,%eax
   18ba8:	52                   	push   %edx
   18ba9:	8a 46 01             	mov    0x1(%esi),%al
   18bac:	50                   	push   %eax
   18bad:	68 a0 cb 01 00       	push   $0x1cba0
   18bb2:	e8 d9 1c 00 00       	call   1a890 <_DbgPrint>
   18bb7:	8b 46 08             	mov    0x8(%esi),%eax
   18bba:	83 c4 10             	add    $0x10,%esp
   18bbd:	a8 01                	test   $0x1,%al
   18bbf:	0f 85 23 01 00 00    	jne    18ce8 <_HaliMPProcessorInfo+0x1d8>
   18bc5:	a9 80 00 00 00       	test   $0x80,%eax
   18bca:	0f 85 db 04 00 00    	jne    190ab <_HaliMPProcessorInfo+0x59b>
   18bd0:	f6 c4 01             	test   $0x1,%ah
   18bd3:	0f 85 a9 04 00 00    	jne    19082 <_HaliMPProcessorInfo+0x572>
   18bd9:	f6 c4 02             	test   $0x2,%ah
   18bdc:	0f 85 77 04 00 00    	jne    19059 <_HaliMPProcessorInfo+0x549>
   18be2:	f6 c4 08             	test   $0x8,%ah
   18be5:	0f 85 45 04 00 00    	jne    19030 <_HaliMPProcessorInfo+0x520>
   18beb:	f6 c4 10             	test   $0x10,%ah
   18bee:	0f 85 13 04 00 00    	jne    19007 <_HaliMPProcessorInfo+0x4f7>
   18bf4:	f6 c4 20             	test   $0x20,%ah
   18bf7:	0f 85 e1 03 00 00    	jne    18fde <_HaliMPProcessorInfo+0x4ce>
   18bfd:	f6 c4 40             	test   $0x40,%ah
   18c00:	0f 85 af 03 00 00    	jne    18fb5 <_HaliMPProcessorInfo+0x4a5>
   18c06:	a9 00 80 00 00       	test   $0x8000,%eax
   18c0b:	0f 85 7b 03 00 00    	jne    18f8c <_HaliMPProcessorInfo+0x47c>
   18c11:	a9 00 00 01 00       	test   $0x10000,%eax
   18c16:	0f 85 47 03 00 00    	jne    18f63 <_HaliMPProcessorInfo+0x453>
   18c1c:	a9 00 00 02 00       	test   $0x20000,%eax
   18c21:	0f 85 13 03 00 00    	jne    18f3a <_HaliMPProcessorInfo+0x42a>
   18c27:	a9 00 00 04 00       	test   $0x40000,%eax
   18c2c:	0f 85 df 02 00 00    	jne    18f11 <_HaliMPProcessorInfo+0x401>
   18c32:	a9 00 00 08 00       	test   $0x80000,%eax
   18c37:	0f 85 a8 02 00 00    	jne    18ee5 <_HaliMPProcessorInfo+0x3d5>
   18c3d:	a9 00 00 20 00       	test   $0x200000,%eax
   18c42:	0f 85 71 02 00 00    	jne    18eb9 <_HaliMPProcessorInfo+0x3a9>
   18c48:	a9 00 00 40 00       	test   $0x400000,%eax
   18c4d:	0f 85 3a 02 00 00    	jne    18e8d <_HaliMPProcessorInfo+0x37d>
   18c53:	a9 00 00 80 00       	test   $0x800000,%eax
   18c58:	0f 85 03 02 00 00    	jne    18e61 <_HaliMPProcessorInfo+0x351>
   18c5e:	a9 00 00 00 01       	test   $0x1000000,%eax
   18c63:	0f 85 cc 01 00 00    	jne    18e35 <_HaliMPProcessorInfo+0x325>
   18c69:	a9 00 00 00 02       	test   $0x2000000,%eax
   18c6e:	0f 85 95 01 00 00    	jne    18e09 <_HaliMPProcessorInfo+0x2f9>
   18c74:	a9 00 00 00 04       	test   $0x4000000,%eax
   18c79:	0f 85 5e 01 00 00    	jne    18ddd <_HaliMPProcessorInfo+0x2cd>
   18c7f:	a9 00 00 00 08       	test   $0x8000000,%eax
   18c84:	0f 85 27 01 00 00    	jne    18db1 <_HaliMPProcessorInfo+0x2a1>
   18c8a:	a9 00 00 00 20       	test   $0x20000000,%eax
   18c8f:	0f 85 f3 00 00 00    	jne    18d88 <_HaliMPProcessorInfo+0x278>
   18c95:	8b 0d c0 e8 03 00    	mov    0x3e8c0,%ecx
   18c9b:	8a 46 01             	mov    0x1(%esi),%al
   18c9e:	89 ca                	mov    %ecx,%edx
   18ca0:	c1 e2 04             	shl    $0x4,%edx
   18ca3:	88 82 31 e6 03 00    	mov    %al,0x3e631(%edx)
   18ca9:	c6 82 30 e6 03 00 01 	movb   $0x1,0x3e630(%edx)
   18cb0:	f6 46 03 02          	testb  $0x2,0x3(%esi)
   18cb4:	0f 85 89 00 00 00    	jne    18d43 <_HaliMPProcessorInfo+0x233>
   18cba:	80 7e 01 20          	cmpb   $0x20,0x1(%esi)
   18cbe:	77 51                	ja     18d11 <_HaliMPProcessorInfo+0x201>
   18cc0:	31 d2                	xor    %edx,%edx
   18cc2:	8a 56 02             	mov    0x2(%esi),%dl
   18cc5:	85 d2                	test   %edx,%edx
   18cc7:	0f 84 07 04 00 00    	je     190d4 <_HaliMPProcessorInfo+0x5c4>
   18ccd:	89 c8                	mov    %ecx,%eax
   18ccf:	c1 e0 04             	shl    $0x4,%eax
   18cd2:	88 90 32 e6 03 00    	mov    %dl,0x3e632(%eax)
   18cd8:	8d 41 01             	lea    0x1(%ecx),%eax
   18cdb:	a3 c0 e8 03 00       	mov    %eax,0x3e8c0
   18ce0:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   18ce3:	5b                   	pop    %ebx
   18ce4:	5e                   	pop    %esi
   18ce5:	5f                   	pop    %edi
   18ce6:	5d                   	pop    %ebp
   18ce7:	c3                   	ret    
   18ce8:	50                   	push   %eax
   18ce9:	6a 68                	push   $0x68
   18ceb:	68 80 ca 01 00       	push   $0x1ca80
   18cf0:	68 8b ca 01 00       	push   $0x1ca8b
   18cf5:	e8 96 1b 00 00       	call   1a890 <_DbgPrint>
   18cfa:	c7 04 24 c4 cb 01 00 	movl   $0x1cbc4,(%esp)
   18d01:	e8 8a 1b 00 00       	call   1a890 <_DbgPrint>
   18d06:	83 c4 10             	add    $0x10,%esp
   18d09:	8b 46 08             	mov    0x8(%esi),%eax
   18d0c:	e9 b4 fe ff ff       	jmp    18bc5 <_HaliMPProcessorInfo+0xb5>
   18d11:	50                   	push   %eax
   18d12:	68 a2 00 00 00       	push   $0xa2
   18d17:	68 80 ca 01 00       	push   $0x1ca80
   18d1c:	68 8b ca 01 00       	push   $0x1ca8b
   18d21:	e8 6a 1b 00 00       	call   1a890 <_DbgPrint>
   18d26:	83 c4 0c             	add    $0xc,%esp
   18d29:	31 c0                	xor    %eax,%eax
   18d2b:	6a 20                	push   $0x20
   18d2d:	8a 46 01             	mov    0x1(%esi),%al
   18d30:	50                   	push   %eax
   18d31:	68 e8 cb 01 00       	push   $0x1cbe8
   18d36:	e8 55 1b 00 00       	call   1a890 <_DbgPrint>
   18d3b:	83 c4 10             	add    $0x10,%esp
   18d3e:	e9 de fd ff ff       	jmp    18b21 <_HaliMPProcessorInfo+0x11>
   18d43:	50                   	push   %eax
   18d44:	68 9b 00 00 00       	push   $0x9b
   18d49:	68 80 ca 01 00       	push   $0x1ca80
   18d4e:	68 8b ca 01 00       	push   $0x1ca8b
   18d53:	e8 38 1b 00 00       	call   1a890 <_DbgPrint>
   18d58:	c7 04 24 0e cc 01 00 	movl   $0x1cc0e,(%esp)
   18d5f:	e8 2c 1b 00 00       	call   1a890 <_DbgPrint>
   18d64:	8b 0d c0 e8 03 00    	mov    0x3e8c0,%ecx
   18d6a:	89 c8                	mov    %ecx,%eax
   18d6c:	83 c4 10             	add    $0x10,%esp
   18d6f:	c1 e0 04             	shl    $0x4,%eax
   18d72:	80 88 30 e6 03 00 04 	orb    $0x4,0x3e630(%eax)
   18d79:	31 c0                	xor    %eax,%eax
   18d7b:	8a 46 01             	mov    0x1(%esi),%al
   18d7e:	a3 50 e9 03 00       	mov    %eax,0x3e950
   18d83:	e9 32 ff ff ff       	jmp    18cba <_HaliMPProcessorInfo+0x1aa>
   18d88:	50                   	push   %eax
   18d89:	68 92 00 00 00       	push   $0x92
   18d8e:	68 80 ca 01 00       	push   $0x1ca80
   18d93:	68 8b ca 01 00       	push   $0x1ca8b
   18d98:	e8 f3 1a 00 00       	call   1a890 <_DbgPrint>
   18d9d:	c7 04 24 1e cc 01 00 	movl   $0x1cc1e,(%esp)
   18da4:	e8 e7 1a 00 00       	call   1a890 <_DbgPrint>
   18da9:	83 c4 10             	add    $0x10,%esp
   18dac:	e9 e4 fe ff ff       	jmp    18c95 <_HaliMPProcessorInfo+0x185>
   18db1:	50                   	push   %eax
   18db2:	68 8f 00 00 00       	push   $0x8f
   18db7:	68 80 ca 01 00       	push   $0x1ca80
   18dbc:	68 8b ca 01 00       	push   $0x1ca8b
   18dc1:	e8 ca 1a 00 00       	call   1a890 <_DbgPrint>
   18dc6:	c7 04 24 3c cc 01 00 	movl   $0x1cc3c,(%esp)
   18dcd:	e8 be 1a 00 00       	call   1a890 <_DbgPrint>
   18dd2:	83 c4 10             	add    $0x10,%esp
   18dd5:	8b 46 08             	mov    0x8(%esi),%eax
   18dd8:	e9 ad fe ff ff       	jmp    18c8a <_HaliMPProcessorInfo+0x17a>
   18ddd:	50                   	push   %eax
   18dde:	68 8d 00 00 00       	push   $0x8d
   18de3:	68 80 ca 01 00       	push   $0x1ca80
   18de8:	68 8b ca 01 00       	push   $0x1ca8b
   18ded:	e8 9e 1a 00 00       	call   1a890 <_DbgPrint>
   18df2:	c7 04 24 58 cc 01 00 	movl   $0x1cc58,(%esp)
   18df9:	e8 92 1a 00 00       	call   1a890 <_DbgPrint>
   18dfe:	83 c4 10             	add    $0x10,%esp
   18e01:	8b 46 08             	mov    0x8(%esi),%eax
   18e04:	e9 76 fe ff ff       	jmp    18c7f <_HaliMPProcessorInfo+0x16f>
   18e09:	50                   	push   %eax
   18e0a:	68 8b 00 00 00       	push   $0x8b
   18e0f:	68 80 ca 01 00       	push   $0x1ca80
   18e14:	68 8b ca 01 00       	push   $0x1ca8b
   18e19:	e8 72 1a 00 00       	call   1a890 <_DbgPrint>
   18e1e:	c7 04 24 82 cc 01 00 	movl   $0x1cc82,(%esp)
   18e25:	e8 66 1a 00 00       	call   1a890 <_DbgPrint>
   18e2a:	83 c4 10             	add    $0x10,%esp
   18e2d:	8b 46 08             	mov    0x8(%esi),%eax
   18e30:	e9 3f fe ff ff       	jmp    18c74 <_HaliMPProcessorInfo+0x164>
   18e35:	52                   	push   %edx
   18e36:	68 89 00 00 00       	push   $0x89
   18e3b:	68 80 ca 01 00       	push   $0x1ca80
   18e40:	68 8b ca 01 00       	push   $0x1ca8b
   18e45:	e8 46 1a 00 00       	call   1a890 <_DbgPrint>
   18e4a:	c7 04 24 95 cc 01 00 	movl   $0x1cc95,(%esp)
   18e51:	e8 3a 1a 00 00       	call   1a890 <_DbgPrint>
   18e56:	83 c4 10             	add    $0x10,%esp
   18e59:	8b 46 08             	mov    0x8(%esi),%eax
   18e5c:	e9 08 fe ff ff       	jmp    18c69 <_HaliMPProcessorInfo+0x159>
   18e61:	51                   	push   %ecx
   18e62:	68 87 00 00 00       	push   $0x87
   18e67:	68 80 ca 01 00       	push   $0x1ca80
   18e6c:	68 8b ca 01 00       	push   $0x1ca8b
   18e71:	e8 1a 1a 00 00       	call   1a890 <_DbgPrint>
   18e76:	c7 04 24 a9 cc 01 00 	movl   $0x1cca9,(%esp)
   18e7d:	e8 0e 1a 00 00       	call   1a890 <_DbgPrint>
   18e82:	83 c4 10             	add    $0x10,%esp
   18e85:	8b 46 08             	mov    0x8(%esi),%eax
   18e88:	e9 d1 fd ff ff       	jmp    18c5e <_HaliMPProcessorInfo+0x14e>
   18e8d:	53                   	push   %ebx
   18e8e:	68 85 00 00 00       	push   $0x85
   18e93:	68 80 ca 01 00       	push   $0x1ca80
   18e98:	68 8b ca 01 00       	push   $0x1ca8b
   18e9d:	e8 ee 19 00 00       	call   1a890 <_DbgPrint>
   18ea2:	c7 04 24 bc cc 01 00 	movl   $0x1ccbc,(%esp)
   18ea9:	e8 e2 19 00 00       	call   1a890 <_DbgPrint>
   18eae:	83 c4 10             	add    $0x10,%esp
   18eb1:	8b 46 08             	mov    0x8(%esi),%eax
   18eb4:	e9 9a fd ff ff       	jmp    18c53 <_HaliMPProcessorInfo+0x143>
   18eb9:	57                   	push   %edi
   18eba:	68 83 00 00 00       	push   $0x83
   18ebf:	68 80 ca 01 00       	push   $0x1ca80
   18ec4:	68 8b ca 01 00       	push   $0x1ca8b
   18ec9:	e8 c2 19 00 00       	call   1a890 <_DbgPrint>
   18ece:	c7 04 24 ec cc 01 00 	movl   $0x1ccec,(%esp)
   18ed5:	e8 b6 19 00 00       	call   1a890 <_DbgPrint>
   18eda:	83 c4 10             	add    $0x10,%esp
   18edd:	8b 46 08             	mov    0x8(%esi),%eax
   18ee0:	e9 63 fd ff ff       	jmp    18c48 <_HaliMPProcessorInfo+0x138>
   18ee5:	50                   	push   %eax
   18ee6:	68 80 00 00 00       	push   $0x80
   18eeb:	68 80 ca 01 00       	push   $0x1ca80
   18ef0:	68 8b ca 01 00       	push   $0x1ca8b
   18ef5:	e8 96 19 00 00       	call   1a890 <_DbgPrint>
   18efa:	c7 04 24 18 cd 01 00 	movl   $0x1cd18,(%esp)
   18f01:	e8 8a 19 00 00       	call   1a890 <_DbgPrint>
   18f06:	83 c4 10             	add    $0x10,%esp
   18f09:	8b 46 08             	mov    0x8(%esi),%eax
   18f0c:	e9 2c fd ff ff       	jmp    18c3d <_HaliMPProcessorInfo+0x12d>
   18f11:	50                   	push   %eax
   18f12:	6a 7e                	push   $0x7e
   18f14:	68 80 ca 01 00       	push   $0x1ca80
   18f19:	68 8b ca 01 00       	push   $0x1ca8b
   18f1e:	e8 6d 19 00 00       	call   1a890 <_DbgPrint>
   18f23:	c7 04 24 43 cd 01 00 	movl   $0x1cd43,(%esp)
   18f2a:	e8 61 19 00 00       	call   1a890 <_DbgPrint>
   18f2f:	83 c4 10             	add    $0x10,%esp
   18f32:	8b 46 08             	mov    0x8(%esi),%eax
   18f35:	e9 f8 fc ff ff       	jmp    18c32 <_HaliMPProcessorInfo+0x122>
   18f3a:	50                   	push   %eax
   18f3b:	6a 7c                	push   $0x7c
   18f3d:	68 80 ca 01 00       	push   $0x1ca80
   18f42:	68 8b ca 01 00       	push   $0x1ca8b
   18f47:	e8 44 19 00 00       	call   1a890 <_DbgPrint>
   18f4c:	c7 04 24 56 cd 01 00 	movl   $0x1cd56,(%esp)
   18f53:	e8 38 19 00 00       	call   1a890 <_DbgPrint>
   18f58:	83 c4 10             	add    $0x10,%esp
   18f5b:	8b 46 08             	mov    0x8(%esi),%eax
   18f5e:	e9 c4 fc ff ff       	jmp    18c27 <_HaliMPProcessorInfo+0x117>
   18f63:	50                   	push   %eax
   18f64:	6a 7a                	push   $0x7a
   18f66:	68 80 ca 01 00       	push   $0x1ca80
   18f6b:	68 8b ca 01 00       	push   $0x1ca8b
   18f70:	e8 1b 19 00 00       	call   1a890 <_DbgPrint>
   18f75:	c7 04 24 69 cd 01 00 	movl   $0x1cd69,(%esp)
   18f7c:	e8 0f 19 00 00       	call   1a890 <_DbgPrint>
   18f81:	83 c4 10             	add    $0x10,%esp
   18f84:	8b 46 08             	mov    0x8(%esi),%eax
   18f87:	e9 90 fc ff ff       	jmp    18c1c <_HaliMPProcessorInfo+0x10c>
   18f8c:	50                   	push   %eax
   18f8d:	6a 78                	push   $0x78
   18f8f:	68 80 ca 01 00       	push   $0x1ca80
   18f94:	68 8b ca 01 00       	push   $0x1ca8b
   18f99:	e8 f2 18 00 00       	call   1a890 <_DbgPrint>
   18f9e:	c7 04 24 7c cd 01 00 	movl   $0x1cd7c,(%esp)
   18fa5:	e8 e6 18 00 00       	call   1a890 <_DbgPrint>
   18faa:	83 c4 10             	add    $0x10,%esp
   18fad:	8b 46 08             	mov    0x8(%esi),%eax
   18fb0:	e9 5c fc ff ff       	jmp    18c11 <_HaliMPProcessorInfo+0x101>
   18fb5:	50                   	push   %eax
   18fb6:	6a 76                	push   $0x76
   18fb8:	68 80 ca 01 00       	push   $0x1ca80
   18fbd:	68 8b ca 01 00       	push   $0x1ca8b
   18fc2:	e8 c9 18 00 00       	call   1a890 <_DbgPrint>
   18fc7:	c7 04 24 90 cd 01 00 	movl   $0x1cd90,(%esp)
   18fce:	e8 bd 18 00 00       	call   1a890 <_DbgPrint>
   18fd3:	83 c4 10             	add    $0x10,%esp
   18fd6:	8b 46 08             	mov    0x8(%esi),%eax
   18fd9:	e9 28 fc ff ff       	jmp    18c06 <_HaliMPProcessorInfo+0xf6>
   18fde:	52                   	push   %edx
   18fdf:	6a 74                	push   $0x74
   18fe1:	68 80 ca 01 00       	push   $0x1ca80
   18fe6:	68 8b ca 01 00       	push   $0x1ca8b
   18feb:	e8 a0 18 00 00       	call   1a890 <_DbgPrint>
   18ff0:	c7 04 24 a3 cd 01 00 	movl   $0x1cda3,(%esp)
   18ff7:	e8 94 18 00 00       	call   1a890 <_DbgPrint>
   18ffc:	83 c4 10             	add    $0x10,%esp
   18fff:	8b 46 08             	mov    0x8(%esi),%eax
   19002:	e9 f6 fb ff ff       	jmp    18bfd <_HaliMPProcessorInfo+0xed>
   19007:	51                   	push   %ecx
   19008:	6a 72                	push   $0x72
   1900a:	68 80 ca 01 00       	push   $0x1ca80
   1900f:	68 8b ca 01 00       	push   $0x1ca8b
   19014:	e8 77 18 00 00       	call   1a890 <_DbgPrint>
   19019:	c7 04 24 b6 cd 01 00 	movl   $0x1cdb6,(%esp)
   19020:	e8 6b 18 00 00       	call   1a890 <_DbgPrint>
   19025:	83 c4 10             	add    $0x10,%esp
   19028:	8b 46 08             	mov    0x8(%esi),%eax
   1902b:	e9 c4 fb ff ff       	jmp    18bf4 <_HaliMPProcessorInfo+0xe4>
   19030:	53                   	push   %ebx
   19031:	6a 70                	push   $0x70
   19033:	68 80 ca 01 00       	push   $0x1ca80
   19038:	68 8b ca 01 00       	push   $0x1ca8b
   1903d:	e8 4e 18 00 00       	call   1a890 <_DbgPrint>
   19042:	c7 04 24 c9 cd 01 00 	movl   $0x1cdc9,(%esp)
   19049:	e8 42 18 00 00       	call   1a890 <_DbgPrint>
   1904e:	83 c4 10             	add    $0x10,%esp
   19051:	8b 46 08             	mov    0x8(%esi),%eax
   19054:	e9 92 fb ff ff       	jmp    18beb <_HaliMPProcessorInfo+0xdb>
   19059:	57                   	push   %edi
   1905a:	6a 6e                	push   $0x6e
   1905c:	68 80 ca 01 00       	push   $0x1ca80
   19061:	68 8b ca 01 00       	push   $0x1ca8b
   19066:	e8 25 18 00 00       	call   1a890 <_DbgPrint>
   1906b:	c7 04 24 db cd 01 00 	movl   $0x1cddb,(%esp)
   19072:	e8 19 18 00 00       	call   1a890 <_DbgPrint>
   19077:	83 c4 10             	add    $0x10,%esp
   1907a:	8b 46 08             	mov    0x8(%esi),%eax
   1907d:	e9 60 fb ff ff       	jmp    18be2 <_HaliMPProcessorInfo+0xd2>
   19082:	50                   	push   %eax
   19083:	6a 6c                	push   $0x6c
   19085:	68 80 ca 01 00       	push   $0x1ca80
   1908a:	68 8b ca 01 00       	push   $0x1ca8b
   1908f:	e8 fc 17 00 00       	call   1a890 <_DbgPrint>
   19094:	c7 04 24 f8 cd 01 00 	movl   $0x1cdf8,(%esp)
   1909b:	e8 f0 17 00 00       	call   1a890 <_DbgPrint>
   190a0:	83 c4 10             	add    $0x10,%esp
   190a3:	8b 46 08             	mov    0x8(%esi),%eax
   190a6:	e9 2e fb ff ff       	jmp    18bd9 <_HaliMPProcessorInfo+0xc9>
   190ab:	50                   	push   %eax
   190ac:	6a 6a                	push   $0x6a
   190ae:	68 80 ca 01 00       	push   $0x1ca80
   190b3:	68 8b ca 01 00       	push   $0x1ca8b
   190b8:	e8 d3 17 00 00       	call   1a890 <_DbgPrint>
   190bd:	c7 04 24 24 ce 01 00 	movl   $0x1ce24,(%esp)
   190c4:	e8 c7 17 00 00       	call   1a890 <_DbgPrint>
   190c9:	83 c4 10             	add    $0x10,%esp
   190cc:	8b 46 08             	mov    0x8(%esi),%eax
   190cf:	e9 fc fa ff ff       	jmp    18bd0 <_HaliMPProcessorInfo+0xc0>
   190d4:	57                   	push   %edi
   190d5:	68 ac 00 00 00       	push   $0xac
   190da:	68 80 ca 01 00       	push   $0x1ca80
   190df:	68 8b ca 01 00       	push   $0x1ca8b
   190e4:	e8 a7 17 00 00       	call   1a890 <_DbgPrint>
   190e9:	31 c0                	xor    %eax,%eax
   190eb:	59                   	pop    %ecx
   190ec:	8a 46 01             	mov    0x1(%esi),%al
   190ef:	5b                   	pop    %ebx
   190f0:	50                   	push   %eax
   190f1:	68 48 ce 01 00       	push   $0x1ce48
   190f6:	e8 95 17 00 00       	call   1a890 <_DbgPrint>
   190fb:	83 c4 10             	add    $0x10,%esp
   190fe:	ba 10 00 00 00       	mov    $0x10,%edx
   19103:	8b 0d c0 e8 03 00    	mov    0x3e8c0,%ecx
   19109:	e9 bf fb ff ff       	jmp    18ccd <_HaliMPProcessorInfo+0x1bd>
   1910e:	83 f9 04             	cmp    $0x4,%ecx
   19111:	0f 94 c2             	sete   %dl
   19114:	83 fb 08             	cmp    $0x8,%ebx
   19117:	0f 96 c0             	setbe  %al
   1911a:	25 ff 00 00 00       	and    $0xff,%eax
   1911f:	85 c2                	test   %eax,%edx
   19121:	74 0c                	je     1912f <_HaliMPProcessorInfo+0x61f>
   19123:	8b 14 9d 20 b0 01 00 	mov    0x1b020(,%ebx,4),%edx
   1912a:	e9 71 fa ff ff       	jmp    18ba0 <_HaliMPProcessorInfo+0x90>
   1912f:	53                   	push   %ebx
   19130:	51                   	push   %ecx
   19131:	68 9c ce 01 00       	push   $0x1ce9c
   19136:	68 d8 e4 03 00       	push   $0x3e4d8
   1913b:	e8 10 18 00 00       	call   1a950 <_sprintf>
   19140:	83 c4 10             	add    $0x10,%esp
   19143:	ba d8 e4 03 00       	mov    $0x3e4d8,%edx
   19148:	e9 53 fa ff ff       	jmp    18ba0 <_HaliMPProcessorInfo+0x90>
   1914d:	8d 76 00             	lea    0x0(%esi),%esi

00019150 <_HaliMPBusInfo>:
   19150:	55                   	push   %ebp
   19151:	89 e5                	mov    %esp,%ebp
   19153:	57                   	push   %edi
   19154:	56                   	push   %esi
   19155:	53                   	push   %ebx
   19156:	83 ec 10             	sub    $0x10,%esp
   19159:	89 c3                	mov    %eax,%ebx
   1915b:	bf cc ce 01 00       	mov    $0x1cecc,%edi
   19160:	68 bb 00 00 00       	push   $0xbb
   19165:	68 80 ca 01 00       	push   $0x1ca80
   1916a:	68 8b ca 01 00       	push   $0x1ca8b
   1916f:	e8 1c 17 00 00       	call   1a890 <_DbgPrint>
   19174:	8d 43 02             	lea    0x2(%ebx),%eax
   19177:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   1917a:	50                   	push   %eax
   1917b:	31 c0                	xor    %eax,%eax
   1917d:	6a 06                	push   $0x6
   1917f:	8a 43 01             	mov    0x1(%ebx),%al
   19182:	50                   	push   %eax
   19183:	68 d0 ce 01 00       	push   $0x1ced0
   19188:	e8 03 17 00 00       	call   1a890 <_DbgPrint>
   1918d:	b9 03 00 00 00       	mov    $0x3,%ecx
   19192:	fc                   	cld    
   19193:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
   19196:	83 c4 20             	add    $0x20,%esp
   19199:	f3 a6                	repz cmpsb %es:(%edi),%ds:(%esi)
   1919b:	75 14                	jne    191b1 <_HaliMPBusInfo+0x61>
   1919d:	31 c0                	xor    %eax,%eax
   1919f:	8a 43 01             	mov    0x1(%ebx),%al
   191a2:	c6 80 f0 ed 03 00 01 	movb   $0x1,0x3edf0(%eax)
   191a9:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   191ac:	5b                   	pop    %ebx
   191ad:	5e                   	pop    %esi
   191ae:	5f                   	pop    %edi
   191af:	5d                   	pop    %ebp
   191b0:	c3                   	ret    
   191b1:	fc                   	cld    
   191b2:	bf e1 ce 01 00       	mov    $0x1cee1,%edi
   191b7:	b9 04 00 00 00       	mov    $0x4,%ecx
   191bc:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
   191bf:	f3 a6                	repz cmpsb %es:(%edi),%ds:(%esi)
   191c1:	75 14                	jne    191d7 <_HaliMPBusInfo+0x87>
   191c3:	31 c0                	xor    %eax,%eax
   191c5:	8a 43 01             	mov    0x1(%ebx),%al
   191c8:	c6 80 f0 ed 03 00 02 	movb   $0x2,0x3edf0(%eax)
   191cf:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   191d2:	5b                   	pop    %ebx
   191d3:	5e                   	pop    %esi
   191d4:	5f                   	pop    %edi
   191d5:	5d                   	pop    %ebp
   191d6:	c3                   	ret    
   191d7:	fc                   	cld    
   191d8:	bf e6 ce 01 00       	mov    $0x1cee6,%edi
   191dd:	b9 03 00 00 00       	mov    $0x3,%ecx
   191e2:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
   191e5:	f3 a6                	repz cmpsb %es:(%edi),%ds:(%esi)
   191e7:	74 27                	je     19210 <_HaliMPBusInfo+0xc0>
   191e9:	fc                   	cld    
   191ea:	bf ea ce 01 00       	mov    $0x1ceea,%edi
   191ef:	b9 03 00 00 00       	mov    $0x3,%ecx
   191f4:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
   191f7:	f3 a6                	repz cmpsb %es:(%edi),%ds:(%esi)
   191f9:	75 3f                	jne    1923a <_HaliMPBusInfo+0xea>
   191fb:	31 c0                	xor    %eax,%eax
   191fd:	8a 43 01             	mov    0x1(%ebx),%al
   19200:	c6 80 f0 ed 03 00 04 	movb   $0x4,0x3edf0(%eax)
   19207:	eb a0                	jmp    191a9 <_HaliMPBusInfo+0x59>
   19209:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   19210:	31 c0                	xor    %eax,%eax
   19212:	31 d2                	xor    %edx,%edx
   19214:	8a 43 01             	mov    0x1(%ebx),%al
   19217:	c6 80 f0 ed 03 00 03 	movb   $0x3,0x3edf0(%eax)
   1921e:	a1 18 e5 03 00       	mov    0x3e518,%eax
   19223:	8a 53 01             	mov    0x1(%ebx),%dl
   19226:	88 82 30 ee 03 00    	mov    %al,0x3ee30(%edx)
   1922c:	40                   	inc    %eax
   1922d:	a3 18 e5 03 00       	mov    %eax,0x3e518
   19232:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   19235:	5b                   	pop    %ebx
   19236:	5e                   	pop    %esi
   19237:	5f                   	pop    %edi
   19238:	5d                   	pop    %ebp
   19239:	c3                   	ret    
   1923a:	50                   	push   %eax
   1923b:	68 d1 00 00 00       	push   $0xd1
   19240:	68 80 ca 01 00       	push   $0x1ca80
   19245:	68 8b ca 01 00       	push   $0x1ca8b
   1924a:	e8 41 16 00 00       	call   1a890 <_DbgPrint>
   1924f:	83 c4 0c             	add    $0xc,%esp
   19252:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   19255:	50                   	push   %eax
   19256:	6a 06                	push   $0x6
   19258:	68 f0 ce 01 00       	push   $0x1cef0
   1925d:	e8 2e 16 00 00       	call   1a890 <_DbgPrint>
   19262:	83 c4 10             	add    $0x10,%esp
   19265:	e9 3f ff ff ff       	jmp    191a9 <_HaliMPBusInfo+0x59>
   1926a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00019270 <_HaliMPIOApicInfo>:
   19270:	55                   	push   %ebp
   19271:	89 e5                	mov    %esp,%ebp
   19273:	53                   	push   %ebx
   19274:	52                   	push   %edx
   19275:	89 c3                	mov    %eax,%ebx
   19277:	f6 40 03 01          	testb  $0x1,0x3(%eax)
   1927b:	75 05                	jne    19282 <_HaliMPIOApicInfo+0x12>
   1927d:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   19280:	c9                   	leave  
   19281:	c3                   	ret    
   19282:	50                   	push   %eax
   19283:	68 dc 00 00 00       	push   $0xdc
   19288:	68 80 ca 01 00       	push   $0x1ca80
   1928d:	68 8b ca 01 00       	push   $0x1ca8b
   19292:	e8 f9 15 00 00       	call   1a890 <_DbgPrint>
   19297:	8b 43 04             	mov    0x4(%ebx),%eax
   1929a:	50                   	push   %eax
   1929b:	31 c0                	xor    %eax,%eax
   1929d:	8a 43 02             	mov    0x2(%ebx),%al
   192a0:	50                   	push   %eax
   192a1:	31 c0                	xor    %eax,%eax
   192a3:	8a 43 01             	mov    0x1(%ebx),%al
   192a6:	50                   	push   %eax
   192a7:	68 14 cf 01 00       	push   $0x1cf14
   192ac:	e8 df 15 00 00       	call   1a890 <_DbgPrint>
   192b1:	8b 0d 50 ee 03 00    	mov    0x3ee50,%ecx
   192b7:	83 c4 20             	add    $0x20,%esp
   192ba:	83 f9 02             	cmp    $0x2,%ecx
   192bd:	77 31                	ja     192f0 <_HaliMPIOApicInfo+0x80>
   192bf:	89 ca                	mov    %ecx,%edx
   192c1:	31 c0                	xor    %eax,%eax
   192c3:	c1 e2 04             	shl    $0x4,%edx
   192c6:	8a 43 01             	mov    0x1(%ebx),%al
   192c9:	89 82 10 ee 03 00    	mov    %eax,0x3ee10(%edx)
   192cf:	31 c0                	xor    %eax,%eax
   192d1:	8a 43 02             	mov    0x2(%ebx),%al
   192d4:	89 82 14 ee 03 00    	mov    %eax,0x3ee14(%edx)
   192da:	8b 43 04             	mov    0x4(%ebx),%eax
   192dd:	89 82 18 ee 03 00    	mov    %eax,0x3ee18(%edx)
   192e3:	8d 41 01             	lea    0x1(%ecx),%eax
   192e6:	a3 50 ee 03 00       	mov    %eax,0x3ee50
   192eb:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   192ee:	c9                   	leave  
   192ef:	c3                   	ret    
   192f0:	51                   	push   %ecx
   192f1:	68 e0 00 00 00       	push   $0xe0
   192f6:	68 80 ca 01 00       	push   $0x1ca80
   192fb:	68 8b ca 01 00       	push   $0x1ca8b
   19300:	e8 8b 15 00 00       	call   1a890 <_DbgPrint>
   19305:	83 c4 0c             	add    $0xc,%esp
   19308:	8b 15 50 ee 03 00    	mov    0x3ee50,%edx
   1930e:	52                   	push   %edx
   1930f:	6a 02                	push   $0x2
   19311:	68 38 cf 01 00       	push   $0x1cf38
   19316:	e8 75 15 00 00       	call   1a890 <_DbgPrint>
   1931b:	83 c4 0c             	add    $0xc,%esp
   1931e:	68 e1 00 00 00       	push   $0xe1
   19323:	68 80 ca 01 00       	push   $0x1ca80
   19328:	68 8b ca 01 00       	push   $0x1ca8b
   1932d:	e8 5e 15 00 00       	call   1a890 <_DbgPrint>
   19332:	c7 04 24 68 cf 01 00 	movl   $0x1cf68,(%esp)
   19339:	e8 52 15 00 00       	call   1a890 <_DbgPrint>
   1933e:	83 c4 0c             	add    $0xc,%esp
   19341:	68 e2 00 00 00       	push   $0xe2
   19346:	68 80 ca 01 00       	push   $0x1ca80
   1934b:	68 01 cb 01 00       	push   $0x1cb01
   19350:	e8 3b 15 00 00       	call   1a890 <_DbgPrint>
   19355:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1935c:	e8 0f 15 00 00       	call   1a870 <_KeBugCheck@4>
   19361:	8b 0d 50 ee 03 00    	mov    0x3ee50,%ecx
   19367:	83 c4 0c             	add    $0xc,%esp
   1936a:	e9 50 ff ff ff       	jmp    192bf <_HaliMPIOApicInfo+0x4f>
   1936f:	90                   	nop    

00019370 <_HaliMPIntLocalInfo>:
   19370:	55                   	push   %ebp
   19371:	89 e5                	mov    %esp,%ebp
   19373:	53                   	push   %ebx
   19374:	89 c3                	mov    %eax,%ebx
   19376:	52                   	push   %edx
   19377:	52                   	push   %edx
   19378:	68 f3 00 00 00       	push   $0xf3
   1937d:	68 80 ca 01 00       	push   $0x1ca80
   19382:	68 8b ca 01 00       	push   $0x1ca8b
   19387:	e8 04 15 00 00       	call   1a890 <_DbgPrint>
   1938c:	31 c0                	xor    %eax,%eax
   1938e:	8a 43 07             	mov    0x7(%ebx),%al
   19391:	31 c9                	xor    %ecx,%ecx
   19393:	50                   	push   %eax
   19394:	31 c0                	xor    %eax,%eax
   19396:	8a 43 06             	mov    0x6(%ebx),%al
   19399:	31 d2                	xor    %edx,%edx
   1939b:	50                   	push   %eax
   1939c:	8a 43 05             	mov    0x5(%ebx),%al
   1939f:	88 c1                	mov    %al,%cl
   193a1:	c0 e8 02             	shr    $0x2,%al
   193a4:	51                   	push   %ecx
   193a5:	8a 53 04             	mov    0x4(%ebx),%dl
   193a8:	83 e0 03             	and    $0x3,%eax
   193ab:	83 e1 03             	and    $0x3,%ecx
   193ae:	52                   	push   %edx
   193af:	50                   	push   %eax
   193b0:	31 c0                	xor    %eax,%eax
   193b2:	51                   	push   %ecx
   193b3:	8a 43 01             	mov    0x1(%ebx),%al
   193b6:	50                   	push   %eax
   193b7:	68 8c cf 01 00       	push   $0x1cf8c
   193bc:	e8 cf 14 00 00       	call   1a890 <_DbgPrint>
   193c1:	8a 43 01             	mov    0x1(%ebx),%al
   193c4:	83 c4 30             	add    $0x30,%esp
   193c7:	3c 03                	cmp    $0x3,%al
   193c9:	74 5b                	je     19426 <_HaliMPIntLocalInfo+0xb6>
   193cb:	fe c8                	dec    %al
   193cd:	74 05                	je     193d4 <_HaliMPIntLocalInfo+0x64>
   193cf:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   193d2:	c9                   	leave  
   193d3:	c3                   	ret    
   193d4:	80 7b 07 01          	cmpb   $0x1,0x7(%ebx)
   193d8:	74 f5                	je     193cf <_HaliMPIntLocalInfo+0x5f>
   193da:	51                   	push   %ecx
   193db:	68 02 01 00 00       	push   $0x102
   193e0:	68 80 ca 01 00       	push   $0x1ca80
   193e5:	68 8b ca 01 00       	push   $0x1ca8b
   193ea:	e8 a1 14 00 00       	call   1a890 <_DbgPrint>
   193ef:	c7 04 24 da cf 01 00 	movl   $0x1cfda,(%esp)
   193f6:	e8 95 14 00 00       	call   1a890 <_DbgPrint>
   193fb:	83 c4 0c             	add    $0xc,%esp
   193fe:	68 03 01 00 00       	push   $0x103
   19403:	68 80 ca 01 00       	push   $0x1ca80
   19408:	68 01 cb 01 00       	push   $0x1cb01
   1940d:	e8 7e 14 00 00       	call   1a890 <_DbgPrint>
   19412:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   19419:	e8 52 14 00 00       	call   1a870 <_KeBugCheck@4>
   1941e:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   19421:	83 c4 0c             	add    $0xc,%esp
   19424:	c9                   	leave  
   19425:	c3                   	ret    
   19426:	80 7b 07 00          	cmpb   $0x0,0x7(%ebx)
   1942a:	74 a3                	je     193cf <_HaliMPIntLocalInfo+0x5f>
   1942c:	50                   	push   %eax
   1942d:	68 fd 00 00 00       	push   $0xfd
   19432:	68 80 ca 01 00       	push   $0x1ca80
   19437:	68 8b ca 01 00       	push   $0x1ca8b
   1943c:	e8 4f 14 00 00       	call   1a890 <_DbgPrint>
   19441:	c7 04 24 da cf 01 00 	movl   $0x1cfda,(%esp)
   19448:	e8 43 14 00 00       	call   1a890 <_DbgPrint>
   1944d:	83 c4 0c             	add    $0xc,%esp
   19450:	68 fe 00 00 00       	push   $0xfe
   19455:	68 80 ca 01 00       	push   $0x1ca80
   1945a:	68 01 cb 01 00       	push   $0x1cb01
   1945f:	e8 2c 14 00 00       	call   1a890 <_DbgPrint>
   19464:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1946b:	e8 00 14 00 00       	call   1a870 <_KeBugCheck@4>
   19470:	8a 43 01             	mov    0x1(%ebx),%al
   19473:	83 c4 0c             	add    $0xc,%esp
   19476:	e9 50 ff ff ff       	jmp    193cb <_HaliMPIntLocalInfo+0x5b>
   1947b:	90                   	nop    
   1947c:	8d 74 26 00          	lea    0x0(%esi),%esi

00019480 <_HaliConstructDefaultIOIrqMPTable>:
   19480:	55                   	push   %ebp
   19481:	89 e5                	mov    %esp,%ebp
   19483:	57                   	push   %edi
   19484:	56                   	push   %esi
   19485:	53                   	push   %ebx
   19486:	83 ec 0c             	sub    $0xc,%esp
   19489:	89 c7                	mov    %eax,%edi
   1948b:	8d 75 e8             	lea    0xffffffe8(%ebp),%esi
   1948e:	a1 10 ee 03 00       	mov    0x3ee10,%eax
   19493:	31 db                	xor    %ebx,%ebx
   19495:	c6 45 e8 03          	movb   $0x3,0xffffffe8(%ebp)
   19499:	66 c7 45 ea 00 00    	movw   $0x0,0xffffffea(%ebp)
   1949f:	c6 45 ec 00          	movb   $0x0,0xffffffec(%ebp)
   194a3:	88 45 ee             	mov    %al,0xffffffee(%ebp)
   194a6:	c6 45 e9 00          	movb   $0x0,0xffffffe9(%ebp)
   194aa:	eb 25                	jmp    194d1 <_HaliConstructDefaultIOIrqMPTable+0x51>
   194ac:	8d 74 26 00          	lea    0x0(%esi),%esi
   194b0:	83 fb 02             	cmp    $0x2,%ebx
   194b3:	74 16                	je     194cb <_HaliConstructDefaultIOIrqMPTable+0x4b>
   194b5:	88 5e 05             	mov    %bl,0x5(%esi)
   194b8:	88 d8                	mov    %bl,%al
   194ba:	85 db                	test   %ebx,%ebx
   194bc:	75 02                	jne    194c0 <_HaliConstructDefaultIOIrqMPTable+0x40>
   194be:	b0 02                	mov    $0x2,%al
   194c0:	88 46 07             	mov    %al,0x7(%esi)
   194c3:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   194c6:	e8 55 f5 ff ff       	call   18a20 <_HaliMPIntSrcInfo>
   194cb:	43                   	inc    %ebx
   194cc:	83 fb 0f             	cmp    $0xf,%ebx
   194cf:	77 1c                	ja     194ed <_HaliConstructDefaultIOIrqMPTable+0x6d>
   194d1:	83 ff 02             	cmp    $0x2,%edi
   194d4:	75 da                	jne    194b0 <_HaliConstructDefaultIOIrqMPTable+0x30>
   194d6:	85 db                	test   %ebx,%ebx
   194d8:	0f 94 c2             	sete   %dl
   194db:	83 fb 0d             	cmp    $0xd,%ebx
   194de:	0f 94 c0             	sete   %al
   194e1:	09 d0                	or     %edx,%eax
   194e3:	a8 01                	test   $0x1,%al
   194e5:	74 c9                	je     194b0 <_HaliConstructDefaultIOIrqMPTable+0x30>
   194e7:	43                   	inc    %ebx
   194e8:	83 fb 0f             	cmp    $0xf,%ebx
   194eb:	76 e4                	jbe    194d1 <_HaliConstructDefaultIOIrqMPTable+0x51>
   194ed:	c6 46 01 03          	movb   $0x3,0x1(%esi)
   194f1:	c6 46 05 00          	movb   $0x0,0x5(%esi)
   194f5:	c6 46 07 00          	movb   $0x0,0x7(%esi)
   194f9:	89 f0                	mov    %esi,%eax
   194fb:	e8 20 f5 ff ff       	call   18a20 <_HaliMPIntSrcInfo>
   19500:	83 c4 0c             	add    $0xc,%esp
   19503:	5b                   	pop    %ebx
   19504:	5e                   	pop    %esi
   19505:	5f                   	pop    %edi
   19506:	5d                   	pop    %ebp
   19507:	c3                   	ret    
   19508:	90                   	nop    
   19509:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00019510 <_HaliScanForMPConfigTable>:
   19510:	55                   	push   %ebp
   19511:	89 e5                	mov    %esp,%ebp
   19513:	57                   	push   %edi
   19514:	56                   	push   %esi
   19515:	53                   	push   %ebx
   19516:	83 ec 0c             	sub    $0xc,%esp
   19519:	89 d6                	mov    %edx,%esi
   1951b:	89 c7                	mov    %eax,%edi
   1951d:	85 d2                	test   %edx,%edx
   1951f:	eb 0e                	jmp    1952f <_HaliScanForMPConfigTable+0x1f>
   19521:	81 3f 5f 4d 50 5f    	cmpl   $0x5f504d5f,(%edi)
   19527:	74 17                	je     19540 <_HaliScanForMPConfigTable+0x30>
   19529:	83 c7 10             	add    $0x10,%edi
   1952c:	83 ee 10             	sub    $0x10,%esi
   1952f:	75 f0                	jne    19521 <_HaliScanForMPConfigTable+0x11>
   19531:	31 c0                	xor    %eax,%eax
   19533:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   19536:	5b                   	pop    %ebx
   19537:	5e                   	pop    %esi
   19538:	5f                   	pop    %edi
   19539:	5d                   	pop    %ebp
   1953a:	c3                   	ret    
   1953b:	90                   	nop    
   1953c:	8d 74 26 00          	lea    0x0(%esi),%esi
   19540:	ba 10 00 00 00       	mov    $0x10,%edx
   19545:	89 f8                	mov    %edi,%eax
   19547:	e8 b4 f4 ff ff       	call   18a00 <_MPChecksum>
   1954c:	88 c3                	mov    %al,%bl
   1954e:	50                   	push   %eax
   1954f:	68 f7 01 00 00       	push   $0x1f7
   19554:	68 80 ca 01 00       	push   $0x1ca80
   19559:	68 8b ca 01 00       	push   $0x1ca8b
   1955e:	e8 2d 13 00 00       	call   1a890 <_DbgPrint>
   19563:	83 c4 0c             	add    $0xc,%esp
   19566:	31 c0                	xor    %eax,%eax
   19568:	88 d8                	mov    %bl,%al
   1956a:	50                   	push   %eax
   1956b:	57                   	push   %edi
   1956c:	68 f0 cf 01 00       	push   $0x1cff0
   19571:	e8 1a 13 00 00       	call   1a890 <_DbgPrint>
   19576:	83 c4 10             	add    $0x10,%esp
   19579:	84 db                	test   %bl,%bl
   1957b:	75 ac                	jne    19529 <_HaliScanForMPConfigTable+0x19>
   1957d:	80 7f 08 01          	cmpb   $0x1,0x8(%edi)
   19581:	75 a6                	jne    19529 <_HaliScanForMPConfigTable+0x19>
   19583:	50                   	push   %eax
   19584:	68 fc 01 00 00       	push   $0x1fc
   19589:	68 80 ca 01 00       	push   $0x1ca80
   1958e:	68 8b ca 01 00       	push   $0x1ca8b
   19593:	e8 f8 12 00 00       	call   1a890 <_DbgPrint>
   19598:	5e                   	pop    %esi
   19599:	58                   	pop    %eax
   1959a:	31 c0                	xor    %eax,%eax
   1959c:	8a 47 09             	mov    0x9(%edi),%al
   1959f:	50                   	push   %eax
   195a0:	68 18 d0 01 00       	push   $0x1d018
   195a5:	e8 e6 12 00 00       	call   1a890 <_DbgPrint>
   195aa:	83 c4 10             	add    $0x10,%esp
   195ad:	80 7f 0c 00          	cmpb   $0x0,0xc(%edi)
   195b1:	0f 88 59 01 00 00    	js     19710 <_HaliScanForMPConfigTable+0x200>
   195b7:	51                   	push   %ecx
   195b8:	68 04 02 00 00       	push   $0x204
   195bd:	68 80 ca 01 00       	push   $0x1ca80
   195c2:	68 8b ca 01 00       	push   $0x1ca8b
   195c7:	e8 c4 12 00 00       	call   1a890 <_DbgPrint>
   195cc:	c7 04 24 54 d0 01 00 	movl   $0x1d054,(%esp)
   195d3:	e8 b8 12 00 00       	call   1a890 <_DbgPrint>
   195d8:	31 c0                	xor    %eax,%eax
   195da:	8a 47 0b             	mov    0xb(%edi),%al
   195dd:	83 c4 10             	add    $0x10,%esp
   195e0:	83 f8 07             	cmp    $0x7,%eax
   195e3:	0f 87 f8 00 00 00    	ja     196e1 <_HaliScanForMPConfigTable+0x1d1>
   195e9:	ff 24 85 2c d1 01 00 	jmp    *0x1d12c(,%eax,4)
   195f0:	50                   	push   %eax
   195f1:	68 20 02 00 00       	push   $0x220
   195f6:	68 80 ca 01 00       	push   $0x1ca80
   195fb:	68 8b ca 01 00       	push   $0x1ca8b
   19600:	e8 8b 12 00 00       	call   1a890 <_DbgPrint>
   19605:	c7 04 24 81 d0 01 00 	movl   $0x1d081,(%esp)
   1960c:	e8 7f 12 00 00       	call   1a890 <_DbgPrint>
   19611:	83 c4 10             	add    $0x10,%esp
   19614:	b8 01 00 00 00       	mov    $0x1,%eax
   19619:	89 3d d0 e4 03 00    	mov    %edi,0x3e4d0
   1961f:	e9 0f ff ff ff       	jmp    19533 <_HaliScanForMPConfigTable+0x23>
   19624:	50                   	push   %eax
   19625:	68 1d 02 00 00       	push   $0x21d
   1962a:	68 80 ca 01 00       	push   $0x1ca80
   1962f:	68 8b ca 01 00       	push   $0x1ca8b
   19634:	e8 57 12 00 00       	call   1a890 <_DbgPrint>
   19639:	c7 04 24 8e d0 01 00 	movl   $0x1d08e,(%esp)
   19640:	eb ca                	jmp    1960c <_HaliScanForMPConfigTable+0xfc>
   19642:	50                   	push   %eax
   19643:	68 1a 02 00 00       	push   $0x21a
   19648:	68 80 ca 01 00       	push   $0x1ca80
   1964d:	68 8b ca 01 00       	push   $0x1ca8b
   19652:	e8 39 12 00 00       	call   1a890 <_DbgPrint>
   19657:	c7 04 24 9c d0 01 00 	movl   $0x1d09c,(%esp)
   1965e:	eb ac                	jmp    1960c <_HaliScanForMPConfigTable+0xfc>
   19660:	50                   	push   %eax
   19661:	68 17 02 00 00       	push   $0x217
   19666:	68 80 ca 01 00       	push   $0x1ca80
   1966b:	68 8b ca 01 00       	push   $0x1ca8b
   19670:	e8 1b 12 00 00       	call   1a890 <_DbgPrint>
   19675:	c7 04 24 a9 d0 01 00 	movl   $0x1d0a9,(%esp)
   1967c:	eb 8e                	jmp    1960c <_HaliScanForMPConfigTable+0xfc>
   1967e:	50                   	push   %eax
   1967f:	68 14 02 00 00       	push   $0x214
   19684:	68 80 ca 01 00       	push   $0x1ca80
   19689:	68 8b ca 01 00       	push   $0x1ca8b
   1968e:	e8 fd 11 00 00       	call   1a890 <_DbgPrint>
   19693:	c7 04 24 ae d0 01 00 	movl   $0x1d0ae,(%esp)
   1969a:	e9 6d ff ff ff       	jmp    1960c <_HaliScanForMPConfigTable+0xfc>
   1969f:	50                   	push   %eax
   196a0:	68 11 02 00 00       	push   $0x211
   196a5:	68 80 ca 01 00       	push   $0x1ca80
   196aa:	68 8b ca 01 00       	push   $0x1ca8b
   196af:	e8 dc 11 00 00       	call   1a890 <_DbgPrint>
   196b4:	c7 04 24 b4 d0 01 00 	movl   $0x1d0b4,(%esp)
   196bb:	e9 4c ff ff ff       	jmp    1960c <_HaliScanForMPConfigTable+0xfc>
   196c0:	52                   	push   %edx
   196c1:	68 0e 02 00 00       	push   $0x20e
   196c6:	68 80 ca 01 00       	push   $0x1ca80
   196cb:	68 8b ca 01 00       	push   $0x1ca8b
   196d0:	e8 bb 11 00 00       	call   1a890 <_DbgPrint>
   196d5:	c7 04 24 d0 d0 01 00 	movl   $0x1d0d0,(%esp)
   196dc:	e9 2b ff ff ff       	jmp    1960c <_HaliScanForMPConfigTable+0xfc>
   196e1:	56                   	push   %esi
   196e2:	68 23 02 00 00       	push   $0x223
   196e7:	68 80 ca 01 00       	push   $0x1ca80
   196ec:	68 8b ca 01 00       	push   $0x1ca8b
   196f1:	e8 9a 11 00 00       	call   1a890 <_DbgPrint>
   196f6:	31 c0                	xor    %eax,%eax
   196f8:	59                   	pop    %ecx
   196f9:	8a 47 0b             	mov    0xb(%edi),%al
   196fc:	5b                   	pop    %ebx
   196fd:	50                   	push   %eax
   196fe:	68 d8 d0 01 00       	push   $0x1d0d8
   19703:	e8 88 11 00 00       	call   1a890 <_DbgPrint>
   19708:	83 c4 10             	add    $0x10,%esp
   1970b:	e9 21 fe ff ff       	jmp    19531 <_HaliScanForMPConfigTable+0x21>
   19710:	53                   	push   %ebx
   19711:	68 00 02 00 00       	push   $0x200
   19716:	68 80 ca 01 00       	push   $0x1ca80
   1971b:	68 8b ca 01 00       	push   $0x1ca8b
   19720:	e8 6b 11 00 00       	call   1a890 <_DbgPrint>
   19725:	c7 04 24 fc d0 01 00 	movl   $0x1d0fc,(%esp)
   1972c:	e9 a2 fe ff ff       	jmp    195d3 <_HaliScanForMPConfigTable+0xc3>
   19731:	eb 0d                	jmp    19740 <_HaliFindSmpConfig>
   19733:	90                   	nop    
   19734:	90                   	nop    
   19735:	90                   	nop    
   19736:	90                   	nop    
   19737:	90                   	nop    
   19738:	90                   	nop    
   19739:	90                   	nop    
   1973a:	90                   	nop    
   1973b:	90                   	nop    
   1973c:	90                   	nop    
   1973d:	90                   	nop    
   1973e:	90                   	nop    
   1973f:	90                   	nop    

00019740 <_HaliFindSmpConfig>:
   19740:	55                   	push   %ebp
   19741:	31 c0                	xor    %eax,%eax
   19743:	89 e5                	mov    %esp,%ebp
   19745:	57                   	push   %edi
   19746:	56                   	push   %esi
   19747:	53                   	push   %ebx
   19748:	83 ec 5c             	sub    $0x5c,%esp
   1974b:	ba 00 04 00 00       	mov    $0x400,%edx
   19750:	e8 bb fd ff ff       	call   19510 <_HaliScanForMPConfigTable>
   19755:	84 c0                	test   %al,%al
   19757:	0f 84 85 01 00 00    	je     198e2 <_HaliFindSmpConfig+0x1a2>
   1975d:	a1 d0 e4 03 00       	mov    0x3e4d0,%eax
   19762:	31 d2                	xor    %edx,%edx
   19764:	85 c0                	test   %eax,%eax
   19766:	0f 84 d9 00 00 00    	je     19845 <_HaliFindSmpConfig+0x105>
   1976c:	80 78 0c 00          	cmpb   $0x0,0xc(%eax)
   19770:	0f 88 fa 02 00 00    	js     19a70 <_HaliFindSmpConfig+0x330>
   19776:	57                   	push   %edi
   19777:	68 3f 02 00 00       	push   $0x23f
   1977c:	68 80 ca 01 00       	push   $0x1ca80
   19781:	68 8b ca 01 00       	push   $0x1ca8b
   19786:	e8 05 11 00 00       	call   1a890 <_DbgPrint>
   1978b:	c7 04 24 54 d0 01 00 	movl   $0x1d054,(%esp)
   19792:	e8 f9 10 00 00       	call   1a890 <_DbgPrint>
   19797:	83 c4 10             	add    $0x10,%esp
   1979a:	c7 05 60 e9 03 00 01 	movl   $0x1,0x3e960
   197a1:	00 00 00 
   197a4:	a1 d0 e4 03 00       	mov    0x3e4d0,%eax
   197a9:	80 78 0b 00          	cmpb   $0x0,0xb(%eax)
   197ad:	0f 85 ad 00 00 00    	jne    19860 <_HaliFindSmpConfig+0x120>
   197b3:	8b 58 04             	mov    0x4(%eax),%ebx
   197b6:	85 db                	test   %ebx,%ebx
   197b8:	0f 84 a2 00 00 00    	je     19860 <_HaliFindSmpConfig+0x120>
   197be:	81 3b 50 43 4d 50    	cmpl   $0x504d4350,(%ebx)
   197c4:	0f 84 b1 03 00 00    	je     19b7b <_HaliFindSmpConfig+0x43b>
   197ca:	56                   	push   %esi
   197cb:	68 17 01 00 00       	push   $0x117
   197d0:	68 80 ca 01 00       	push   $0x1ca80
   197d5:	68 8b ca 01 00       	push   $0x1ca8b
   197da:	e8 b1 10 00 00       	call   1a890 <_DbgPrint>
   197df:	31 c0                	xor    %eax,%eax
   197e1:	8a 43 03             	mov    0x3(%ebx),%al
   197e4:	89 04 24             	mov    %eax,(%esp)
   197e7:	31 c0                	xor    %eax,%eax
   197e9:	8a 43 02             	mov    0x2(%ebx),%al
   197ec:	50                   	push   %eax
   197ed:	31 c0                	xor    %eax,%eax
   197ef:	8a 43 01             	mov    0x1(%ebx),%al
   197f2:	50                   	push   %eax
   197f3:	31 c0                	xor    %eax,%eax
   197f5:	8a 03                	mov    (%ebx),%al
   197f7:	50                   	push   %eax
   197f8:	68 4c d1 01 00       	push   $0x1d14c
   197fd:	e8 8e 10 00 00       	call   1a890 <_DbgPrint>
   19802:	83 c4 1c             	add    $0x1c,%esp
   19805:	68 18 01 00 00       	push   $0x118
   1980a:	68 80 ca 01 00       	push   $0x1ca80
   1980f:	68 01 cb 01 00       	push   $0x1cb01
   19814:	e8 77 10 00 00       	call   1a890 <_DbgPrint>
   19819:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   19820:	e8 4b 10 00 00       	call   1a870 <_KeBugCheck@4>
   19825:	31 c0                	xor    %eax,%eax
   19827:	83 c4 0c             	add    $0xc,%esp
   1982a:	85 c0                	test   %eax,%eax
   1982c:	0f 84 fb 02 00 00    	je     19b2d <_HaliFindSmpConfig+0x3ed>
   19832:	8b 35 c0 e4 03 00    	mov    0x3e4c0,%esi
   19838:	85 f6                	test   %esi,%esi
   1983a:	0f 84 9c 02 00 00    	je     19adc <_HaliFindSmpConfig+0x39c>
   19840:	ba 01 00 00 00       	mov    $0x1,%edx
   19845:	b8 01 00 00 00       	mov    $0x1,%eax
   1984a:	85 d2                	test   %edx,%edx
   1984c:	0f 84 fe 00 00 00    	je     19950 <_HaliFindSmpConfig+0x210>
   19852:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   19855:	5b                   	pop    %ebx
   19856:	5e                   	pop    %esi
   19857:	5f                   	pop    %edi
   19858:	5d                   	pop    %ebp
   19859:	c3                   	ret    
   1985a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   19860:	8a 40 0b             	mov    0xb(%eax),%al
   19863:	84 c0                	test   %al,%al
   19865:	0f 84 d5 01 00 00    	je     19a40 <_HaliFindSmpConfig+0x300>
   1986b:	31 db                	xor    %ebx,%ebx
   1986d:	c7 45 b0 03 00 00 00 	movl   $0x3,0xffffffb0(%ebp)
   19874:	88 c3                	mov    %al,%bl
   19876:	c7 45 b4 01 00 00 00 	movl   $0x1,0xffffffb4(%ebp)
   1987d:	83 fb 05             	cmp    $0x5,%ebx
   19880:	c6 45 b8 00          	movb   $0x0,0xffffffb8(%ebp)
   19884:	19 c0                	sbb    %eax,%eax
   19886:	c6 45 bb 03          	movb   $0x3,0xffffffbb(%ebp)
   1988a:	83 e0 f1             	and    $0xfffffff1,%eax
   1988d:	c7 45 bc 00 00 00 00 	movl   $0x0,0xffffffbc(%ebp)
   19894:	83 c0 10             	add    $0x10,%eax
   19897:	c7 45 c0 00 00 00 00 	movl   $0x0,0xffffffc0(%ebp)
   1989e:	88 45 ba             	mov    %al,0xffffffba(%ebp)
   198a1:	c7 45 c4 00 00 00 00 	movl   $0x0,0xffffffc4(%ebp)
   198a8:	c7 45 c8 00 00 00 00 	movl   $0x0,0xffffffc8(%ebp)
   198af:	31 f6                	xor    %esi,%esi
   198b1:	8d 7d b8             	lea    0xffffffb8(%ebp),%edi
   198b4:	89 f0                	mov    %esi,%eax
   198b6:	46                   	inc    %esi
   198b7:	88 45 b9             	mov    %al,0xffffffb9(%ebp)
   198ba:	89 f8                	mov    %edi,%eax
   198bc:	e8 4f f2 ff ff       	call   18b10 <_HaliMPProcessorInfo>
   198c1:	80 65 bb fd          	andb   $0xfd,0xffffffbb(%ebp)
   198c5:	83 fe 01             	cmp    $0x1,%esi
   198c8:	76 ea                	jbe    198b4 <_HaliFindSmpConfig+0x174>
   198ca:	c6 45 d8 01          	movb   $0x1,0xffffffd8(%ebp)
   198ce:	c6 45 d9 00          	movb   $0x0,0xffffffd9(%ebp)
   198d2:	83 fb 07             	cmp    $0x7,%ebx
   198d5:	0f 87 a5 00 00 00    	ja     19980 <_HaliFindSmpConfig+0x240>
   198db:	ff 24 9d 54 d3 01 00 	jmp    *0x1d354(,%ebx,4)
   198e2:	ba 00 04 00 00       	mov    $0x400,%edx
   198e7:	b8 00 fc 09 00       	mov    $0x9fc00,%eax
   198ec:	e8 1f fc ff ff       	call   19510 <_HaliScanForMPConfigTable>
   198f1:	84 c0                	test   %al,%al
   198f3:	0f 85 64 fe ff ff    	jne    1975d <_HaliFindSmpConfig+0x1d>
   198f9:	ba 00 00 01 00       	mov    $0x10000,%edx
   198fe:	b8 00 00 0f 00       	mov    $0xf0000,%eax
   19903:	e8 08 fc ff ff       	call   19510 <_HaliScanForMPConfigTable>
   19908:	84 c0                	test   %al,%al
   1990a:	0f 85 4d fe ff ff    	jne    1975d <_HaliFindSmpConfig+0x1d>
   19910:	66 a1 0e 04 00 00    	mov    0x40e,%ax
   19916:	ba 00 04 00 00       	mov    $0x400,%edx
   1991b:	25 ff ff 00 00       	and    $0xffff,%eax
   19920:	c1 e0 04             	shl    $0x4,%eax
   19923:	e8 e8 fb ff ff       	call   19510 <_HaliScanForMPConfigTable>
   19928:	84 c0                	test   %al,%al
   1992a:	0f 85 2d fe ff ff    	jne    1975d <_HaliFindSmpConfig+0x1d>
   19930:	50                   	push   %eax
   19931:	68 76 02 00 00       	push   $0x276
   19936:	68 80 ca 01 00       	push   $0x1ca80
   1993b:	68 8b ca 01 00       	push   $0x1ca8b
   19940:	e8 4b 0f 00 00       	call   1a890 <_DbgPrint>
   19945:	c7 04 24 7c d1 01 00 	movl   $0x1d17c,(%esp)
   1994c:	eb 1e                	jmp    1996c <_HaliFindSmpConfig+0x22c>
   1994e:	89 f6                	mov    %esi,%esi
   19950:	50                   	push   %eax
   19951:	68 83 02 00 00       	push   $0x283
   19956:	68 80 ca 01 00       	push   $0x1ca80
   1995b:	68 8b ca 01 00       	push   $0x1ca8b
   19960:	e8 2b 0f 00 00       	call   1a890 <_DbgPrint>
   19965:	c7 04 24 a7 d1 01 00 	movl   $0x1d1a7,(%esp)
   1996c:	e8 1f 0f 00 00       	call   1a890 <_DbgPrint>
   19971:	83 c4 10             	add    $0x10,%esp
   19974:	31 c0                	xor    %eax,%eax
   19976:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   19979:	5b                   	pop    %ebx
   1997a:	5e                   	pop    %esi
   1997b:	5f                   	pop    %edi
   1997c:	5d                   	pop    %ebp
   1997d:	c3                   	ret    
   1997e:	89 f6                	mov    %esi,%esi
   19980:	51                   	push   %ecx
   19981:	68 ae 01 00 00       	push   $0x1ae
   19986:	68 80 ca 01 00       	push   $0x1ca80
   1998b:	68 8b ca 01 00       	push   $0x1ca8b
   19990:	e8 fb 0e 00 00       	call   1a890 <_DbgPrint>
   19995:	58                   	pop    %eax
   19996:	5a                   	pop    %edx
   19997:	53                   	push   %ebx
   19998:	68 d8 d0 01 00       	push   $0x1d0d8
   1999d:	e8 ee 0e 00 00       	call   1a890 <_DbgPrint>
   199a2:	83 c4 10             	add    $0x10,%esp
   199a5:	c7 45 da 49 53 41 20 	movl   $0x20415349,0xffffffda(%ebp)
   199ac:	8d 75 d8             	lea    0xffffffd8(%ebp),%esi
   199af:	66 c7 45 de 20 20    	movw   $0x2020,0xffffffde(%ebp)
   199b5:	89 f0                	mov    %esi,%eax
   199b7:	e8 94 f7 ff ff       	call   19150 <_HaliMPBusInfo>
   199bc:	83 fb 04             	cmp    $0x4,%ebx
   199bf:	0f 87 de 00 00 00    	ja     19aa3 <_HaliFindSmpConfig+0x363>
   199c5:	83 fb 05             	cmp    $0x5,%ebx
   199c8:	c6 45 a8 02          	movb   $0x2,0xffffffa8(%ebp)
   199cc:	19 c0                	sbb    %eax,%eax
   199ce:	c6 45 a9 02          	movb   $0x2,0xffffffa9(%ebp)
   199d2:	83 e0 f1             	and    $0xfffffff1,%eax
   199d5:	c6 45 ab 01          	movb   $0x1,0xffffffab(%ebp)
   199d9:	83 c0 10             	add    $0x10,%eax
   199dc:	c7 45 ac 00 00 c0 fe 	movl   $0xfec00000,0xffffffac(%ebp)
   199e3:	88 45 aa             	mov    %al,0xffffffaa(%ebp)
   199e6:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
   199e9:	e8 82 f8 ff ff       	call   19270 <_HaliMPIOApicInfo>
   199ee:	89 d8                	mov    %ebx,%eax
   199f0:	e8 8b fa ff ff       	call   19480 <_HaliConstructDefaultIOIrqMPTable>
   199f5:	8d 7d a0             	lea    0xffffffa0(%ebp),%edi
   199f8:	c6 45 a0 04          	movb   $0x4,0xffffffa0(%ebp)
   199fc:	c6 45 a1 00          	movb   $0x0,0xffffffa1(%ebp)
   19a00:	66 c7 45 a2 00 00    	movw   $0x0,0xffffffa2(%ebp)
   19a06:	c6 45 a4 00          	movb   $0x0,0xffffffa4(%ebp)
   19a0a:	c6 45 a5 00          	movb   $0x0,0xffffffa5(%ebp)
   19a0e:	c6 45 a6 ff          	movb   $0xff,0xffffffa6(%ebp)
   19a12:	31 f6                	xor    %esi,%esi
   19a14:	8d 5d b0             	lea    0xffffffb0(%ebp),%ebx
   19a17:	8b 03                	mov    (%ebx),%eax
   19a19:	83 c3 04             	add    $0x4,%ebx
   19a1c:	88 47 01             	mov    %al,0x1(%edi)
   19a1f:	89 f0                	mov    %esi,%eax
   19a21:	88 47 07             	mov    %al,0x7(%edi)
   19a24:	46                   	inc    %esi
   19a25:	89 f8                	mov    %edi,%eax
   19a27:	e8 44 f9 ff ff       	call   19370 <_HaliMPIntLocalInfo>
   19a2c:	83 fe 01             	cmp    $0x1,%esi
   19a2f:	76 e6                	jbe    19a17 <_HaliFindSmpConfig+0x2d7>
   19a31:	ba 01 00 00 00       	mov    $0x1,%edx
   19a36:	e9 0a fe ff ff       	jmp    19845 <_HaliFindSmpConfig+0x105>
   19a3b:	90                   	nop    
   19a3c:	8d 74 26 00          	lea    0x0(%esi),%esi
   19a40:	50                   	push   %eax
   19a41:	68 5e 02 00 00       	push   $0x25e
   19a46:	68 80 ca 01 00       	push   $0x1ca80
   19a4b:	68 01 cb 01 00       	push   $0x1cb01
   19a50:	e8 3b 0e 00 00       	call   1a890 <_DbgPrint>
   19a55:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   19a5c:	e8 0f 0e 00 00       	call   1a870 <_KeBugCheck@4>
   19a61:	ba 01 00 00 00       	mov    $0x1,%edx
   19a66:	83 c4 0c             	add    $0xc,%esp
   19a69:	e9 d7 fd ff ff       	jmp    19845 <_HaliFindSmpConfig+0x105>
   19a6e:	89 f6                	mov    %esi,%esi
   19a70:	50                   	push   %eax
   19a71:	68 3a 02 00 00       	push   $0x23a
   19a76:	68 80 ca 01 00       	push   $0x1ca80
   19a7b:	68 8b ca 01 00       	push   $0x1ca8b
   19a80:	e8 0b 0e 00 00       	call   1a890 <_DbgPrint>
   19a85:	c7 04 24 fc d0 01 00 	movl   $0x1d0fc,(%esp)
   19a8c:	e8 ff 0d 00 00       	call   1a890 <_DbgPrint>
   19a91:	83 c4 10             	add    $0x10,%esp
   19a94:	c7 05 60 e9 03 00 00 	movl   $0x0,0x3e960
   19a9b:	00 00 00 
   19a9e:	e9 01 fd ff ff       	jmp    197a4 <_HaliFindSmpConfig+0x64>
   19aa3:	c6 45 d8 01          	movb   $0x1,0xffffffd8(%ebp)
   19aa7:	c6 45 d9 01          	movb   $0x1,0xffffffd9(%ebp)
   19aab:	c7 45 da 50 43 49 20 	movl   $0x20494350,0xffffffda(%ebp)
   19ab2:	66 c7 45 de 20 20    	movw   $0x2020,0xffffffde(%ebp)
   19ab8:	89 f0                	mov    %esi,%eax
   19aba:	e8 91 f6 ff ff       	call   19150 <_HaliMPBusInfo>
   19abf:	e9 01 ff ff ff       	jmp    199c5 <_HaliFindSmpConfig+0x285>
   19ac4:	c7 45 da 4d 43 41 20 	movl   $0x2041434d,0xffffffda(%ebp)
   19acb:	e9 dc fe ff ff       	jmp    199ac <_HaliFindSmpConfig+0x26c>
   19ad0:	c7 45 da 45 49 53 41 	movl   $0x41534945,0xffffffda(%ebp)
   19ad7:	e9 d0 fe ff ff       	jmp    199ac <_HaliFindSmpConfig+0x26c>
   19adc:	53                   	push   %ebx
   19add:	68 4f 02 00 00       	push   $0x24f
   19ae2:	68 80 ca 01 00       	push   $0x1ca80
   19ae7:	68 8b ca 01 00       	push   $0x1ca8b
   19aec:	e8 9f 0d 00 00       	call   1a890 <_DbgPrint>
   19af1:	c7 04 24 c4 d1 01 00 	movl   $0x1d1c4,(%esp)
   19af8:	e8 93 0d 00 00       	call   1a890 <_DbgPrint>
   19afd:	83 c4 10             	add    $0x10,%esp
   19b00:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
   19b03:	c6 45 d9 01          	movb   $0x1,0xffffffd9(%ebp)
   19b07:	c7 45 da 49 53 41 20 	movl   $0x20415349,0xffffffda(%ebp)
   19b0e:	66 c7 45 de 20 20    	movw   $0x2020,0xffffffde(%ebp)
   19b14:	e8 37 f6 ff ff       	call   19150 <_HaliMPBusInfo>
   19b19:	31 c0                	xor    %eax,%eax
   19b1b:	8a 45 d9             	mov    0xffffffd9(%ebp),%al
   19b1e:	e8 5d f9 ff ff       	call   19480 <_HaliConstructDefaultIOIrqMPTable>
   19b23:	ba 01 00 00 00       	mov    $0x1,%edx
   19b28:	e9 18 fd ff ff       	jmp    19845 <_HaliFindSmpConfig+0x105>
   19b2d:	57                   	push   %edi
   19b2e:	68 47 02 00 00       	push   $0x247
   19b33:	68 80 ca 01 00       	push   $0x1ca80
   19b38:	68 8b ca 01 00       	push   $0x1ca8b
   19b3d:	e8 4e 0d 00 00       	call   1a890 <_DbgPrint>
   19b42:	c7 04 24 18 d2 01 00 	movl   $0x1d218,(%esp)
   19b49:	e8 42 0d 00 00       	call   1a890 <_DbgPrint>
   19b4e:	83 c4 0c             	add    $0xc,%esp
   19b51:	68 48 02 00 00       	push   $0x248
   19b56:	68 80 ca 01 00       	push   $0x1ca80
   19b5b:	68 8b ca 01 00       	push   $0x1ca8b
   19b60:	e8 2b 0d 00 00       	call   1a890 <_DbgPrint>
   19b65:	c7 04 24 40 d2 01 00 	movl   $0x1d240,(%esp)
   19b6c:	e8 1f 0d 00 00       	call   1a890 <_DbgPrint>
   19b71:	83 c4 10             	add    $0x10,%esp
   19b74:	31 d2                	xor    %edx,%edx
   19b76:	e9 ca fc ff ff       	jmp    19845 <_HaliFindSmpConfig+0x105>
   19b7b:	66 8b 53 04          	mov    0x4(%ebx),%dx
   19b7f:	89 d8                	mov    %ebx,%eax
   19b81:	81 e2 ff ff 00 00    	and    $0xffff,%edx
   19b87:	e8 74 ee ff ff       	call   18a00 <_MPChecksum>
   19b8c:	84 c0                	test   %al,%al
   19b8e:	75 55                	jne    19be5 <_HaliFindSmpConfig+0x4a5>
   19b90:	8a 43 06             	mov    0x6(%ebx),%al
   19b93:	3c 01                	cmp    $0x1,%al
   19b95:	0f 95 c2             	setne  %dl
   19b98:	3c 04                	cmp    $0x4,%al
   19b9a:	0f 95 c0             	setne  %al
   19b9d:	25 ff 00 00 00       	and    $0xff,%eax
   19ba2:	85 c2                	test   %eax,%edx
   19ba4:	75 6d                	jne    19c13 <_HaliFindSmpConfig+0x4d3>
   19ba6:	81 7b 24 00 00 e0 fe 	cmpl   $0xfee00000,0x24(%ebx)
   19bad:	0f 84 93 00 00 00    	je     19c46 <_HaliFindSmpConfig+0x506>
   19bb3:	50                   	push   %eax
   19bb4:	68 2e 01 00 00       	push   $0x12e
   19bb9:	68 80 ca 01 00       	push   $0x1ca80
   19bbe:	68 8b ca 01 00       	push   $0x1ca8b
   19bc3:	e8 c8 0c 00 00       	call   1a890 <_DbgPrint>
   19bc8:	8b 5b 24             	mov    0x24(%ebx),%ebx
   19bcb:	5e                   	pop    %esi
   19bcc:	5f                   	pop    %edi
   19bcd:	53                   	push   %ebx
   19bce:	68 74 d2 01 00       	push   $0x1d274
   19bd3:	e8 b8 0c 00 00       	call   1a890 <_DbgPrint>
   19bd8:	83 c4 0c             	add    $0xc,%esp
   19bdb:	68 2f 01 00 00       	push   $0x12f
   19be0:	e9 25 fc ff ff       	jmp    1980a <_HaliFindSmpConfig+0xca>
   19be5:	53                   	push   %ebx
   19be6:	68 1e 01 00 00       	push   $0x11e
   19beb:	68 80 ca 01 00       	push   $0x1ca80
   19bf0:	68 8b ca 01 00       	push   $0x1ca8b
   19bf5:	e8 96 0c 00 00       	call   1a890 <_DbgPrint>
   19bfa:	c7 04 24 bc d2 01 00 	movl   $0x1d2bc,(%esp)
   19c01:	e8 8a 0c 00 00       	call   1a890 <_DbgPrint>
   19c06:	83 c4 0c             	add    $0xc,%esp
   19c09:	68 1f 01 00 00       	push   $0x11f
   19c0e:	e9 f7 fb ff ff       	jmp    1980a <_HaliFindSmpConfig+0xca>
   19c13:	51                   	push   %ecx
   19c14:	68 26 01 00 00       	push   $0x126
   19c19:	68 80 ca 01 00       	push   $0x1ca80
   19c1e:	68 8b ca 01 00       	push   $0x1ca8b
   19c23:	e8 68 0c 00 00       	call   1a890 <_DbgPrint>
   19c28:	58                   	pop    %eax
   19c29:	5a                   	pop    %edx
   19c2a:	0f be 43 06          	movsbl 0x6(%ebx),%eax
   19c2e:	50                   	push   %eax
   19c2f:	68 e4 d2 01 00       	push   $0x1d2e4
   19c34:	e8 57 0c 00 00       	call   1a890 <_DbgPrint>
   19c39:	83 c4 0c             	add    $0xc,%esp
   19c3c:	68 27 01 00 00       	push   $0x127
   19c41:	e9 c4 fb ff ff       	jmp    1980a <_HaliFindSmpConfig+0xca>
   19c46:	51                   	push   %ecx
   19c47:	68 33 01 00 00       	push   $0x133
   19c4c:	68 80 ca 01 00       	push   $0x1ca80
   19c51:	68 8b ca 01 00       	push   $0x1ca8b
   19c56:	e8 35 0c 00 00       	call   1a890 <_DbgPrint>
   19c5b:	8d 43 10             	lea    0x10(%ebx),%eax
   19c5e:	31 ff                	xor    %edi,%edi
   19c60:	89 04 24             	mov    %eax,(%esp)
   19c63:	8d 43 08             	lea    0x8(%ebx),%eax
   19c66:	6a 0c                	push   $0xc
   19c68:	50                   	push   %eax
   19c69:	6a 08                	push   $0x8
   19c6b:	68 0d d3 01 00       	push   $0x1d30d
   19c70:	e8 1b 0c 00 00       	call   1a890 <_DbgPrint>
   19c75:	83 c4 1c             	add    $0x1c,%esp
   19c78:	68 34 01 00 00       	push   $0x134
   19c7d:	68 80 ca 01 00       	push   $0x1ca80
   19c82:	68 8b ca 01 00       	push   $0x1ca8b
   19c87:	e8 04 0c 00 00       	call   1a890 <_DbgPrint>
   19c8c:	58                   	pop    %eax
   19c8d:	8b 43 24             	mov    0x24(%ebx),%eax
   19c90:	5a                   	pop    %edx
   19c91:	8d 73 2c             	lea    0x2c(%ebx),%esi
   19c94:	50                   	push   %eax
   19c95:	68 29 d3 01 00       	push   $0x1d329
   19c9a:	e8 f1 0b 00 00       	call   1a890 <_DbgPrint>
   19c9f:	83 c4 10             	add    $0x10,%esp
   19ca2:	66 83 7b 04 2c       	cmpw   $0x2c,0x4(%ebx)
   19ca7:	74 2d                	je     19cd6 <_HaliFindSmpConfig+0x596>
   19ca9:	31 c0                	xor    %eax,%eax
   19cab:	8a 06                	mov    (%esi),%al
   19cad:	83 f8 04             	cmp    $0x4,%eax
   19cb0:	77 58                	ja     19d0a <_HaliFindSmpConfig+0x5ca>
   19cb2:	ff 24 85 74 d3 01 00 	jmp    *0x1d374(,%eax,4)
   19cb9:	89 f0                	mov    %esi,%eax
   19cbb:	e8 b0 f6 ff ff       	call   19370 <_HaliMPIntLocalInfo>
   19cc0:	83 c6 08             	add    $0x8,%esi
   19cc3:	83 c7 08             	add    $0x8,%edi
   19cc6:	66 8b 43 04          	mov    0x4(%ebx),%ax
   19cca:	25 ff ff 00 00       	and    $0xffff,%eax
   19ccf:	83 e8 2c             	sub    $0x2c,%eax
   19cd2:	39 f8                	cmp    %edi,%eax
   19cd4:	77 d3                	ja     19ca9 <_HaliFindSmpConfig+0x569>
   19cd6:	b8 01 00 00 00       	mov    $0x1,%eax
   19cdb:	e9 4a fb ff ff       	jmp    1982a <_HaliFindSmpConfig+0xea>
   19ce0:	89 f0                	mov    %esi,%eax
   19ce2:	e8 39 ed ff ff       	call   18a20 <_HaliMPIntSrcInfo>
   19ce7:	eb d7                	jmp    19cc0 <_HaliFindSmpConfig+0x580>
   19ce9:	89 f0                	mov    %esi,%eax
   19ceb:	e8 80 f5 ff ff       	call   19270 <_HaliMPIOApicInfo>
   19cf0:	eb ce                	jmp    19cc0 <_HaliFindSmpConfig+0x580>
   19cf2:	89 f0                	mov    %esi,%eax
   19cf4:	e8 57 f4 ff ff       	call   19150 <_HaliMPBusInfo>
   19cf9:	eb c5                	jmp    19cc0 <_HaliFindSmpConfig+0x580>
   19cfb:	89 f0                	mov    %esi,%eax
   19cfd:	83 c7 14             	add    $0x14,%edi
   19d00:	e8 0b ee ff ff       	call   18b10 <_HaliMPProcessorInfo>
   19d05:	83 c6 14             	add    $0x14,%esi
   19d08:	eb bc                	jmp    19cc6 <_HaliFindSmpConfig+0x586>
   19d0a:	50                   	push   %eax
   19d0b:	68 62 01 00 00       	push   $0x162
   19d10:	68 80 ca 01 00       	push   $0x1ca80
   19d15:	68 8b ca 01 00       	push   $0x1ca8b
   19d1a:	e8 71 0b 00 00       	call   1a890 <_DbgPrint>
   19d1f:	c7 04 24 38 d3 01 00 	movl   $0x1d338,(%esp)
   19d26:	e8 65 0b 00 00       	call   1a890 <_DbgPrint>
   19d2b:	83 c4 0c             	add    $0xc,%esp
   19d2e:	68 63 01 00 00       	push   $0x163
   19d33:	e9 d2 fa ff ff       	jmp    1980a <_HaliFindSmpConfig+0xca>
   19d38:	90                   	nop    
   19d39:	90                   	nop    
   19d3a:	90                   	nop    
   19d3b:	90                   	nop    
   19d3c:	90                   	nop    
   19d3d:	90                   	nop    
   19d3e:	90                   	nop    
   19d3f:	90                   	nop    

00019d40 <_KeGetCurrentIrql@0>:
   19d40:	55                   	push   %ebp
   19d41:	89 e5                	mov    %esp,%ebp
   19d43:	56                   	push   %esi
   19d44:	53                   	push   %ebx
   19d45:	9c                   	pushf  
   19d46:	5e                   	pop    %esi
   19d47:	fa                   	cli    
#define Ki386Rdmsr(msr,val1,val2)   __asm__ __volatile__("rdmsr" : "=a" (val1), "=d" (val2) : "c" (msr))
#define Ki386Wrmsr(msr,val1,val2)   __asm__ __volatile__("wrmsr" : /* no outputs */ : "c" (msr), "a" (val1), "d" (val2))

static inline BYTE Ki386ReadFsByte(ULONG offset)
{
   19d48:	b8 24 00 00 00       	mov    $0x24,%eax
   19d4d:	89 c3                	mov    %eax,%ebx
   19d4f:	64 8a 1b             	mov    %fs:(%ebx),%bl
   19d52:	80 fb 1f             	cmp    $0x1f,%bl
   19d55:	77 19                	ja     19d70 <_KeGetCurrentIrql@0+0x30>
   19d57:	81 e6 00 02 00 00    	and    $0x200,%esi
   19d5d:	74 01                	je     19d60 <_KeGetCurrentIrql@0+0x20>
   19d5f:	fb                   	sti    
   19d60:	31 c0                	xor    %eax,%eax
   19d62:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   19d65:	88 d8                	mov    %bl,%al
   19d67:	5b                   	pop    %ebx
   19d68:	5e                   	pop    %esi
   19d69:	5d                   	pop    %ebp
   19d6a:	c3                   	ret    
   19d6b:	90                   	nop    
   19d6c:	8d 74 26 00          	lea    0x0(%esi),%esi
   19d70:	51                   	push   %ecx
   19d71:	6a 2f                	push   $0x2f
   19d73:	68 90 d3 01 00       	push   $0x1d390
   19d78:	68 9a d3 01 00       	push   $0x1d39a
   19d7d:	e8 0e 0b 00 00       	call   1a890 <_DbgPrint>
   19d82:	58                   	pop    %eax
   19d83:	31 c0                	xor    %eax,%eax
   19d85:	5a                   	pop    %edx
   19d86:	88 d8                	mov    %bl,%al
   19d88:	50                   	push   %eax
   19d89:	68 a3 d3 01 00       	push   $0x1d3a3
   19d8e:	e8 fd 0a 00 00       	call   1a890 <_DbgPrint>
   19d93:	83 c4 0c             	add    $0xc,%esp
   19d96:	6a 30                	push   $0x30
   19d98:	68 90 d3 01 00       	push   $0x1d390
   19d9d:	68 b3 d3 01 00       	push   $0x1d3b3
   19da2:	e8 e9 0a 00 00       	call   1a890 <_DbgPrint>
   19da7:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   19dae:	e8 bd 0a 00 00       	call   1a870 <_KeBugCheck@4>
   19db3:	83 c4 0c             	add    $0xc,%esp
   19db6:	eb 9f                	jmp    19d57 <_KeGetCurrentIrql@0+0x17>
   19db8:	90                   	nop    
   19db9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00019dc0 <_KeSetCurrentIrql>:
   19dc0:	55                   	push   %ebp
   19dc1:	89 e5                	mov    %esp,%ebp
   19dc3:	56                   	push   %esi
   19dc4:	53                   	push   %ebx
   19dc5:	8b 5d 08             	mov    0x8(%ebp),%ebx
   19dc8:	89 de                	mov    %ebx,%esi
   19dca:	80 fb 1f             	cmp    $0x1f,%bl
   19dcd:	77 18                	ja     19de7 <_KeSetCurrentIrql+0x27>
   19dcf:	9c                   	pushf  
   19dd0:	5a                   	pop    %edx
   19dd1:	fa                   	cli    
   return b;
}

static inline VOID Ki386WriteFsByte(ULONG offset, BYTE value)
{
   19dd2:	b8 24 00 00 00       	mov    $0x24,%eax
    __asm__ __volatile__("movb %0,%%fs:(%1)"::"q" (value), "r" (offset));
   19dd7:	64 88 18             	mov    %bl,%fs:(%eax)
   19dda:	80 e6 02             	and    $0x2,%dh
   19ddd:	74 01                	je     19de0 <_KeSetCurrentIrql+0x20>
   19ddf:	fb                   	sti    
   19de0:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   19de3:	5b                   	pop    %ebx
   19de4:	5e                   	pop    %esi
   19de5:	5d                   	pop    %ebp
   19de6:	c3                   	ret    
   19de7:	51                   	push   %ecx
   19de8:	6a 42                	push   $0x42
   19dea:	68 90 d3 01 00       	push   $0x1d390
   19def:	68 9a d3 01 00       	push   $0x1d39a
   19df4:	e8 97 0a 00 00       	call   1a890 <_DbgPrint>
   19df9:	58                   	pop    %eax
   19dfa:	89 f0                	mov    %esi,%eax
   19dfc:	5a                   	pop    %edx
   19dfd:	25 ff 00 00 00       	and    $0xff,%eax
   19e02:	50                   	push   %eax
   19e03:	68 c8 d3 01 00       	push   $0x1d3c8
   19e08:	e8 83 0a 00 00       	call   1a890 <_DbgPrint>
   19e0d:	83 c4 0c             	add    $0xc,%esp
   19e10:	6a 43                	push   $0x43
   19e12:	68 90 d3 01 00       	push   $0x1d390
   19e17:	68 b3 d3 01 00       	push   $0x1d3b3
   19e1c:	e8 6f 0a 00 00       	call   1a890 <_DbgPrint>
   19e21:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   19e28:	e8 43 0a 00 00       	call   1a870 <_KeBugCheck@4>
   19e2d:	83 c4 0c             	add    $0xc,%esp
   19e30:	eb 9d                	jmp    19dcf <_KeSetCurrentIrql+0xf>
   19e32:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   19e39:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00019e40 <_HalpLowerIrql>:
   19e40:	55                   	push   %ebp
   19e41:	89 e5                	mov    %esp,%ebp
   19e43:	57                   	push   %edi
   19e44:	56                   	push   %esi
   19e45:	53                   	push   %ebx
   19e46:	83 ec 0c             	sub    $0xc,%esp
   19e49:	8a 5d 08             	mov    0x8(%ebp),%bl
   19e4c:	8b 75 0c             	mov    0xc(%ebp),%esi
   19e4f:	80 fb 01             	cmp    $0x1,%bl
   19e52:	76 52                	jbe    19ea6 <_HalpLowerIrql+0x66>
   19e54:	83 ec 0c             	sub    $0xc,%esp
   19e57:	88 d8                	mov    %bl,%al
   19e59:	25 ff 00 00 00       	and    $0xff,%eax
   19e5e:	50                   	push   %eax
   19e5f:	89 c6                	mov    %eax,%esi
   19e61:	e8 5a ff ff ff       	call   19dc0 <_KeSetCurrentIrql>
   19e66:	83 c4 10             	add    $0x10,%esp
   19e69:	b8 fb 00 00 00       	mov    $0xfb,%eax
   19e6e:	80 fb 1c             	cmp    $0x1c,%bl
   19e71:	77 1d                	ja     19e90 <_HalpLowerIrql+0x50>
   19e73:	b0 ef                	mov    $0xef,%al
   19e75:	80 fb 1a             	cmp    $0x1a,%bl
   19e78:	77 16                	ja     19e90 <_HalpLowerIrql+0x50>
   19e7a:	30 c0                	xor    %al,%al
   19e7c:	80 fb 02             	cmp    $0x2,%bl
   19e7f:	76 0f                	jbe    19e90 <_HalpLowerIrql+0x50>
   19e81:	8d 04 f5 10 00 00 00 	lea    0x10(,%esi,8),%eax
   19e88:	25 ff 00 00 00       	and    $0xff,%eax
   19e8d:	8d 76 00             	lea    0x0(%esi),%esi
   19e90:	89 45 0c             	mov    %eax,0xc(%ebp)
   19e93:	c7 45 08 80 00 00 00 	movl   $0x80,0x8(%ebp)
   19e9a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   19e9d:	5b                   	pop    %ebx
   19e9e:	5e                   	pop    %esi
   19e9f:	5f                   	pop    %edi
   19ea0:	5d                   	pop    %ebp
   19ea1:	e9 2a bc ff ff       	jmp    15ad0 <_APICWrite>
   19ea6:	9c                   	pushf  
   19ea7:	5f                   	pop    %edi
   19ea8:	e8 93 fe ff ff       	call   19d40 <_KeGetCurrentIrql@0>
   19ead:	3c 01                	cmp    $0x1,%al
   19eaf:	77 2f                	ja     19ee0 <_HalpLowerIrql+0xa0>
   19eb1:	fe cb                	dec    %bl
   19eb3:	74 1c                	je     19ed1 <_HalpLowerIrql+0x91>
   19eb5:	e8 86 0a 00 00       	call   1a940 <_KeGetCurrentThread@0>
   19eba:	85 c0                	test   %eax,%eax
   19ebc:	75 78                	jne    19f36 <_HalpLowerIrql+0xf6>
   19ebe:	c7 45 08 00 00 00 00 	movl   $0x0,0x8(%ebp)
   19ec5:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   19ec8:	5b                   	pop    %ebx
   19ec9:	5e                   	pop    %esi
   19eca:	5f                   	pop    %edi
   19ecb:	5d                   	pop    %ebp
   19ecc:	e9 ef fe ff ff       	jmp    19dc0 <_KeSetCurrentIrql>
   19ed1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   19ed4:	5b                   	pop    %ebx
   19ed5:	5e                   	pop    %esi
   19ed6:	5f                   	pop    %edi
   19ed7:	5d                   	pop    %ebp
   19ed8:	c3                   	ret    
   19ed9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   19ee0:	83 ec 0c             	sub    $0xc,%esp
   19ee3:	6a 02                	push   $0x2
   19ee5:	e8 d6 fe ff ff       	call   19dc0 <_KeSetCurrentIrql>
   19eea:	58                   	pop    %eax
   19eeb:	5a                   	pop    %edx
   19eec:	6a 00                	push   $0x0
   19eee:	68 80 00 00 00       	push   $0x80
   19ef3:	e8 d8 bb ff ff       	call   15ad0 <_APICWrite>
   19ef8:	83 c4 10             	add    $0x10,%esp
   19efb:	85 f6                	test   %esi,%esi
   19efd:	75 0c                	jne    19f0b <_HalpLowerIrql+0xcb>
#define Ki386Rdmsr(msr,val1,val2)   __asm__ __volatile__("rdmsr" : "=a" (val1), "=d" (val2) : "c" (msr))
#define Ki386Wrmsr(msr,val1,val2)   __asm__ __volatile__("wrmsr" : /* no outputs */ : "c" (msr), "a" (val1), "d" (val2))

static inline BYTE Ki386ReadFsByte(ULONG offset)
{
   19eff:	b8 98 00 00 00       	mov    $0x98,%eax
   19f04:	64 8a 00             	mov    %fs:(%eax),%al
   19f07:	84 c0                	test   %al,%al
   19f09:	74 19                	je     19f24 <_HalpLowerIrql+0xe4>
   BYTE b;
   __asm__ __volatile__("movb %%fs:(%1),%0":"=q" (b):"0" (offset));
   return b;
}

static inline VOID Ki386WriteFsByte(ULONG offset, BYTE value)
{
   19f0b:	ba 98 00 00 00       	mov    $0x98,%edx
   19f10:	31 c0                	xor    %eax,%eax
    __asm__ __volatile__("movb %0,%%fs:(%1)"::"q" (value), "r" (offset));
   19f12:	64 88 02             	mov    %al,%fs:(%edx)
   19f15:	fb                   	sti    
   19f16:	e8 e5 0a 00 00       	call   1aa00 <_KiDispatchInterrupt@0>
   19f1b:	f7 c7 00 02 00 00    	test   $0x200,%edi
   19f21:	75 01                	jne    19f24 <_HalpLowerIrql+0xe4>
   19f23:	fa                   	cli    
   19f24:	83 ec 0c             	sub    $0xc,%esp
   19f27:	6a 01                	push   $0x1
   19f29:	e8 92 fe ff ff       	call   19dc0 <_KeSetCurrentIrql>
   19f2e:	83 c4 10             	add    $0x10,%esp
   19f31:	e9 7b ff ff ff       	jmp    19eb1 <_HalpLowerIrql+0x71>
   19f36:	e8 05 0a 00 00       	call   1a940 <_KeGetCurrentThread@0>
   19f3b:	80 78 49 00          	cmpb   $0x0,0x49(%eax)
   19f3f:	0f 84 79 ff ff ff    	je     19ebe <_HalpLowerIrql+0x7e>
   19f45:	fb                   	sti    
   19f46:	56                   	push   %esi
   19f47:	6a 00                	push   $0x0
   19f49:	6a 00                	push   $0x0
   19f4b:	6a 00                	push   $0x0
   19f4d:	e8 be 0a 00 00       	call   1aa10 <_KiDeliverApc@12>
   19f52:	81 e7 00 02 00 00    	and    $0x200,%edi
   19f58:	5b                   	pop    %ebx
   19f59:	0f 85 5f ff ff ff    	jne    19ebe <_HalpLowerIrql+0x7e>
   19f5f:	fa                   	cli    
   19f60:	e9 59 ff ff ff       	jmp    19ebe <_HalpLowerIrql+0x7e>
   19f65:	8d 74 26 00          	lea    0x0(%esi),%esi
   19f69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00019f70 <@KfLowerIrql@4>:
   19f70:	55                   	push   %ebp
   19f71:	89 e5                	mov    %esp,%ebp
   19f73:	56                   	push   %esi
   19f74:	89 ce                	mov    %ecx,%esi
   19f76:	53                   	push   %ebx
   19f77:	e8 c4 fd ff ff       	call   19d40 <_KeGetCurrentIrql@0>
   19f7c:	88 c3                	mov    %al,%bl
   19f7e:	89 f0                	mov    %esi,%eax
   19f80:	38 d8                	cmp    %bl,%al
   19f82:	77 1c                	ja     19fa0 <@KfLowerIrql@4+0x30>
   19f84:	89 f0                	mov    %esi,%eax
   19f86:	25 ff 00 00 00       	and    $0xff,%eax
   19f8b:	51                   	push   %ecx
   19f8c:	51                   	push   %ecx
   19f8d:	6a 00                	push   $0x0
   19f8f:	50                   	push   %eax
   19f90:	e8 ab fe ff ff       	call   19e40 <_HalpLowerIrql>
   19f95:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   19f98:	5b                   	pop    %ebx
   19f99:	5e                   	pop    %esi
   19f9a:	5d                   	pop    %ebp
   19f9b:	c3                   	ret    
   19f9c:	8d 74 26 00          	lea    0x0(%esi),%esi
   19fa0:	50                   	push   %eax
   19fa1:	68 91 00 00 00       	push   $0x91
   19fa6:	68 90 d3 01 00       	push   $0x1d390
   19fab:	68 9a d3 01 00       	push   $0x1d39a
   19fb0:	e8 db 08 00 00       	call   1a890 <_DbgPrint>
   19fb5:	83 c4 0c             	add    $0xc,%esp
   19fb8:	31 c0                	xor    %eax,%eax
   19fba:	88 d8                	mov    %bl,%al
   19fbc:	50                   	push   %eax
   19fbd:	89 f0                	mov    %esi,%eax
   19fbf:	25 ff 00 00 00       	and    $0xff,%eax
   19fc4:	50                   	push   %eax
   19fc5:	68 d4 d3 01 00       	push   $0x1d3d4
   19fca:	e8 c1 08 00 00       	call   1a890 <_DbgPrint>
   19fcf:	83 c4 0c             	add    $0xc,%esp
   19fd2:	68 92 00 00 00       	push   $0x92
   19fd7:	68 90 d3 01 00       	push   $0x1d390
   19fdc:	68 b3 d3 01 00       	push   $0x1d3b3
   19fe1:	e8 aa 08 00 00       	call   1a890 <_DbgPrint>
   19fe6:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   19fed:	e8 7e 08 00 00       	call   1a870 <_KeBugCheck@4>
   19ff2:	89 f0                	mov    %esi,%eax
   19ff4:	83 c4 0c             	add    $0xc,%esp
   19ff7:	25 ff 00 00 00       	and    $0xff,%eax
   19ffc:	51                   	push   %ecx
   19ffd:	51                   	push   %ecx
   19ffe:	6a 00                	push   $0x0
   1a000:	50                   	push   %eax
   1a001:	e8 3a fe ff ff       	call   19e40 <_HalpLowerIrql>
   1a006:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1a009:	5b                   	pop    %ebx
   1a00a:	5e                   	pop    %esi
   1a00b:	5d                   	pop    %ebp
   1a00c:	c3                   	ret    
   1a00d:	8d 76 00             	lea    0x0(%esi),%esi

0001a010 <_KeLowerIrql@4>:
   1a010:	55                   	push   %ebp
   1a011:	89 e5                	mov    %esp,%ebp
   1a013:	31 c9                	xor    %ecx,%ecx
   1a015:	50                   	push   %eax
   1a016:	50                   	push   %eax
   1a017:	8a 4d 08             	mov    0x8(%ebp),%cl
   1a01a:	e8 51 ff ff ff       	call   19f70 <@KfLowerIrql@4>
   1a01f:	c9                   	leave  
   1a020:	c2 04 00             	ret    $0x4
   1a023:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1a029:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

0001a030 <@KfRaiseIrql@4>:
   1a030:	55                   	push   %ebp
   1a031:	89 e5                	mov    %esp,%ebp
   1a033:	57                   	push   %edi
   1a034:	56                   	push   %esi
   1a035:	53                   	push   %ebx
   1a036:	83 ec 0c             	sub    $0xc,%esp
   1a039:	88 cb                	mov    %cl,%bl
   1a03b:	9c                   	pushf  
   1a03c:	5f                   	pop    %edi
   1a03d:	fa                   	cli    
   1a03e:	e8 fd fc ff ff       	call   19d40 <_KeGetCurrentIrql@0>
   1a043:	89 c6                	mov    %eax,%esi
   1a045:	38 c3                	cmp    %al,%bl
   1a047:	72 67                	jb     1a0b0 <@KfRaiseIrql@4+0x80>
   1a049:	80 fb 02             	cmp    $0x2,%bl
   1a04c:	76 38                	jbe    1a086 <@KfRaiseIrql@4+0x56>
   1a04e:	80 fb 1c             	cmp    $0x1c,%bl
   1a051:	50                   	push   %eax
   1a052:	50                   	push   %eax
   1a053:	b8 fb 00 00 00       	mov    $0xfb,%eax
   1a058:	77 1e                	ja     1a078 <@KfRaiseIrql@4+0x48>
   1a05a:	b0 ef                	mov    $0xef,%al
   1a05c:	80 fb 1a             	cmp    $0x1a,%bl
   1a05f:	77 17                	ja     1a078 <@KfRaiseIrql@4+0x48>
   1a061:	30 c0                	xor    %al,%al
   1a063:	80 fb 02             	cmp    $0x2,%bl
   1a066:	76 10                	jbe    1a078 <@KfRaiseIrql@4+0x48>
   1a068:	31 c0                	xor    %eax,%eax
   1a06a:	88 d8                	mov    %bl,%al
   1a06c:	8d 04 c5 10 00 00 00 	lea    0x10(,%eax,8),%eax
   1a073:	25 ff 00 00 00       	and    $0xff,%eax
   1a078:	50                   	push   %eax
   1a079:	68 80 00 00 00       	push   $0x80
   1a07e:	e8 4d ba ff ff       	call   15ad0 <_APICWrite>
   1a083:	83 c4 10             	add    $0x10,%esp
   1a086:	83 ec 0c             	sub    $0xc,%esp
   1a089:	31 c0                	xor    %eax,%eax
   1a08b:	88 d8                	mov    %bl,%al
   1a08d:	50                   	push   %eax
   1a08e:	e8 2d fd ff ff       	call   19dc0 <_KeSetCurrentIrql>
   1a093:	83 c4 10             	add    $0x10,%esp
   1a096:	81 e7 00 02 00 00    	and    $0x200,%edi
   1a09c:	74 01                	je     1a09f <@KfRaiseIrql@4+0x6f>
   1a09e:	fb                   	sti    
   1a09f:	89 f0                	mov    %esi,%eax
   1a0a1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1a0a4:	25 ff 00 00 00       	and    $0xff,%eax
   1a0a9:	5b                   	pop    %ebx
   1a0aa:	5e                   	pop    %esi
   1a0ab:	5f                   	pop    %edi
   1a0ac:	5d                   	pop    %ebp
   1a0ad:	c3                   	ret    
   1a0ae:	89 f6                	mov    %esi,%esi
   1a0b0:	50                   	push   %eax
   1a0b1:	68 cd 00 00 00       	push   $0xcd
   1a0b6:	68 90 d3 01 00       	push   $0x1d390
   1a0bb:	68 9a d3 01 00       	push   $0x1d39a
   1a0c0:	e8 cb 07 00 00       	call   1a890 <_DbgPrint>
   1a0c5:	83 c4 0c             	add    $0xc,%esp
   1a0c8:	31 c0                	xor    %eax,%eax
   1a0ca:	88 d8                	mov    %bl,%al
   1a0cc:	50                   	push   %eax
   1a0cd:	50                   	push   %eax
   1a0ce:	50                   	push   %eax
   1a0cf:	e8 6c fc ff ff       	call   19d40 <_KeGetCurrentIrql@0>
   1a0d4:	5a                   	pop    %edx
   1a0d5:	25 ff 00 00 00       	and    $0xff,%eax
   1a0da:	59                   	pop    %ecx
   1a0db:	50                   	push   %eax
   1a0dc:	68 ef d3 01 00       	push   $0x1d3ef
   1a0e1:	e8 aa 07 00 00       	call   1a890 <_DbgPrint>
   1a0e6:	83 c4 0c             	add    $0xc,%esp
   1a0e9:	68 ce 00 00 00       	push   $0xce
   1a0ee:	68 90 d3 01 00       	push   $0x1d390
   1a0f3:	68 b3 d3 01 00       	push   $0x1d3b3
   1a0f8:	e8 93 07 00 00       	call   1a890 <_DbgPrint>
   1a0fd:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1a104:	e8 67 07 00 00       	call   1a870 <_KeBugCheck@4>
   1a109:	83 c4 0c             	add    $0xc,%esp
   1a10c:	e9 38 ff ff ff       	jmp    1a049 <@KfRaiseIrql@4+0x19>
   1a111:	eb 0d                	jmp    1a120 <_KeRaiseIrql@8>
   1a113:	90                   	nop    
   1a114:	90                   	nop    
   1a115:	90                   	nop    
   1a116:	90                   	nop    
   1a117:	90                   	nop    
   1a118:	90                   	nop    
   1a119:	90                   	nop    
   1a11a:	90                   	nop    
   1a11b:	90                   	nop    
   1a11c:	90                   	nop    
   1a11d:	90                   	nop    
   1a11e:	90                   	nop    
   1a11f:	90                   	nop    

0001a120 <_KeRaiseIrql@8>:
   1a120:	55                   	push   %ebp
   1a121:	89 e5                	mov    %esp,%ebp
   1a123:	31 c9                	xor    %ecx,%ecx
   1a125:	50                   	push   %eax
   1a126:	50                   	push   %eax
   1a127:	8a 4d 08             	mov    0x8(%ebp),%cl
   1a12a:	e8 01 ff ff ff       	call   1a030 <@KfRaiseIrql@4>
   1a12f:	8b 55 0c             	mov    0xc(%ebp),%edx
   1a132:	88 02                	mov    %al,(%edx)
   1a134:	c9                   	leave  
   1a135:	c2 08 00             	ret    $0x8
   1a138:	90                   	nop    
   1a139:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

0001a140 <_KeRaiseIrqlToDpcLevel@0>:
   1a140:	55                   	push   %ebp
   1a141:	b9 02 00 00 00       	mov    $0x2,%ecx
   1a146:	89 e5                	mov    %esp,%ebp
   1a148:	50                   	push   %eax
   1a149:	50                   	push   %eax
   1a14a:	e8 e1 fe ff ff       	call   1a030 <@KfRaiseIrql@4>
   1a14f:	c9                   	leave  
   1a150:	25 ff 00 00 00       	and    $0xff,%eax
   1a155:	c3                   	ret    
   1a156:	8d 76 00             	lea    0x0(%esi),%esi
   1a159:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

0001a160 <_KeRaiseIrqlToSynchLevel@0>:
   1a160:	55                   	push   %ebp
   1a161:	b9 1c 00 00 00       	mov    $0x1c,%ecx
   1a166:	89 e5                	mov    %esp,%ebp
   1a168:	50                   	push   %eax
   1a169:	50                   	push   %eax
   1a16a:	e8 c1 fe ff ff       	call   1a030 <@KfRaiseIrql@4>
   1a16f:	c9                   	leave  
   1a170:	25 ff 00 00 00       	and    $0xff,%eax
   1a175:	c3                   	ret    
   1a176:	8d 76 00             	lea    0x0(%esi),%esi
   1a179:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

0001a180 <_HalBeginSystemInterrupt@12>:
   1a180:	55                   	push   %ebp
   1a181:	89 e5                	mov    %esp,%ebp
   1a183:	53                   	push   %ebx
   1a184:	50                   	push   %eax
   1a185:	8a 5d 0c             	mov    0xc(%ebp),%bl
   1a188:	e8 b3 fb ff ff       	call   19d40 <_KeGetCurrentIrql@0>
   1a18d:	38 d8                	cmp    %bl,%al
   1a18f:	0f 83 ab 00 00 00    	jae    1a240 <_HalBeginSystemInterrupt@12+0xc0>
   1a195:	9c                   	pushf  
   1a196:	58                   	pop    %eax
   1a197:	f6 c4 02             	test   $0x2,%ah
   1a19a:	75 57                	jne    1a1f3 <_HalBeginSystemInterrupt@12+0x73>
   1a19c:	80 fb 1c             	cmp    $0x1c,%bl
   1a19f:	50                   	push   %eax
   1a1a0:	50                   	push   %eax
   1a1a1:	b8 fb 00 00 00       	mov    $0xfb,%eax
   1a1a6:	77 1e                	ja     1a1c6 <_HalBeginSystemInterrupt@12+0x46>
   1a1a8:	b0 ef                	mov    $0xef,%al
   1a1aa:	80 fb 1a             	cmp    $0x1a,%bl
   1a1ad:	77 17                	ja     1a1c6 <_HalBeginSystemInterrupt@12+0x46>
   1a1af:	30 c0                	xor    %al,%al
   1a1b1:	80 fb 02             	cmp    $0x2,%bl
   1a1b4:	76 10                	jbe    1a1c6 <_HalBeginSystemInterrupt@12+0x46>
   1a1b6:	31 c0                	xor    %eax,%eax
   1a1b8:	88 d8                	mov    %bl,%al
   1a1ba:	8d 04 c5 10 00 00 00 	lea    0x10(,%eax,8),%eax
   1a1c1:	25 ff 00 00 00       	and    $0xff,%eax
   1a1c6:	50                   	push   %eax
   1a1c7:	68 80 00 00 00       	push   $0x80
   1a1cc:	e8 ff b8 ff ff       	call   15ad0 <_APICWrite>
   1a1d1:	e8 6a fb ff ff       	call   19d40 <_KeGetCurrentIrql@0>
   1a1d6:	8b 55 10             	mov    0x10(%ebp),%edx
   1a1d9:	88 02                	mov    %al,(%edx)
   1a1db:	31 c0                	xor    %eax,%eax
   1a1dd:	88 d8                	mov    %bl,%al
   1a1df:	89 04 24             	mov    %eax,(%esp)
   1a1e2:	e8 d9 fb ff ff       	call   19dc0 <_KeSetCurrentIrql>
   1a1e7:	b8 01 00 00 00       	mov    $0x1,%eax
   1a1ec:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1a1ef:	c9                   	leave  
   1a1f0:	c2 0c 00             	ret    $0xc
   1a1f3:	52                   	push   %edx
   1a1f4:	68 3a 01 00 00       	push   $0x13a
   1a1f9:	68 90 d3 01 00       	push   $0x1d390
   1a1fe:	68 9a d3 01 00       	push   $0x1d39a
   1a203:	e8 88 06 00 00       	call   1a890 <_DbgPrint>
   1a208:	c7 04 24 0c d4 01 00 	movl   $0x1d40c,(%esp)
   1a20f:	e8 7c 06 00 00       	call   1a890 <_DbgPrint>
   1a214:	83 c4 0c             	add    $0xc,%esp
   1a217:	68 3b 01 00 00       	push   $0x13b
   1a21c:	68 90 d3 01 00       	push   $0x1d390
   1a221:	68 b3 d3 01 00       	push   $0x1d3b3
   1a226:	e8 65 06 00 00       	call   1a890 <_DbgPrint>
   1a22b:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1a232:	e8 39 06 00 00       	call   1a870 <_KeBugCheck@4>
   1a237:	83 c4 0c             	add    $0xc,%esp
   1a23a:	e9 5d ff ff ff       	jmp    1a19c <_HalBeginSystemInterrupt@12+0x1c>
   1a23f:	90                   	nop    
   1a240:	50                   	push   %eax
   1a241:	68 33 01 00 00       	push   $0x133
   1a246:	68 90 d3 01 00       	push   $0x1d390
   1a24b:	68 9a d3 01 00       	push   $0x1d39a
   1a250:	e8 3b 06 00 00       	call   1a890 <_DbgPrint>
   1a255:	83 c4 0c             	add    $0xc,%esp
   1a258:	31 c0                	xor    %eax,%eax
   1a25a:	88 d8                	mov    %bl,%al
   1a25c:	50                   	push   %eax
   1a25d:	51                   	push   %ecx
   1a25e:	51                   	push   %ecx
   1a25f:	e8 dc fa ff ff       	call   19d40 <_KeGetCurrentIrql@0>
   1a264:	59                   	pop    %ecx
   1a265:	25 ff 00 00 00       	and    $0xff,%eax
   1a26a:	5a                   	pop    %edx
   1a26b:	50                   	push   %eax
   1a26c:	68 49 d4 01 00       	push   $0x1d449
   1a271:	e8 1a 06 00 00       	call   1a890 <_DbgPrint>
   1a276:	83 c4 0c             	add    $0xc,%esp
   1a279:	68 34 01 00 00       	push   $0x134
   1a27e:	68 90 d3 01 00       	push   $0x1d390
   1a283:	68 b3 d3 01 00       	push   $0x1d3b3
   1a288:	e8 03 06 00 00       	call   1a890 <_DbgPrint>
   1a28d:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1a294:	e8 d7 05 00 00       	call   1a870 <_KeBugCheck@4>
   1a299:	83 c4 0c             	add    $0xc,%esp
   1a29c:	e9 f4 fe ff ff       	jmp    1a195 <_HalBeginSystemInterrupt@12+0x15>
   1a2a1:	eb 0d                	jmp    1a2b0 <_HalEndSystemInterrupt@8>
   1a2a3:	90                   	nop    
   1a2a4:	90                   	nop    
   1a2a5:	90                   	nop    
   1a2a6:	90                   	nop    
   1a2a7:	90                   	nop    
   1a2a8:	90                   	nop    
   1a2a9:	90                   	nop    
   1a2aa:	90                   	nop    
   1a2ab:	90                   	nop    
   1a2ac:	90                   	nop    
   1a2ad:	90                   	nop    
   1a2ae:	90                   	nop    
   1a2af:	90                   	nop    

0001a2b0 <_HalEndSystemInterrupt@8>:
   1a2b0:	55                   	push   %ebp
   1a2b1:	89 e5                	mov    %esp,%ebp
   1a2b3:	53                   	push   %ebx
   1a2b4:	50                   	push   %eax
   1a2b5:	8a 5d 08             	mov    0x8(%ebp),%bl
   1a2b8:	9c                   	pushf  
   1a2b9:	58                   	pop    %eax
   1a2ba:	f6 c4 02             	test   $0x2,%ah
   1a2bd:	75 21                	jne    1a2e0 <_HalEndSystemInterrupt@8+0x30>
   1a2bf:	e8 fc bb ff ff       	call   15ec0 <_APICSendEOI>
   1a2c4:	50                   	push   %eax
   1a2c5:	50                   	push   %eax
   1a2c6:	31 c0                	xor    %eax,%eax
   1a2c8:	6a 01                	push   $0x1
   1a2ca:	88 d8                	mov    %bl,%al
   1a2cc:	50                   	push   %eax
   1a2cd:	e8 6e fb ff ff       	call   19e40 <_HalpLowerIrql>
   1a2d2:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1a2d5:	c9                   	leave  
   1a2d6:	c2 08 00             	ret    $0x8
   1a2d9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   1a2e0:	50                   	push   %eax
   1a2e1:	68 50 01 00 00       	push   $0x150
   1a2e6:	68 90 d3 01 00       	push   $0x1d390
   1a2eb:	68 9a d3 01 00       	push   $0x1d39a
   1a2f0:	e8 9b 05 00 00       	call   1a890 <_DbgPrint>
   1a2f5:	c7 04 24 68 d4 01 00 	movl   $0x1d468,(%esp)
   1a2fc:	e8 8f 05 00 00       	call   1a890 <_DbgPrint>
   1a301:	83 c4 0c             	add    $0xc,%esp
   1a304:	68 51 01 00 00       	push   $0x151
   1a309:	68 90 d3 01 00       	push   $0x1d390
   1a30e:	68 b3 d3 01 00       	push   $0x1d3b3
   1a313:	e8 78 05 00 00       	call   1a890 <_DbgPrint>
   1a318:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1a31f:	e8 4c 05 00 00       	call   1a870 <_KeBugCheck@4>
   1a324:	83 c4 0c             	add    $0xc,%esp
   1a327:	e8 94 bb ff ff       	call   15ec0 <_APICSendEOI>
   1a32c:	50                   	push   %eax
   1a32d:	50                   	push   %eax
   1a32e:	31 c0                	xor    %eax,%eax
   1a330:	6a 01                	push   $0x1
   1a332:	88 d8                	mov    %bl,%al
   1a334:	50                   	push   %eax
   1a335:	e8 06 fb ff ff       	call   19e40 <_HalpLowerIrql>
   1a33a:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1a33d:	c9                   	leave  
   1a33e:	c2 08 00             	ret    $0x8
   1a341:	eb 0d                	jmp    1a350 <_HalDisableSystemInterrupt@8>
   1a343:	90                   	nop    
   1a344:	90                   	nop    
   1a345:	90                   	nop    
   1a346:	90                   	nop    
   1a347:	90                   	nop    
   1a348:	90                   	nop    
   1a349:	90                   	nop    
   1a34a:	90                   	nop    
   1a34b:	90                   	nop    
   1a34c:	90                   	nop    
   1a34d:	90                   	nop    
   1a34e:	90                   	nop    
   1a34f:	90                   	nop    

0001a350 <_HalDisableSystemInterrupt@8>:
   1a350:	55                   	push   %ebp
   1a351:	89 e5                	mov    %esp,%ebp
   1a353:	53                   	push   %ebx
   1a354:	53                   	push   %ebx
   1a355:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1a358:	8d 53 d0             	lea    0xffffffd0(%ebx),%edx
   1a35b:	81 fa be 00 00 00    	cmp    $0xbe,%edx
   1a361:	76 2e                	jbe    1a391 <_HalDisableSystemInterrupt@8+0x41>
   1a363:	51                   	push   %ecx
   1a364:	68 62 01 00 00       	push   $0x162
   1a369:	68 90 d3 01 00       	push   $0x1d390
   1a36e:	68 9a d3 01 00       	push   $0x1d39a
   1a373:	e8 18 05 00 00       	call   1a890 <_DbgPrint>
   1a378:	58                   	pop    %eax
   1a379:	5a                   	pop    %edx
   1a37a:	53                   	push   %ebx
   1a37b:	68 a4 d4 01 00       	push   $0x1d4a4
   1a380:	e8 0b 05 00 00       	call   1a890 <_DbgPrint>
   1a385:	83 c4 10             	add    $0x10,%esp
   1a388:	31 c0                	xor    %eax,%eax
   1a38a:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1a38d:	c9                   	leave  
   1a38e:	c2 08 00             	ret    $0x8
   1a391:	83 ec 0c             	sub    $0xc,%esp
   1a394:	b8 17 00 00 00       	mov    $0x17,%eax
   1a399:	c1 ea 03             	shr    $0x3,%edx
   1a39c:	29 d0                	sub    %edx,%eax
   1a39e:	50                   	push   %eax
   1a39f:	e8 7c dd ff ff       	call   18120 <_IOAPICMaskIrq>
   1a3a4:	b8 01 00 00 00       	mov    $0x1,%eax
   1a3a9:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1a3ac:	c9                   	leave  
   1a3ad:	c2 08 00             	ret    $0x8

0001a3b0 <_HalEnableSystemInterrupt@12>:
   1a3b0:	55                   	push   %ebp
   1a3b1:	89 e5                	mov    %esp,%ebp
   1a3b3:	50                   	push   %eax
   1a3b4:	50                   	push   %eax
   1a3b5:	31 c0                	xor    %eax,%eax
   1a3b7:	8b 55 08             	mov    0x8(%ebp),%edx
   1a3ba:	83 ea 30             	sub    $0x30,%edx
   1a3bd:	81 fa be 00 00 00    	cmp    $0xbe,%edx
   1a3c3:	76 0b                	jbe    1a3d0 <_HalEnableSystemInterrupt@12+0x20>
   1a3c5:	c9                   	leave  
   1a3c6:	c2 0c 00             	ret    $0xc
   1a3c9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   1a3d0:	83 ec 0c             	sub    $0xc,%esp
   1a3d3:	b0 17                	mov    $0x17,%al
   1a3d5:	c1 ea 03             	shr    $0x3,%edx
   1a3d8:	29 d0                	sub    %edx,%eax
   1a3da:	50                   	push   %eax
   1a3db:	e8 b0 dd ff ff       	call   18190 <_IOAPICUnmaskIrq>
   1a3e0:	b8 01 00 00 00       	mov    $0x1,%eax
   1a3e5:	c9                   	leave  
   1a3e6:	c2 0c 00             	ret    $0xc
   1a3e9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

0001a3f0 <@HalRequestSoftwareInterrupt@4>:
   1a3f0:	55                   	push   %ebp
   1a3f1:	89 e5                	mov    %esp,%ebp
   1a3f3:	50                   	push   %eax
   1a3f4:	50                   	push   %eax
   1a3f5:	31 c0                	xor    %eax,%eax
   1a3f7:	88 c8                	mov    %cl,%al
   1a3f9:	83 f8 01             	cmp    $0x1,%eax
   1a3fc:	74 32                	je     1a430 <@HalRequestSoftwareInterrupt@4+0x40>
   1a3fe:	83 f8 02             	cmp    $0x2,%eax
   1a401:	74 3d                	je     1a440 <@HalRequestSoftwareInterrupt@4+0x50>
   1a403:	50                   	push   %eax
   1a404:	68 91 01 00 00       	push   $0x191
   1a409:	68 90 d3 01 00       	push   $0x1d390
   1a40e:	68 b3 d3 01 00       	push   $0x1d3b3
   1a413:	e8 78 04 00 00       	call   1a890 <_DbgPrint>
   1a418:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1a41f:	e8 4c 04 00 00       	call   1a870 <_KeBugCheck@4>
   1a424:	83 c4 0c             	add    $0xc,%esp
   1a427:	c9                   	leave  
   1a428:	c3                   	ret    
   1a429:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   return b;
}

static inline VOID Ki386WriteFsByte(ULONG offset, BYTE value)
{
   1a430:	ba 94 00 00 00       	mov    $0x94,%edx
   1a435:	b0 01                	mov    $0x1,%al
    __asm__ __volatile__("movb %0,%%fs:(%1)"::"q" (value), "r" (offset));
   1a437:	64 88 02             	mov    %al,%fs:(%edx)
   1a43a:	c9                   	leave  
   1a43b:	c3                   	ret    
   1a43c:	8d 74 26 00          	lea    0x0(%esi),%esi
   return b;
}

static inline VOID Ki386WriteFsByte(ULONG offset, BYTE value)
{
   1a440:	ba 98 00 00 00       	mov    $0x98,%edx
   1a445:	eb ee                	jmp    1a435 <@HalRequestSoftwareInterrupt@4+0x45>
   1a447:	90                   	nop    
   1a448:	90                   	nop    
   1a449:	90                   	nop    
   1a44a:	90                   	nop    
   1a44b:	90                   	nop    
   1a44c:	90                   	nop    
   1a44d:	90                   	nop    
   1a44e:	90                   	nop    
   1a44f:	90                   	nop    

0001a450 <_APstart>:
   1a450:	fa                   	cli    
   1a451:	31 c0                	xor    %eax,%eax
   1a453:	8e d8                	mov    %eax,%ds
   1a455:	8e d0                	mov    %eax,%ss
   1a457:	66 b8 69 30          	mov    $0x3069,%ax
   1a45b:	00 00                	add    %al,(%eax)
   1a45d:	67 0f 01 10          	addr16 lgdtl (%bx,%si)
   1a461:	66 a1 04 20 0f 22    	mov    0x220f2004,%ax
   1a467:	d8 66 a1             	fsubs  0xffffffa1(%esi)
   1a46a:	0c 20                	or     $0x20,%al
   1a46c:	66 3d 00 00          	cmp    $0x0,%ax
   1a470:	00 00                	add    %al,(%eax)
   1a472:	74 0c                	je     1a480 <NoPae>
   1a474:	0f 20 e0             	mov    %cr4,%eax
   1a477:	66 0d 20 00          	or     $0x20,%ax
   1a47b:	00 00                	add    %al,(%eax)
   1a47d:	0f 22 e0             	mov    %eax,%cr4

0001a480 <NoPae>:
   1a480:	0f 20 c0             	mov    %cr0,%eax
   1a483:	66 0d 01 00          	or     $0x1,%ax
   1a487:	01 80 0f 22 c0 ea    	add    %eax,0xeac0220f(%eax)
   1a48d:	41                   	inc    %ecx
   1a48e:	30 08                	xor    %cl,(%eax)
	...

0001a491 <flush>:
   1a491:	66 b8 10 00          	mov    $0x10,%ax
   1a495:	66 8e d8             	mov    %ax,%ds
   1a498:	66 8e c0             	mov    %ax,%es
   1a49b:	66 8e e0             	mov    %ax,%fs
   1a49e:	66 8e e8             	mov    %ax,%gs
   1a4a1:	66 8e d0             	mov    %ax,%ss
   1a4a4:	b8 00 20 00 00       	mov    $0x2000,%eax
   1a4a9:	8b 00                	mov    (%eax),%eax
   1a4ab:	89 c4                	mov    %eax,%esp
   1a4ad:	b9 20 10 48 12       	mov    $0x12481020,%ecx
   1a4b2:	a1 08 20 00 00       	mov    0x2008,%eax
   1a4b7:	ff e0                	jmp    *%eax

0001a4b9 <APgdt>:
   1a4b9:	17                   	pop    %ss
   1a4ba:	00 6f 30             	add    %ch,0x30(%edi)
	...

0001a4bf <gdt>:
	...
   1a4c7:	ff                   	(bad)  
   1a4c8:	ff 00                	incl   (%eax)
   1a4ca:	00 00                	add    %al,(%eax)
   1a4cc:	9a cf 00 ff ff 00 00 	lcall  $0x0,$0xffff00cf
   1a4d3:	00 92 cf 00 00 00    	add    %dl,0xcf(%edx)

0001a4d7 <_APend>:
	...

0001a4e0 <_MpsIpiInterrupt>:

.global _MpsIpiInterrupt
_MpsIpiInterrupt:
  /* Save registers */	
  BEFORE
   1a4e0:	fc                   	cld    
   1a4e1:	60                   	pusha  
   1a4e2:	1e                   	push   %ds
   1a4e3:	06                   	push   %es
   1a4e4:	0f a0                	push   %fs
   1a4e6:	0f a8                	push   %gs
   1a4e8:	b8 10 00 00 00       	mov    $0x10,%eax
   1a4ed:	8e d8                	mov    %eax,%ds
   1a4ef:	8e c0                	mov    %eax,%es
   1a4f1:	8e e8                	mov    %eax,%gs
   1a4f3:	b8 30 00 00 00       	mov    $0x30,%eax
   1a4f8:	8e e0                	mov    %eax,%fs

  /* Call the C handler */
  call  _MpsIpiHandler
   1a4fa:	e8 31 d0 ff ff       	call   17530 <_MpsIpiHandler>

	/* Return to the caller */
  AFTER
   1a4ff:	0f a9                	pop    %gs
   1a501:	0f a1                	pop    %fs
   1a503:	07                   	pop    %es
   1a504:	1f                   	pop    %ds
   1a505:	61                   	popa   
  iret
   1a506:	cf                   	iret   

0001a507 <_MpsErrorInterrupt>:
  
  
.globl _MpsErrorInterrupt
_MpsErrorInterrupt:
  /* Save registers */	
  BEFORE
   1a507:	fc                   	cld    
   1a508:	60                   	pusha  
   1a509:	1e                   	push   %ds
   1a50a:	06                   	push   %es
   1a50b:	0f a0                	push   %fs
   1a50d:	0f a8                	push   %gs
   1a50f:	b8 10 00 00 00       	mov    $0x10,%eax
   1a514:	8e d8                	mov    %eax,%ds
   1a516:	8e c0                	mov    %eax,%es
   1a518:	8e e8                	mov    %eax,%gs
   1a51a:	b8 30 00 00 00       	mov    $0x30,%eax
   1a51f:	8e e0                	mov    %eax,%fs

  /* Call the C handler */
  call  _MpsErrorHandler
   1a521:	e8 0a ce ff ff       	call   17330 <_MpsErrorHandler>

	/* Return to the caller */
  AFTER
   1a526:	0f a9                	pop    %gs
   1a528:	0f a1                	pop    %fs
   1a52a:	07                   	pop    %es
   1a52b:	1f                   	pop    %ds
   1a52c:	61                   	popa   
  iret
   1a52d:	cf                   	iret   

0001a52e <_MpsSpuriousInterrupt>:


.globl _MpsSpuriousInterrupt
_MpsSpuriousInterrupt:
  /* Save registers */	
  BEFORE
   1a52e:	fc                   	cld    
   1a52f:	60                   	pusha  
   1a530:	1e                   	push   %ds
   1a531:	06                   	push   %es
   1a532:	0f a0                	push   %fs
   1a534:	0f a8                	push   %gs
   1a536:	b8 10 00 00 00       	mov    $0x10,%eax
   1a53b:	8e d8                	mov    %eax,%ds
   1a53d:	8e c0                	mov    %eax,%es
   1a53f:	8e e8                	mov    %eax,%gs
   1a541:	b8 30 00 00 00       	mov    $0x30,%eax
   1a546:	8e e0                	mov    %eax,%fs

  /* Call the C handler */
  call  _MpsSpuriousHandler
   1a548:	e8 73 cf ff ff       	call   174c0 <_MpsSpuriousHandler>

	/* Return to the caller */
  AFTER
   1a54d:	0f a9                	pop    %gs
   1a54f:	0f a1                	pop    %fs
   1a551:	07                   	pop    %es
   1a552:	1f                   	pop    %ds
   1a553:	61                   	popa   
  iret
   1a554:	cf                   	iret   

0001a555 <_MpsTimerInterrupt>:

.global _MpsTimerInterrupt
_MpsTimerInterrupt:
	cld
   1a555:	fc                   	cld    
	pusha	
   1a556:	60                   	pusha  
	movl	$0xef,%ebx		
   1a557:	bb ef 00 00 00       	mov    $0xef,%ebx
  	pushl 	%ds
   1a55c:	1e                   	push   %ds
  	pushl 	%es
   1a55d:	06                   	push   %es
  	pushl 	%fs
   1a55e:	0f a0                	push   %fs
  	pushl	%gs
   1a560:	0f a8                	push   %gs
  	movl	$0xceafbeef,%eax
   1a562:	b8 ef be af ce       	mov    $0xceafbeef,%eax
  	pushl 	%eax
   1a567:	50                   	push   %eax
  	movl	$(KERNEL_DS),%eax
   1a568:	b8 10 00 00 00       	mov    $0x10,%eax
  	movl	%eax,%ds
   1a56d:	8e d8                	mov    %eax,%ds
  	movl	%eax,%es
   1a56f:	8e c0                	mov    %eax,%es
  	movl	%eax,%gs
   1a571:	8e e8                	mov    %eax,%gs
  	movl	$(PCR_SELECTOR),%eax
   1a573:	b8 30 00 00 00       	mov    $0x30,%eax
  	movl	%eax,%fs
   1a578:	8e e0                	mov    %eax,%fs
  	pushl 	%esp
   1a57a:	54                   	push   %esp
  	pushl 	%ebx
   1a57b:	53                   	push   %ebx
  	call	_MpsTimerHandler
   1a57c:	e8 5f d0 ff ff       	call   175e0 <_MpsTimerHandler>
    	popl	%eax
   1a581:	58                   	pop    %eax
  	popl	%eax
   1a582:	58                   	pop    %eax
  	popl	%eax
   1a583:	58                   	pop    %eax
  	popl	%gs
   1a584:	0f a9                	pop    %gs
  	popl	%fs
   1a586:	0f a1                	pop    %fs
  	popl	%es
   1a588:	07                   	pop    %es
  	popl	%ds
   1a589:	1f                   	pop    %ds
  	popa
   1a58a:	61                   	popa   
  	iret
   1a58b:	cf                   	iret   
   1a58c:	90                   	nop    
   1a58d:	90                   	nop    
   1a58e:	90                   	nop    
   1a58f:	90                   	nop    

0001a590 <_HalInitializeProcessor@8>:
   1a590:	55                   	push   %ebp
   1a591:	89 e5                	mov    %esp,%ebp
   1a593:	53                   	push   %ebx
   1a594:	83 ec 10             	sub    $0x10,%esp
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
    return (APICRead(APIC_ID) & APIC_ID_MASK) >> 24;
   1a597:	6a 20                	push   $0x20
   1a599:	e8 a2 b4 ff ff       	call   15a40 <_APICRead>
   1a59e:	89 c3                	mov    %eax,%ebx
   1a5a0:	b8 01 00 00 00       	mov    $0x1,%eax
VOID HaliStartApplicationProcessor(ULONG Cpu, ULONG Stack);

static inline ULONG ThisCPU(VOID)
{
    return (APICRead(APIC_ID) & APIC_ID_MASK) >> 24;
   1a5a5:	81 e3 00 00 00 0f    	and    $0xf000000,%ebx
   1a5ab:	83 c4 10             	add    $0x10,%esp
   1a5ae:	c1 eb 18             	shr    $0x18,%ebx
   1a5b1:	88 d9                	mov    %bl,%cl
   1a5b3:	d3 e0                	shl    %cl,%eax
   1a5b5:	85 05 90 e5 03 00    	test   %eax,0x3e590
   1a5bb:	75 53                	jne    1a610 <_HalInitializeProcessor@8+0x80>
   1a5bd:	8b 4d 08             	mov    0x8(%ebp),%ecx
   1a5c0:	85 c9                	test   %ecx,%ecx
   1a5c2:	75 34                	jne    1a5f8 <_HalInitializeProcessor@8+0x68>
   1a5c4:	e8 17 d3 ff ff       	call   178e0 <_HaliInitBSP>
   1a5c9:	89 d8                	mov    %ebx,%eax
   1a5cb:	88 d9                	mov    %bl,%cl
   1a5cd:	c1 e0 04             	shl    $0x4,%eax
   1a5d0:	8b 15 90 e5 03 00    	mov    0x3e590,%edx
   1a5d6:	80 88 30 e6 03 00 02 	orb    $0x2,0x3e630(%eax)
   1a5dd:	b8 01 00 00 00       	mov    $0x1,%eax
   1a5e2:	d3 e0                	shl    %cl,%eax
   1a5e4:	09 c2                	or     %eax,%edx
   1a5e6:	89 15 90 e5 03 00    	mov    %edx,0x3e590
   1a5ec:	e8 1f b1 ff ff       	call   15710 <_HalpCalibrateStallExecution>
   1a5f1:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1a5f4:	c9                   	leave  
   1a5f5:	c2 08 00             	ret    $0x8
   1a5f8:	e8 63 c5 ff ff       	call   16b60 <_APICSetup>
   1a5fd:	83 ec 0c             	sub    $0xc,%esp
   1a600:	53                   	push   %ebx
   1a601:	e8 4a d1 ff ff       	call   17750 <_APICCalibrateTimer>
   1a606:	83 c4 10             	add    $0x10,%esp
   1a609:	eb be                	jmp    1a5c9 <_HalInitializeProcessor@8+0x39>
   1a60b:	90                   	nop    
   1a60c:	8d 74 26 00          	lea    0x0(%esi),%esi
   1a610:	50                   	push   %eax
   1a611:	6a 30                	push   $0x30
   1a613:	68 d0 d4 01 00       	push   $0x1d4d0
   1a618:	68 df d4 01 00       	push   $0x1d4df
   1a61d:	e8 6e 02 00 00       	call   1a890 <_DbgPrint>
   1a622:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1a629:	e8 42 02 00 00       	call   1a870 <_KeBugCheck@4>
   1a62e:	83 c4 0c             	add    $0xc,%esp
   1a631:	eb 8a                	jmp    1a5bd <_HalInitializeProcessor@8+0x2d>
   1a633:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1a639:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

0001a640 <_HalAllProcessorsStarted@0>:
   1a640:	55                   	push   %ebp
   1a641:	31 d2                	xor    %edx,%edx
   1a643:	89 e5                	mov    %esp,%ebp
   1a645:	56                   	push   %esi
   1a646:	53                   	push   %ebx
   1a647:	31 c9                	xor    %ecx,%ecx
   1a649:	8b 1d 90 e5 03 00    	mov    0x3e590,%ebx
   1a64f:	be 01 00 00 00       	mov    $0x1,%esi
   1a654:	89 f0                	mov    %esi,%eax
   1a656:	d3 e0                	shl    %cl,%eax
   1a658:	21 d8                	and    %ebx,%eax
   1a65a:	83 f8 01             	cmp    $0x1,%eax
   1a65d:	83 da ff             	sbb    $0xffffffff,%edx
   1a660:	41                   	inc    %ecx
   1a661:	83 f9 1f             	cmp    $0x1f,%ecx
   1a664:	76 ee                	jbe    1a654 <_HalAllProcessorsStarted@0+0x14>
   1a666:	3b 15 c0 e8 03 00    	cmp    0x3e8c0,%edx
   1a66c:	77 0b                	ja     1a679 <_HalAllProcessorsStarted@0+0x39>
   1a66e:	74 2c                	je     1a69c <_HalAllProcessorsStarted@0+0x5c>
   1a670:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1a673:	31 c0                	xor    %eax,%eax
   1a675:	5b                   	pop    %ebx
   1a676:	5e                   	pop    %esi
   1a677:	5d                   	pop    %ebp
   1a678:	c3                   	ret    
   1a679:	50                   	push   %eax
   1a67a:	6a 57                	push   $0x57
   1a67c:	68 d0 d4 01 00       	push   $0x1d4d0
   1a681:	68 df d4 01 00       	push   $0x1d4df
   1a686:	e8 05 02 00 00       	call   1a890 <_DbgPrint>
   1a68b:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1a692:	e8 d9 01 00 00       	call   1a870 <_KeBugCheck@4>
   1a697:	83 c4 0c             	add    $0xc,%esp
   1a69a:	eb d4                	jmp    1a670 <_HalAllProcessorsStarted@0+0x30>
   1a69c:	e8 0f d8 ff ff       	call   17eb0 <_IOAPICEnable>
   1a6a1:	e8 ca d8 ff ff       	call   17f70 <_IOAPICSetupIds>
   1a6a6:	83 3d c0 e8 03 00 01 	cmpl   $0x1,0x3e8c0
   1a6ad:	77 11                	ja     1a6c0 <_HalAllProcessorsStarted@0+0x80>
   1a6af:	e8 cc df ff ff       	call   18680 <_IOAPICSetupIrqs>
   1a6b4:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   1a6b7:	b8 01 00 00 00       	mov    $0x1,%eax
   1a6bc:	5b                   	pop    %ebx
   1a6bd:	5e                   	pop    %esi
   1a6be:	5d                   	pop    %ebp
   1a6bf:	c3                   	ret    
   1a6c0:	e8 cb cb ff ff       	call   17290 <_APICSyncArbIDs>
   1a6c5:	eb e8                	jmp    1a6af <_HalAllProcessorsStarted@0+0x6f>
   1a6c7:	89 f6                	mov    %esi,%esi
   1a6c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

0001a6d0 <_HalStartNextProcessor@8>:
   1a6d0:	55                   	push   %ebp
   1a6d1:	89 e5                	mov    %esp,%ebp
   1a6d3:	57                   	push   %edi
   1a6d4:	56                   	push   %esi
   1a6d5:	53                   	push   %ebx
   1a6d6:	83 ec 0c             	sub    $0xc,%esp
   1a6d9:	31 db                	xor    %ebx,%ebx
   1a6db:	8b 15 c0 e8 03 00    	mov    0x3e8c0,%edx
   1a6e1:	39 d3                	cmp    %edx,%ebx
   1a6e3:	73 1a                	jae    1a6ff <_HalStartNextProcessor@8+0x2f>
   1a6e5:	8b 3d 90 e5 03 00    	mov    0x3e590,%edi
   1a6eb:	be 01 00 00 00       	mov    $0x1,%esi
   1a6f0:	89 f0                	mov    %esi,%eax
   1a6f2:	88 d9                	mov    %bl,%cl
   1a6f4:	d3 e0                	shl    %cl,%eax
   1a6f6:	85 c7                	test   %eax,%edi
   1a6f8:	74 60                	je     1a75a <_HalStartNextProcessor@8+0x8a>
   1a6fa:	43                   	inc    %ebx
   1a6fb:	39 d3                	cmp    %edx,%ebx
   1a6fd:	72 f1                	jb     1a6f0 <_HalStartNextProcessor@8+0x20>
   1a6ff:	50                   	push   %eax
   1a700:	6a 7b                	push   $0x7b
   1a702:	68 d0 d4 01 00       	push   $0x1d4d0
   1a707:	68 df d4 01 00       	push   $0x1d4df
   1a70c:	e8 7f 01 00 00       	call   1a890 <_DbgPrint>
   1a711:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1a718:	e8 53 01 00 00       	call   1a870 <_KeBugCheck@4>
   1a71d:	83 c4 0c             	add    $0xc,%esp
   1a720:	57                   	push   %edi
   1a721:	6a 7e                	push   $0x7e
   1a723:	68 d0 d4 01 00       	push   $0x1d4d0
   1a728:	68 f4 d4 01 00       	push   $0x1d4f4
   1a72d:	e8 5e 01 00 00       	call   1a890 <_DbgPrint>
   1a732:	59                   	pop    %ecx
   1a733:	5e                   	pop    %esi
   1a734:	53                   	push   %ebx
   1a735:	68 fd d4 01 00       	push   $0x1d4fd
   1a73a:	e8 51 01 00 00       	call   1a890 <_DbgPrint>
   1a73f:	58                   	pop    %eax
   1a740:	8b 45 0c             	mov    0xc(%ebp),%eax
   1a743:	5a                   	pop    %edx
   1a744:	50                   	push   %eax
   1a745:	53                   	push   %ebx
   1a746:	e8 d5 d2 ff ff       	call   17a20 <_HaliStartApplicationProcessor>
   1a74b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1a74e:	b8 01 00 00 00       	mov    $0x1,%eax
   1a753:	5b                   	pop    %ebx
   1a754:	5e                   	pop    %esi
   1a755:	5f                   	pop    %edi
   1a756:	5d                   	pop    %ebp
   1a757:	c2 08 00             	ret    $0x8
   1a75a:	39 d3                	cmp    %edx,%ebx
   1a75c:	72 c2                	jb     1a720 <_HalStartNextProcessor@8+0x50>
   1a75e:	eb 9f                	jmp    1a6ff <_HalStartNextProcessor@8+0x2f>

0001a760 <_HalReportResourceUsage@0>:
   1a760:	55                   	push   %ebp
   1a761:	89 e5                	mov    %esp,%ebp
   1a763:	50                   	push   %eax
   1a764:	50                   	push   %eax
   1a765:	e8 f6 a0 ff ff       	call   14860 <_HalpInitPciBus>
   1a76a:	c9                   	leave  
   1a76b:	e9 30 de ff ff       	jmp    185a0 <_HaliReconfigurePciInterrupts>

0001a770 <_ObCreateObject@36>:
   1a770:	ff 25 70 11 04 00    	jmp    *0x41170
   1a776:	90                   	nop    
   1a777:	90                   	nop    
	...

0001a780 <_ObReferenceObjectByPointer@16>:
   1a780:	ff 25 78 11 04 00    	jmp    *0x41178
   1a786:	90                   	nop    
   1a787:	90                   	nop    
	...

0001a790 <_RtlZeroMemory@8>:
   1a790:	ff 25 8c 11 04 00    	jmp    *0x4118c
   1a796:	90                   	nop    
   1a797:	90                   	nop    
	...

0001a7a0 <_ObInsertObject@24>:
   1a7a0:	ff 25 74 11 04 00    	jmp    *0x41174
   1a7a6:	90                   	nop    
   1a7a7:	90                   	nop    
	...

0001a7b0 <_NtClose@4>:
   1a7b0:	ff 25 6c 11 04 00    	jmp    *0x4116c
   1a7b6:	90                   	nop    
   1a7b7:	90                   	nop    
	...

0001a7c0 <_KeInitializeDeviceQueue@4>:
   1a7c0:	ff 25 28 11 04 00    	jmp    *0x41128
   1a7c6:	90                   	nop    
   1a7c7:	90                   	nop    
	...

0001a7d0 <_KeInitializeSpinLock@4>:
   1a7d0:	ff 25 2c 11 04 00    	jmp    *0x4112c
   1a7d6:	90                   	nop    
   1a7d7:	90                   	nop    
	...

0001a7e0 <_RtlInitializeBitMap@12>:
   1a7e0:	ff 25 80 11 04 00    	jmp    *0x41180
   1a7e6:	90                   	nop    
   1a7e7:	90                   	nop    
	...

0001a7f0 <_RtlSetAllBits@4>:
   1a7f0:	ff 25 88 11 04 00    	jmp    *0x41188
   1a7f6:	90                   	nop    
   1a7f7:	90                   	nop    
	...

0001a800 <_ExAllocatePool@8>:
   1a800:	ff 25 08 11 04 00    	jmp    *0x41108
   1a806:	90                   	nop    
   1a807:	90                   	nop    
	...

0001a810 <_MmMapLockedPages@8>:
   1a810:	ff 25 64 11 04 00    	jmp    *0x41164
   1a816:	90                   	nop    
   1a817:	90                   	nop    
	...

0001a820 <_MmFreeContiguousMemory@4>:
   1a820:	ff 25 58 11 04 00    	jmp    *0x41158
   1a826:	90                   	nop    
   1a827:	90                   	nop    
	...

0001a830 <_KeRemoveDeviceQueue@4>:
   1a830:	ff 25 3c 11 04 00    	jmp    *0x4113c
   1a836:	90                   	nop    
   1a837:	90                   	nop    
	...

0001a840 <_MmAllocateContiguousAlignedMemory@36>:
   1a840:	ff 25 54 11 04 00    	jmp    *0x41154
   1a846:	90                   	nop    
   1a847:	90                   	nop    
	...

0001a850 <_KeInsertDeviceQueue@8>:
   1a850:	ff 25 30 11 04 00    	jmp    *0x41130
   1a856:	90                   	nop    
   1a857:	90                   	nop    
	...

0001a860 <_MmGetPhysicalAddress@4>:
   1a860:	ff 25 5c 11 04 00    	jmp    *0x4115c
   1a866:	90                   	nop    
   1a867:	90                   	nop    
	...

0001a870 <_KeBugCheck@4>:
   1a870:	ff 25 18 11 04 00    	jmp    *0x41118
   1a876:	90                   	nop    
   1a877:	90                   	nop    
	...

0001a880 <_memcpy>:
   1a880:	ff 25 94 11 04 00    	jmp    *0x41194
   1a886:	90                   	nop    
   1a887:	90                   	nop    
	...

0001a890 <_DbgPrint>:
   1a890:	ff 25 04 11 04 00    	jmp    *0x41104
   1a896:	90                   	nop    
   1a897:	90                   	nop    
	...

0001a8a0 <_ExAllocatePoolWithTag@12>:
   1a8a0:	ff 25 0c 11 04 00    	jmp    *0x4110c
   1a8a6:	90                   	nop    
   1a8a7:	90                   	nop    
	...

0001a8b0 <_MmMapIoSpace@16>:
   1a8b0:	ff 25 60 11 04 00    	jmp    *0x41160
   1a8b6:	90                   	nop    
   1a8b7:	90                   	nop    
	...

0001a8c0 <@KiAcquireSpinLock@4>:
   1a8c0:	ff 25 f8 10 04 00    	jmp    *0x410f8
   1a8c6:	90                   	nop    
   1a8c7:	90                   	nop    
	...

0001a8d0 <_RtlMoveMemory@12>:
   1a8d0:	ff 25 84 11 04 00    	jmp    *0x41184
   1a8d6:	90                   	nop    
   1a8d7:	90                   	nop    
	...

0001a8e0 <@KiReleaseSpinLock@4>:
   1a8e0:	ff 25 fc 10 04 00    	jmp    *0x410fc
   1a8e6:	90                   	nop    
   1a8e7:	90                   	nop    
	...

0001a8f0 <_KeEnterCriticalRegion@0>:
   1a8f0:	ff 25 1c 11 04 00    	jmp    *0x4111c
   1a8f6:	90                   	nop    
   1a8f7:	90                   	nop    
	...

0001a900 <@ExAcquireFastMutexUnsafe@4>:
   1a900:	ff 25 ec 10 04 00    	jmp    *0x410ec
   1a906:	90                   	nop    
   1a907:	90                   	nop    
	...

0001a910 <@ExReleaseFastMutexUnsafe@4>:
   1a910:	ff 25 f0 10 04 00    	jmp    *0x410f0
   1a916:	90                   	nop    
   1a917:	90                   	nop    
	...

0001a920 <_KeLeaveCriticalRegion@0>:
   1a920:	ff 25 34 11 04 00    	jmp    *0x41134
   1a926:	90                   	nop    
   1a927:	90                   	nop    
	...

0001a930 <@InterlockedExchange@8>:
   1a930:	ff 25 f4 10 04 00    	jmp    *0x410f4
   1a936:	90                   	nop    
   1a937:	90                   	nop    
	...

0001a940 <_KeGetCurrentThread@0>:
   1a940:	ff 25 24 11 04 00    	jmp    *0x41124
   1a946:	90                   	nop    
   1a947:	90                   	nop    
	...

0001a950 <_sprintf>:
   1a950:	ff 25 9c 11 04 00    	jmp    *0x4119c
   1a956:	90                   	nop    
   1a957:	90                   	nop    
	...

0001a960 <_KeEnterKernelDebugger@0>:
   1a960:	ff 25 20 11 04 00    	jmp    *0x41120
   1a966:	90                   	nop    
   1a967:	90                   	nop    
	...

0001a970 <_DbgBreakPoint@0>:
   1a970:	ff 25 00 11 04 00    	jmp    *0x41100
   1a976:	90                   	nop    
   1a977:	90                   	nop    
	...

0001a980 <_strncpy>:
   1a980:	ff 25 a0 11 04 00    	jmp    *0x411a0
   1a986:	90                   	nop    
   1a987:	90                   	nop    
	...

0001a990 <__stricmp>:
   1a990:	ff 25 90 11 04 00    	jmp    *0x41190
   1a996:	90                   	nop    
   1a997:	90                   	nop    
	...

0001a9a0 <_KeQueryTickCount@4>:
   1a9a0:	ff 25 38 11 04 00    	jmp    *0x41138
   1a9a6:	90                   	nop    
   1a9a7:	90                   	nop    
	...

0001a9b0 <_KiIpiServiceRoutine@8>:
   1a9b0:	ff 25 50 11 04 00    	jmp    *0x41150
   1a9b6:	90                   	nop    
   1a9b7:	90                   	nop    
	...

0001a9c0 <_KeUpdateSystemTime@8>:
   1a9c0:	ff 25 44 11 04 00    	jmp    *0x41144
   1a9c6:	90                   	nop    
   1a9c7:	90                   	nop    
	...

0001a9d0 <_KeUpdateRunTime@8>:
   1a9d0:	ff 25 40 11 04 00    	jmp    *0x41140
   1a9d6:	90                   	nop    
   1a9d7:	90                   	nop    
	...

0001a9e0 <_RtlImageNtHeader@4>:
   1a9e0:	ff 25 7c 11 04 00    	jmp    *0x4117c
   1a9e6:	90                   	nop    
   1a9e7:	90                   	nop    
	...

0001a9f0 <_memset>:
   1a9f0:	ff 25 98 11 04 00    	jmp    *0x41198
   1a9f6:	90                   	nop    
   1a9f7:	90                   	nop    
	...

0001aa00 <_KiDispatchInterrupt@0>:
   1aa00:	ff 25 4c 11 04 00    	jmp    *0x4114c
   1aa06:	90                   	nop    
   1aa07:	90                   	nop    
	...

0001aa10 <_KiDeliverApc@12>:
   1aa10:	ff 25 48 11 04 00    	jmp    *0x41148
   1aa16:	90                   	nop    
   1aa17:	90                   	nop    
	...

0001aa20 <__CTOR_LIST__>:
   1aa20:	ff                   	(bad)  
   1aa21:	ff                   	(bad)  
   1aa22:	ff                   	(bad)  
   1aa23:	ff 00                	incl   (%eax)
   1aa25:	00 00                	add    %al,(%eax)
	...

0001aa28 <__DTOR_LIST__>:
   1aa28:	ff                   	(bad)  
   1aa29:	ff                   	(bad)  
   1aa2a:	ff                   	(bad)  
   1aa2b:	ff 00                	incl   (%eax)
   1aa2d:	00 00                	add    %al,(%eax)
	...
