
isapnp.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_ReadUchar>:
	return READ_PORT_UCHAR(IsaPnPReadPort);
}

UCHAR ReadUchar(UCHAR Index)
{
   11000:	55                   	push   %ebp
   11001:	31 c0                	xor    %eax,%eax
   11003:	89 e5                	mov    %esp,%ebp
   11005:	83 ec 10             	sub    $0x10,%esp
   11008:	8a 45 08             	mov    0x8(%ebp),%al
   1100b:	50                   	push   %eax
   1100c:	68 79 02 00 00       	push   $0x279
   11011:	e8 2a 1d 00 00       	call   12d40 <_WRITE_PORT_UCHAR@8>
   11016:	52                   	push   %edx
   11017:	6a 14                	push   $0x14
   11019:	e8 32 1d 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   1101e:	a1 00 40 01 00       	mov    0x14000,%eax
   11023:	50                   	push   %eax
   11024:	e8 37 1d 00 00       	call   12d60 <_READ_PORT_UCHAR@4>
   11029:	83 c4 0c             	add    $0xc,%esp
   1102c:	25 ff 00 00 00       	and    $0xff,%eax
	WriteAddress(Index);
	return ReadData();
}
   11031:	c9                   	leave  
   11032:	c3                   	ret    
   11033:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11039:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011040 <_ReadUshort>:

USHORT ReadUshort(UCHAR Index)
{
   11040:	55                   	push   %ebp
	USHORT Value;

	Value = ReadUchar(Index);
   11041:	31 c0                	xor    %eax,%eax
   11043:	89 e5                	mov    %esp,%ebp
   11045:	56                   	push   %esi
   11046:	53                   	push   %ebx
   11047:	83 ec 0c             	sub    $0xc,%esp
   1104a:	8a 5d 08             	mov    0x8(%ebp),%bl
   1104d:	88 d8                	mov    %bl,%al
	Value = (Value << 8) + ReadUchar(Index + 1);
   1104f:	43                   	inc    %ebx
   11050:	50                   	push   %eax
   11051:	e8 aa ff ff ff       	call   11000 <_ReadUchar>
   11056:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   1105c:	25 ff 00 00 00       	and    $0xff,%eax
   11061:	89 1c 24             	mov    %ebx,(%esp)
   11064:	89 c6                	mov    %eax,%esi
   11066:	c1 e6 08             	shl    $0x8,%esi
   11069:	e8 92 ff ff ff       	call   11000 <_ReadUchar>
   1106e:	25 ff 00 00 00       	and    $0xff,%eax
	return Value;
}
   11073:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11076:	01 f0                	add    %esi,%eax
   11078:	5b                   	pop    %ebx
   11079:	25 ff ff 00 00       	and    $0xffff,%eax
   1107e:	5e                   	pop    %esi
   1107f:	5d                   	pop    %ebp
   11080:	c3                   	ret    
   11081:	eb 0d                	jmp    11090 <_ReadUlong>
   11083:	90                   	nop    
   11084:	90                   	nop    
   11085:	90                   	nop    
   11086:	90                   	nop    
   11087:	90                   	nop    
   11088:	90                   	nop    
   11089:	90                   	nop    
   1108a:	90                   	nop    
   1108b:	90                   	nop    
   1108c:	90                   	nop    
   1108d:	90                   	nop    
   1108e:	90                   	nop    
   1108f:	90                   	nop    

00011090 <_ReadUlong>:

ULONG ReadUlong(UCHAR Index)
{
   11090:	55                   	push   %ebp
	ULONG Value;

	Value = ReadUchar(Index);
   11091:	31 c0                	xor    %eax,%eax
   11093:	89 e5                	mov    %esp,%ebp
   11095:	56                   	push   %esi
   11096:	53                   	push   %ebx
   11097:	83 ec 0c             	sub    $0xc,%esp
   1109a:	8a 5d 08             	mov    0x8(%ebp),%bl
   1109d:	88 d8                	mov    %bl,%al
   1109f:	50                   	push   %eax
   110a0:	e8 5b ff ff ff       	call   11000 <_ReadUchar>
   110a5:	25 ff 00 00 00       	and    $0xff,%eax
   110aa:	89 c6                	mov    %eax,%esi
	Value = (Value << 8) + ReadUchar(Index + 1);
   110ac:	8d 43 01             	lea    0x1(%ebx),%eax
   110af:	c1 e6 08             	shl    $0x8,%esi
   110b2:	25 ff 00 00 00       	and    $0xff,%eax
   110b7:	89 04 24             	mov    %eax,(%esp)
   110ba:	e8 41 ff ff ff       	call   11000 <_ReadUchar>
   110bf:	25 ff 00 00 00       	and    $0xff,%eax
   110c4:	01 c6                	add    %eax,%esi
	Value = (Value << 8) + ReadUchar(Index + 2);
   110c6:	8d 43 02             	lea    0x2(%ebx),%eax
   110c9:	25 ff 00 00 00       	and    $0xff,%eax
	Value = (Value << 8) + ReadUchar(Index + 3);
   110ce:	83 c3 03             	add    $0x3,%ebx
   110d1:	89 04 24             	mov    %eax,(%esp)
   110d4:	e8 27 ff ff ff       	call   11000 <_ReadUchar>
   110d9:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   110df:	25 ff 00 00 00       	and    $0xff,%eax
   110e4:	c1 e6 08             	shl    $0x8,%esi
   110e7:	89 1c 24             	mov    %ebx,(%esp)
   110ea:	01 c6                	add    %eax,%esi
   110ec:	e8 0f ff ff ff       	call   11000 <_ReadUchar>
   110f1:	c1 e6 08             	shl    $0x8,%esi
   110f4:	25 ff 00 00 00       	and    $0xff,%eax
	return Value;
}
   110f9:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   110fc:	8d 04 06             	lea    (%esi,%eax,1),%eax
   110ff:	5b                   	pop    %ebx
   11100:	5e                   	pop    %esi
   11101:	5d                   	pop    %ebp
   11102:	c3                   	ret    
   11103:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11109:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011110 <_WriteUchar>:

VOID WriteUchar(UCHAR Index, UCHAR Value)
{
   11110:	55                   	push   %ebp
   11111:	31 c0                	xor    %eax,%eax
   11113:	89 e5                	mov    %esp,%ebp
   11115:	53                   	push   %ebx
   11116:	83 ec 0c             	sub    $0xc,%esp
   11119:	8a 45 08             	mov    0x8(%ebp),%al
   1111c:	8a 5d 0c             	mov    0xc(%ebp),%bl
   1111f:	50                   	push   %eax
   11120:	68 79 02 00 00       	push   $0x279
   11125:	e8 16 1c 00 00       	call   12d40 <_WRITE_PORT_UCHAR@8>
   1112a:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   11130:	50                   	push   %eax
   11131:	6a 14                	push   $0x14
   11133:	e8 18 1c 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11138:	89 1c 24             	mov    %ebx,(%esp)
   1113b:	68 79 0a 00 00       	push   $0xa79
   11140:	e8 fb 1b 00 00       	call   12d40 <_WRITE_PORT_UCHAR@8>
   11145:	59                   	pop    %ecx
   11146:	5b                   	pop    %ebx
   11147:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1114a:	c9                   	leave  
   1114b:	c3                   	ret    
   1114c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011150 <_WriteUshort>:
	WriteAddress(Index);
	WriteData(Value);
}

VOID WriteUshort(UCHAR Index, USHORT Value)
{
   11150:	55                   	push   %ebp
   11151:	89 e5                	mov    %esp,%ebp
   11153:	56                   	push   %esi
   11154:	53                   	push   %ebx
   11155:	0f b6 75 08          	movzbl 0x8(%ebp),%esi
   11159:	8b 5d 0c             	mov    0xc(%ebp),%ebx
	WriteUchar(Index, Value >> 8);
   1115c:	50                   	push   %eax
   1115d:	50                   	push   %eax
   1115e:	0f b6 c7             	movzbl %bh,%eax
   11161:	50                   	push   %eax
   11162:	89 f0                	mov    %esi,%eax
   11164:	25 ff 00 00 00       	and    $0xff,%eax
	WriteUchar(Index + 1, Value);
   11169:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   1116f:	50                   	push   %eax
   11170:	e8 9b ff ff ff       	call   11110 <_WriteUchar>
   11175:	8d 46 01             	lea    0x1(%esi),%eax
   11178:	89 5d 0c             	mov    %ebx,0xc(%ebp)
   1117b:	25 ff 00 00 00       	and    $0xff,%eax
   11180:	83 c4 10             	add    $0x10,%esp
   11183:	89 45 08             	mov    %eax,0x8(%ebp)
   11186:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11189:	5b                   	pop    %ebx
   1118a:	5e                   	pop    %esi
   1118b:	5d                   	pop    %ebp
   1118c:	eb 82                	jmp    11110 <_WriteUchar>
   1118e:	89 f6                	mov    %esi,%esi

00011190 <_WriteUlong>:
}

VOID WriteUlong(UCHAR Index, ULONG Value)
{
   11190:	55                   	push   %ebp
   11191:	89 e5                	mov    %esp,%ebp
   11193:	56                   	push   %esi
   11194:	53                   	push   %ebx
   11195:	8b 75 0c             	mov    0xc(%ebp),%esi
   11198:	8a 5d 08             	mov    0x8(%ebp),%bl
	WriteUchar(Index, Value >> 24);
   1119b:	50                   	push   %eax
   1119c:	50                   	push   %eax
   1119d:	89 f0                	mov    %esi,%eax
   1119f:	c1 e8 18             	shr    $0x18,%eax
   111a2:	50                   	push   %eax
   111a3:	31 c0                	xor    %eax,%eax
   111a5:	88 d8                	mov    %bl,%al
   111a7:	50                   	push   %eax
   111a8:	e8 63 ff ff ff       	call   11110 <_WriteUchar>
	WriteUchar(Index + 1, Value >> 16);
   111ad:	59                   	pop    %ecx
   111ae:	58                   	pop    %eax
   111af:	89 f0                	mov    %esi,%eax
   111b1:	c1 e8 10             	shr    $0x10,%eax
   111b4:	25 ff 00 00 00       	and    $0xff,%eax
   111b9:	50                   	push   %eax
   111ba:	8d 43 01             	lea    0x1(%ebx),%eax
   111bd:	25 ff 00 00 00       	and    $0xff,%eax
   111c2:	50                   	push   %eax
   111c3:	e8 48 ff ff ff       	call   11110 <_WriteUchar>
	WriteUchar(Index + 2, Value >> 8);
   111c8:	58                   	pop    %eax
   111c9:	5a                   	pop    %edx
   111ca:	89 f2                	mov    %esi,%edx
   111cc:	0f b6 c6             	movzbl %dh,%eax
   111cf:	50                   	push   %eax
   111d0:	8d 43 02             	lea    0x2(%ebx),%eax
   111d3:	25 ff 00 00 00       	and    $0xff,%eax
	WriteUchar(Index + 3, Value);
   111d8:	83 c3 03             	add    $0x3,%ebx
   111db:	50                   	push   %eax
   111dc:	e8 2f ff ff ff       	call   11110 <_WriteUchar>
   111e1:	89 f0                	mov    %esi,%eax
   111e3:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   111e9:	25 ff 00 00 00       	and    $0xff,%eax
   111ee:	89 5d 08             	mov    %ebx,0x8(%ebp)
   111f1:	89 45 0c             	mov    %eax,0xc(%ebp)
   111f4:	83 c4 10             	add    $0x10,%esp
   111f7:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   111fa:	5b                   	pop    %ebx
   111fb:	5e                   	pop    %esi
   111fc:	5d                   	pop    %ebp
   111fd:	e9 0e ff ff ff       	jmp    11110 <_WriteUchar>
   11202:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11209:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011210 <_SendKey>:
}

static inline VOID SetReadDataPort(ULONG Port)
{
  IsaPnPReadPort = (PUCHAR)Port;
	WriteUchar(0x00, Port >> 2);
	KeStallExecutionProcessor(100);
}

static VOID SendKey(VOID)
{
   11210:	55                   	push   %ebp
   11211:	89 e5                	mov    %esp,%ebp
   11213:	56                   	push   %esi
   11214:	53                   	push   %ebx
   11215:	be 1e 00 00 00       	mov    $0x1e,%esi
  ULONG i;
  UCHAR msb;
	UCHAR code;

  /* FIXME: Is there something better? */
	KeStallExecutionProcessor(1000);
   1121a:	83 ec 0c             	sub    $0xc,%esp
	WriteAddress(0x00);
	WriteAddress(0x00);

  code = 0x6a;
   1121d:	b3 6a                	mov    $0x6a,%bl
   1121f:	68 e8 03 00 00       	push   $0x3e8
   11224:	e8 27 1b 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11229:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11230:	68 79 02 00 00       	push   $0x279
   11235:	e8 06 1b 00 00       	call   12d40 <_WRITE_PORT_UCHAR@8>
   1123a:	52                   	push   %edx
   1123b:	6a 14                	push   $0x14
   1123d:	e8 0e 1b 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11242:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11249:	68 79 02 00 00       	push   $0x279
   1124e:	e8 ed 1a 00 00       	call   12d40 <_WRITE_PORT_UCHAR@8>
   11253:	50                   	push   %eax
   11254:	6a 14                	push   $0x14
   11256:	e8 f5 1a 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   1125b:	c7 04 24 6a 00 00 00 	movl   $0x6a,(%esp)
   11262:	68 79 02 00 00       	push   $0x279
   11267:	e8 d4 1a 00 00       	call   12d40 <_WRITE_PORT_UCHAR@8>
   1126c:	50                   	push   %eax
   1126d:	6a 14                	push   $0x14
   1126f:	e8 dc 1a 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11274:	83 c4 0c             	add    $0xc,%esp
	WriteAddress(code);
	for (i = 1; i < 32; i++) {
		msb = ((code & 0x01) ^ ((code & 0x02) >> 1)) << 7;
   11277:	89 da                	mov    %ebx,%edx
   11279:	88 d8                	mov    %bl,%al
   1127b:	83 e2 02             	and    $0x2,%edx
   1127e:	83 e0 01             	and    $0x1,%eax
   11281:	d1 fa                	sar    %edx
		code = (code >> 1) | msb;
   11283:	d0 eb                	shr    %bl
   11285:	31 d0                	xor    %edx,%eax
   11287:	c1 e0 07             	shl    $0x7,%eax
   1128a:	09 c3                	or     %eax,%ebx
   1128c:	50                   	push   %eax
   1128d:	50                   	push   %eax
   1128e:	31 c0                	xor    %eax,%eax
   11290:	88 d8                	mov    %bl,%al
   11292:	50                   	push   %eax
   11293:	68 79 02 00 00       	push   $0x279
   11298:	e8 a3 1a 00 00       	call   12d40 <_WRITE_PORT_UCHAR@8>
   1129d:	50                   	push   %eax
   1129e:	6a 14                	push   $0x14
   112a0:	e8 ab 1a 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   112a5:	83 c4 0c             	add    $0xc,%esp
   112a8:	4e                   	dec    %esi
   112a9:	79 cc                	jns    11277 <_SendKey+0x67>
   112ab:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   112ae:	5b                   	pop    %ebx
   112af:	5e                   	pop    %esi
   112b0:	5d                   	pop    %ebp
   112b1:	c3                   	ret    
   112b2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   112b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000112c0 <_SendWait>:
		WriteAddress(code);
	}
}

/* Place all PnP cards in wait-for-key state */
static VOID SendWait(VOID)
{
   112c0:	55                   	push   %ebp
   112c1:	89 e5                	mov    %esp,%ebp
   112c3:	83 ec 10             	sub    $0x10,%esp
	WriteUchar(0x02, 0x02);
   112c6:	6a 02                	push   $0x2
   112c8:	6a 02                	push   $0x2
   112ca:	e8 41 fe ff ff       	call   11110 <_WriteUchar>
   112cf:	c9                   	leave  
   112d0:	c3                   	ret    
   112d1:	eb 0d                	jmp    112e0 <_SendWake>
   112d3:	90                   	nop    
   112d4:	90                   	nop    
   112d5:	90                   	nop    
   112d6:	90                   	nop    
   112d7:	90                   	nop    
   112d8:	90                   	nop    
   112d9:	90                   	nop    
   112da:	90                   	nop    
   112db:	90                   	nop    
   112dc:	90                   	nop    
   112dd:	90                   	nop    
   112de:	90                   	nop    
   112df:	90                   	nop    

000112e0 <_SendWake>:
}

VOID SendWake(UCHAR csn)
{
   112e0:	55                   	push   %ebp
	WriteUchar(ISAPNP_CARD_WAKECSN, csn);
   112e1:	31 c0                	xor    %eax,%eax
   112e3:	89 e5                	mov    %esp,%ebp
   112e5:	83 ec 10             	sub    $0x10,%esp
   112e8:	8a 45 08             	mov    0x8(%ebp),%al
   112eb:	50                   	push   %eax
   112ec:	6a 03                	push   $0x3
   112ee:	e8 1d fe ff ff       	call   11110 <_WriteUchar>
   112f3:	c9                   	leave  
   112f4:	c3                   	ret    
   112f5:	8d 74 26 00          	lea    0x0(%esi),%esi
   112f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011300 <_SelectLogicalDevice>:
}

VOID SelectLogicalDevice(UCHAR LogicalDevice)
{
   11300:	55                   	push   %ebp
	WriteUchar(ISAPNP_CARD_LOG_DEVICE_NUM, LogicalDevice);
   11301:	31 c0                	xor    %eax,%eax
   11303:	89 e5                	mov    %esp,%ebp
   11305:	83 ec 10             	sub    $0x10,%esp
   11308:	8a 45 08             	mov    0x8(%ebp),%al
   1130b:	50                   	push   %eax
   1130c:	6a 07                	push   $0x7
   1130e:	e8 fd fd ff ff       	call   11110 <_WriteUchar>
   11313:	c9                   	leave  
   11314:	c3                   	ret    
   11315:	8d 74 26 00          	lea    0x0(%esi),%esi
   11319:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011320 <_ActivateLogicalDevice>:
}

VOID ActivateLogicalDevice(UCHAR LogicalDevice)
{
   11320:	55                   	push   %ebp
	SelectLogicalDevice(LogicalDevice);
   11321:	31 c0                	xor    %eax,%eax
   11323:	89 e5                	mov    %esp,%ebp
   11325:	83 ec 14             	sub    $0x14,%esp
   11328:	8a 45 08             	mov    0x8(%ebp),%al
   1132b:	50                   	push   %eax
   1132c:	e8 cf ff ff ff       	call   11300 <_SelectLogicalDevice>
	WriteUchar(ISAPNP_CONTROL_ACTIVATE, 0x1);
   11331:	59                   	pop    %ecx
   11332:	58                   	pop    %eax
   11333:	6a 01                	push   $0x1
   11335:	6a 30                	push   $0x30
   11337:	e8 d4 fd ff ff       	call   11110 <_WriteUchar>
	KeStallExecutionProcessor(250);
   1133c:	c7 04 24 fa 00 00 00 	movl   $0xfa,(%esp)
   11343:	e8 08 1a 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11348:	c9                   	leave  
   11349:	c3                   	ret    
   1134a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011350 <_DeactivateLogicalDevice>:
}

VOID DeactivateLogicalDevice(UCHAR LogicalDevice)
{
   11350:	55                   	push   %ebp
	SelectLogicalDevice(LogicalDevice);
   11351:	31 c0                	xor    %eax,%eax
   11353:	89 e5                	mov    %esp,%ebp
   11355:	83 ec 14             	sub    $0x14,%esp
   11358:	8a 45 08             	mov    0x8(%ebp),%al
   1135b:	50                   	push   %eax
   1135c:	e8 9f ff ff ff       	call   11300 <_SelectLogicalDevice>
	WriteUchar(ISAPNP_CONTROL_ACTIVATE, 0x0);
   11361:	58                   	pop    %eax
   11362:	5a                   	pop    %edx
   11363:	6a 00                	push   $0x0
   11365:	6a 30                	push   $0x30
   11367:	e8 a4 fd ff ff       	call   11110 <_WriteUchar>
	KeStallExecutionProcessor(500);
   1136c:	c7 04 24 f4 01 00 00 	movl   $0x1f4,(%esp)
   11373:	e8 d8 19 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11378:	c9                   	leave  
   11379:	c3                   	ret    
   1137a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011380 <_IsolateReadDataPortSelect>:
}

#define READ_DATA_PORT_STEP 32  /* Minimum is 4 */

static ULONG FindNextReadPort(VOID)
{
	ULONG Port;



	Port = (ULONG)IsaPnPReadPort;

	while (TRUE) {

		Port += READ_DATA_PORT_STEP;



		if (Port > ISAPNP_MAX_READ_PORT)

		{

			return 0;

		}



		/*

		 * We cannot use NE2000 probe spaces for

		 * ISAPnP or we will lock up machines

		 */

		if ((Port < 0x280) || (Port > 0x380))

		{

			return Port;

		}

	}

}

static BOOLEAN IsolateReadDataPortSelect(VOID)
{
   11380:	55                   	push   %ebp
   11381:	89 e5                	mov    %esp,%ebp
   11383:	50                   	push   %eax
   11384:	50                   	push   %eax
  ULONG Port;

	SendWait();
   11385:	e8 36 ff ff ff       	call   112c0 <_SendWait>
	SendKey();
   1138a:	e8 81 fe ff ff       	call   11210 <_SendKey>

	/* Control: reset CSN and conditionally everything else too */
	WriteUchar(0x02, 0x05);
   1138f:	50                   	push   %eax
   11390:	50                   	push   %eax
   11391:	6a 05                	push   $0x5
   11393:	6a 02                	push   $0x2
   11395:	e8 76 fd ff ff       	call   11110 <_WriteUchar>
	KeStallExecutionProcessor(2000);
   1139a:	c7 04 24 d0 07 00 00 	movl   $0x7d0,(%esp)
   113a1:	e8 aa 19 00 00       	call   12d50 <_KeStallExecutionProcessor@4>

	SendWait();
   113a6:	83 c4 0c             	add    $0xc,%esp
   113a9:	e8 12 ff ff ff       	call   112c0 <_SendWait>
	SendKey();
   113ae:	e8 5d fe ff ff       	call   11210 <_SendKey>
	SendWake(0x00);
   113b3:	83 ec 0c             	sub    $0xc,%esp
   113b6:	6a 00                	push   $0x0
   113b8:	e8 23 ff ff ff       	call   112e0 <_SendWake>
   113bd:	83 c4 10             	add    $0x10,%esp
   113c0:	8b 15 00 40 01 00    	mov    0x14000,%edx
   113c6:	83 c2 20             	add    $0x20,%edx
   113c9:	81 fa ff 03 00 00    	cmp    $0x3ff,%edx
   113cf:	77 11                	ja     113e2 <_IsolateReadDataPortSelect+0x62>
   113d1:	8d 82 80 fd ff ff    	lea    0xfffffd80(%edx),%eax
   113d7:	3d 00 01 00 00       	cmp    $0x100,%eax
   113dc:	76 e8                	jbe    113c6 <_IsolateReadDataPortSelect+0x46>

	Port = FindNextReadPort();
  if (Port == 0) {
   113de:	85 d2                	test   %edx,%edx
   113e0:	75 09                	jne    113eb <_IsolateReadDataPortSelect+0x6b>
		SendWait();
   113e2:	e8 d9 fe ff ff       	call   112c0 <_SendWait>
		return FALSE;
   113e7:	31 c0                	xor    %eax,%eax
	}

	SetReadDataPort(Port);
	KeStallExecutionProcessor(1000);
  WriteAddress(0x01);
	KeStallExecutionProcessor(1000);
	return TRUE;
}
   113e9:	c9                   	leave  
   113ea:	c3                   	ret    
   113eb:	89 15 00 40 01 00    	mov    %edx,0x14000
   113f1:	c1 ea 02             	shr    $0x2,%edx
   113f4:	50                   	push   %eax
   113f5:	50                   	push   %eax
   113f6:	31 c0                	xor    %eax,%eax
   113f8:	88 d0                	mov    %dl,%al
   113fa:	50                   	push   %eax
   113fb:	6a 00                	push   $0x0
   113fd:	e8 0e fd ff ff       	call   11110 <_WriteUchar>
   11402:	c7 04 24 64 00 00 00 	movl   $0x64,(%esp)
   11409:	e8 42 19 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   1140e:	68 e8 03 00 00       	push   $0x3e8
   11413:	e8 38 19 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11418:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
   1141f:	68 79 02 00 00       	push   $0x279
   11424:	e8 17 19 00 00       	call   12d40 <_WRITE_PORT_UCHAR@8>
   11429:	51                   	push   %ecx
   1142a:	6a 14                	push   $0x14
   1142c:	e8 1f 19 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11431:	68 e8 03 00 00       	push   $0x3e8
   11436:	e8 15 19 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   1143b:	b8 01 00 00 00       	mov    $0x1,%eax
   11440:	c9                   	leave  
   11441:	c3                   	ret    
   11442:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11449:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011450 <_Peek>:

/*
 * Isolate (assign uniqued CSN) to all ISA PnP devices
 */
static ULONG IsolatePnPCards(VOID)
{
	UCHAR checksum = 0x6a;
	UCHAR chksum = 0x00;
	UCHAR bit = 0x00;
	ULONG data;
	ULONG csn = 0;
	ULONG i;
	ULONG iteration = 1;

  DPRINT("Called\n");

	IsaPnPReadPort = (PUCHAR)ISAPNP_MIN_READ_PORT;
  if (!IsolateReadDataPortSelect()) {
    DPRINT("Could not set read data port\n");
		return 0;
  }

	while (TRUE) {
		for (i = 1; i <= 64; i++) {
			data = ReadData() << 8;
			KeStallExecutionProcessor(250);
			data = data | ReadData();
			KeStallExecutionProcessor(250);
			if (data == 0x55aa)
				bit = 0x01;
			checksum = ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7) | (checksum >> 1);
			bit = 0x00;
		}
		for (i = 65; i <= 72; i++) {
			data = ReadData() << 8;
			KeStallExecutionProcessor(250);
			data = data | ReadData();
			KeStallExecutionProcessor(250);
			if (data == 0x55aa)
				chksum |= (1 << (i - 65));
		}
		if ((checksum != 0x00) && (checksum == chksum)) {
			csn++;

			WriteUchar(0x06, csn);
			KeStallExecutionProcessor(250);
			iteration++;
			SendWake(0x00);
			SetReadDataPort((ULONG)IsaPnPReadPort);
			KeStallExecutionProcessor(1000);
			WriteAddress(0x01);
			KeStallExecutionProcessor(1000);
			goto next;
		}
		if (iteration == 1) {
			IsaPnPReadPort += READ_DATA_PORT_STEP;
      if (!IsolateReadDataPortSelect()) {
        DPRINT("Could not set read data port\n");
				return 0;
      }
		} else if (iteration > 1) {
			break;
		}
next:
		checksum = 0x6a;
		chksum = 0x00;
		bit = 0x00;
	}
	SendWait();
	return csn;
}


VOID Peek(PUCHAR Data, ULONG Count)
{
   11450:	55                   	push   %ebp
   11451:	89 e5                	mov    %esp,%ebp
   11453:	57                   	push   %edi
   11454:	56                   	push   %esi
   11455:	53                   	push   %ebx
   11456:	83 ec 0c             	sub    $0xc,%esp
	ULONG i, j;
	UCHAR d = 0;

	for (i = 1; i <= Count; i++) {
   11459:	bf 01 00 00 00       	mov    $0x1,%edi
   1145e:	8b 75 08             	mov    0x8(%ebp),%esi
   11461:	3b 7d 0c             	cmp    0xc(%ebp),%edi
   11464:	77 48                	ja     114ae <_Peek+0x5e>
		for (j = 0; j < 20; j++) {
   11466:	31 db                	xor    %ebx,%ebx
   11468:	eb 19                	jmp    11483 <_Peek+0x33>
   1146a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
			d = ReadUchar(0x05);
			if (d & 0x1)
				break;
			KeStallExecutionProcessor(100);
   11470:	83 ec 0c             	sub    $0xc,%esp
   11473:	43                   	inc    %ebx
   11474:	6a 64                	push   $0x64
   11476:	e8 d5 18 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   1147b:	83 c4 0c             	add    $0xc,%esp
   1147e:	83 fb 13             	cmp    $0x13,%ebx
   11481:	77 33                	ja     114b6 <_Peek+0x66>
   11483:	83 ec 0c             	sub    $0xc,%esp
   11486:	6a 05                	push   $0x5
   11488:	e8 73 fb ff ff       	call   11000 <_ReadUchar>
   1148d:	83 c4 10             	add    $0x10,%esp
   11490:	a8 01                	test   $0x1,%al
   11492:	74 dc                	je     11470 <_Peek+0x20>
		}
		if (!(d & 0x1)) {
			if (Data != NULL)
				*Data++ = 0xff;
			continue;
		}
		d = ReadUchar(0x04); /* PRESDI */
   11494:	83 ec 0c             	sub    $0xc,%esp
   11497:	6a 04                	push   $0x4
   11499:	e8 62 fb ff ff       	call   11000 <_ReadUchar>
		if (Data != NULL)
   1149e:	83 c4 10             	add    $0x10,%esp
   114a1:	85 f6                	test   %esi,%esi
   114a3:	74 03                	je     114a8 <_Peek+0x58>
			*Data++ = d;
   114a5:	88 06                	mov    %al,(%esi)
   114a7:	46                   	inc    %esi
   114a8:	47                   	inc    %edi
   114a9:	3b 7d 0c             	cmp    0xc(%ebp),%edi
   114ac:	76 b8                	jbe    11466 <_Peek+0x16>
   114ae:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   114b1:	5b                   	pop    %ebx
   114b2:	5e                   	pop    %esi
   114b3:	5f                   	pop    %edi
   114b4:	5d                   	pop    %ebp
   114b5:	c3                   	ret    
   114b6:	85 f6                	test   %esi,%esi
   114b8:	74 ee                	je     114a8 <_Peek+0x58>
   114ba:	c6 06 ff             	movb   $0xff,(%esi)
   114bd:	46                   	inc    %esi
   114be:	eb e8                	jmp    114a8 <_Peek+0x58>

000114c0 <_Skip>:
	}
}


/*
 * Skip specified number of bytes from stream
 */
static VOID Skip(ULONG Count)
{
   114c0:	55                   	push   %ebp
   114c1:	89 e5                	mov    %esp,%ebp
   114c3:	83 ec 10             	sub    $0x10,%esp
	Peek(NULL, Count);
   114c6:	50                   	push   %eax
   114c7:	6a 00                	push   $0x0
   114c9:	e8 82 ff ff ff       	call   11450 <_Peek>
   114ce:	c9                   	leave  
   114cf:	c3                   	ret    

000114d0 <_ReadTag>:
}


/*
 * Read one tag from stream
 */
static BOOLEAN ReadTag(PUCHAR Type,
  PUSHORT Size,
  PBOOLEAN Small)
{
   114d0:	55                   	push   %ebp
   114d1:	89 e5                	mov    %esp,%ebp
   114d3:	57                   	push   %edi
   114d4:	56                   	push   %esi
   114d5:	53                   	push   %ebx
   114d6:	83 ec 14             	sub    $0x14,%esp
   114d9:	89 c3                	mov    %eax,%ebx
	UCHAR tag, tmp[2];

	Peek(&tag, 1);
   114db:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   114de:	89 d6                	mov    %edx,%esi
   114e0:	6a 01                	push   $0x1
   114e2:	8b 7d 08             	mov    0x8(%ebp),%edi
   114e5:	50                   	push   %eax
   114e6:	e8 65 ff ff ff       	call   11450 <_Peek>
  if (tag == 0) {
   114eb:	8a 55 f3             	mov    0xfffffff3(%ebp),%dl
   114ee:	83 c4 10             	add    $0x10,%esp
    /* Invalid tag */
    DPRINT("Invalid tag with value 0\n");
#ifndef NDEBUG
    for (;;);
#endif
		return FALSE;
   114f1:	31 c0                	xor    %eax,%eax
   114f3:	84 d2                	test   %dl,%dl
   114f5:	74 21                	je     11518 <_ReadTag+0x48>
  }

	if (tag & ISAPNP_RESOURCE_ITEM_TYPE) {
   114f7:	7c 2f                	jl     11528 <_ReadTag+0x58>
    /* Large resource item */
		*Type = (tag & 0x7f);
		Peek(tmp, 2);
		*Size = UCHAR2USHORT(tmp[0], tmp[1]);
    *Small = FALSE;
#ifndef NDEBUG
    if (*Type > ISAPNP_LRIN_FL_MEMORY_RANGE32) {
      DPRINT("Invalid large tag with value 0x%X\n", *Type);
      for (;;);
    }
#endif
	} else {
    /* Small resource item */
		*Type = (tag >> 3) & 0x0f;
   114f9:	88 d0                	mov    %dl,%al
   114fb:	c0 e8 03             	shr    $0x3,%al
   114fe:	83 e0 0f             	and    $0xf,%eax
   11501:	88 03                	mov    %al,(%ebx)
		*Size = tag & 0x07;
   11503:	89 d0                	mov    %edx,%eax
   11505:	83 e0 07             	and    $0x7,%eax
   11508:	66 89 06             	mov    %ax,(%esi)
    *Small = TRUE;
   1150b:	c6 07 01             	movb   $0x1,(%edi)
#ifndef NDEBUG
    if (*Type > ISAPNP_SRIN_END_TAG) {
      DPRINT("Invalid small tag with value 0x%X\n", *Type);
      for (;;);
    }
#endif
  }

	DPRINT("Tag = 0x%X, Type = 0x%X, Size = %d (%s)\n",
    tag, *Type, *Size, TagName(*Type, *Small));

  /* Probably invalid data */
  if ((*Type == 0xff) && (*Size == 0xffff)) {
   1150e:	80 3b ff             	cmpb   $0xff,(%ebx)
   11511:	74 0d                	je     11520 <_ReadTag+0x50>
    DPRINT("Invalid data (Type 0x%X  Size 0x%X)\n", *Type, *Size);
    for (;;);
		return FALSE;
  }

	return TRUE;
   11513:	b8 01 00 00 00       	mov    $0x1,%eax
}
   11518:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1151b:	5b                   	pop    %ebx
   1151c:	5e                   	pop    %esi
   1151d:	5f                   	pop    %edi
   1151e:	5d                   	pop    %ebp
   1151f:	c3                   	ret    
   11520:	66 83 3e ff          	cmpw   $0xffffffff,(%esi)
   11524:	75 ed                	jne    11513 <_ReadTag+0x43>
   11526:	eb fe                	jmp    11526 <_ReadTag+0x56>
   11528:	83 e2 7f             	and    $0x7f,%edx
   1152b:	88 13                	mov    %dl,(%ebx)
   1152d:	50                   	push   %eax
   1152e:	50                   	push   %eax
   1152f:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11532:	6a 02                	push   $0x2
   11534:	50                   	push   %eax
   11535:	e8 16 ff ff ff       	call   11450 <_Peek>
   1153a:	31 d2                	xor    %edx,%edx
   1153c:	8a 55 f1             	mov    0xfffffff1(%ebp),%dl
   1153f:	31 c0                	xor    %eax,%eax
   11541:	8a 45 f0             	mov    0xfffffff0(%ebp),%al
   11544:	83 c4 10             	add    $0x10,%esp
   11547:	c1 e2 08             	shl    $0x8,%edx
   1154a:	09 d0                	or     %edx,%eax
   1154c:	66 89 06             	mov    %ax,(%esi)
   1154f:	c6 07 00             	movb   $0x0,(%edi)
   11552:	eb ba                	jmp    1150e <_ReadTag+0x3e>
   11554:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1155a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011560 <_ParseAnsiName>:


/*
 * Parse ANSI name for ISA PnP logical device
 */
static NTSTATUS ParseAnsiName(PUNICODE_STRING Name, PUSHORT Size)
{
   11560:	55                   	push   %ebp
   11561:	89 e5                	mov    %esp,%ebp
   11563:	57                   	push   %edi
   11564:	56                   	push   %esi
   11565:	53                   	push   %ebx
   11566:	81 ec 1c 01 00 00    	sub    $0x11c,%esp
   1156c:	89 d7                	mov    %edx,%edi
  ANSI_STRING AnsiString;
  UCHAR Buffer[256];
  USHORT size1;

  size1 = (*Size >= sizeof(Buffer)) ? (sizeof(Buffer) - 1) : *Size;
   1156e:	66 8b 32             	mov    (%edx),%si
   11571:	89 85 dc fe ff ff    	mov    %eax,0xfffffedc(%ebp)
   11577:	66 81 fe ff 00       	cmp    $0xff,%si
   1157c:	76 05                	jbe    11583 <_ParseAnsiName+0x23>
   1157e:	be ff 00 00 00       	mov    $0xff,%esi

  Peek(Buffer, size1);
   11583:	89 f3                	mov    %esi,%ebx
   11585:	8d 85 e8 fe ff ff    	lea    0xfffffee8(%ebp),%eax
   1158b:	81 e3 ff ff 00 00    	and    $0xffff,%ebx
   11591:	52                   	push   %edx
   11592:	52                   	push   %edx
   11593:	53                   	push   %ebx
   11594:	50                   	push   %eax
   11595:	e8 b6 fe ff ff       	call   11450 <_Peek>
  Buffer[size1] = '\0';
  *Size -= size1;

  /* Clean whitespace from end of string */
  while ((size1 > 0) && (Buffer[--size1] == ' ')) 
   1159a:	83 c4 10             	add    $0x10,%esp
   1159d:	66 29 37             	sub    %si,(%edi)
   115a0:	c6 84 2b e8 fe ff ff 	movb   $0x0,0xfffffee8(%ebx,%ebp,1)
   115a7:	00 
    Buffer[size1] = '\0';
   115a8:	66 85 f6             	test   %si,%si
   115ab:	74 23                	je     115d0 <_ParseAnsiName+0x70>
   115ad:	4e                   	dec    %esi
   115ae:	89 f0                	mov    %esi,%eax
   115b0:	25 ff ff 00 00       	and    $0xffff,%eax
   115b5:	80 bc 28 e8 fe ff ff 	cmpb   $0x20,0xfffffee8(%eax,%ebp,1)
   115bc:	20 
   115bd:	75 11                	jne    115d0 <_ParseAnsiName+0x70>
   115bf:	66 85 f6             	test   %si,%si
   115c2:	c6 84 28 e8 fe ff ff 	movb   $0x0,0xfffffee8(%eax,%ebp,1)
   115c9:	00 
   115ca:	75 e1                	jne    115ad <_ParseAnsiName+0x4d>
   115cc:	8d 74 26 00          	lea    0x0(%esi),%esi

  DPRINT("ANSI name: %s\n", Buffer);

  RtlInitAnsiString(&AnsiString, (PCSZ)&Buffer);
   115d0:	8d 9d e0 fe ff ff    	lea    0xfffffee0(%ebp),%ebx
   115d6:	50                   	push   %eax
   115d7:	50                   	push   %eax
   115d8:	8d 85 e8 fe ff ff    	lea    0xfffffee8(%ebp),%eax
   115de:	50                   	push   %eax
   115df:	53                   	push   %ebx
   115e0:	e8 9b 16 00 00       	call   12c80 <_RtlInitAnsiString@8>
  return RtlAnsiStringToUnicodeString(Name, &AnsiString, TRUE);
   115e5:	8b 85 dc fe ff ff    	mov    0xfffffedc(%ebp),%eax
   115eb:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
   115f2:	53                   	push   %ebx
   115f3:	50                   	push   %eax
   115f4:	e8 97 16 00 00       	call   12c90 <_RtlAnsiStringToUnicodeString@12>
}
   115f9:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   115fc:	5b                   	pop    %ebx
   115fd:	5e                   	pop    %esi
   115fe:	5f                   	pop    %edi
   115ff:	5d                   	pop    %ebp
   11600:	c3                   	ret    
   11601:	eb 0d                	jmp    11610 <_AddResourceDescriptor>
   11603:	90                   	nop    
   11604:	90                   	nop    
   11605:	90                   	nop    
   11606:	90                   	nop    
   11607:	90                   	nop    
   11608:	90                   	nop    
   11609:	90                   	nop    
   1160a:	90                   	nop    
   1160b:	90                   	nop    
   1160c:	90                   	nop    
   1160d:	90                   	nop    
   1160e:	90                   	nop    
   1160f:	90                   	nop    

00011610 <_AddResourceDescriptor>:


/*
 * Add a resource list to the
 * resource lists of a logical device
 */
static NTSTATUS AddResourceList(
  PISAPNP_LOGICAL_DEVICE LogicalDevice,
  ULONG Priority,
  PISAPNP_CONFIGURATION_LIST *NewList)
{
  PISAPNP_CONFIGURATION_LIST List;

  DPRINT("Adding resource list for logical device %d on card %d (Priority %d)\n",
        LogicalDevice->Number,
        LogicalDevice->Card->CardId,
        Priority);

  List = (PISAPNP_CONFIGURATION_LIST)
      ExAllocatePool(PagedPool, sizeof(ISAPNP_CONFIGURATION_LIST));
  if (!List)
    return STATUS_INSUFFICIENT_RESOURCES;

  RtlZeroMemory(List, sizeof(ISAPNP_CONFIGURATION_LIST));

  List->Priority = Priority;

  InitializeListHead(&List->ListHead);

  InsertTailList(&LogicalDevice->Configuration, &List->ListEntry);

  *NewList = List;

  return STATUS_SUCCESS;
}


/*
 * Add a resource entry to the
 * resource list of a logical device
 */
static NTSTATUS AddResourceDescriptor(
  PISAPNP_LOGICAL_DEVICE LogicalDevice,
  ULONG Priority,
  ULONG Option,
  PISAPNP_DESCRIPTOR *Descriptor)
{
   11610:	55                   	push   %ebp
   11611:	89 e5                	mov    %esp,%ebp
   11613:	57                   	push   %edi
   11614:	56                   	push   %esi
   11615:	53                   	push   %ebx
   11616:	83 ec 14             	sub    $0x14,%esp
   11619:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   1161c:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
  PLIST_ENTRY CurrentEntry;
  PISAPNP_CONFIGURATION_LIST List;
  PISAPNP_DESCRIPTOR d;
  NTSTATUS Status;

  DPRINT("Adding resource descriptor for logical device %d on card %d (%d of %d)\n",
        LogicalDevice->Number,
        LogicalDevice->Card->CardId,
        LogicalDevice->CurrentDescriptorCount,
        LogicalDevice->DescriptorCount);

  d = (PISAPNP_DESCRIPTOR)
   1161f:	6a 28                	push   $0x28
   11621:	6a 01                	push   $0x1
   11623:	e8 78 16 00 00       	call   12ca0 <_ExAllocatePool@8>
   11628:	89 c7                	mov    %eax,%edi
    ExAllocatePool(PagedPool, sizeof(ISAPNP_DESCRIPTOR));
  if (!d)
   1162a:	5e                   	pop    %esi
   1162b:	85 ff                	test   %edi,%edi
   1162d:	58                   	pop    %eax
    return STATUS_NO_MEMORY;
   1162e:	b8 17 00 00 c0       	mov    $0xc0000017,%eax
   11633:	0f 84 a5 00 00 00    	je     116de <_AddResourceDescriptor+0xce>

  RtlZeroMemory(d, sizeof(ISAPNP_DESCRIPTOR));
   11639:	53                   	push   %ebx
   1163a:	53                   	push   %ebx
   1163b:	6a 28                	push   $0x28
   1163d:	57                   	push   %edi
   1163e:	e8 6d 16 00 00       	call   12cb0 <_RtlZeroMemory@8>

  d->Descriptor.Option = Option;
   11643:	8b 45 08             	mov    0x8(%ebp),%eax
   11646:	88 47 08             	mov    %al,0x8(%edi)

  *Descriptor = d;
   11649:	8b 45 0c             	mov    0xc(%ebp),%eax

  CurrentEntry = LogicalDevice->Configuration.Flink;
   1164c:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   1164f:	89 38                	mov    %edi,(%eax)
   11651:	8b 82 ac 00 00 00    	mov    0xac(%edx),%eax
  while (CurrentEntry != &LogicalDevice->Configuration) {
   11657:	5e                   	pop    %esi
    List = CONTAINING_RECORD(
      CurrentEntry, ISAPNP_CONFIGURATION_LIST, ListEntry);

    if (List->Priority == Priority) {

      LogicalDevice->ConfigurationSize += sizeof(IO_RESOURCE_DESCRIPTOR);
      InsertTailList(&List->ListHead, &d->ListEntry);
      LogicalDevice->CurrentDescriptorCount++;
      if (LogicalDevice->DescriptorCount <
        LogicalDevice->CurrentDescriptorCount) {
        LogicalDevice->DescriptorCount =
          LogicalDevice->CurrentDescriptorCount;
      }

      return STATUS_SUCCESS;
    }
    CurrentEntry = CurrentEntry->Flink;
   11658:	89 d6                	mov    %edx,%esi
   1165a:	59                   	pop    %ecx
   1165b:	81 c6 ac 00 00 00    	add    $0xac,%esi
   11661:	eb 0a                	jmp    1166d <_AddResourceDescriptor+0x5d>
   11663:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11666:	39 50 08             	cmp    %edx,0x8(%eax)
   11669:	74 7b                	je     116e6 <_AddResourceDescriptor+0xd6>
   1166b:	8b 00                	mov    (%eax),%eax
   1166d:	39 c6                	cmp    %eax,%esi
   1166f:	75 f2                	jne    11663 <_AddResourceDescriptor+0x53>
   11671:	51                   	push   %ecx
   11672:	51                   	push   %ecx
   11673:	6a 14                	push   $0x14
   11675:	6a 01                	push   $0x1
   11677:	e8 24 16 00 00       	call   12ca0 <_ExAllocatePool@8>
   1167c:	b9 9a 00 00 c0       	mov    $0xc000009a,%ecx
   11681:	5b                   	pop    %ebx
   11682:	85 c0                	test   %eax,%eax
   11684:	5a                   	pop    %edx
   11685:	89 c3                	mov    %eax,%ebx
   11687:	74 53                	je     116dc <_AddResourceDescriptor+0xcc>
   11689:	51                   	push   %ecx
   1168a:	51                   	push   %ecx
   1168b:	6a 14                	push   $0x14
   1168d:	50                   	push   %eax
   1168e:	e8 1d 16 00 00       	call   12cb0 <_RtlZeroMemory@8>
   11693:	58                   	pop    %eax
   11694:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11697:	5a                   	pop    %edx
   11698:	89 43 08             	mov    %eax,0x8(%ebx)
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   1169b:	8d 43 0c             	lea    0xc(%ebx),%eax
	ListHead->Flink = ListHead->Blink = ListHead;
}


/*
 * VOID
 * InsertHeadList (
 *		PLIST_ENTRY	ListHead,
 *		PLIST_ENTRY	Entry
 *		);
 *
 * FUNCTION: Inserts an entry in a double linked list
 * ARGUMENTS:
 *        ListHead = Head of the list
 *        Entry = Entry to insert
 */
static __inline VOID
InsertHeadList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldFlink;
	OldFlink = ListHead->Flink;
	Entry->Flink = OldFlink;
	Entry->Blink = ListHead;
	OldFlink->Blink = Entry;
	ListHead->Flink = Entry;
}


/*
 * VOID
 * InsertTailList (
 *		PLIST_ENTRY	ListHead,
 *		PLIST_ENTRY	Entry
 *		);
 *
 * FUNCTION:
 *	Inserts an entry in a double linked list
 *
 * ARGUMENTS:
 *	ListHead = Head of the list
 *	Entry = Entry to insert
 */
static __inline VOID
InsertTailList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
   1169e:	89 33                	mov    %esi,(%ebx)
   116a0:	89 43 0c             	mov    %eax,0xc(%ebx)
  InitializeListHead(&List->ListHead);

  InsertTailList(&LogicalDevice->Configuration, &List->ListEntry);

  *NewList = List;
   116a3:	31 c9                	xor    %ecx,%ecx
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   116a5:	89 40 04             	mov    %eax,0x4(%eax)
}


/*
 * VOID
 * InsertHeadList (
 *		PLIST_ENTRY	ListHead,
 *		PLIST_ENTRY	Entry
 *		);
 *
 * FUNCTION: Inserts an entry in a double linked list
 * ARGUMENTS:
 *        ListHead = Head of the list
 *        Entry = Entry to insert
 */
static __inline VOID
InsertHeadList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldFlink;
	OldFlink = ListHead->Flink;
	Entry->Flink = OldFlink;
	Entry->Blink = ListHead;
	OldFlink->Blink = Entry;
	ListHead->Flink = Entry;
}


/*
 * VOID
 * InsertTailList (
 *		PLIST_ENTRY	ListHead,
 *		PLIST_ENTRY	Entry
 *		);
 *
 * FUNCTION:
 *	Inserts an entry in a double linked list
 *
 * ARGUMENTS:
 *	ListHead = Head of the list
 *	Entry = Entry to insert
 */
static __inline VOID
InsertTailList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   116a8:	8b 56 04             	mov    0x4(%esi),%edx
	Entry->Flink = ListHead;
	Entry->Blink = OldBlink;
   116ab:	89 53 04             	mov    %edx,0x4(%ebx)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   116ae:	89 5e 04             	mov    %ebx,0x4(%esi)
   116b1:	89 1a                	mov    %ebx,(%edx)

  return STATUS_SUCCESS;
}


/*
 * Add a resource entry to the
 * resource list of a logical device
 */
static NTSTATUS AddResourceDescriptor(
  PISAPNP_LOGICAL_DEVICE LogicalDevice,
  ULONG Priority,
  ULONG Option,
  PISAPNP_DESCRIPTOR *Descriptor)
{
  PLIST_ENTRY CurrentEntry;
  PISAPNP_CONFIGURATION_LIST List;
  PISAPNP_DESCRIPTOR d;
  NTSTATUS Status;

  DPRINT("Adding resource descriptor for logical device %d on card %d (%d of %d)\n",
        LogicalDevice->Number,
        LogicalDevice->Card->CardId,
        LogicalDevice->CurrentDescriptorCount,
        LogicalDevice->DescriptorCount);

  d = (PISAPNP_DESCRIPTOR)
    ExAllocatePool(PagedPool, sizeof(ISAPNP_DESCRIPTOR));
  if (!d)
    return STATUS_NO_MEMORY;

  RtlZeroMemory(d, sizeof(ISAPNP_DESCRIPTOR));

  d->Descriptor.Option = Option;

  *Descriptor = d;

  CurrentEntry = LogicalDevice->Configuration.Flink;
  while (CurrentEntry != &LogicalDevice->Configuration) {
    List = CONTAINING_RECORD(
      CurrentEntry, ISAPNP_CONFIGURATION_LIST, ListEntry);

    if (List->Priority == Priority) {

      LogicalDevice->ConfigurationSize += sizeof(IO_RESOURCE_DESCRIPTOR);
      InsertTailList(&List->ListHead, &d->ListEntry);
      LogicalDevice->CurrentDescriptorCount++;
      if (LogicalDevice->DescriptorCount <
        LogicalDevice->CurrentDescriptorCount) {
        LogicalDevice->DescriptorCount =
          LogicalDevice->CurrentDescriptorCount;
      }

      return STATUS_SUCCESS;
    }
    CurrentEntry = CurrentEntry->Flink;
  }

  Status = AddResourceList(LogicalDevice, Priority, &List);
  if (NT_SUCCESS(Status)) {
    LogicalDevice->ConfigurationSize += sizeof(IO_RESOURCE_LIST);
   116b3:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
   116b6:	89 07                	mov    %eax,(%edi)
   116b8:	8b 9a b4 00 00 00    	mov    0xb4(%edx),%ebx
    LogicalDevice->CurrentDescriptorCount = 0;
   116be:	c7 82 bc 00 00 00 00 	movl   $0x0,0xbc(%edx)
   116c5:	00 00 00 
   116c8:	83 c3 28             	add    $0x28,%ebx
   116cb:	89 9a b4 00 00 00    	mov    %ebx,0xb4(%edx)
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   116d1:	8b 50 04             	mov    0x4(%eax),%edx
	Entry->Flink = ListHead;
	Entry->Blink = OldBlink;
   116d4:	89 57 04             	mov    %edx,0x4(%edi)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   116d7:	89 78 04             	mov    %edi,0x4(%eax)
   116da:	89 3a                	mov    %edi,(%edx)
    InsertTailList(&List->ListHead, &d->ListEntry);
  }

  return Status;
   116dc:	89 c8                	mov    %ecx,%eax
}
   116de:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   116e1:	5b                   	pop    %ebx
   116e2:	5e                   	pop    %esi
   116e3:	5f                   	pop    %edi
   116e4:	5d                   	pop    %ebp
   116e5:	c3                   	ret    
   116e6:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
static __inline VOID
InsertTailList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   116e9:	83 c0 0c             	add    $0xc,%eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
   116ec:	89 07                	mov    %eax,(%edi)
   116ee:	8b 9a b4 00 00 00    	mov    0xb4(%edx),%ebx
   116f4:	83 c3 20             	add    $0x20,%ebx
   116f7:	89 9a b4 00 00 00    	mov    %ebx,0xb4(%edx)
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   116fd:	8b 50 04             	mov    0x4(%eax),%edx
	Entry->Flink = ListHead;
	Entry->Blink = OldBlink;
   11700:	89 57 04             	mov    %edx,0x4(%edi)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   11703:	89 78 04             	mov    %edi,0x4(%eax)
   11706:	89 3a                	mov    %edi,(%edx)
   11708:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   1170b:	8b 82 bc 00 00 00    	mov    0xbc(%edx),%eax
   11711:	40                   	inc    %eax
   11712:	89 82 bc 00 00 00    	mov    %eax,0xbc(%edx)
   11718:	39 82 b8 00 00 00    	cmp    %eax,0xb8(%edx)
   1171e:	73 06                	jae    11726 <_AddResourceDescriptor+0x116>
   11720:	89 82 b8 00 00 00    	mov    %eax,0xb8(%edx)
   11726:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11729:	31 c0                	xor    %eax,%eax
   1172b:	5b                   	pop    %ebx
   1172c:	5e                   	pop    %esi
   1172d:	5f                   	pop    %edi
   1172e:	5d                   	pop    %ebp
   1172f:	c3                   	ret    

00011730 <_ParseLogicalDevice>:


/*
 * Add IRQ resource to resources list
 */
static NTSTATUS AddIrqResource(
  PISAPNP_LOGICAL_DEVICE LogicalDevice,
  ULONG Size,
  ULONG Priority,
  ULONG Option)
{
  PISAPNP_DESCRIPTOR Descriptor;
	UCHAR tmp[3];
  ULONG irq, i, last = 0;
  BOOLEAN found;
  NTSTATUS Status;

	Peek(tmp, Size);

	irq = UCHAR2USHORT(tmp[0], tmp[0]);

  DPRINT("IRQ bitmask: 0x%X\n", irq);

  found = FALSE;
  for (i = 0; i < 16; i++) {
    if (!found && (irq & (1 << i))) {
      last = i;
      found = TRUE;
    }

    if ((found && !(irq & (1 << i))) || (irq & (1 << i) && (i == 15))) {
      Status = AddResourceDescriptor(LogicalDevice,
        Priority, Option, &Descriptor);
      if (!NT_SUCCESS(Status))
        return Status;
      Descriptor->Descriptor.Type = CmResourceTypeInterrupt;
      Descriptor->Descriptor.ShareDisposition = CmResourceShareDeviceExclusive;
      Descriptor->Descriptor.u.Interrupt.MinimumVector = last;

      if ((irq & (1 << i)) && (i == 15))
        Descriptor->Descriptor.u.Interrupt.MaximumVector = i;
      else
        Descriptor->Descriptor.u.Interrupt.MaximumVector = i - 1;

      DPRINT("Found IRQ range %d - %d for logical device %d on card %d\n",
        Descriptor->Descriptor.u.Interrupt.MinimumVector,
        Descriptor->Descriptor.u.Interrupt.MaximumVector,
        LogicalDevice->Number,
        LogicalDevice->Card->CardId);

      found = FALSE;
    }
  }

  return STATUS_SUCCESS;
}

/*
 * Add DMA resource to resources list
 */
static NTSTATUS AddDmaResource(
  PISAPNP_LOGICAL_DEVICE LogicalDevice,
  ULONG Size,
  ULONG Priority,
  ULONG Option)
{
  PISAPNP_DESCRIPTOR Descriptor;
	UCHAR tmp[2];
  ULONG dma, flags, i, last = 0;
  BOOLEAN found;
  NTSTATUS Status;

	Peek(tmp, Size);

	dma = tmp[0];
  flags = tmp[1];

  DPRINT("DMA bitmask: 0x%X\n", dma);

  found = FALSE;
  for (i = 0; i < 8; i++) {
    if (!found && (dma & (1 << i))) {
      last = i;
      found = TRUE;
    }

    if ((found && !(dma & (1 << i))) || (dma & (1 << i) && (i == 15))) {
      Status = AddResourceDescriptor(LogicalDevice,
        Priority, Option, &Descriptor);
      if (!NT_SUCCESS(Status))
        return Status;
      Descriptor->Descriptor.Type = CmResourceTypeDma;
      Descriptor->Descriptor.ShareDisposition = CmResourceShareDeviceExclusive;
      Descriptor->Descriptor.u.Dma.MinimumChannel = last;

      if ((dma & (1 << i)) && (i == 15))
        Descriptor->Descriptor.u.Dma.MaximumChannel = i;
      else
        Descriptor->Descriptor.u.Dma.MaximumChannel = i - 1;

      /* FIXME: Parse flags */

      DPRINT("Found DMA range %d - %d for logical device %d on card %d\n",
        Descriptor->Descriptor.u.Dma.MinimumChannel,
        Descriptor->Descriptor.u.Dma.MaximumChannel,
        LogicalDevice->Number,
        LogicalDevice->Card->CardId);

      found = FALSE;
    }
  }

  return STATUS_SUCCESS;
}

/*
 * Add port resource to resources list
 */
static NTSTATUS AddIOPortResource(
  PISAPNP_LOGICAL_DEVICE LogicalDevice,
  ULONG Size,
  ULONG Priority,
  ULONG Option)
{
#if 0
  DPRINT("I/O port: size 0x%X\n", Size);
  Skip(Size);
#else
  PISAPNP_DESCRIPTOR Descriptor;
	UCHAR tmp[7];
  NTSTATUS Status;

	Peek(tmp, Size);

  Status = AddResourceDescriptor(LogicalDevice,
    Priority, Option, &Descriptor);
  if (!NT_SUCCESS(Status))
    return Status;
  Descriptor->Descriptor.Type = CmResourceTypePort;
  Descriptor->Descriptor.ShareDisposition = CmResourceShareDeviceExclusive;
  Descriptor->Descriptor.u.Port.Length = tmp[6];
  /* FIXME: Parse flags */
  Descriptor->Descriptor.u.Port.Alignment = 0;
  Descriptor->Descriptor.u.Port.MinimumAddress.QuadPart = UCHAR2USHORT(tmp[1], tmp[2]);
  Descriptor->Descriptor.u.Port.MaximumAddress.QuadPart = UCHAR2USHORT(tmp[4], tmp[4]);

  DPRINT("Found I/O port range 0x%X - 0x%X for logical device %d on card %d\n",
    Descriptor->Descriptor.u.Port.MinimumAddress,
    Descriptor->Descriptor.u.Port.MaximumAddress,
    LogicalDevice->Number,
    LogicalDevice->Card->CardId);
#endif
  return STATUS_SUCCESS;
}

/*
 * Add fixed port resource to resources list
 */
static NTSTATUS AddFixedIOPortResource(
  PISAPNP_LOGICAL_DEVICE LogicalDevice,
  ULONG Size,
  ULONG Priority,
  ULONG Option)
{
#if 0
  DPRINT("Fixed I/O port: size 0x%X\n", Size);
  Skip(Size);
#else
  PISAPNP_DESCRIPTOR Descriptor;
	UCHAR tmp[3];
  NTSTATUS Status;

	Peek(tmp, Size);

  Status = AddResourceDescriptor(LogicalDevice,
    Priority, Option, &Descriptor);
  if (!NT_SUCCESS(Status))
    return Status;
  Descriptor->Descriptor.Type = CmResourceTypePort;
  Descriptor->Descriptor.ShareDisposition = CmResourceShareDeviceExclusive;
  Descriptor->Descriptor.u.Port.Length = tmp[2];
  Descriptor->Descriptor.u.Port.Alignment = 0;
  Descriptor->Descriptor.u.Port.MinimumAddress.QuadPart = UCHAR2USHORT(tmp[0], tmp[1]);
  Descriptor->Descriptor.u.Port.MaximumAddress.QuadPart = UCHAR2USHORT(tmp[0], tmp[1]);

  DPRINT("Found fixed I/O port range 0x%X - 0x%X for logical device %d on card %d\n",
    Descriptor->Descriptor.u.Port.MinimumAddress,
    Descriptor->Descriptor.u.Port.MaximumAddress,
    LogicalDevice->Number,
    LogicalDevice->Card->CardId);
#endif
  return STATUS_SUCCESS;
}

/*
 * Add memory resource to resources list
 */
static NTSTATUS AddMemoryResource(
  PISAPNP_LOGICAL_DEVICE LogicalDevice,
  ULONG Size,
  ULONG Priority,
  ULONG Option)
{
#if 0
  DPRINT("Memory range: size 0x%X\n", Size);
  Skip(Size);
#else
  PISAPNP_DESCRIPTOR Descriptor;
	UCHAR tmp[9];
  NTSTATUS Status;

	Peek(tmp, Size);

  Status = AddResourceDescriptor(LogicalDevice,
    Priority, Option, &Descriptor);
  if (!NT_SUCCESS(Status))
    return Status;
  Descriptor->Descriptor.Type = CmResourceTypeMemory;
  Descriptor->Descriptor.ShareDisposition = CmResourceShareDeviceExclusive;
  Descriptor->Descriptor.u.Memory.Length = UCHAR2USHORT(tmp[7], tmp[8]) << 8;
  Descriptor->Descriptor.u.Memory.Alignment = UCHAR2USHORT(tmp[5], tmp[6]);
  Descriptor->Descriptor.u.Memory.MinimumAddress.QuadPart = UCHAR2USHORT(tmp[1], tmp[2]) << 8;
  Descriptor->Descriptor.u.Memory.MaximumAddress.QuadPart = UCHAR2USHORT(tmp[3], tmp[4]) << 8;

  DPRINT("Found memory range 0x%X - 0x%X for logical device %d on card %d\n",
    Descriptor->Descriptor.u.Memory.MinimumAddress,
    Descriptor->Descriptor.u.Memory.MaximumAddress,
    LogicalDevice->Number,
    LogicalDevice->Card->CardId);
#endif
  return STATUS_SUCCESS;
}

/*
 * Add 32-bit memory resource to resources list
 */
static NTSTATUS AddMemory32Resource(
  PISAPNP_LOGICAL_DEVICE LogicalDevice,
  ULONG Size,
  ULONG Priority,
  ULONG Option)
{
#if 0
  DPRINT("Memory32 range: size 0x%X\n", Size);
  Skip(Size);
#else
  PISAPNP_DESCRIPTOR Descriptor;
	UCHAR tmp[17];
  NTSTATUS Status;

	Peek(tmp, Size);

  Status = AddResourceDescriptor(LogicalDevice,
    Priority, Option, &Descriptor);
  if (!NT_SUCCESS(Status))
    return Status;
  Descriptor->Descriptor.Type = CmResourceTypeMemory;
  Descriptor->Descriptor.ShareDisposition = CmResourceShareDeviceExclusive;
  Descriptor->Descriptor.u.Memory.Length =
    UCHAR2ULONG(tmp[13], tmp[14], tmp[15], tmp[16]);
  Descriptor->Descriptor.u.Memory.Alignment =
    UCHAR2ULONG(tmp[9], tmp[10], tmp[11], tmp[12]);
  Descriptor->Descriptor.u.Memory.MinimumAddress.QuadPart =
    UCHAR2ULONG(tmp[1], tmp[2], tmp[3], tmp[4]);
  Descriptor->Descriptor.u.Memory.MaximumAddress.QuadPart =
    UCHAR2ULONG(tmp[5], tmp[6], tmp[7], tmp[8]);

  DPRINT("Found memory32 range 0x%X - 0x%X for logical device %d on card %d\n",
    Descriptor->Descriptor.u.Memory.MinimumAddress,
    Descriptor->Descriptor.u.Memory.MaximumAddress,
    LogicalDevice->Number,
    LogicalDevice->Card->CardId);
#endif
  return STATUS_SUCCESS;
}

/*
 * Add 32-bit fixed memory resource to resources list
 */
static NTSTATUS AddFixedMemory32Resource(
  PISAPNP_LOGICAL_DEVICE LogicalDevice,
  ULONG Size,
  ULONG Priority,
  ULONG Option)
{
#if 0
  DPRINT("Memory32 range: size 0x%X\n", Size);
  Skip(Size);
#else
  PISAPNP_DESCRIPTOR Descriptor;
	UCHAR tmp[17];
  NTSTATUS Status;

	Peek(tmp, Size);

  Status = AddResourceDescriptor(LogicalDevice,
    Priority, Option, &Descriptor);
  if (!NT_SUCCESS(Status))
    return Status;
  Descriptor->Descriptor.Type = CmResourceTypeMemory;
  Descriptor->Descriptor.ShareDisposition = CmResourceShareDeviceExclusive;
  Descriptor->Descriptor.u.Memory.Length =
    UCHAR2ULONG(tmp[9], tmp[10], tmp[11], tmp[12]);
  Descriptor->Descriptor.u.Memory.Alignment =
    UCHAR2ULONG(tmp[5], tmp[6], tmp[7], tmp[8]);
  Descriptor->Descriptor.u.Memory.MinimumAddress.QuadPart =
    UCHAR2ULONG(tmp[1], tmp[2], tmp[3], tmp[4]);
  Descriptor->Descriptor.u.Memory.MaximumAddress.QuadPart =
    UCHAR2ULONG(tmp[1], tmp[2], tmp[3], tmp[4]);

  DPRINT("Found fixed memory32 range 0x%X - 0x%X for logical device %d on card %d\n",
    Descriptor->Descriptor.u.Memory.MinimumAddress,
    Descriptor->Descriptor.u.Memory.MaximumAddress,
    LogicalDevice->Number,
    LogicalDevice->Card->CardId);
#endif
  return STATUS_SUCCESS;
}


/*
 * Parse logical device tag
 */
static PISAPNP_LOGICAL_DEVICE ParseLogicalDevice(
  PISAPNP_DEVICE_EXTENSION DeviceExtension,
  PISAPNP_CARD Card,
  ULONG Size,
  USHORT Number)
{
   11730:	55                   	push   %ebp
   11731:	89 e5                	mov    %esp,%ebp
   11733:	57                   	push   %edi
   11734:	56                   	push   %esi
   11735:	53                   	push   %ebx
   11736:	83 ec 34             	sub    $0x34,%esp
   11739:	89 c6                	mov    %eax,%esi
   1173b:	8b 45 0c             	mov    0xc(%ebp),%eax
   1173e:	89 d7                	mov    %edx,%edi
   11740:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
	UCHAR tmp[6];
	PISAPNP_LOGICAL_DEVICE LogicalDevice;

  DPRINT("Card %d  Number %d\n", Card->CardId, Number);

  Peek(tmp, Size);
   11743:	8b 45 08             	mov    0x8(%ebp),%eax
   11746:	50                   	push   %eax
   11747:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
   1174a:	50                   	push   %eax
   1174b:	e8 00 fd ff ff       	call   11450 <_Peek>

  LogicalDevice = (PISAPNP_LOGICAL_DEVICE)ExAllocatePool(
   11750:	59                   	pop    %ecx
   11751:	5b                   	pop    %ebx
   11752:	68 c0 00 00 00       	push   $0xc0
   11757:	6a 01                	push   $0x1
   11759:	e8 42 15 00 00       	call   12ca0 <_ExAllocatePool@8>
   1175e:	89 c3                	mov    %eax,%ebx
    PagedPool, sizeof(ISAPNP_LOGICAL_DEVICE));
	if (!LogicalDevice)
   11760:	58                   	pop    %eax
		return NULL;
   11761:	31 c0                	xor    %eax,%eax
   11763:	5a                   	pop    %edx
   11764:	85 db                	test   %ebx,%ebx
   11766:	0f 84 8c 00 00 00    	je     117f8 <_ParseLogicalDevice+0xc8>

  RtlZeroMemory(LogicalDevice, sizeof(ISAPNP_LOGICAL_DEVICE));
   1176c:	50                   	push   %eax
   1176d:	50                   	push   %eax
   1176e:	68 c0 00 00 00       	push   $0xc0
   11773:	53                   	push   %ebx
   11774:	e8 37 15 00 00       	call   12cb0 <_RtlZeroMemory@8>

  LogicalDevice->Number = Number;
   11779:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
	LogicalDevice->VendorId = UCHAR2USHORT(tmp[0], tmp[1]);
   1177c:	31 d2                	xor    %edx,%edx
   1177e:	66 89 43 10          	mov    %ax,0x10(%ebx)
   11782:	31 c0                	xor    %eax,%eax
   11784:	8a 55 d9             	mov    0xffffffd9(%ebp),%dl
   11787:	8a 45 d8             	mov    0xffffffd8(%ebp),%al
   1178a:	c1 e2 08             	shl    $0x8,%edx
   1178d:	09 d0                	or     %edx,%eax
	LogicalDevice->DeviceId = UCHAR2USHORT(tmp[2], tmp[3]);
   1178f:	31 d2                	xor    %edx,%edx
   11791:	66 89 43 12          	mov    %ax,0x12(%ebx)
   11795:	31 c0                	xor    %eax,%eax
   11797:	8a 55 db             	mov    0xffffffdb(%ebp),%dl
   1179a:	8a 45 da             	mov    0xffffffda(%ebp),%al
   1179d:	c1 e2 08             	shl    $0x8,%edx
   117a0:	09 d0                	or     %edx,%eax
	LogicalDevice->Regs = tmp[4];
   117a2:	31 d2                	xor    %edx,%edx
   117a4:	66 89 43 14          	mov    %ax,0x14(%ebx)
   117a8:	8a 55 dc             	mov    0xffffffdc(%ebp),%dl
	LogicalDevice->Card = Card;
   117ab:	89 bb 98 00 00 00    	mov    %edi,0x98(%ebx)
   117b1:	66 89 93 96 00 00 00 	mov    %dx,0x96(%ebx)
	if (Size > 5)
   117b8:	58                   	pop    %eax
   117b9:	59                   	pop    %ecx
   117ba:	83 7d 08 05          	cmpl   $0x5,0x8(%ebp)
   117be:	77 40                	ja     11800 <_ParseLogicalDevice+0xd0>
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   117c0:	8d 83 ac 00 00 00    	lea    0xac(%ebx),%eax
	ListHead->Flink = ListHead->Blink = ListHead;
   117c6:	89 83 ac 00 00 00    	mov    %eax,0xac(%ebx)
   117cc:	89 40 04             	mov    %eax,0x4(%eax)
		LogicalDevice->Regs |= tmp[5] << 8;

  InitializeListHead(&LogicalDevice->Configuration);

  ExInterlockedInsertTailList(&Card->LogicalDevices,
   117cf:	50                   	push   %eax
   117d0:	8d 47 28             	lea    0x28(%edi),%eax
   117d3:	50                   	push   %eax
   117d4:	8d 47 20             	lea    0x20(%edi),%eax
   117d7:	53                   	push   %ebx
   117d8:	50                   	push   %eax
   117d9:	e8 e2 14 00 00       	call   12cc0 <_ExInterlockedInsertTailList@12>
    &LogicalDevice->CardListEntry,
    &Card->LogicalDevicesLock);

  ExInterlockedInsertTailList(&DeviceExtension->DeviceListHead,
   117de:	8d 46 1c             	lea    0x1c(%esi),%eax
   117e1:	50                   	push   %eax
   117e2:	8d 43 08             	lea    0x8(%ebx),%eax
   117e5:	50                   	push   %eax
   117e6:	8d 46 10             	lea    0x10(%esi),%eax
   117e9:	50                   	push   %eax
   117ea:	e8 d1 14 00 00       	call   12cc0 <_ExInterlockedInsertTailList@12>
    &LogicalDevice->DeviceListEntry,
    &DeviceExtension->GlobalListLock);

  DeviceExtension->DeviceListCount++;
   117ef:	8b 46 18             	mov    0x18(%esi),%eax
   117f2:	40                   	inc    %eax
   117f3:	89 46 18             	mov    %eax,0x18(%esi)

	return LogicalDevice;
   117f6:	89 d8                	mov    %ebx,%eax
}
   117f8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   117fb:	5b                   	pop    %ebx
   117fc:	5e                   	pop    %esi
   117fd:	5f                   	pop    %edi
   117fe:	5d                   	pop    %ebp
   117ff:	c3                   	ret    
   11800:	31 c0                	xor    %eax,%eax
   11802:	8a 45 dd             	mov    0xffffffdd(%ebp),%al
   11805:	c1 e0 08             	shl    $0x8,%eax
   11808:	09 c2                	or     %eax,%edx
   1180a:	66 89 93 96 00 00 00 	mov    %dx,0x96(%ebx)
   11811:	eb ad                	jmp    117c0 <_ParseLogicalDevice+0x90>
   11813:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11819:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011820 <_ISAPNPQueryBusRelations>:


/*
 * Parse resource map for logical device
 */
static BOOLEAN CreateLogicalDevice(PISAPNP_DEVICE_EXTENSION DeviceExtension,
  PISAPNP_CARD Card, USHORT Size)
{
	ULONG number = 0, skip = 0, compat = 0;
	UCHAR type, tmp[17];
  PISAPNP_LOGICAL_DEVICE LogicalDevice;
  BOOLEAN Small;
  ULONG Priority = 0;
  ULONG Option = IO_RESOURCE_REQUIRED;

  DPRINT("Card %d  Size %d\n", Card->CardId, Size);

  LogicalDevice = ParseLogicalDevice(DeviceExtension, Card, Size, number++);
	if (!LogicalDevice)
		return FALSE;

  while (TRUE) {
		if (!ReadTag(&type, &Size, &Small))
			return FALSE;

                if (skip && !(Small && ((type == ISAPNP_SRIN_LDEVICE_ID)
      || (type == ISAPNP_SRIN_END_TAG))))
			goto skip;

    if (Small) {
  		switch (type) {
	  	case ISAPNP_SRIN_LDEVICE_ID:
        if ((Size >= 5) && (Size <= 6)) {
          LogicalDevice = ParseLogicalDevice(
            DeviceExtension, Card, Size, number++);
	        if (!LogicalDevice)
  	        return FALSE;
  				Size = 0;
	  			skip = 0;
		  	} else {
			  	skip = 1;
			  }
        Priority = 0;
        Option = IO_RESOURCE_REQUIRED;
			  compat = 0;
			  break;

		  case ISAPNP_SRIN_CDEVICE_ID:
			  if ((Size == 4) && (compat < MAX_COMPATIBLE_ID)) {
				  Peek(tmp, 4);
				  LogicalDevice->CVendorId[compat] = UCHAR2USHORT(tmp[0], tmp[1]); 
				  LogicalDevice->CDeviceId[compat] = UCHAR2USHORT(tmp[2], tmp[3]);
				  compat++;
				  Size = 0;
			  }
			  break;

		  case ISAPNP_SRIN_IRQ_FORMAT:
  			if ((Size < 2) || (Size > 3))
				  goto skip;
			  AddIrqResource(LogicalDevice, Size, Priority, Option);
			  Size = 0;
			  break;

		  case ISAPNP_SRIN_DMA_FORMAT:
  			if (Size != 2)
				  goto skip;
        AddDmaResource(LogicalDevice, Size, Priority, Option);
			  Size = 0;
			  break;

		  case ISAPNP_SRIN_START_DFUNCTION:
  			if (Size > 1)
				  goto skip;

        if (Size > 0) {
  				Peek(tmp, Size);
          Priority = tmp[0];
				  Size = 0;
          /* FIXME: Maybe use IO_RESOURCE_PREFERRED for some */
          Option = IO_RESOURCE_ALTERNATIVE;
        } else {
          Priority = 0;
          Option = IO_RESOURCE_ALTERNATIVE;
        }

        DPRINT("   Start priority %d   \n", Priority);

        LogicalDevice->CurrentDescriptorCount = 0;

			  break;

  		case ISAPNP_SRIN_END_DFUNCTION:

        DPRINT("   End priority %d   \n", Priority);

	  		if (Size != 0)
		  		goto skip;
        Priority = 0;
        Option = IO_RESOURCE_REQUIRED;
        LogicalDevice->CurrentDescriptorCount = 0;
			  break;

  		case ISAPNP_SRIN_IO_DESCRIPTOR:
	  		if (Size != 7)
		  		goto skip;
			  AddIOPortResource(LogicalDevice, Size, Priority, Option);
			  Size = 0;
			  break;

		  case ISAPNP_SRIN_FL_IO_DESCRIPOTOR:
			  if (Size != 3)
  				goto skip;
			  AddFixedIOPortResource(LogicalDevice, Size, Priority, Option);
			  Size = 0;
			  break;

		  case ISAPNP_SRIN_VENDOR_DEFINED:
  			break;

		  case ISAPNP_SRIN_END_TAG:
			  if (Size > 0)
  				Skip(Size);
        return FALSE;

		  default:
  			DPRINT("Ignoring small tag of type 0x%X for logical device %d on card %d\n",
          type, LogicalDevice->Number, Card->CardId);
      }
    } else {
      switch (type) {
		  case ISAPNP_LRIN_MEMORY_RANGE:
			  if (Size != 9)
  				goto skip;
			  AddMemoryResource(LogicalDevice, Size, Priority, Option);
			  Size = 0;
			  break;

		  case ISAPNP_LRIN_ID_STRING_ANSI:
        ParseAnsiName(&LogicalDevice->Name, &Size);
			  break;

		  case ISAPNP_LRIN_ID_STRING_UNICODE:
  			break;

	  	case ISAPNP_LRIN_VENDOR_DEFINED:
			  break;

		  case ISAPNP_LRIN_MEMORY_RANGE32:
  			if (Size != 17)
				  goto skip;
			  AddMemory32Resource(LogicalDevice, Size, Priority, Option);
			  Size = 0;
			  break;

		  case ISAPNP_LRIN_FL_MEMORY_RANGE32:
  			if (Size != 17)
				  goto skip;
			  AddFixedMemory32Resource(LogicalDevice, Size, Priority, Option);
			  Size = 0;
			  break;

		  default:
  			DPRINT("Ignoring large tag of type 0x%X for logical device %d on card %d\n",
          type, LogicalDevice->Number, Card->CardId);
		  }
    }
skip:
  if (Size > 0)
	  Skip(Size);
	}

	return TRUE;
}


/*
 * Parse resource map for ISA PnP card
 */
static BOOLEAN ParseResourceMap(PISAPNP_DEVICE_EXTENSION DeviceExtension,
  PISAPNP_CARD Card)
{
	UCHAR type, tmp[17];
	USHORT size;
  BOOLEAN Small;

  DPRINT("Card %d\n", Card->CardId);

	while (TRUE) {
		if (!ReadTag(&type, &size, &Small))
			return FALSE;

    if (Small) {
		  switch (type) {
		  case ISAPNP_SRIN_VERSION:
  			if (size != 2)
	  			goto skip;
		  	Peek(tmp, 2);
			  Card->PNPVersion = tmp[0];
			  Card->ProductVersion = tmp[1];
			  size = 0;
			  break;

      case ISAPNP_SRIN_LDEVICE_ID:
  			if ((size >= 5) && (size <= 6)) {
				  if (!CreateLogicalDevice(DeviceExtension, Card, size))
  					return FALSE;
				  size = 0;
			  }
			  break;
  
      case ISAPNP_SRIN_CDEVICE_ID:
        /* FIXME: Parse compatible IDs */
        break;

		  case ISAPNP_SRIN_END_TAG:
			  if (size > 0)
  				Skip(size);
			  return TRUE;

		  default:
  			DPRINT("Ignoring small tag Type 0x%X for Card %d\n", type, Card->CardId);
		  }
    } else {
		  switch (type) {
		  case ISAPNP_LRIN_ID_STRING_ANSI:
  			ParseAnsiName(&Card->Name, &size);
			  break;

      default:
  			DPRINT("Ignoring large tag Type 0x%X for Card %d\n",
          type, Card->CardId);
		  }
    }
skip:
  if (size > 0)
    Skip(size);
  }

  return TRUE;
}


/*
 * Compute ISA PnP checksum for first eight bytes
 */
static UCHAR Checksum(PUCHAR data)
{
	ULONG i, j;
	UCHAR checksum = 0x6a, bit, b;

	for (i = 0; i < 8; i++) {
		b = data[i];
		for (j = 0; j < 8; j++) {
			bit = 0;
			if (b & (1 << j))
				bit = 1;
			checksum = ((((checksum ^ (checksum >> 1)) &
        0x01) ^ bit) << 7) | (checksum >> 1);
		}
	}
	return checksum;
}


/*
 * Build a resource list for a logical ISA PnP device
 */
static NTSTATUS BuildResourceList(PISAPNP_LOGICAL_DEVICE LogicalDevice,
  PIO_RESOURCE_LIST DestinationList,
  ULONG Priority)
{
  PLIST_ENTRY CurrentEntry, Entry;
  PISAPNP_CONFIGURATION_LIST List;
  PISAPNP_DESCRIPTOR Descriptor;
  ULONG i;

  if (IsListEmpty(&LogicalDevice->Configuration))
    return STATUS_NOT_FOUND;

  CurrentEntry = LogicalDevice->Configuration.Flink;
  while (CurrentEntry != &LogicalDevice->Configuration) {
    List = CONTAINING_RECORD(
      CurrentEntry, ISAPNP_CONFIGURATION_LIST, ListEntry);

    if (List->Priority == Priority) {

      DPRINT("Logical device %d  DestinationList 0x%X\n",
        LogicalDevice->Number,
        DestinationList);

      DestinationList->Version = 1;
      DestinationList->Revision = 1;
      DestinationList->Count = LogicalDevice->DescriptorCount;

      i = 0;
      Entry = List->ListHead.Flink;
      while (Entry != &List->ListHead) {
        Descriptor = CONTAINING_RECORD(
          Entry, ISAPNP_DESCRIPTOR, ListEntry);

        DPRINT("Logical device %d  Destination 0x%X(%d)\n",
          LogicalDevice->Number,
          &DestinationList->Descriptors[i],
          i);

        RtlCopyMemory(&DestinationList->Descriptors[i],
          &Descriptor->Descriptor,
          sizeof(IO_RESOURCE_DESCRIPTOR));

        i++;

        Entry = Entry->Flink;
      }

      RemoveEntryList(&List->ListEntry);

      ExFreePool(List);

      return STATUS_SUCCESS;
    }

    CurrentEntry = CurrentEntry->Flink;
  }

  return STATUS_UNSUCCESSFUL;
}


/*
 * Build resource lists for a logical ISA PnP device
 */
static NTSTATUS BuildResourceLists(PISAPNP_LOGICAL_DEVICE LogicalDevice)
{
  ULONG ListSize;
  ULONG Priority;
  ULONG SingleListSize;
  PIO_RESOURCE_LIST p;
  NTSTATUS Status;

  ListSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST)
    - sizeof(IO_RESOURCE_LIST)
    + LogicalDevice->ConfigurationSize;

  DPRINT("Logical device %d  ListSize 0x%X  ConfigurationSize 0x%X  DescriptorCount %d\n",
    LogicalDevice->Number, ListSize,
    LogicalDevice->ConfigurationSize,
    LogicalDevice->DescriptorCount);

  LogicalDevice->ResourceLists =
    (PIO_RESOURCE_REQUIREMENTS_LIST)ExAllocatePool(
      PagedPool, ListSize);
	if (!LogicalDevice->ResourceLists)
		return STATUS_INSUFFICIENT_RESOURCES;

  RtlZeroMemory(LogicalDevice->ResourceLists, ListSize);

  SingleListSize = sizeof(IO_RESOURCE_LIST) +
    (LogicalDevice->DescriptorCount - 1) *
    sizeof(IO_RESOURCE_DESCRIPTOR);

  DPRINT("SingleListSize %d\n", SingleListSize);

  Priority = 0;
  p = &LogicalDevice->ResourceLists->List[0];
  do {
    Status = BuildResourceList(LogicalDevice, p, Priority);
    if (NT_SUCCESS(Status)) {
      p = (PIO_RESOURCE_LIST)((ULONG)p + SingleListSize);
      Priority++;
    }
  } while (Status != STATUS_NOT_FOUND);

  LogicalDevice->ResourceLists->ListSize = ListSize;
  LogicalDevice->ResourceLists->AlternativeLists = Priority + 1;

  return STATUS_SUCCESS;
}


/*
 * Build resource lists for a ISA PnP card
 */
static NTSTATUS BuildResourceListsForCard(PISAPNP_CARD Card)
{
  PISAPNP_LOGICAL_DEVICE LogicalDevice;
  PLIST_ENTRY CurrentEntry;
  NTSTATUS Status;

  CurrentEntry = Card->LogicalDevices.Flink;
  while (CurrentEntry != &Card->LogicalDevices) {
    LogicalDevice = CONTAINING_RECORD(
      CurrentEntry, ISAPNP_LOGICAL_DEVICE, CardListEntry);
    Status = BuildResourceLists(LogicalDevice);
    if (!NT_SUCCESS(Status))
      return Status;
    CurrentEntry = CurrentEntry->Flink;
  }

  return STATUS_SUCCESS;
}


/*
 * Build resource lists for all present ISA PnP cards
 */
static NTSTATUS BuildResourceListsForAll(
  PISAPNP_DEVICE_EXTENSION DeviceExtension)
{
  PLIST_ENTRY CurrentEntry;
  PISAPNP_CARD Card;
  NTSTATUS Status;

  CurrentEntry = DeviceExtension->CardListHead.Flink;
  while (CurrentEntry != &DeviceExtension->CardListHead) {
    Card = CONTAINING_RECORD(
      CurrentEntry, ISAPNP_CARD, ListEntry);
    Status = BuildResourceListsForCard(Card);
    if (!NT_SUCCESS(Status))
      return Status;
    CurrentEntry = CurrentEntry->Flink;
  }

  return STATUS_SUCCESS;
}


/*
 * Build device list for all present ISA PnP cards
 */
static NTSTATUS BuildDeviceList(PISAPNP_DEVICE_EXTENSION DeviceExtension)
{
	ULONG csn;
	UCHAR header[9], checksum;
  PISAPNP_CARD Card;

  DPRINT("Called\n");

	SendWait();
	SendKey();
	for (csn = 1; csn <= 10; csn++) {
		SendWake(csn);
		Peek(header, 9);
		checksum = Checksum(header);

    if (checksum == 0x00 || checksum != header[8])  /* Invalid CSN */
			continue;

		DPRINT("VENDOR: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
			header[0], header[1], header[2], header[3],
			header[4], header[5], header[6], header[7], header[8]);

    Card = (PISAPNP_CARD)ExAllocatePool(
      PagedPool, sizeof(ISAPNP_CARD));
    if (!Card)
      return STATUS_INSUFFICIENT_RESOURCES;

    RtlZeroMemory(Card, sizeof(ISAPNP_CARD));

		Card->CardId = csn;
		Card->VendorId = (header[1] << 8) | header[0];
		Card->DeviceId = (header[3] << 8) | header[2];
		Card->Serial = (header[7] << 24) | (header[6] << 16) | (header[5] << 8) | header[4];

    InitializeListHead(&Card->LogicalDevices);
    KeInitializeSpinLock(&Card->LogicalDevicesLock);

    ParseResourceMap(DeviceExtension, Card);

    ExInterlockedInsertTailList(&DeviceExtension->CardListHead,
      &Card->ListEntry,
      &DeviceExtension->GlobalListLock);
	}

  return STATUS_SUCCESS;
}


NTSTATUS
ISAPNPQueryBusRelations(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP Irp,
  PIO_STACK_LOCATION IrpSp)
{
   11820:	55                   	push   %ebp
   11821:	89 e5                	mov    %esp,%ebp
   11823:	57                   	push   %edi
   11824:	56                   	push   %esi
   11825:	53                   	push   %ebx
   11826:	83 ec 14             	sub    $0x14,%esp
  PISAPNP_DEVICE_EXTENSION DeviceExtension;
  PISAPNP_LOGICAL_DEVICE LogicalDevice;
  PDEVICE_RELATIONS Relations;
  PLIST_ENTRY CurrentEntry;
  NTSTATUS Status = STATUS_SUCCESS;
   11829:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
  ULONG Size;
  ULONG i;

  DPRINT("Called\n");

  DeviceExtension = (PISAPNP_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
   11830:	8b 45 08             	mov    0x8(%ebp),%eax
   11833:	8b 58 28             	mov    0x28(%eax),%ebx

  if (Irp->IoStatus.Information) {
    /* FIXME: Another bus driver has already created a DEVICE_RELATIONS 
              structure so we must merge this structure with our own */
  }

  Size = sizeof(DEVICE_RELATIONS) + sizeof(Relations->Objects) *
   11836:	8b 43 18             	mov    0x18(%ebx),%eax
   11839:	8d 04 85 04 00 00 00 	lea    0x4(,%eax,4),%eax
    (DeviceExtension->DeviceListCount - 1);
  Relations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool, Size);
   11840:	50                   	push   %eax
   11841:	6a 01                	push   $0x1
   11843:	e8 58 14 00 00       	call   12ca0 <_ExAllocatePool@8>
  if (!Relations)
   11848:	59                   	pop    %ecx
   11849:	5e                   	pop    %esi
   1184a:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
    return STATUS_INSUFFICIENT_RESOURCES;
   1184d:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   11852:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   11855:	85 d2                	test   %edx,%edx
   11857:	74 7f                	je     118d8 <_ISAPNPQueryBusRelations+0xb8>

  Relations->Count = DeviceExtension->DeviceListCount;
   11859:	8b 43 18             	mov    0x18(%ebx),%eax

  i = 0;
  CurrentEntry = DeviceExtension->DeviceListHead.Flink;
   1185c:	8b 73 10             	mov    0x10(%ebx),%esi
   1185f:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
  while (CurrentEntry != &DeviceExtension->DeviceListHead) {
    LogicalDevice = CONTAINING_RECORD(
      CurrentEntry, ISAPNP_LOGICAL_DEVICE, DeviceListEntry);

    if (!LogicalDevice->Pdo) {
      /* Create a physical device object for the
         device as it does not already have one */
      Status = IoCreateDevice(DeviceObject->DriverObject, 0,
        NULL, FILE_DEVICE_CONTROLLER, 0, FALSE, &LogicalDevice->Pdo);
      if (!NT_SUCCESS(Status)) {
        DPRINT("IoCreateDevice() failed with status 0x%X\n", Status);
        ExFreePool(Relations);
        return Status;
      }

      LogicalDevice->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
    }

    /* Reference the physical device object. The PnP manager
       will dereference it again when it is no longer needed */
    ObReferenceObject(LogicalDevice->Pdo);

    Relations->Objects[i] = LogicalDevice->Pdo;

    i++;

    CurrentEntry = CurrentEntry->Flink;
   11862:	83 c3 10             	add    $0x10,%ebx
   11865:	31 ff                	xor    %edi,%edi
   11867:	39 f3                	cmp    %esi,%ebx
   11869:	89 02                	mov    %eax,(%edx)
   1186b:	89 5d e8             	mov    %ebx,0xffffffe8(%ebp)
   1186e:	eb 5a                	jmp    118ca <_ISAPNPQueryBusRelations+0xaa>
   11870:	8d 5e f8             	lea    0xfffffff8(%esi),%ebx
   11873:	8b 8b a4 00 00 00    	mov    0xa4(%ebx),%ecx
   11879:	85 c9                	test   %ecx,%ecx
   1187b:	75 35                	jne    118b2 <_ISAPNPQueryBusRelations+0x92>
   1187d:	50                   	push   %eax
   1187e:	8d 86 9c 00 00 00    	lea    0x9c(%esi),%eax
   11884:	50                   	push   %eax
   11885:	8b 45 08             	mov    0x8(%ebp),%eax
   11888:	6a 00                	push   $0x0
   1188a:	6a 00                	push   $0x0
   1188c:	6a 04                	push   $0x4
   1188e:	6a 00                	push   $0x0
   11890:	6a 00                	push   $0x0
   11892:	8b 48 08             	mov    0x8(%eax),%ecx
   11895:	51                   	push   %ecx
   11896:	e8 35 14 00 00       	call   12cd0 <_IoCreateDevice@28>
   1189b:	5a                   	pop    %edx
   1189c:	85 c0                	test   %eax,%eax
   1189e:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   118a1:	78 3d                	js     118e0 <_ISAPNPQueryBusRelations+0xc0>
   118a3:	8b 8b a4 00 00 00    	mov    0xa4(%ebx),%ecx
   118a9:	8b 41 1c             	mov    0x1c(%ecx),%eax
   118ac:	80 cc 10             	or     $0x10,%ah
   118af:	89 41 1c             	mov    %eax,0x1c(%ecx)
   118b2:	e8 29 14 00 00       	call   12ce0 <@ObfReferenceObject@4>
   118b7:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   118ba:	8b 83 a4 00 00 00    	mov    0xa4(%ebx),%eax
   118c0:	8b 36                	mov    (%esi),%esi
   118c2:	89 44 ba 04          	mov    %eax,0x4(%edx,%edi,4)
   118c6:	47                   	inc    %edi
   118c7:	39 75 e8             	cmp    %esi,0xffffffe8(%ebp)
   118ca:	75 a4                	jne    11870 <_ISAPNPQueryBusRelations+0x50>
  }

  Irp->IoStatus.Information = (ULONG)Relations;
   118cc:	8b 45 0c             	mov    0xc(%ebp),%eax
   118cf:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   118d2:	89 50 1c             	mov    %edx,0x1c(%eax)

  return Status;
   118d5:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
}
   118d8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   118db:	5b                   	pop    %ebx
   118dc:	5e                   	pop    %esi
   118dd:	5f                   	pop    %edi
   118de:	5d                   	pop    %ebp
   118df:	c3                   	ret    
   118e0:	83 ec 0c             	sub    $0xc,%esp
   118e3:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   118e6:	50                   	push   %eax
   118e7:	e8 04 14 00 00       	call   12cf0 <_ExFreePool@4>
   118ec:	eb e7                	jmp    118d5 <_ISAPNPQueryBusRelations+0xb5>
   118ee:	89 f6                	mov    %esi,%esi

000118f0 <_ISAPNPQueryDeviceRelations>:


NTSTATUS
ISAPNPQueryDeviceRelations(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP Irp,
  PIO_STACK_LOCATION IrpSp)
{
   118f0:	55                   	push   %ebp
   118f1:	89 e5                	mov    %esp,%ebp
   118f3:	53                   	push   %ebx
   118f4:	50                   	push   %eax
  PISAPNP_DEVICE_EXTENSION DeviceExtension;
  NTSTATUS Status;

  DPRINT("Called\n");

  DeviceExtension = (PISAPNP_DEVICE_EXTENSION)DeviceObject->DeviceExtension;

  if (DeviceExtension->State == dsStopped)
    return STATUS_UNSUCCESSFUL;
   118f5:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   118fa:	8b 5d 08             	mov    0x8(%ebp),%ebx
   118fd:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11900:	8b 43 28             	mov    0x28(%ebx),%eax
   11903:	8b 40 20             	mov    0x20(%eax),%eax
   11906:	85 c0                	test   %eax,%eax
   11908:	74 0e                	je     11918 <_ISAPNPQueryDeviceRelations+0x28>

  switch (IrpSp->Parameters.QueryDeviceRelations.Type) {
   1190a:	8b 51 04             	mov    0x4(%ecx),%edx
    case BusRelations:
      Status = ISAPNPQueryBusRelations(DeviceObject, Irp, IrpSp);
      break;

    default:
      Status = STATUS_NOT_IMPLEMENTED;
   1190d:	b8 02 00 00 c0       	mov    $0xc0000002,%eax
   11912:	85 d2                	test   %edx,%edx
   11914:	74 0a                	je     11920 <_ISAPNPQueryDeviceRelations+0x30>
  }

  return Status;
   11916:	89 c2                	mov    %eax,%edx
}
   11918:	89 d0                	mov    %edx,%eax
   1191a:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   1191d:	c9                   	leave  
   1191e:	c3                   	ret    
   1191f:	90                   	nop    
   11920:	50                   	push   %eax
   11921:	8b 45 0c             	mov    0xc(%ebp),%eax
   11924:	51                   	push   %ecx
   11925:	50                   	push   %eax
   11926:	53                   	push   %ebx
   11927:	e8 f4 fe ff ff       	call   11820 <_ISAPNPQueryBusRelations>
   1192c:	83 c4 10             	add    $0x10,%esp
   1192f:	eb e5                	jmp    11916 <_ISAPNPQueryDeviceRelations+0x26>
   11931:	eb 0d                	jmp    11940 <_ISAPNPStartDevice>
   11933:	90                   	nop    
   11934:	90                   	nop    
   11935:	90                   	nop    
   11936:	90                   	nop    
   11937:	90                   	nop    
   11938:	90                   	nop    
   11939:	90                   	nop    
   1193a:	90                   	nop    
   1193b:	90                   	nop    
   1193c:	90                   	nop    
   1193d:	90                   	nop    
   1193e:	90                   	nop    
   1193f:	90                   	nop    

00011940 <_ISAPNPStartDevice>:


NTSTATUS
ISAPNPStartDevice(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP Irp,
  PIO_STACK_LOCATION IrpSp)
{
   11940:	55                   	push   %ebp
   11941:	89 e5                	mov    %esp,%ebp
   11943:	57                   	push   %edi
   11944:	56                   	push   %esi
   11945:	53                   	push   %ebx
   11946:	81 ec 8c 01 00 00    	sub    $0x18c,%esp
  PISAPNP_DEVICE_EXTENSION DeviceExtension;
  NTSTATUS Status;
  ULONG NumCards;

  DPRINT("Called\n");

  DeviceExtension = (PISAPNP_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
   1194c:	8b 45 08             	mov    0x8(%ebp),%eax
   1194f:	8b 40 28             	mov    0x28(%eax),%eax
   11952:	89 85 e8 fe ff ff    	mov    %eax,0xfffffee8(%ebp)

  if (DeviceExtension->State == dsStarted)
    return STATUS_SUCCESS;
   11958:	31 c0                	xor    %eax,%eax
   1195a:	8b 95 e8 fe ff ff    	mov    0xfffffee8(%ebp),%edx
   11960:	83 7a 20 01          	cmpl   $0x1,0x20(%edx)
   11964:	75 08                	jne    1196e <_ISAPNPStartDevice+0x2e>

  NumCards = IsolatePnPCards();

  DPRINT("Number of ISA PnP cards found: %d\n", NumCards);

  Status = BuildDeviceList(DeviceExtension);
  if (!NT_SUCCESS(Status)) {
    DPRINT("BuildDeviceList() failed with status 0x%X\n", Status);
    return Status;
  }

  Status = BuildResourceListsForAll(DeviceExtension);
  if (!NT_SUCCESS(Status)) {
    DPRINT("BuildResourceListsForAll() failed with status 0x%X\n", Status);
    return Status;
  }

  DeviceExtension->State = dsStarted;

  return STATUS_SUCCESS;
}
   11966:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11969:	5b                   	pop    %ebx
   1196a:	5e                   	pop    %esi
   1196b:	5f                   	pop    %edi
   1196c:	5d                   	pop    %ebp
   1196d:	c3                   	ret    
   1196e:	c6 85 e7 fe ff ff 00 	movb   $0x0,0xfffffee7(%ebp)
   11975:	c6 85 c8 fe ff ff 00 	movb   $0x0,0xfffffec8(%ebp)
   1197c:	c7 85 c4 fe ff ff 00 	movl   $0x0,0xfffffec4(%ebp)
   11983:	00 00 00 
   11986:	c7 85 c0 fe ff ff 01 	movl   $0x1,0xfffffec0(%ebp)
   1198d:	00 00 00 
   11990:	c7 05 00 40 01 00 03 	movl   $0x203,0x14000
   11997:	02 00 00 
   1199a:	e8 e1 f9 ff ff       	call   11380 <_IsolateReadDataPortSelect>
   1199f:	be 6a 00 00 00       	mov    $0x6a,%esi
   119a4:	84 c0                	test   %al,%al
   119a6:	0f 85 17 03 00 00    	jne    11cc3 <_ISAPNPStartDevice+0x383>
   119ac:	e8 0f f9 ff ff       	call   112c0 <_SendWait>
   119b1:	e8 5a f8 ff ff       	call   11210 <_SendKey>
   119b6:	c7 85 bc fe ff ff 01 	movl   $0x1,0xfffffebc(%ebp)
   119bd:	00 00 00 
   119c0:	83 ec 0c             	sub    $0xc,%esp
   119c3:	31 c0                	xor    %eax,%eax
   119c5:	8a 85 bc fe ff ff    	mov    0xfffffebc(%ebp),%al
   119cb:	b3 6a                	mov    $0x6a,%bl
   119cd:	50                   	push   %eax
   119ce:	e8 0d f9 ff ff       	call   112e0 <_SendWake>
   119d3:	5f                   	pop    %edi
   119d4:	58                   	pop    %eax
   119d5:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
   119d8:	6a 09                	push   $0x9
   119da:	50                   	push   %eax
   119db:	e8 70 fa ff ff       	call   11450 <_Peek>
   119e0:	83 c4 10             	add    $0x10,%esp
   119e3:	c7 85 b4 fe ff ff 00 	movl   $0x0,0xfffffeb4(%ebp)
   119ea:	00 00 00 
   119ed:	8b 85 b4 fe ff ff    	mov    0xfffffeb4(%ebp),%eax
   119f3:	31 c9                	xor    %ecx,%ecx
   119f5:	8a 54 28 d8          	mov    0xffffffd8(%eax,%ebp,1),%dl
   119f9:	81 e2 ff 00 00 00    	and    $0xff,%edx
   119ff:	89 d7                	mov    %edx,%edi
   11a01:	89 f8                	mov    %edi,%eax
   11a03:	31 f6                	xor    %esi,%esi
   11a05:	d3 f8                	sar    %cl,%eax
   11a07:	a8 01                	test   $0x1,%al
   11a09:	74 05                	je     11a10 <_ISAPNPStartDevice+0xd0>
   11a0b:	be 01 00 00 00       	mov    $0x1,%esi
   11a10:	88 da                	mov    %bl,%dl
   11a12:	89 f0                	mov    %esi,%eax
   11a14:	d0 ea                	shr    %dl
   11a16:	41                   	inc    %ecx
   11a17:	31 d3                	xor    %edx,%ebx
   11a19:	31 d8                	xor    %ebx,%eax
   11a1b:	88 d3                	mov    %dl,%bl
   11a1d:	83 e0 01             	and    $0x1,%eax
   11a20:	c1 e0 07             	shl    $0x7,%eax
   11a23:	09 c3                	or     %eax,%ebx
   11a25:	83 f9 07             	cmp    $0x7,%ecx
   11a28:	76 d7                	jbe    11a01 <_ISAPNPStartDevice+0xc1>
   11a2a:	8b b5 b4 fe ff ff    	mov    0xfffffeb4(%ebp),%esi
   11a30:	46                   	inc    %esi
   11a31:	89 b5 b4 fe ff ff    	mov    %esi,0xfffffeb4(%ebp)
   11a37:	83 bd b4 fe ff ff 07 	cmpl   $0x7,0xfffffeb4(%ebp)
   11a3e:	76 ad                	jbe    119ed <_ISAPNPStartDevice+0xad>
   11a40:	84 db                	test   %bl,%bl
   11a42:	0f 85 82 03 00 00    	jne    11dca <_ISAPNPStartDevice+0x48a>
   11a48:	8b b5 bc fe ff ff    	mov    0xfffffebc(%ebp),%esi
   11a4e:	46                   	inc    %esi
   11a4f:	89 b5 bc fe ff ff    	mov    %esi,0xfffffebc(%ebp)
   11a55:	83 bd bc fe ff ff 0a 	cmpl   $0xa,0xfffffebc(%ebp)
   11a5c:	0f 86 5e ff ff ff    	jbe    119c0 <_ISAPNPStartDevice+0x80>
   11a62:	8b 8d e8 fe ff ff    	mov    0xfffffee8(%ebp),%ecx
   11a68:	8b 85 e8 fe ff ff    	mov    0xfffffee8(%ebp),%eax
   11a6e:	83 c0 08             	add    $0x8,%eax
   11a71:	8b 49 08             	mov    0x8(%ecx),%ecx
   11a74:	89 85 7c fe ff ff    	mov    %eax,0xfffffe7c(%ebp)
   11a7a:	89 8d 94 fe ff ff    	mov    %ecx,0xfffffe94(%ebp)
   11a80:	39 c8                	cmp    %ecx,%eax
   11a82:	0f 84 df 01 00 00    	je     11c67 <_ISAPNPStartDevice+0x327>
   11a88:	8b 95 94 fe ff ff    	mov    0xfffffe94(%ebp),%edx
   11a8e:	8b 8d 94 fe ff ff    	mov    0xfffffe94(%ebp),%ecx
   11a94:	83 c1 20             	add    $0x20,%ecx
   11a97:	8b 52 20             	mov    0x20(%edx),%edx
   11a9a:	89 8d 78 fe ff ff    	mov    %ecx,0xfffffe78(%ebp)
   11aa0:	89 95 90 fe ff ff    	mov    %edx,0xfffffe90(%ebp)
   11aa6:	39 d1                	cmp    %edx,%ecx
   11aa8:	0f 84 9f 01 00 00    	je     11c4d <_ISAPNPStartDevice+0x30d>
   11aae:	8b 85 90 fe ff ff    	mov    0xfffffe90(%ebp),%eax
   11ab4:	8b 90 b4 00 00 00    	mov    0xb4(%eax),%edx
   11aba:	53                   	push   %ebx
   11abb:	83 c2 20             	add    $0x20,%edx
   11abe:	53                   	push   %ebx
   11abf:	89 95 8c fe ff ff    	mov    %edx,0xfffffe8c(%ebp)
   11ac5:	52                   	push   %edx
   11ac6:	6a 01                	push   $0x1
   11ac8:	e8 d3 11 00 00       	call   12ca0 <_ExAllocatePool@8>
   11acd:	5a                   	pop    %edx
   11ace:	59                   	pop    %ecx
   11acf:	8b 8d 90 fe ff ff    	mov    0xfffffe90(%ebp),%ecx
   11ad5:	85 c0                	test   %eax,%eax
   11ad7:	89 81 a8 00 00 00    	mov    %eax,0xa8(%ecx)
   11add:	0f 84 6d 06 00 00    	je     12150 <_ISAPNPStartDevice+0x810>
   11ae3:	8b bd 8c fe ff ff    	mov    0xfffffe8c(%ebp),%edi
   11ae9:	50                   	push   %eax
   11aea:	50                   	push   %eax
   11aeb:	57                   	push   %edi
   11aec:	8b b1 a8 00 00 00    	mov    0xa8(%ecx),%esi
   11af2:	56                   	push   %esi
   11af3:	e8 b8 11 00 00       	call   12cb0 <_RtlZeroMemory@8>
   11af8:	8b 95 90 fe ff ff    	mov    0xfffffe90(%ebp),%edx
   11afe:	59                   	pop    %ecx
   11aff:	c7 85 88 fe ff ff 00 	movl   $0x0,0xfffffe88(%ebp)
   11b06:	00 00 00 
   11b09:	5b                   	pop    %ebx
   11b0a:	8b 82 b8 00 00 00    	mov    0xb8(%edx),%eax
   11b10:	8b 8a a8 00 00 00    	mov    0xa8(%edx),%ecx
   11b16:	c1 e0 05             	shl    $0x5,%eax
   11b19:	83 c1 20             	add    $0x20,%ecx
   11b1c:	83 c0 08             	add    $0x8,%eax
   11b1f:	89 8d 80 fe ff ff    	mov    %ecx,0xfffffe80(%ebp)
   11b25:	89 85 84 fe ff ff    	mov    %eax,0xfffffe84(%ebp)
   11b2b:	8d b2 ac 00 00 00    	lea    0xac(%edx),%esi
   11b31:	8b 95 90 fe ff ff    	mov    0xfffffe90(%ebp),%edx
   11b37:	8b 82 ac 00 00 00    	mov    0xac(%edx),%eax
   11b3d:	39 f0                	cmp    %esi,%eax
   11b3f:	0f 84 d6 00 00 00    	je     11c1b <_ISAPNPStartDevice+0x2db>
   11b45:	89 c3                	mov    %eax,%ebx
   11b47:	eb 09                	jmp    11b52 <_ISAPNPStartDevice+0x212>
   11b49:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11b50:	8b 1b                	mov    (%ebx),%ebx
   11b52:	39 de                	cmp    %ebx,%esi
   11b54:	74 db                	je     11b31 <_ISAPNPStartDevice+0x1f1>
   11b56:	8b 8d 88 fe ff ff    	mov    0xfffffe88(%ebp),%ecx
   11b5c:	39 4b 08             	cmp    %ecx,0x8(%ebx)
   11b5f:	75 ef                	jne    11b50 <_ISAPNPStartDevice+0x210>
   11b61:	8b 85 80 fe ff ff    	mov    0xfffffe80(%ebp),%eax
   11b67:	8b 95 90 fe ff ff    	mov    0xfffffe90(%ebp),%edx
   11b6d:	8b 8d 80 fe ff ff    	mov    0xfffffe80(%ebp),%ecx
   11b73:	8d 7b 0c             	lea    0xc(%ebx),%edi
   11b76:	66 c7 00 01 00       	movw   $0x1,(%eax)
   11b7b:	66 c7 40 02 01 00    	movw   $0x1,0x2(%eax)
   11b81:	8b 82 b8 00 00 00    	mov    0xb8(%edx),%eax
   11b87:	89 41 04             	mov    %eax,0x4(%ecx)
   11b8a:	8b 4b 0c             	mov    0xc(%ebx),%ecx
   11b8d:	39 cf                	cmp    %ecx,%edi
   11b8f:	74 3f                	je     11bd0 <_ISAPNPStartDevice+0x290>
   11b91:	8b 95 80 fe ff ff    	mov    0xfffffe80(%ebp),%edx
   11b97:	8b 41 08             	mov    0x8(%ecx),%eax
   11b9a:	89 42 08             	mov    %eax,0x8(%edx)
   11b9d:	8b 41 0c             	mov    0xc(%ecx),%eax
   11ba0:	89 42 0c             	mov    %eax,0xc(%edx)
   11ba3:	8b 41 10             	mov    0x10(%ecx),%eax
   11ba6:	89 42 10             	mov    %eax,0x10(%edx)
   11ba9:	8b 41 14             	mov    0x14(%ecx),%eax
   11bac:	89 42 14             	mov    %eax,0x14(%edx)
   11baf:	8b 41 18             	mov    0x18(%ecx),%eax
   11bb2:	89 42 18             	mov    %eax,0x18(%edx)
   11bb5:	8b 41 1c             	mov    0x1c(%ecx),%eax
   11bb8:	89 42 1c             	mov    %eax,0x1c(%edx)
   11bbb:	8b 41 20             	mov    0x20(%ecx),%eax
   11bbe:	89 42 20             	mov    %eax,0x20(%edx)
   11bc1:	8b 41 24             	mov    0x24(%ecx),%eax
   11bc4:	89 42 24             	mov    %eax,0x24(%edx)
   11bc7:	83 c2 20             	add    $0x20,%edx
   11bca:	8b 09                	mov    (%ecx),%ecx
   11bcc:	39 cf                	cmp    %ecx,%edi
   11bce:	75 c7                	jne    11b97 <_ISAPNPStartDevice+0x257>
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   11bd0:	8b 13                	mov    (%ebx),%edx
  OldBlink = Entry->Blink;
   11bd2:	8b 43 04             	mov    0x4(%ebx),%eax
   11bd5:	83 ec 0c             	sub    $0xc,%esp
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
  OldFlink->Blink = OldBlink;
   11bd8:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   11bdb:	89 10                	mov    %edx,(%eax)
   11bdd:	53                   	push   %ebx
   11bde:	e8 0d 11 00 00       	call   12cf0 <_ExFreePool@4>
   11be3:	8b 85 84 fe ff ff    	mov    0xfffffe84(%ebp),%eax
   11be9:	8b 95 80 fe ff ff    	mov    0xfffffe80(%ebp),%edx
   11bef:	01 c2                	add    %eax,%edx
   11bf1:	8b 85 88 fe ff ff    	mov    0xfffffe88(%ebp),%eax
   11bf7:	40                   	inc    %eax
   11bf8:	83 c4 0c             	add    $0xc,%esp
   11bfb:	89 95 80 fe ff ff    	mov    %edx,0xfffffe80(%ebp)
   11c01:	89 85 88 fe ff ff    	mov    %eax,0xfffffe88(%ebp)
   11c07:	8b 95 90 fe ff ff    	mov    0xfffffe90(%ebp),%edx
   11c0d:	8b 82 ac 00 00 00    	mov    0xac(%edx),%eax
   11c13:	39 f0                	cmp    %esi,%eax
   11c15:	0f 85 2a ff ff ff    	jne    11b45 <_ISAPNPStartDevice+0x205>
   11c1b:	8b 8d 90 fe ff ff    	mov    0xfffffe90(%ebp),%ecx
   11c21:	8b 85 8c fe ff ff    	mov    0xfffffe8c(%ebp),%eax
   11c27:	8b 91 a8 00 00 00    	mov    0xa8(%ecx),%edx
   11c2d:	89 02                	mov    %eax,(%edx)
   11c2f:	8b 85 88 fe ff ff    	mov    0xfffffe88(%ebp),%eax
   11c35:	40                   	inc    %eax
   11c36:	89 42 1c             	mov    %eax,0x1c(%edx)
   11c39:	8b 11                	mov    (%ecx),%edx
   11c3b:	89 95 90 fe ff ff    	mov    %edx,0xfffffe90(%ebp)
   11c41:	39 95 78 fe ff ff    	cmp    %edx,0xfffffe78(%ebp)
   11c47:	0f 85 61 fe ff ff    	jne    11aae <_ISAPNPStartDevice+0x16e>
   11c4d:	8b 8d 94 fe ff ff    	mov    0xfffffe94(%ebp),%ecx
   11c53:	8b 09                	mov    (%ecx),%ecx
   11c55:	89 8d 94 fe ff ff    	mov    %ecx,0xfffffe94(%ebp)
   11c5b:	39 8d 7c fe ff ff    	cmp    %ecx,0xfffffe7c(%ebp)
   11c61:	0f 85 21 fe ff ff    	jne    11a88 <_ISAPNPStartDevice+0x148>
   11c67:	8b 85 e8 fe ff ff    	mov    0xfffffee8(%ebp),%eax
   11c6d:	c7 40 20 01 00 00 00 	movl   $0x1,0x20(%eax)
   11c74:	31 c0                	xor    %eax,%eax
   11c76:	e9 eb fc ff ff       	jmp    11966 <_ISAPNPStartDevice+0x26>
   11c7b:	90                   	nop    
   11c7c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11c80:	89 f1                	mov    %esi,%ecx
   11c82:	84 c9                	test   %cl,%cl
   11c84:	0f 95 c2             	setne  %dl
   11c87:	3a 8d e7 fe ff ff    	cmp    0xfffffee7(%ebp),%cl
   11c8d:	0f 94 c0             	sete   %al
   11c90:	25 ff 00 00 00       	and    $0xff,%eax
   11c95:	85 c2                	test   %eax,%edx
   11c97:	0f 85 b6 03 00 00    	jne    12053 <_ISAPNPStartDevice+0x713>
   11c9d:	83 bd c0 fe ff ff 01 	cmpl   $0x1,0xfffffec0(%ebp)
   11ca4:	0f 84 40 04 00 00    	je     120ea <_ISAPNPStartDevice+0x7aa>
   11caa:	0f 87 aa 04 00 00    	ja     1215a <_ISAPNPStartDevice+0x81a>
   11cb0:	be 6a 00 00 00       	mov    $0x6a,%esi
   11cb5:	c6 85 e7 fe ff ff 00 	movb   $0x0,0xfffffee7(%ebp)
   11cbc:	c6 85 c8 fe ff ff 00 	movb   $0x0,0xfffffec8(%ebp)
   11cc3:	bf 3f 00 00 00       	mov    $0x3f,%edi
   11cc8:	eb 28                	jmp    11cf2 <_ISAPNPStartDevice+0x3b2>
   11cca:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11cd0:	89 f2                	mov    %esi,%edx
   11cd2:	8a 85 c8 fe ff ff    	mov    0xfffffec8(%ebp),%al
   11cd8:	d0 ea                	shr    %dl
   11cda:	c6 85 c8 fe ff ff 00 	movb   $0x0,0xfffffec8(%ebp)
   11ce1:	31 d6                	xor    %edx,%esi
   11ce3:	31 f0                	xor    %esi,%eax
   11ce5:	83 e0 01             	and    $0x1,%eax
   11ce8:	c1 e0 07             	shl    $0x7,%eax
   11ceb:	09 c2                	or     %eax,%edx
   11ced:	4f                   	dec    %edi
   11cee:	89 d6                	mov    %edx,%esi
   11cf0:	78 6f                	js     11d61 <_ISAPNPStartDevice+0x421>
   11cf2:	83 ec 0c             	sub    $0xc,%esp
   11cf5:	a1 00 40 01 00       	mov    0x14000,%eax
   11cfa:	31 db                	xor    %ebx,%ebx
   11cfc:	50                   	push   %eax
   11cfd:	e8 5e 10 00 00       	call   12d60 <_READ_PORT_UCHAR@4>
   11d02:	88 c3                	mov    %al,%bl
   11d04:	c1 e3 08             	shl    $0x8,%ebx
   11d07:	68 fa 00 00 00       	push   $0xfa
   11d0c:	e8 3f 10 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11d11:	a1 00 40 01 00       	mov    0x14000,%eax
   11d16:	50                   	push   %eax
   11d17:	e8 44 10 00 00       	call   12d60 <_READ_PORT_UCHAR@4>
   11d1c:	25 ff 00 00 00       	and    $0xff,%eax
   11d21:	09 c3                	or     %eax,%ebx
   11d23:	68 fa 00 00 00       	push   $0xfa
   11d28:	e8 23 10 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11d2d:	83 c4 0c             	add    $0xc,%esp
   11d30:	81 fb aa 55 00 00    	cmp    $0x55aa,%ebx
   11d36:	75 98                	jne    11cd0 <_ISAPNPStartDevice+0x390>
   11d38:	89 f2                	mov    %esi,%edx
   11d3a:	c6 85 c8 fe ff ff 01 	movb   $0x1,0xfffffec8(%ebp)
   11d41:	d0 ea                	shr    %dl
   11d43:	8a 85 c8 fe ff ff    	mov    0xfffffec8(%ebp),%al
   11d49:	31 d6                	xor    %edx,%esi
   11d4b:	c6 85 c8 fe ff ff 00 	movb   $0x0,0xfffffec8(%ebp)
   11d52:	31 f0                	xor    %esi,%eax
   11d54:	83 e0 01             	and    $0x1,%eax
   11d57:	c1 e0 07             	shl    $0x7,%eax
   11d5a:	09 c2                	or     %eax,%edx
   11d5c:	4f                   	dec    %edi
   11d5d:	89 d6                	mov    %edx,%esi
   11d5f:	79 91                	jns    11cf2 <_ISAPNPStartDevice+0x3b2>
   11d61:	bf 41 00 00 00       	mov    $0x41,%edi
   11d66:	eb 0a                	jmp    11d72 <_ISAPNPStartDevice+0x432>
   11d68:	47                   	inc    %edi
   11d69:	83 ff 48             	cmp    $0x48,%edi
   11d6c:	0f 87 0e ff ff ff    	ja     11c80 <_ISAPNPStartDevice+0x340>
   11d72:	83 ec 0c             	sub    $0xc,%esp
   11d75:	a1 00 40 01 00       	mov    0x14000,%eax
   11d7a:	31 db                	xor    %ebx,%ebx
   11d7c:	50                   	push   %eax
   11d7d:	e8 de 0f 00 00       	call   12d60 <_READ_PORT_UCHAR@4>
   11d82:	88 c3                	mov    %al,%bl
   11d84:	c1 e3 08             	shl    $0x8,%ebx
   11d87:	68 fa 00 00 00       	push   $0xfa
   11d8c:	e8 bf 0f 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11d91:	a1 00 40 01 00       	mov    0x14000,%eax
   11d96:	50                   	push   %eax
   11d97:	e8 c4 0f 00 00       	call   12d60 <_READ_PORT_UCHAR@4>
   11d9c:	25 ff 00 00 00       	and    $0xff,%eax
   11da1:	09 c3                	or     %eax,%ebx
   11da3:	68 fa 00 00 00       	push   $0xfa
   11da8:	e8 a3 0f 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   11dad:	83 c4 0c             	add    $0xc,%esp
   11db0:	81 fb aa 55 00 00    	cmp    $0x55aa,%ebx
   11db6:	75 b0                	jne    11d68 <_ISAPNPStartDevice+0x428>
   11db8:	8d 4f bf             	lea    0xffffffbf(%edi),%ecx
   11dbb:	b8 01 00 00 00       	mov    $0x1,%eax
   11dc0:	d3 e0                	shl    %cl,%eax
   11dc2:	08 85 e7 fe ff ff    	or     %al,0xfffffee7(%ebp)
   11dc8:	eb 9e                	jmp    11d68 <_ISAPNPStartDevice+0x428>
   11dca:	38 5d e0             	cmp    %bl,0xffffffe0(%ebp)
   11dcd:	0f 85 75 fc ff ff    	jne    11a48 <_ISAPNPStartDevice+0x108>
   11dd3:	51                   	push   %ecx
   11dd4:	51                   	push   %ecx
   11dd5:	6a 2c                	push   $0x2c
   11dd7:	6a 01                	push   $0x1
   11dd9:	e8 c2 0e 00 00       	call   12ca0 <_ExAllocatePool@8>
   11dde:	5f                   	pop    %edi
   11ddf:	85 c0                	test   %eax,%eax
   11de1:	5a                   	pop    %edx
   11de2:	89 85 b8 fe ff ff    	mov    %eax,0xfffffeb8(%ebp)
   11de8:	0f 84 62 03 00 00    	je     12150 <_ISAPNPStartDevice+0x810>
   11dee:	56                   	push   %esi
   11def:	56                   	push   %esi
   11df0:	6a 2c                	push   $0x2c
   11df2:	50                   	push   %eax
   11df3:	e8 b8 0e 00 00       	call   12cb0 <_RtlZeroMemory@8>
   11df8:	8b 95 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%edx
   11dfe:	8b 8d bc fe ff ff    	mov    0xfffffebc(%ebp),%ecx
   11e04:	53                   	push   %ebx
   11e05:	31 c0                	xor    %eax,%eax
   11e07:	66 89 4a 08          	mov    %cx,0x8(%edx)
   11e0b:	31 d2                	xor    %edx,%edx
   11e0d:	8a 55 d9             	mov    0xffffffd9(%ebp),%dl
   11e10:	8a 45 d8             	mov    0xffffffd8(%ebp),%al
   11e13:	c1 e2 08             	shl    $0x8,%edx
   11e16:	8b 8d b8 fe ff ff    	mov    0xfffffeb8(%ebp),%ecx
   11e1c:	09 d0                	or     %edx,%eax
   11e1e:	8b 95 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%edx
   11e24:	8d 9d 17 ff ff ff    	lea    0xffffff17(%ebp),%ebx
   11e2a:	66 89 42 0a          	mov    %ax,0xa(%edx)
   11e2e:	31 d2                	xor    %edx,%edx
   11e30:	8a 55 db             	mov    0xffffffdb(%ebp),%dl
   11e33:	31 c0                	xor    %eax,%eax
   11e35:	c1 e2 08             	shl    $0x8,%edx
   11e38:	8a 45 da             	mov    0xffffffda(%ebp),%al
   11e3b:	09 d0                	or     %edx,%eax
   11e3d:	31 d2                	xor    %edx,%edx
   11e3f:	66 89 41 0c          	mov    %ax,0xc(%ecx)
   11e43:	31 c0                	xor    %eax,%eax
   11e45:	8a 55 df             	mov    0xffffffdf(%ebp),%dl
   11e48:	8a 45 de             	mov    0xffffffde(%ebp),%al
   11e4b:	c1 e0 10             	shl    $0x10,%eax
   11e4e:	c1 e2 18             	shl    $0x18,%edx
   11e51:	09 c2                	or     %eax,%edx
   11e53:	31 c0                	xor    %eax,%eax
   11e55:	8a 45 dd             	mov    0xffffffdd(%ebp),%al
   11e58:	c1 e0 08             	shl    $0x8,%eax
   11e5b:	09 c2                	or     %eax,%edx
   11e5d:	31 c0                	xor    %eax,%eax
   11e5f:	8a 45 dc             	mov    0xffffffdc(%ebp),%al
   11e62:	09 c2                	or     %eax,%edx
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   11e64:	89 c8                	mov    %ecx,%eax
   11e66:	83 c0 20             	add    $0x20,%eax
   11e69:	89 51 10             	mov    %edx,0x10(%ecx)
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   11e6c:	89 41 20             	mov    %eax,0x20(%ecx)
   11e6f:	89 40 04             	mov    %eax,0x4(%eax)
   11e72:	83 c0 08             	add    $0x8,%eax
   11e75:	50                   	push   %eax
   11e76:	e8 85 0e 00 00       	call   12d00 <_KeInitializeSpinLock@4>
   11e7b:	83 c4 0c             	add    $0xc,%esp
   11e7e:	83 ec 0c             	sub    $0xc,%esp
   11e81:	8d 95 14 ff ff ff    	lea    0xffffff14(%ebp),%edx
   11e87:	8d 85 13 ff ff ff    	lea    0xffffff13(%ebp),%eax
   11e8d:	53                   	push   %ebx
   11e8e:	e8 3d f6 ff ff       	call   114d0 <_ReadTag>
   11e93:	83 c4 10             	add    $0x10,%esp
   11e96:	84 c0                	test   %al,%al
   11e98:	74 5a                	je     11ef4 <_ISAPNPStartDevice+0x5b4>
   11e9a:	80 bd 17 ff ff ff 00 	cmpb   $0x0,0xffffff17(%ebp)
   11ea1:	74 7d                	je     11f20 <_ISAPNPStartDevice+0x5e0>
   11ea3:	31 c0                	xor    %eax,%eax
   11ea5:	8a 85 13 ff ff ff    	mov    0xffffff13(%ebp),%al
   11eab:	83 f8 02             	cmp    $0x2,%eax
   11eae:	0f 84 ac 00 00 00    	je     11f60 <_ISAPNPStartDevice+0x620>
   11eb4:	0f 8f 85 00 00 00    	jg     11f3f <_ISAPNPStartDevice+0x5ff>
   11eba:	48                   	dec    %eax
   11ebb:	0f 84 4f 02 00 00    	je     12110 <_ISAPNPStartDevice+0x7d0>
   11ec1:	8b 95 14 ff ff ff    	mov    0xffffff14(%ebp),%edx
   11ec7:	66 85 d2             	test   %dx,%dx
   11eca:	74 b2                	je     11e7e <_ISAPNPStartDevice+0x53e>
   11ecc:	89 d0                	mov    %edx,%eax
   11ece:	25 ff ff 00 00       	and    $0xffff,%eax
   11ed3:	e8 e8 f5 ff ff       	call   114c0 <_Skip>
   11ed8:	83 ec 0c             	sub    $0xc,%esp
   11edb:	8d 95 14 ff ff ff    	lea    0xffffff14(%ebp),%edx
   11ee1:	8d 85 13 ff ff ff    	lea    0xffffff13(%ebp),%eax
   11ee7:	53                   	push   %ebx
   11ee8:	e8 e3 f5 ff ff       	call   114d0 <_ReadTag>
   11eed:	83 c4 10             	add    $0x10,%esp
   11ef0:	84 c0                	test   %al,%al
   11ef2:	75 a6                	jne    11e9a <_ISAPNPStartDevice+0x55a>
   11ef4:	50                   	push   %eax
   11ef5:	8b 85 e8 fe ff ff    	mov    0xfffffee8(%ebp),%eax
   11efb:	83 c0 1c             	add    $0x1c,%eax
   11efe:	50                   	push   %eax
   11eff:	8b 85 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%eax
   11f05:	50                   	push   %eax
   11f06:	8b 85 e8 fe ff ff    	mov    0xfffffee8(%ebp),%eax
   11f0c:	83 c0 08             	add    $0x8,%eax
   11f0f:	50                   	push   %eax
   11f10:	e8 ab 0d 00 00       	call   12cc0 <_ExInterlockedInsertTailList@12>
   11f15:	5f                   	pop    %edi
   11f16:	e9 2d fb ff ff       	jmp    11a48 <_ISAPNPStartDevice+0x108>
   11f1b:	90                   	nop    
   11f1c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11f20:	80 bd 13 ff ff ff 02 	cmpb   $0x2,0xffffff13(%ebp)
   11f27:	75 98                	jne    11ec1 <_ISAPNPStartDevice+0x581>
   11f29:	8b 85 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%eax
   11f2f:	8d 95 14 ff ff ff    	lea    0xffffff14(%ebp),%edx
   11f35:	83 c0 18             	add    $0x18,%eax
   11f38:	e8 23 f6 ff ff       	call   11560 <_ParseAnsiName>
   11f3d:	eb 82                	jmp    11ec1 <_ISAPNPStartDevice+0x581>
   11f3f:	83 f8 03             	cmp    $0x3,%eax
   11f42:	0f 84 79 ff ff ff    	je     11ec1 <_ISAPNPStartDevice+0x581>
   11f48:	83 f8 0f             	cmp    $0xf,%eax
   11f4b:	0f 85 70 ff ff ff    	jne    11ec1 <_ISAPNPStartDevice+0x581>
   11f51:	8b 85 14 ff ff ff    	mov    0xffffff14(%ebp),%eax
   11f57:	e9 60 02 00 00       	jmp    121bc <_ISAPNPStartDevice+0x87c>
   11f5c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11f60:	8b 95 14 ff ff ff    	mov    0xffffff14(%ebp),%edx
   11f66:	8d 42 fb             	lea    0xfffffffb(%edx),%eax
   11f69:	66 83 f8 01          	cmp    $0x1,%ax
   11f6d:	0f 87 54 ff ff ff    	ja     11ec7 <_ISAPNPStartDevice+0x587>
   11f73:	89 d0                	mov    %edx,%eax
   11f75:	25 ff ff 00 00       	and    $0xffff,%eax
   11f7a:	52                   	push   %edx
   11f7b:	66 89 85 10 ff ff ff 	mov    %ax,0xffffff10(%ebp)
   11f82:	52                   	push   %edx
   11f83:	8b 95 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%edx
   11f89:	6a 00                	push   $0x0
   11f8b:	50                   	push   %eax
   11f8c:	8b 85 e8 fe ff ff    	mov    0xfffffee8(%ebp),%eax
   11f92:	c7 85 ac fe ff ff 00 	movl   $0x0,0xfffffeac(%ebp)
   11f99:	00 00 00 
   11f9c:	c7 85 a8 fe ff ff 00 	movl   $0x0,0xfffffea8(%ebp)
   11fa3:	00 00 00 
   11fa6:	c7 85 a4 fe ff ff 00 	movl   $0x0,0xfffffea4(%ebp)
   11fad:	00 00 00 
   11fb0:	c7 85 a0 fe ff ff 00 	movl   $0x0,0xfffffea0(%ebp)
   11fb7:	00 00 00 
   11fba:	c7 85 b0 fe ff ff 01 	movl   $0x1,0xfffffeb0(%ebp)
   11fc1:	00 00 00 
   11fc4:	e8 67 f7 ff ff       	call   11730 <_ParseLogicalDevice>
   11fc9:	83 c4 10             	add    $0x10,%esp
   11fcc:	89 c7                	mov    %eax,%edi
   11fce:	85 c0                	test   %eax,%eax
   11fd0:	0f 84 1e ff ff ff    	je     11ef4 <_ISAPNPStartDevice+0x5b4>
   11fd6:	83 ec 0c             	sub    $0xc,%esp
   11fd9:	8d 8d 12 ff ff ff    	lea    0xffffff12(%ebp),%ecx
   11fdf:	8d 95 10 ff ff ff    	lea    0xffffff10(%ebp),%edx
   11fe5:	8d 85 0f ff ff ff    	lea    0xffffff0f(%ebp),%eax
   11feb:	51                   	push   %ecx
   11fec:	e8 df f4 ff ff       	call   114d0 <_ReadTag>
   11ff1:	83 c4 10             	add    $0x10,%esp
   11ff4:	84 c0                	test   %al,%al
   11ff6:	0f 84 f8 fe ff ff    	je     11ef4 <_ISAPNPStartDevice+0x5b4>
   11ffc:	8b 85 ac fe ff ff    	mov    0xfffffeac(%ebp),%eax
   12002:	85 c0                	test   %eax,%eax
   12004:	0f 84 8b 01 00 00    	je     12195 <_ISAPNPStartDevice+0x855>
   1200a:	8a 9d 12 ff ff ff    	mov    0xffffff12(%ebp),%bl
   12010:	84 db                	test   %bl,%bl
   12012:	0f 84 5d 01 00 00    	je     12175 <_ISAPNPStartDevice+0x835>
   12018:	8a 8d 0f ff ff ff    	mov    0xffffff0f(%ebp),%cl
   1201e:	80 f9 02             	cmp    $0x2,%cl
   12021:	0f 95 c2             	setne  %dl
   12024:	80 f9 0f             	cmp    $0xf,%cl
   12027:	0f 95 c0             	setne  %al
   1202a:	25 ff 00 00 00       	and    $0xff,%eax
   1202f:	85 c2                	test   %eax,%edx
   12031:	0f 85 3e 01 00 00    	jne    12175 <_ISAPNPStartDevice+0x835>
   12037:	84 db                	test   %bl,%bl
   12039:	0f 84 67 01 00 00    	je     121a6 <_ISAPNPStartDevice+0x866>
   1203f:	31 c0                	xor    %eax,%eax
   12041:	88 c8                	mov    %cl,%al
   12043:	83 f8 0f             	cmp    $0xf,%eax
   12046:	0f 87 29 01 00 00    	ja     12175 <_ISAPNPStartDevice+0x835>
   1204c:	ff 24 85 00 30 01 00 	jmp    *0x13000(,%eax,4)
   12053:	8b b5 c4 fe ff ff    	mov    0xfffffec4(%ebp),%esi
   12059:	31 c0                	xor    %eax,%eax
   1205b:	46                   	inc    %esi
   1205c:	89 b5 c4 fe ff ff    	mov    %esi,0xfffffec4(%ebp)
   12062:	53                   	push   %ebx
   12063:	8a 85 c4 fe ff ff    	mov    0xfffffec4(%ebp),%al
   12069:	53                   	push   %ebx
   1206a:	50                   	push   %eax
   1206b:	6a 06                	push   $0x6
   1206d:	e8 9e f0 ff ff       	call   11110 <_WriteUchar>
   12072:	c7 04 24 fa 00 00 00 	movl   $0xfa,(%esp)
   12079:	e8 d2 0c 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   1207e:	8b 8d c0 fe ff ff    	mov    0xfffffec0(%ebp),%ecx
   12084:	41                   	inc    %ecx
   12085:	89 8d c0 fe ff ff    	mov    %ecx,0xfffffec0(%ebp)
   1208b:	6a 00                	push   $0x0
   1208d:	e8 4e f2 ff ff       	call   112e0 <_SendWake>
   12092:	58                   	pop    %eax
   12093:	a1 00 40 01 00       	mov    0x14000,%eax
   12098:	5a                   	pop    %edx
   12099:	c1 e8 02             	shr    $0x2,%eax
   1209c:	25 ff 00 00 00       	and    $0xff,%eax
   120a1:	50                   	push   %eax
   120a2:	6a 00                	push   $0x0
   120a4:	e8 67 f0 ff ff       	call   11110 <_WriteUchar>
   120a9:	c7 04 24 64 00 00 00 	movl   $0x64,(%esp)
   120b0:	e8 9b 0c 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   120b5:	68 e8 03 00 00       	push   $0x3e8
   120ba:	e8 91 0c 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   120bf:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
   120c6:	68 79 02 00 00       	push   $0x279
   120cb:	e8 70 0c 00 00       	call   12d40 <_WRITE_PORT_UCHAR@8>
   120d0:	50                   	push   %eax
   120d1:	6a 14                	push   $0x14
   120d3:	e8 78 0c 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   120d8:	68 e8 03 00 00       	push   $0x3e8
   120dd:	e8 6e 0c 00 00       	call   12d50 <_KeStallExecutionProcessor@4>
   120e2:	83 c4 0c             	add    $0xc,%esp
   120e5:	e9 c6 fb ff ff       	jmp    11cb0 <_ISAPNPStartDevice+0x370>
   120ea:	a1 00 40 01 00       	mov    0x14000,%eax
   120ef:	83 c0 20             	add    $0x20,%eax
   120f2:	a3 00 40 01 00       	mov    %eax,0x14000
   120f7:	e8 84 f2 ff ff       	call   11380 <_IsolateReadDataPortSelect>
   120fc:	84 c0                	test   %al,%al
   120fe:	0f 85 ac fb ff ff    	jne    11cb0 <_ISAPNPStartDevice+0x370>
   12104:	e9 a3 f8 ff ff       	jmp    119ac <_ISAPNPStartDevice+0x6c>
   12109:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   12110:	8b 95 14 ff ff ff    	mov    0xffffff14(%ebp),%edx
   12116:	66 83 fa 02          	cmp    $0x2,%dx
   1211a:	0f 85 a7 fd ff ff    	jne    11ec7 <_ISAPNPStartDevice+0x587>
   12120:	8d 45 b8             	lea    0xffffffb8(%ebp),%eax
   12123:	51                   	push   %ecx
   12124:	51                   	push   %ecx
   12125:	6a 02                	push   $0x2
   12127:	50                   	push   %eax
   12128:	e8 23 f3 ff ff       	call   11450 <_Peek>
   1212d:	8b 95 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%edx
   12133:	8a 45 b8             	mov    0xffffffb8(%ebp),%al
   12136:	83 c4 10             	add    $0x10,%esp
   12139:	88 42 14             	mov    %al,0x14(%edx)
   1213c:	8a 45 b9             	mov    0xffffffb9(%ebp),%al
   1213f:	88 42 15             	mov    %al,0x15(%edx)
   12142:	66 c7 85 14 ff ff ff 	movw   $0x0,0xffffff14(%ebp)
   12149:	00 00 
   1214b:	e9 2e fd ff ff       	jmp    11e7e <_ISAPNPStartDevice+0x53e>
   12150:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   12155:	e9 0c f8 ff ff       	jmp    11966 <_ISAPNPStartDevice+0x26>
   1215a:	e8 61 f1 ff ff       	call   112c0 <_SendWait>
   1215f:	e9 48 f8 ff ff       	jmp    119ac <_ISAPNPStartDevice+0x6c>
   12164:	8d 87 9c 00 00 00    	lea    0x9c(%edi),%eax
   1216a:	8d 95 10 ff ff ff    	lea    0xffffff10(%ebp),%edx
   12170:	e8 eb f3 ff ff       	call   11560 <_ParseAnsiName>
   12175:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   1217b:	66 85 c9             	test   %cx,%cx
   1217e:	0f 84 52 fe ff ff    	je     11fd6 <_ISAPNPStartDevice+0x696>
   12184:	89 c8                	mov    %ecx,%eax
   12186:	25 ff ff 00 00       	and    $0xffff,%eax
   1218b:	e8 30 f3 ff ff       	call   114c0 <_Skip>
   12190:	e9 41 fe ff ff       	jmp    11fd6 <_ISAPNPStartDevice+0x696>
   12195:	8a 9d 12 ff ff ff    	mov    0xffffff12(%ebp),%bl
   1219b:	8a 8d 0f ff ff ff    	mov    0xffffff0f(%ebp),%cl
   121a1:	e9 91 fe ff ff       	jmp    12037 <_ISAPNPStartDevice+0x6f7>
   121a6:	31 c0                	xor    %eax,%eax
   121a8:	88 c8                	mov    %cl,%al
   121aa:	83 f8 06             	cmp    $0x6,%eax
   121ad:	77 c6                	ja     12175 <_ISAPNPStartDevice+0x835>
   121af:	ff 24 85 40 30 01 00 	jmp    *0x13040(,%eax,4)
   121b6:	8b 85 10 ff ff ff    	mov    0xffffff10(%ebp),%eax
   121bc:	66 85 c0             	test   %ax,%ax
   121bf:	0f 84 2f fd ff ff    	je     11ef4 <_ISAPNPStartDevice+0x5b4>
   121c5:	25 ff ff 00 00       	and    $0xffff,%eax
   121ca:	e8 f1 f2 ff ff       	call   114c0 <_Skip>
   121cf:	e9 20 fd ff ff       	jmp    11ef4 <_ISAPNPStartDevice+0x5b4>
   121d4:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   121da:	66 83 f9 03          	cmp    $0x3,%cx
   121de:	75 9b                	jne    1217b <_ISAPNPStartDevice+0x83b>
   121e0:	50                   	push   %eax
   121e1:	50                   	push   %eax
   121e2:	8d 85 68 ff ff ff    	lea    0xffffff68(%ebp),%eax
   121e8:	6a 03                	push   $0x3
   121ea:	50                   	push   %eax
   121eb:	e8 60 f2 ff ff       	call   11450 <_Peek>
   121f0:	5e                   	pop    %esi
   121f1:	58                   	pop    %eax
   121f2:	8d 85 f8 fe ff ff    	lea    0xfffffef8(%ebp),%eax
   121f8:	50                   	push   %eax
   121f9:	8b 9d a0 fe ff ff    	mov    0xfffffea0(%ebp),%ebx
   121ff:	8b 95 a4 fe ff ff    	mov    0xfffffea4(%ebp),%edx
   12205:	89 f8                	mov    %edi,%eax
   12207:	53                   	push   %ebx
   12208:	e8 03 f4 ff ff       	call   11610 <_AddResourceDescriptor>
   1220d:	83 c4 10             	add    $0x10,%esp
   12210:	85 c0                	test   %eax,%eax
   12212:	78 6c                	js     12280 <_ISAPNPStartDevice+0x940>
   12214:	8b 85 f8 fe ff ff    	mov    0xfffffef8(%ebp),%eax
   1221a:	31 d2                	xor    %edx,%edx
   1221c:	c6 40 09 01          	movb   $0x1,0x9(%eax)
   12220:	8b 85 f8 fe ff ff    	mov    0xfffffef8(%ebp),%eax
   12226:	c6 40 0a 01          	movb   $0x1,0xa(%eax)
   1222a:	31 c0                	xor    %eax,%eax
   1222c:	8b 8d f8 fe ff ff    	mov    0xfffffef8(%ebp),%ecx
   12232:	8a 85 6a ff ff ff    	mov    0xffffff6a(%ebp),%al
   12238:	89 41 10             	mov    %eax,0x10(%ecx)
   1223b:	c7 41 14 00 00 00 00 	movl   $0x0,0x14(%ecx)
   12242:	31 c0                	xor    %eax,%eax
   12244:	8a 95 68 ff ff ff    	mov    0xffffff68(%ebp),%dl
   1224a:	8a 85 69 ff ff ff    	mov    0xffffff69(%ebp),%al
   12250:	c1 e0 08             	shl    $0x8,%eax
   12253:	09 d0                	or     %edx,%eax
   12255:	89 c2                	mov    %eax,%edx
   12257:	89 41 18             	mov    %eax,0x18(%ecx)
   1225a:	c1 fa 1f             	sar    $0x1f,%edx
   1225d:	31 c0                	xor    %eax,%eax
   1225f:	89 51 1c             	mov    %edx,0x1c(%ecx)
   12262:	31 d2                	xor    %edx,%edx
   12264:	8a 85 69 ff ff ff    	mov    0xffffff69(%ebp),%al
   1226a:	8a 95 68 ff ff ff    	mov    0xffffff68(%ebp),%dl
   12270:	c1 e0 08             	shl    $0x8,%eax
   12273:	09 d0                	or     %edx,%eax
   12275:	89 c2                	mov    %eax,%edx
   12277:	89 41 20             	mov    %eax,0x20(%ecx)
   1227a:	c1 fa 1f             	sar    $0x1f,%edx
   1227d:	89 51 24             	mov    %edx,0x24(%ecx)
   12280:	66 c7 85 10 ff ff ff 	movw   $0x0,0xffffff10(%ebp)
   12287:	00 00 
   12289:	e9 48 fd ff ff       	jmp    11fd6 <_ISAPNPStartDevice+0x696>
   1228e:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   12294:	66 83 f9 11          	cmp    $0x11,%cx
   12298:	0f 85 dd fe ff ff    	jne    1217b <_ISAPNPStartDevice+0x83b>
   1229e:	8d 85 18 ff ff ff    	lea    0xffffff18(%ebp),%eax
   122a4:	51                   	push   %ecx
   122a5:	51                   	push   %ecx
   122a6:	6a 11                	push   $0x11
   122a8:	50                   	push   %eax
   122a9:	e8 a2 f1 ff ff       	call   11450 <_Peek>
   122ae:	58                   	pop    %eax
   122af:	8d 85 ec fe ff ff    	lea    0xfffffeec(%ebp),%eax
   122b5:	5a                   	pop    %edx
   122b6:	50                   	push   %eax
   122b7:	8b 85 a0 fe ff ff    	mov    0xfffffea0(%ebp),%eax
   122bd:	50                   	push   %eax
   122be:	8b 95 a4 fe ff ff    	mov    0xfffffea4(%ebp),%edx
   122c4:	89 f8                	mov    %edi,%eax
   122c6:	e8 45 f3 ff ff       	call   11610 <_AddResourceDescriptor>
   122cb:	83 c4 10             	add    $0x10,%esp
   122ce:	85 c0                	test   %eax,%eax
   122d0:	78 ae                	js     12280 <_ISAPNPStartDevice+0x940>
   122d2:	8b 85 ec fe ff ff    	mov    0xfffffeec(%ebp),%eax
   122d8:	31 d2                	xor    %edx,%edx
   122da:	31 c9                	xor    %ecx,%ecx
   122dc:	c6 40 09 03          	movb   $0x3,0x9(%eax)
   122e0:	8b 85 ec fe ff ff    	mov    0xfffffeec(%ebp),%eax
   122e6:	c6 40 0a 01          	movb   $0x1,0xa(%eax)
   122ea:	31 c0                	xor    %eax,%eax
   122ec:	8a 85 24 ff ff ff    	mov    0xffffff24(%ebp),%al
   122f2:	8a 95 23 ff ff ff    	mov    0xffffff23(%ebp),%dl
   122f8:	c1 e0 08             	shl    $0x8,%eax
   122fb:	8a 8d 21 ff ff ff    	mov    0xffffff21(%ebp),%cl
   12301:	09 d0                	or     %edx,%eax
   12303:	31 d2                	xor    %edx,%edx
   12305:	8a 95 22 ff ff ff    	mov    0xffffff22(%ebp),%dl
   1230b:	8b 9d ec fe ff ff    	mov    0xfffffeec(%ebp),%ebx
   12311:	c1 e2 08             	shl    $0x8,%edx
   12314:	c1 e0 10             	shl    $0x10,%eax
   12317:	09 ca                	or     %ecx,%edx
   12319:	09 d0                	or     %edx,%eax
   1231b:	31 d2                	xor    %edx,%edx
   1231d:	89 43 10             	mov    %eax,0x10(%ebx)
   12320:	31 c0                	xor    %eax,%eax
   12322:	8a 85 20 ff ff ff    	mov    0xffffff20(%ebp),%al
   12328:	8a 95 1f ff ff ff    	mov    0xffffff1f(%ebp),%dl
   1232e:	c1 e0 08             	shl    $0x8,%eax
   12331:	31 c9                	xor    %ecx,%ecx
   12333:	09 d0                	or     %edx,%eax
   12335:	31 d2                	xor    %edx,%edx
   12337:	8a 95 1e ff ff ff    	mov    0xffffff1e(%ebp),%dl
   1233d:	8a 8d 1d ff ff ff    	mov    0xffffff1d(%ebp),%cl
   12343:	c1 e2 08             	shl    $0x8,%edx
   12346:	c1 e0 10             	shl    $0x10,%eax
   12349:	09 ca                	or     %ecx,%edx
   1234b:	09 d0                	or     %edx,%eax
   1234d:	31 d2                	xor    %edx,%edx
   1234f:	89 43 14             	mov    %eax,0x14(%ebx)
   12352:	31 c0                	xor    %eax,%eax
   12354:	8a 85 1c ff ff ff    	mov    0xffffff1c(%ebp),%al
   1235a:	8a 95 1b ff ff ff    	mov    0xffffff1b(%ebp),%dl
   12360:	c1 e0 08             	shl    $0x8,%eax
   12363:	31 c9                	xor    %ecx,%ecx
   12365:	09 d0                	or     %edx,%eax
   12367:	31 d2                	xor    %edx,%edx
   12369:	8a 95 1a ff ff ff    	mov    0xffffff1a(%ebp),%dl
   1236f:	8a 8d 19 ff ff ff    	mov    0xffffff19(%ebp),%cl
   12375:	c1 e2 08             	shl    $0x8,%edx
   12378:	c1 e0 10             	shl    $0x10,%eax
   1237b:	09 ca                	or     %ecx,%edx
   1237d:	09 d0                	or     %edx,%eax
   1237f:	89 c1                	mov    %eax,%ecx
   12381:	89 43 18             	mov    %eax,0x18(%ebx)
   12384:	c1 f9 1f             	sar    $0x1f,%ecx
   12387:	31 c0                	xor    %eax,%eax
   12389:	89 4b 1c             	mov    %ecx,0x1c(%ebx)
   1238c:	8a 85 1c ff ff ff    	mov    0xffffff1c(%ebp),%al
   12392:	c1 e0 08             	shl    $0x8,%eax
   12395:	31 d2                	xor    %edx,%edx
   12397:	8a 95 1b ff ff ff    	mov    0xffffff1b(%ebp),%dl
   1239d:	31 c9                	xor    %ecx,%ecx
   1239f:	09 d0                	or     %edx,%eax
   123a1:	31 d2                	xor    %edx,%edx
   123a3:	8a 95 1a ff ff ff    	mov    0xffffff1a(%ebp),%dl
   123a9:	8a 8d 19 ff ff ff    	mov    0xffffff19(%ebp),%cl
   123af:	c1 e0 10             	shl    $0x10,%eax
   123b2:	c1 e2 08             	shl    $0x8,%edx
   123b5:	09 ca                	or     %ecx,%edx
   123b7:	09 d0                	or     %edx,%eax
   123b9:	89 c2                	mov    %eax,%edx
   123bb:	89 43 20             	mov    %eax,0x20(%ebx)
   123be:	c1 fa 1f             	sar    $0x1f,%edx
   123c1:	89 53 24             	mov    %edx,0x24(%ebx)
   123c4:	e9 b7 fe ff ff       	jmp    12280 <_ISAPNPStartDevice+0x940>
   123c9:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   123cf:	66 83 f9 11          	cmp    $0x11,%cx
   123d3:	0f 85 a2 fd ff ff    	jne    1217b <_ISAPNPStartDevice+0x83b>
   123d9:	50                   	push   %eax
   123da:	50                   	push   %eax
   123db:	8d 85 38 ff ff ff    	lea    0xffffff38(%ebp),%eax
   123e1:	6a 11                	push   $0x11
   123e3:	50                   	push   %eax
   123e4:	e8 67 f0 ff ff       	call   11450 <_Peek>
   123e9:	5e                   	pop    %esi
   123ea:	58                   	pop    %eax
   123eb:	8d 85 f0 fe ff ff    	lea    0xfffffef0(%ebp),%eax
   123f1:	50                   	push   %eax
   123f2:	8b 9d a0 fe ff ff    	mov    0xfffffea0(%ebp),%ebx
   123f8:	8b 95 a4 fe ff ff    	mov    0xfffffea4(%ebp),%edx
   123fe:	89 f8                	mov    %edi,%eax
   12400:	53                   	push   %ebx
   12401:	e8 0a f2 ff ff       	call   11610 <_AddResourceDescriptor>
   12406:	83 c4 10             	add    $0x10,%esp
   12409:	85 c0                	test   %eax,%eax
   1240b:	0f 88 6f fe ff ff    	js     12280 <_ISAPNPStartDevice+0x940>
   12411:	8b 85 f0 fe ff ff    	mov    0xfffffef0(%ebp),%eax
   12417:	31 d2                	xor    %edx,%edx
   12419:	31 c9                	xor    %ecx,%ecx
   1241b:	c6 40 09 03          	movb   $0x3,0x9(%eax)
   1241f:	8b 85 f0 fe ff ff    	mov    0xfffffef0(%ebp),%eax
   12425:	c6 40 0a 01          	movb   $0x1,0xa(%eax)
   12429:	31 c0                	xor    %eax,%eax
   1242b:	8a 85 48 ff ff ff    	mov    0xffffff48(%ebp),%al
   12431:	8a 95 47 ff ff ff    	mov    0xffffff47(%ebp),%dl
   12437:	c1 e0 08             	shl    $0x8,%eax
   1243a:	8a 8d 45 ff ff ff    	mov    0xffffff45(%ebp),%cl
   12440:	09 d0                	or     %edx,%eax
   12442:	31 d2                	xor    %edx,%edx
   12444:	8a 95 46 ff ff ff    	mov    0xffffff46(%ebp),%dl
   1244a:	8b 9d f0 fe ff ff    	mov    0xfffffef0(%ebp),%ebx
   12450:	c1 e2 08             	shl    $0x8,%edx
   12453:	c1 e0 10             	shl    $0x10,%eax
   12456:	09 ca                	or     %ecx,%edx
   12458:	09 d0                	or     %edx,%eax
   1245a:	31 d2                	xor    %edx,%edx
   1245c:	89 43 10             	mov    %eax,0x10(%ebx)
   1245f:	31 c0                	xor    %eax,%eax
   12461:	8a 85 44 ff ff ff    	mov    0xffffff44(%ebp),%al
   12467:	8a 95 43 ff ff ff    	mov    0xffffff43(%ebp),%dl
   1246d:	c1 e0 08             	shl    $0x8,%eax
   12470:	31 c9                	xor    %ecx,%ecx
   12472:	09 d0                	or     %edx,%eax
   12474:	31 d2                	xor    %edx,%edx
   12476:	8a 95 42 ff ff ff    	mov    0xffffff42(%ebp),%dl
   1247c:	8a 8d 41 ff ff ff    	mov    0xffffff41(%ebp),%cl
   12482:	c1 e2 08             	shl    $0x8,%edx
   12485:	c1 e0 10             	shl    $0x10,%eax
   12488:	09 ca                	or     %ecx,%edx
   1248a:	09 d0                	or     %edx,%eax
   1248c:	31 d2                	xor    %edx,%edx
   1248e:	89 43 14             	mov    %eax,0x14(%ebx)
   12491:	31 c0                	xor    %eax,%eax
   12493:	8a 85 3c ff ff ff    	mov    0xffffff3c(%ebp),%al
   12499:	8a 95 3b ff ff ff    	mov    0xffffff3b(%ebp),%dl
   1249f:	c1 e0 08             	shl    $0x8,%eax
   124a2:	31 c9                	xor    %ecx,%ecx
   124a4:	09 d0                	or     %edx,%eax
   124a6:	31 d2                	xor    %edx,%edx
   124a8:	8a 95 3a ff ff ff    	mov    0xffffff3a(%ebp),%dl
   124ae:	8a 8d 39 ff ff ff    	mov    0xffffff39(%ebp),%cl
   124b4:	c1 e2 08             	shl    $0x8,%edx
   124b7:	c1 e0 10             	shl    $0x10,%eax
   124ba:	09 ca                	or     %ecx,%edx
   124bc:	09 d0                	or     %edx,%eax
   124be:	89 c1                	mov    %eax,%ecx
   124c0:	89 43 18             	mov    %eax,0x18(%ebx)
   124c3:	c1 f9 1f             	sar    $0x1f,%ecx
   124c6:	31 c0                	xor    %eax,%eax
   124c8:	89 4b 1c             	mov    %ecx,0x1c(%ebx)
   124cb:	8a 85 40 ff ff ff    	mov    0xffffff40(%ebp),%al
   124d1:	c1 e0 08             	shl    $0x8,%eax
   124d4:	31 d2                	xor    %edx,%edx
   124d6:	8a 95 3f ff ff ff    	mov    0xffffff3f(%ebp),%dl
   124dc:	31 c9                	xor    %ecx,%ecx
   124de:	09 d0                	or     %edx,%eax
   124e0:	31 d2                	xor    %edx,%edx
   124e2:	8a 95 3e ff ff ff    	mov    0xffffff3e(%ebp),%dl
   124e8:	8a 8d 3d ff ff ff    	mov    0xffffff3d(%ebp),%cl
   124ee:	c1 e0 10             	shl    $0x10,%eax
   124f1:	c1 e2 08             	shl    $0x8,%edx
   124f4:	e9 bc fe ff ff       	jmp    123b5 <_ISAPNPStartDevice+0xa75>
   124f9:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   124ff:	66 83 f9 09          	cmp    $0x9,%cx
   12503:	0f 85 72 fc ff ff    	jne    1217b <_ISAPNPStartDevice+0x83b>
   12509:	8d 85 58 ff ff ff    	lea    0xffffff58(%ebp),%eax
   1250f:	51                   	push   %ecx
   12510:	51                   	push   %ecx
   12511:	6a 09                	push   $0x9
   12513:	50                   	push   %eax
   12514:	e8 37 ef ff ff       	call   11450 <_Peek>
   12519:	58                   	pop    %eax
   1251a:	8d 85 f4 fe ff ff    	lea    0xfffffef4(%ebp),%eax
   12520:	5a                   	pop    %edx
   12521:	50                   	push   %eax
   12522:	8b 85 a0 fe ff ff    	mov    0xfffffea0(%ebp),%eax
   12528:	50                   	push   %eax
   12529:	8b 95 a4 fe ff ff    	mov    0xfffffea4(%ebp),%edx
   1252f:	89 f8                	mov    %edi,%eax
   12531:	e8 da f0 ff ff       	call   11610 <_AddResourceDescriptor>
   12536:	83 c4 10             	add    $0x10,%esp
   12539:	85 c0                	test   %eax,%eax
   1253b:	0f 88 3f fd ff ff    	js     12280 <_ISAPNPStartDevice+0x940>
   12541:	8b 85 f4 fe ff ff    	mov    0xfffffef4(%ebp),%eax
   12547:	31 d2                	xor    %edx,%edx
   12549:	c6 40 09 03          	movb   $0x3,0x9(%eax)
   1254d:	8b 85 f4 fe ff ff    	mov    0xfffffef4(%ebp),%eax
   12553:	c6 40 0a 01          	movb   $0x1,0xa(%eax)
   12557:	31 c0                	xor    %eax,%eax
   12559:	8a 85 60 ff ff ff    	mov    0xffffff60(%ebp),%al
   1255f:	8a 95 5f ff ff ff    	mov    0xffffff5f(%ebp),%dl
   12565:	c1 e0 08             	shl    $0x8,%eax
   12568:	8b 8d f4 fe ff ff    	mov    0xfffffef4(%ebp),%ecx
   1256e:	09 d0                	or     %edx,%eax
   12570:	31 d2                	xor    %edx,%edx
   12572:	c1 e0 08             	shl    $0x8,%eax
   12575:	89 41 10             	mov    %eax,0x10(%ecx)
   12578:	31 c0                	xor    %eax,%eax
   1257a:	8a 85 5e ff ff ff    	mov    0xffffff5e(%ebp),%al
   12580:	8a 95 5d ff ff ff    	mov    0xffffff5d(%ebp),%dl
   12586:	c1 e0 08             	shl    $0x8,%eax
   12589:	09 d0                	or     %edx,%eax
   1258b:	31 d2                	xor    %edx,%edx
   1258d:	89 41 14             	mov    %eax,0x14(%ecx)
   12590:	31 c0                	xor    %eax,%eax
   12592:	8a 85 5a ff ff ff    	mov    0xffffff5a(%ebp),%al
   12598:	8a 95 59 ff ff ff    	mov    0xffffff59(%ebp),%dl
   1259e:	c1 e0 08             	shl    $0x8,%eax
   125a1:	09 d0                	or     %edx,%eax
   125a3:	c1 e0 08             	shl    $0x8,%eax
   125a6:	89 c2                	mov    %eax,%edx
   125a8:	89 41 18             	mov    %eax,0x18(%ecx)
   125ab:	c1 fa 1f             	sar    $0x1f,%edx
   125ae:	31 c0                	xor    %eax,%eax
   125b0:	89 51 1c             	mov    %edx,0x1c(%ecx)
   125b3:	31 d2                	xor    %edx,%edx
   125b5:	8a 85 5c ff ff ff    	mov    0xffffff5c(%ebp),%al
   125bb:	8a 95 5b ff ff ff    	mov    0xffffff5b(%ebp),%dl
   125c1:	c1 e0 08             	shl    $0x8,%eax
   125c4:	09 d0                	or     %edx,%eax
   125c6:	c1 e0 08             	shl    $0x8,%eax
   125c9:	e9 a7 fc ff ff       	jmp    12275 <_ISAPNPStartDevice+0x935>
   125ce:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   125d4:	c7 85 ac fe ff ff 01 	movl   $0x1,0xfffffeac(%ebp)
   125db:	00 00 00 
   125de:	8d 41 fb             	lea    0xfffffffb(%ecx),%eax
   125e1:	66 83 f8 01          	cmp    $0x1,%ax
   125e5:	0f 86 c7 01 00 00    	jbe    127b2 <_ISAPNPStartDevice+0xe72>
   125eb:	c7 85 a4 fe ff ff 00 	movl   $0x0,0xfffffea4(%ebp)
   125f2:	00 00 00 
   125f5:	c7 85 a0 fe ff ff 00 	movl   $0x0,0xfffffea0(%ebp)
   125fc:	00 00 00 
   125ff:	c7 85 a8 fe ff ff 00 	movl   $0x0,0xfffffea8(%ebp)
   12606:	00 00 00 
   12609:	e9 6d fb ff ff       	jmp    1217b <_ISAPNPStartDevice+0x83b>
   1260e:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   12614:	8d 41 fe             	lea    0xfffffffe(%ecx),%eax
   12617:	66 83 f8 01          	cmp    $0x1,%ax
   1261b:	0f 87 5a fb ff ff    	ja     1217b <_ISAPNPStartDevice+0x83b>
   12621:	89 c8                	mov    %ecx,%eax
   12623:	25 ff ff 00 00       	and    $0xffff,%eax
   12628:	52                   	push   %edx
   12629:	52                   	push   %edx
   1262a:	50                   	push   %eax
   1262b:	8d 45 88             	lea    0xffffff88(%ebp),%eax
   1262e:	c7 85 9c fe ff ff 00 	movl   $0x0,0xfffffe9c(%ebp)
   12635:	00 00 00 
   12638:	50                   	push   %eax
   12639:	e8 12 ee ff ff       	call   11450 <_Peek>
   1263e:	31 c0                	xor    %eax,%eax
   12640:	83 c4 10             	add    $0x10,%esp
   12643:	8a 45 88             	mov    0xffffff88(%ebp),%al
   12646:	c6 85 77 fe ff ff 00 	movb   $0x0,0xfffffe77(%ebp)
   1264d:	89 c6                	mov    %eax,%esi
   1264f:	31 db                	xor    %ebx,%ebx
   12651:	c1 e6 08             	shl    $0x8,%esi
   12654:	09 c6                	or     %eax,%esi
   12656:	80 bd 77 fe ff ff 00 	cmpb   $0x0,0xfffffe77(%ebp)
   1265d:	75 1a                	jne    12679 <_ISAPNPStartDevice+0xd39>
   1265f:	b8 01 00 00 00       	mov    $0x1,%eax
   12664:	88 d9                	mov    %bl,%cl
   12666:	d3 e0                	shl    %cl,%eax
   12668:	85 c6                	test   %eax,%esi
   1266a:	74 1a                	je     12686 <_ISAPNPStartDevice+0xd46>
   1266c:	89 9d 9c fe ff ff    	mov    %ebx,0xfffffe9c(%ebp)
   12672:	c6 85 77 fe ff ff 01 	movb   $0x1,0xfffffe77(%ebp)
   12679:	b8 01 00 00 00       	mov    $0x1,%eax
   1267e:	88 d9                	mov    %bl,%cl
   12680:	d3 e0                	shl    %cl,%eax
   12682:	85 c6                	test   %eax,%esi
   12684:	74 1d                	je     126a3 <_ISAPNPStartDevice+0xd63>
   12686:	b8 01 00 00 00       	mov    $0x1,%eax
   1268b:	88 d9                	mov    %bl,%cl
   1268d:	d3 e0                	shl    %cl,%eax
   1268f:	85 c6                	test   %eax,%esi
   12691:	0f 95 c2             	setne  %dl
   12694:	83 fb 0f             	cmp    $0xf,%ebx
   12697:	0f 94 c0             	sete   %al
   1269a:	25 ff 00 00 00       	and    $0xff,%eax
   1269f:	85 c2                	test   %eax,%edx
   126a1:	74 7e                	je     12721 <_ISAPNPStartDevice+0xde1>
   126a3:	50                   	push   %eax
   126a4:	50                   	push   %eax
   126a5:	8d 85 08 ff ff ff    	lea    0xffffff08(%ebp),%eax
   126ab:	50                   	push   %eax
   126ac:	8b 85 a0 fe ff ff    	mov    0xfffffea0(%ebp),%eax
   126b2:	50                   	push   %eax
   126b3:	8b 95 a4 fe ff ff    	mov    0xfffffea4(%ebp),%edx
   126b9:	89 f8                	mov    %edi,%eax
   126bb:	e8 50 ef ff ff       	call   11610 <_AddResourceDescriptor>
   126c0:	83 c4 10             	add    $0x10,%esp
   126c3:	85 c0                	test   %eax,%eax
   126c5:	0f 88 b5 fb ff ff    	js     12280 <_ISAPNPStartDevice+0x940>
   126cb:	8b 85 08 ff ff ff    	mov    0xffffff08(%ebp),%eax
   126d1:	88 d9                	mov    %bl,%cl
   126d3:	c6 40 09 02          	movb   $0x2,0x9(%eax)
   126d7:	8b 85 08 ff ff ff    	mov    0xffffff08(%ebp),%eax
   126dd:	c6 40 0a 01          	movb   $0x1,0xa(%eax)
   126e1:	8b 85 08 ff ff ff    	mov    0xffffff08(%ebp),%eax
   126e7:	8b 95 9c fe ff ff    	mov    0xfffffe9c(%ebp),%edx
   126ed:	89 85 70 fe ff ff    	mov    %eax,0xfffffe70(%ebp)
   126f3:	89 50 10             	mov    %edx,0x10(%eax)
   126f6:	b8 01 00 00 00       	mov    $0x1,%eax
   126fb:	d3 e0                	shl    %cl,%eax
   126fd:	85 c6                	test   %eax,%esi
   126ff:	0f 95 c2             	setne  %dl
   12702:	83 fb 0f             	cmp    $0xf,%ebx
   12705:	0f 94 c0             	sete   %al
   12708:	25 ff 00 00 00       	and    $0xff,%eax
   1270d:	85 c2                	test   %eax,%edx
   1270f:	74 1f                	je     12730 <_ISAPNPStartDevice+0xdf0>
   12711:	8b 85 70 fe ff ff    	mov    0xfffffe70(%ebp),%eax
   12717:	89 58 14             	mov    %ebx,0x14(%eax)
   1271a:	c6 85 77 fe ff ff 00 	movb   $0x0,0xfffffe77(%ebp)
   12721:	43                   	inc    %ebx
   12722:	83 fb 0f             	cmp    $0xf,%ebx
   12725:	0f 86 2b ff ff ff    	jbe    12656 <_ISAPNPStartDevice+0xd16>
   1272b:	e9 50 fb ff ff       	jmp    12280 <_ISAPNPStartDevice+0x940>
   12730:	8b 95 70 fe ff ff    	mov    0xfffffe70(%ebp),%edx
   12736:	8d 43 ff             	lea    0xffffffff(%ebx),%eax
   12739:	89 42 14             	mov    %eax,0x14(%edx)
   1273c:	eb dc                	jmp    1271a <_ISAPNPStartDevice+0xdda>
   1273e:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   12744:	66 83 f9 04          	cmp    $0x4,%cx
   12748:	0f 94 c2             	sete   %dl
   1274b:	83 bd a8 fe ff ff 1f 	cmpl   $0x1f,0xfffffea8(%ebp)
   12752:	0f 96 c0             	setbe  %al
   12755:	25 ff 00 00 00       	and    $0xff,%eax
   1275a:	85 c2                	test   %eax,%edx
   1275c:	0f 84 19 fa ff ff    	je     1217b <_ISAPNPStartDevice+0x83b>
   12762:	8d 45 98             	lea    0xffffff98(%ebp),%eax
   12765:	51                   	push   %ecx
   12766:	51                   	push   %ecx
   12767:	6a 04                	push   $0x4
   12769:	50                   	push   %eax
   1276a:	e8 e1 ec ff ff       	call   11450 <_Peek>
   1276f:	31 d2                	xor    %edx,%edx
   12771:	8a 55 99             	mov    0xffffff99(%ebp),%dl
   12774:	31 c0                	xor    %eax,%eax
   12776:	8a 45 98             	mov    0xffffff98(%ebp),%al
   12779:	8b 8d a8 fe ff ff    	mov    0xfffffea8(%ebp),%ecx
   1277f:	c1 e2 08             	shl    $0x8,%edx
   12782:	83 c4 10             	add    $0x10,%esp
   12785:	09 d0                	or     %edx,%eax
   12787:	8b 95 a8 fe ff ff    	mov    0xfffffea8(%ebp),%edx
   1278d:	66 89 44 57 16       	mov    %ax,0x16(%edi,%edx,2)
   12792:	31 d2                	xor    %edx,%edx
   12794:	8a 55 9b             	mov    0xffffff9b(%ebp),%dl
   12797:	31 c0                	xor    %eax,%eax
   12799:	c1 e2 08             	shl    $0x8,%edx
   1279c:	8a 45 9a             	mov    0xffffff9a(%ebp),%al
   1279f:	09 d0                	or     %edx,%eax
   127a1:	66 89 44 4f 56       	mov    %ax,0x56(%edi,%ecx,2)
   127a6:	41                   	inc    %ecx
   127a7:	89 8d a8 fe ff ff    	mov    %ecx,0xfffffea8(%ebp)
   127ad:	e9 ce fa ff ff       	jmp    12280 <_ISAPNPStartDevice+0x940>
   127b2:	8b 85 b0 fe ff ff    	mov    0xfffffeb0(%ebp),%eax
   127b8:	25 ff ff 00 00       	and    $0xffff,%eax
   127bd:	56                   	push   %esi
   127be:	56                   	push   %esi
   127bf:	50                   	push   %eax
   127c0:	89 c8                	mov    %ecx,%eax
   127c2:	8b 9d b0 fe ff ff    	mov    0xfffffeb0(%ebp),%ebx
   127c8:	25 ff ff 00 00       	and    $0xffff,%eax
   127cd:	43                   	inc    %ebx
   127ce:	50                   	push   %eax
   127cf:	8b 95 b8 fe ff ff    	mov    0xfffffeb8(%ebp),%edx
   127d5:	8b 85 e8 fe ff ff    	mov    0xfffffee8(%ebp),%eax
   127db:	89 9d b0 fe ff ff    	mov    %ebx,0xfffffeb0(%ebp)
   127e1:	e8 4a ef ff ff       	call   11730 <_ParseLogicalDevice>
   127e6:	83 c4 10             	add    $0x10,%esp
   127e9:	89 c7                	mov    %eax,%edi
   127eb:	85 c0                	test   %eax,%eax
   127ed:	0f 84 01 f7 ff ff    	je     11ef4 <_ISAPNPStartDevice+0x5b4>
   127f3:	31 c9                	xor    %ecx,%ecx
   127f5:	66 c7 85 10 ff ff ff 	movw   $0x0,0xffffff10(%ebp)
   127fc:	00 00 
   127fe:	c7 85 ac fe ff ff 00 	movl   $0x0,0xfffffeac(%ebp)
   12805:	00 00 00 
   12808:	e9 de fd ff ff       	jmp    125eb <_ISAPNPStartDevice+0xcab>
   1280d:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   12813:	66 83 f9 07          	cmp    $0x7,%cx
   12817:	0f 85 5e f9 ff ff    	jne    1217b <_ISAPNPStartDevice+0x83b>
   1281d:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
   12823:	51                   	push   %ecx
   12824:	51                   	push   %ecx
   12825:	6a 07                	push   $0x7
   12827:	50                   	push   %eax
   12828:	e8 23 ec ff ff       	call   11450 <_Peek>
   1282d:	58                   	pop    %eax
   1282e:	8d 85 fc fe ff ff    	lea    0xfffffefc(%ebp),%eax
   12834:	5a                   	pop    %edx
   12835:	50                   	push   %eax
   12836:	8b 85 a0 fe ff ff    	mov    0xfffffea0(%ebp),%eax
   1283c:	50                   	push   %eax
   1283d:	8b 95 a4 fe ff ff    	mov    0xfffffea4(%ebp),%edx
   12843:	89 f8                	mov    %edi,%eax
   12845:	e8 c6 ed ff ff       	call   11610 <_AddResourceDescriptor>
   1284a:	83 c4 10             	add    $0x10,%esp
   1284d:	85 c0                	test   %eax,%eax
   1284f:	0f 88 2b fa ff ff    	js     12280 <_ISAPNPStartDevice+0x940>
   12855:	8b 85 fc fe ff ff    	mov    0xfffffefc(%ebp),%eax
   1285b:	31 d2                	xor    %edx,%edx
   1285d:	c6 40 09 01          	movb   $0x1,0x9(%eax)
   12861:	8b 85 fc fe ff ff    	mov    0xfffffefc(%ebp),%eax
   12867:	c6 40 0a 01          	movb   $0x1,0xa(%eax)
   1286b:	31 c0                	xor    %eax,%eax
   1286d:	8b 8d fc fe ff ff    	mov    0xfffffefc(%ebp),%ecx
   12873:	8a 85 7e ff ff ff    	mov    0xffffff7e(%ebp),%al
   12879:	89 41 10             	mov    %eax,0x10(%ecx)
   1287c:	c7 41 14 00 00 00 00 	movl   $0x0,0x14(%ecx)
   12883:	31 c0                	xor    %eax,%eax
   12885:	8a 95 79 ff ff ff    	mov    0xffffff79(%ebp),%dl
   1288b:	8a 85 7a ff ff ff    	mov    0xffffff7a(%ebp),%al
   12891:	c1 e0 08             	shl    $0x8,%eax
   12894:	09 d0                	or     %edx,%eax
   12896:	89 c2                	mov    %eax,%edx
   12898:	89 41 18             	mov    %eax,0x18(%ecx)
   1289b:	c1 fa 1f             	sar    $0x1f,%edx
   1289e:	89 51 1c             	mov    %edx,0x1c(%ecx)
   128a1:	31 d2                	xor    %edx,%edx
   128a3:	8a 95 7c ff ff ff    	mov    0xffffff7c(%ebp),%dl
   128a9:	89 d0                	mov    %edx,%eax
   128ab:	c1 e0 08             	shl    $0x8,%eax
   128ae:	e9 c0 f9 ff ff       	jmp    12273 <_ISAPNPStartDevice+0x933>
   128b3:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   128b9:	66 85 c9             	test   %cx,%cx
   128bc:	0f 85 c2 f8 ff ff    	jne    12184 <_ISAPNPStartDevice+0x844>
   128c2:	c7 85 a4 fe ff ff 00 	movl   $0x0,0xfffffea4(%ebp)
   128c9:	00 00 00 
   128cc:	c7 85 a0 fe ff ff 00 	movl   $0x0,0xfffffea0(%ebp)
   128d3:	00 00 00 
   128d6:	c7 87 bc 00 00 00 00 	movl   $0x0,0xbc(%edi)
   128dd:	00 00 00 
   128e0:	e9 f1 f6 ff ff       	jmp    11fd6 <_ISAPNPStartDevice+0x696>
   128e5:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   128eb:	66 83 f9 01          	cmp    $0x1,%cx
   128ef:	0f 87 86 f8 ff ff    	ja     1217b <_ISAPNPStartDevice+0x83b>
   128f5:	c7 85 a4 fe ff ff 00 	movl   $0x0,0xfffffea4(%ebp)
   128fc:	00 00 00 
   128ff:	c7 85 a0 fe ff ff 08 	movl   $0x8,0xfffffea0(%ebp)
   12906:	00 00 00 
   12909:	66 85 c9             	test   %cx,%cx
   1290c:	74 c8                	je     128d6 <_ISAPNPStartDevice+0xf96>
   1290e:	89 c8                	mov    %ecx,%eax
   12910:	25 ff ff 00 00       	and    $0xffff,%eax
   12915:	53                   	push   %ebx
   12916:	53                   	push   %ebx
   12917:	50                   	push   %eax
   12918:	8d 45 98             	lea    0xffffff98(%ebp),%eax
   1291b:	50                   	push   %eax
   1291c:	e8 2f eb ff ff       	call   11450 <_Peek>
   12921:	31 c9                	xor    %ecx,%ecx
   12923:	83 c4 10             	add    $0x10,%esp
   12926:	8a 4d 98             	mov    0xffffff98(%ebp),%cl
   12929:	66 c7 85 10 ff ff ff 	movw   $0x0,0xffffff10(%ebp)
   12930:	00 00 
   12932:	89 8d a4 fe ff ff    	mov    %ecx,0xfffffea4(%ebp)
   12938:	c7 85 a0 fe ff ff 08 	movl   $0x8,0xfffffea0(%ebp)
   1293f:	00 00 00 
   12942:	eb 92                	jmp    128d6 <_ISAPNPStartDevice+0xf96>
   12944:	8b 8d 10 ff ff ff    	mov    0xffffff10(%ebp),%ecx
   1294a:	66 83 f9 02          	cmp    $0x2,%cx
   1294e:	0f 85 27 f8 ff ff    	jne    1217b <_ISAPNPStartDevice+0x83b>
   12954:	50                   	push   %eax
   12955:	50                   	push   %eax
   12956:	8d 85 06 ff ff ff    	lea    0xffffff06(%ebp),%eax
   1295c:	6a 02                	push   $0x2
   1295e:	c7 85 98 fe ff ff 00 	movl   $0x0,0xfffffe98(%ebp)
   12965:	00 00 00 
   12968:	50                   	push   %eax
   12969:	e8 e2 ea ff ff       	call   11450 <_Peek>
   1296e:	8a 8d 06 ff ff ff    	mov    0xffffff06(%ebp),%cl
   12974:	83 c4 10             	add    $0x10,%esp
   12977:	81 e1 ff 00 00 00    	and    $0xff,%ecx
   1297d:	c6 85 70 fe ff ff 00 	movb   $0x0,0xfffffe70(%ebp)
   12984:	89 ce                	mov    %ecx,%esi
   12986:	31 db                	xor    %ebx,%ebx
   12988:	80 bd 70 fe ff ff 00 	cmpb   $0x0,0xfffffe70(%ebp)
   1298f:	75 1a                	jne    129ab <_ISAPNPStartDevice+0x106b>
   12991:	b8 01 00 00 00       	mov    $0x1,%eax
   12996:	88 d9                	mov    %bl,%cl
   12998:	d3 e0                	shl    %cl,%eax
   1299a:	85 c6                	test   %eax,%esi
   1299c:	74 1a                	je     129b8 <_ISAPNPStartDevice+0x1078>
   1299e:	89 9d 98 fe ff ff    	mov    %ebx,0xfffffe98(%ebp)
   129a4:	c6 85 70 fe ff ff 01 	movb   $0x1,0xfffffe70(%ebp)
   129ab:	b8 01 00 00 00       	mov    $0x1,%eax
   129b0:	88 d9                	mov    %bl,%cl
   129b2:	d3 e0                	shl    %cl,%eax
   129b4:	85 c6                	test   %eax,%esi
   129b6:	74 1d                	je     129d5 <_ISAPNPStartDevice+0x1095>
   129b8:	b8 01 00 00 00       	mov    $0x1,%eax
   129bd:	88 d9                	mov    %bl,%cl
   129bf:	d3 e0                	shl    %cl,%eax
   129c1:	85 c6                	test   %eax,%esi
   129c3:	0f 95 c2             	setne  %dl
   129c6:	83 fb 0f             	cmp    $0xf,%ebx
   129c9:	0f 94 c0             	sete   %al
   129cc:	25 ff 00 00 00       	and    $0xff,%eax
   129d1:	85 c2                	test   %eax,%edx
   129d3:	74 7e                	je     12a53 <_ISAPNPStartDevice+0x1113>
   129d5:	50                   	push   %eax
   129d6:	50                   	push   %eax
   129d7:	8d 85 00 ff ff ff    	lea    0xffffff00(%ebp),%eax
   129dd:	50                   	push   %eax
   129de:	8b 85 a0 fe ff ff    	mov    0xfffffea0(%ebp),%eax
   129e4:	50                   	push   %eax
   129e5:	8b 95 a4 fe ff ff    	mov    0xfffffea4(%ebp),%edx
   129eb:	89 f8                	mov    %edi,%eax
   129ed:	e8 1e ec ff ff       	call   11610 <_AddResourceDescriptor>
   129f2:	83 c4 10             	add    $0x10,%esp
   129f5:	85 c0                	test   %eax,%eax
   129f7:	0f 88 83 f8 ff ff    	js     12280 <_ISAPNPStartDevice+0x940>
   129fd:	8b 85 00 ff ff ff    	mov    0xffffff00(%ebp),%eax
   12a03:	88 d9                	mov    %bl,%cl
   12a05:	c6 40 09 04          	movb   $0x4,0x9(%eax)
   12a09:	8b 85 00 ff ff ff    	mov    0xffffff00(%ebp),%eax
   12a0f:	c6 40 0a 01          	movb   $0x1,0xa(%eax)
   12a13:	8b 85 00 ff ff ff    	mov    0xffffff00(%ebp),%eax
   12a19:	8b 95 98 fe ff ff    	mov    0xfffffe98(%ebp),%edx
   12a1f:	89 85 70 fe ff ff    	mov    %eax,0xfffffe70(%ebp)
   12a25:	89 50 10             	mov    %edx,0x10(%eax)
   12a28:	b8 01 00 00 00       	mov    $0x1,%eax
   12a2d:	d3 e0                	shl    %cl,%eax
   12a2f:	85 c6                	test   %eax,%esi
   12a31:	0f 95 c2             	setne  %dl
   12a34:	83 fb 0f             	cmp    $0xf,%ebx
   12a37:	0f 94 c0             	sete   %al
   12a3a:	25 ff 00 00 00       	and    $0xff,%eax
   12a3f:	85 c2                	test   %eax,%edx
   12a41:	74 1f                	je     12a62 <_ISAPNPStartDevice+0x1122>
   12a43:	8b 85 70 fe ff ff    	mov    0xfffffe70(%ebp),%eax
   12a49:	89 58 14             	mov    %ebx,0x14(%eax)
   12a4c:	c6 85 70 fe ff ff 00 	movb   $0x0,0xfffffe70(%ebp)
   12a53:	43                   	inc    %ebx
   12a54:	83 fb 07             	cmp    $0x7,%ebx
   12a57:	0f 86 2b ff ff ff    	jbe    12988 <_ISAPNPStartDevice+0x1048>
   12a5d:	e9 1e f8 ff ff       	jmp    12280 <_ISAPNPStartDevice+0x940>
   12a62:	8b 95 70 fe ff ff    	mov    0xfffffe70(%ebp),%edx
   12a68:	8d 43 ff             	lea    0xffffffff(%ebx),%eax
   12a6b:	89 42 14             	mov    %eax,0x14(%edx)
   12a6e:	eb dc                	jmp    12a4c <_ISAPNPStartDevice+0x110c>

00012a70 <_ISAPNPStopDevice>:


NTSTATUS
ISAPNPStopDevice(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP Irp,
  PIO_STACK_LOCATION IrpSp)
{
   12a70:	55                   	push   %ebp
   12a71:	89 e5                	mov    %esp,%ebp
  PISAPNP_DEVICE_EXTENSION DeviceExtension;

  DPRINT("Called\n");

  DeviceExtension = (PISAPNP_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
   12a73:	8b 45 08             	mov    0x8(%ebp),%eax
   12a76:	8b 40 28             	mov    0x28(%eax),%eax

  if (DeviceExtension->State != dsStopped) {
   12a79:	8b 50 20             	mov    0x20(%eax),%edx
   12a7c:	85 d2                	test   %edx,%edx
   12a7e:	74 07                	je     12a87 <_ISAPNPStopDevice+0x17>
    /* FIXME: Stop device */
    DeviceExtension->State = dsStopped;
   12a80:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%eax)
  }

  return STATUS_SUCCESS;
}
   12a87:	31 c0                	xor    %eax,%eax
   12a89:	5d                   	pop    %ebp
   12a8a:	c3                   	ret    
   12a8b:	90                   	nop    
   12a8c:	8d 74 26 00          	lea    0x0(%esi),%esi

00012a90 <_ISAPNPDispatchOpenClose@8>:


NTSTATUS
STDCALL
ISAPNPDispatchOpenClose(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP Irp)
{
   12a90:	55                   	push   %ebp
   12a91:	89 e5                	mov    %esp,%ebp
   12a93:	83 ec 10             	sub    $0x10,%esp
   12a96:	8b 45 0c             	mov    0xc(%ebp),%eax
  DPRINT("Called\n");

  Irp->IoStatus.Status = STATUS_SUCCESS;
   12a99:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
  Irp->IoStatus.Information = FILE_OPENED;
   12aa0:	c7 40 1c 01 00 00 00 	movl   $0x1,0x1c(%eax)
  IoCompleteRequest(Irp, IO_NO_INCREMENT);
   12aa7:	6a 00                	push   $0x0
   12aa9:	50                   	push   %eax
   12aaa:	e8 61 02 00 00       	call   12d10 <_IoCompleteRequest@8>

  return STATUS_SUCCESS;
}
   12aaf:	31 c0                	xor    %eax,%eax
   12ab1:	c9                   	leave  
   12ab2:	c2 08 00             	ret    $0x8
   12ab5:	8d 74 26 00          	lea    0x0(%esi),%esi
   12ab9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00012ac0 <_ISAPNPDispatchReadWrite@8>:


NTSTATUS
STDCALL
ISAPNPDispatchReadWrite(
  IN PDEVICE_OBJECT PhysicalDeviceObject,
  IN PIRP Irp)
{
   12ac0:	55                   	push   %ebp
   12ac1:	89 e5                	mov    %esp,%ebp
   12ac3:	83 ec 10             	sub    $0x10,%esp
   12ac6:	8b 45 0c             	mov    0xc(%ebp),%eax
  DPRINT("Called\n");

  Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
   12ac9:	c7 40 18 01 00 00 c0 	movl   $0xc0000001,0x18(%eax)
  Irp->IoStatus.Information = 0;
   12ad0:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
  IoCompleteRequest(Irp, IO_NO_INCREMENT);
   12ad7:	6a 00                	push   $0x0
   12ad9:	50                   	push   %eax
   12ada:	e8 31 02 00 00       	call   12d10 <_IoCompleteRequest@8>

  return STATUS_UNSUCCESSFUL;
}
   12adf:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   12ae4:	c9                   	leave  
   12ae5:	c2 08 00             	ret    $0x8
   12ae8:	90                   	nop    
   12ae9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00012af0 <_ISAPNPDispatchDeviceControl@8>:


NTSTATUS
STDCALL
ISAPNPDispatchDeviceControl(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP Irp)
{
   12af0:	55                   	push   %ebp
   12af1:	89 e5                	mov    %esp,%ebp
   12af3:	83 ec 10             	sub    $0x10,%esp
   12af6:	8b 45 0c             	mov    0xc(%ebp),%eax
  PIO_STACK_LOCATION IrpSp;
  NTSTATUS Status;

  DPRINT("Called\n");

  Irp->IoStatus.Information = 0;
   12af9:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)

  IrpSp = IoGetCurrentIrpStackLocation(Irp);
  switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
  default:
    DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
    Status = STATUS_NOT_IMPLEMENTED;
    break;
  }

  if (Status != STATUS_PENDING) {
    Irp->IoStatus.Status = Status;
   12b00:	c7 40 18 02 00 00 c0 	movl   $0xc0000002,0x18(%eax)
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
   12b07:	6a 00                	push   $0x0
   12b09:	50                   	push   %eax
   12b0a:	e8 01 02 00 00       	call   12d10 <_IoCompleteRequest@8>
   12b0f:	59                   	pop    %ecx
   12b10:	58                   	pop    %eax
  }

  DPRINT("Leaving. Status 0x%X\n", Status);

  return Status;
}
   12b11:	b8 02 00 00 c0       	mov    $0xc0000002,%eax
   12b16:	c9                   	leave  
   12b17:	c2 08 00             	ret    $0x8
   12b1a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00012b20 <_ISAPNPControl@8>:


NTSTATUS
STDCALL
ISAPNPControl(
  IN PDEVICE_OBJECT DeviceObject,
  IN PIRP Irp)
{
   12b20:	55                   	push   %ebp
  PIO_STACK_LOCATION IrpSp;
  NTSTATUS Status;

  DPRINT("Called\n");

  IrpSp = IoGetCurrentIrpStackLocation(Irp);
  switch (IrpSp->MinorFunction) {
   12b21:	31 c0                	xor    %eax,%eax
   12b23:	89 e5                	mov    %esp,%ebp
   12b25:	56                   	push   %esi
   12b26:	53                   	push   %ebx
   12b27:	8b 75 0c             	mov    0xc(%ebp),%esi
   12b2a:	8b 4d 08             	mov    0x8(%ebp),%ecx
   12b2d:	8b 56 60             	mov    0x60(%esi),%edx
   12b30:	8a 42 01             	mov    0x1(%edx),%al
   12b33:	83 f8 04             	cmp    $0x4,%eax
   12b36:	74 58                	je     12b90 <_ISAPNPControl@8+0x70>
   12b38:	7f 26                	jg     12b60 <_ISAPNPControl@8+0x40>
   12b3a:	85 c0                	test   %eax,%eax
   12b3c:	74 42                	je     12b80 <_ISAPNPControl@8+0x60>
  case IRP_MN_QUERY_DEVICE_RELATIONS:
    Status = ISAPNPQueryDeviceRelations(DeviceObject, Irp, IrpSp);
    break;

  case IRP_MN_START_DEVICE:
    Status = ISAPNPStartDevice(DeviceObject, Irp, IrpSp);
    break;

  case IRP_MN_STOP_DEVICE:
    Status = ISAPNPStopDevice(DeviceObject, Irp, IrpSp);
    break;

  default:
    DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
    Status = STATUS_NOT_IMPLEMENTED;
   12b3e:	bb 02 00 00 c0       	mov    $0xc0000002,%ebx
    break;
  }

  if (Status != STATUS_PENDING) {
    Irp->IoStatus.Status = Status;
   12b43:	89 5e 18             	mov    %ebx,0x18(%esi)
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
   12b46:	51                   	push   %ecx
   12b47:	51                   	push   %ecx
   12b48:	6a 00                	push   $0x0
   12b4a:	56                   	push   %esi
   12b4b:	e8 c0 01 00 00       	call   12d10 <_IoCompleteRequest@8>
   12b50:	58                   	pop    %eax
   12b51:	5a                   	pop    %edx
  }

  DPRINT("Leaving. Status 0x%X\n", Status);

  return Status;
}
   12b52:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   12b55:	89 d8                	mov    %ebx,%eax
   12b57:	5b                   	pop    %ebx
   12b58:	5e                   	pop    %esi
   12b59:	5d                   	pop    %ebp
   12b5a:	c2 08 00             	ret    $0x8
   12b5d:	8d 76 00             	lea    0x0(%esi),%esi
   12b60:	83 f8 07             	cmp    $0x7,%eax
   12b63:	75 d9                	jne    12b3e <_ISAPNPControl@8+0x1e>
   12b65:	50                   	push   %eax
   12b66:	52                   	push   %edx
   12b67:	56                   	push   %esi
   12b68:	51                   	push   %ecx
   12b69:	e8 82 ed ff ff       	call   118f0 <_ISAPNPQueryDeviceRelations>
   12b6e:	89 f6                	mov    %esi,%esi
   12b70:	89 c3                	mov    %eax,%ebx
   12b72:	83 c4 10             	add    $0x10,%esp
   12b75:	81 fb 03 01 00 00    	cmp    $0x103,%ebx
   12b7b:	75 c6                	jne    12b43 <_ISAPNPControl@8+0x23>
   12b7d:	eb d3                	jmp    12b52 <_ISAPNPControl@8+0x32>
   12b7f:	90                   	nop    
   12b80:	53                   	push   %ebx
   12b81:	52                   	push   %edx
   12b82:	56                   	push   %esi
   12b83:	51                   	push   %ecx
   12b84:	e8 b7 ed ff ff       	call   11940 <_ISAPNPStartDevice>
   12b89:	eb e5                	jmp    12b70 <_ISAPNPControl@8+0x50>
   12b8b:	90                   	nop    
   12b8c:	8d 74 26 00          	lea    0x0(%esi),%esi
   12b90:	52                   	push   %edx
   12b91:	56                   	push   %esi
   12b92:	51                   	push   %ecx
   12b93:	e8 d8 fe ff ff       	call   12a70 <_ISAPNPStopDevice>
   12b98:	83 c4 0c             	add    $0xc,%esp
   12b9b:	89 c3                	mov    %eax,%ebx
   12b9d:	eb d6                	jmp    12b75 <_ISAPNPControl@8+0x55>
   12b9f:	90                   	nop    

00012ba0 <_ISAPNPAddDevice@8>:


NTSTATUS
STDCALL
ISAPNPAddDevice(
  IN PDRIVER_OBJECT DriverObject,
  IN PDEVICE_OBJECT PhysicalDeviceObject)
{
   12ba0:	55                   	push   %ebp
   12ba1:	89 e5                	mov    %esp,%ebp
   12ba3:	56                   	push   %esi
   12ba4:	53                   	push   %ebx
   12ba5:	83 ec 14             	sub    $0x14,%esp
  PISAPNP_DEVICE_EXTENSION DeviceExtension;
  PDEVICE_OBJECT Fdo;
  NTSTATUS Status;

  DPRINT("Called\n");

  Status = IoCreateDevice(DriverObject, sizeof(ISAPNP_DEVICE_EXTENSION),
   12ba8:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
   12bab:	8b 5d 08             	mov    0x8(%ebp),%ebx
   12bae:	8b 75 0c             	mov    0xc(%ebp),%esi
   12bb1:	50                   	push   %eax
   12bb2:	6a 01                	push   $0x1
   12bb4:	68 00 01 00 00       	push   $0x100
   12bb9:	6a 2a                	push   $0x2a
   12bbb:	6a 00                	push   $0x0
   12bbd:	6a 24                	push   $0x24
   12bbf:	53                   	push   %ebx
   12bc0:	e8 0b 01 00 00       	call   12cd0 <_IoCreateDevice@28>
    NULL, FILE_DEVICE_BUS_EXTENDER, FILE_DEVICE_SECURE_OPEN, TRUE, &Fdo);
  if (!NT_SUCCESS(Status)) {
   12bc5:	59                   	pop    %ecx
   12bc6:	85 c0                	test   %eax,%eax
   12bc8:	78 4c                	js     12c16 <_ISAPNPAddDevice@8+0x76>
    DPRINT("IoCreateDevice() failed with status 0x%X\n", Status);
    return Status;
  }

  DeviceExtension = (PISAPNP_DEVICE_EXTENSION)Fdo->DeviceExtension;
   12bca:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
   12bcd:	8b 58 28             	mov    0x28(%eax),%ebx

  DeviceExtension->Pdo = PhysicalDeviceObject;
   12bd0:	89 33                	mov    %esi,(%ebx)

  DeviceExtension->Ldo =
   12bd2:	52                   	push   %edx
   12bd3:	52                   	push   %edx
   12bd4:	56                   	push   %esi
   12bd5:	50                   	push   %eax
   12bd6:	e8 45 01 00 00       	call   12d20 <_IoAttachDeviceToDeviceStack@8>
   12bdb:	89 43 04             	mov    %eax,0x4(%ebx)
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   12bde:	8d 43 08             	lea    0x8(%ebx),%eax
   12be1:	51                   	push   %ecx
	ListHead->Flink = ListHead->Blink = ListHead;
   12be2:	89 43 08             	mov    %eax,0x8(%ebx)
   12be5:	89 40 04             	mov    %eax,0x4(%eax)
   12be8:	8d 43 10             	lea    0x10(%ebx),%eax
   12beb:	89 43 10             	mov    %eax,0x10(%ebx)
    IoAttachDeviceToDeviceStack(Fdo, PhysicalDeviceObject);

  InitializeListHead(&DeviceExtension->CardListHead);
  InitializeListHead(&DeviceExtension->DeviceListHead);
  DeviceExtension->DeviceListCount = 0;
   12bee:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   12bf5:	89 40 04             	mov    %eax,0x4(%eax)
  KeInitializeSpinLock(&DeviceExtension->GlobalListLock);
   12bf8:	8d 43 1c             	lea    0x1c(%ebx),%eax
   12bfb:	50                   	push   %eax
   12bfc:	e8 ff 00 00 00       	call   12d00 <_KeInitializeSpinLock@4>

  DeviceExtension->State = dsStopped;

  Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
   12c01:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
   12c04:	c7 43 20 00 00 00 00 	movl   $0x0,0x20(%ebx)
   12c0b:	8b 50 1c             	mov    0x1c(%eax),%edx
   12c0e:	80 e2 7f             	and    $0x7f,%dl
   12c11:	89 50 1c             	mov    %edx,0x1c(%eax)

  DPRINT("Done AddDevice\n");

  return STATUS_SUCCESS;
   12c14:	31 c0                	xor    %eax,%eax
}
   12c16:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   12c19:	5b                   	pop    %ebx
   12c1a:	5e                   	pop    %esi
   12c1b:	5d                   	pop    %ebp
   12c1c:	c2 08 00             	ret    $0x8
   12c1f:	90                   	nop    

00012c20 <_DriverEntry@8>:


NTSTATUS
STDCALL
DriverEntry(
  IN PDRIVER_OBJECT DriverObject, 
  IN PUNICODE_STRING RegistryPath)
{
   12c20:	55                   	push   %ebp
   12c21:	89 e5                	mov    %esp,%ebp
   12c23:	53                   	push   %ebx
   12c24:	83 ec 10             	sub    $0x10,%esp
   12c27:	8b 5d 08             	mov    0x8(%ebp),%ebx
  DbgPrint("ISA Plug and Play Bus Driver\n");
   12c2a:	68 5c 30 01 00       	push   $0x1305c
   12c2f:	e8 fc 00 00 00       	call   12d30 <_DbgPrint>

  DriverObject->MajorFunction[IRP_MJ_CREATE] = ISAPNPDispatchOpenClose;
  DriverObject->MajorFunction[IRP_MJ_CLOSE] = ISAPNPDispatchOpenClose;
  DriverObject->MajorFunction[IRP_MJ_READ] = ISAPNPDispatchReadWrite;
  DriverObject->MajorFunction[IRP_MJ_WRITE] = ISAPNPDispatchReadWrite;
  DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ISAPNPDispatchDeviceControl;
  DriverObject->MajorFunction[IRP_MJ_PNP] = ISAPNPControl;
  DriverObject->DriverExtension->AddDevice = ISAPNPAddDevice;
   12c34:	8b 43 18             	mov    0x18(%ebx),%eax
   12c37:	c7 43 38 90 2a 01 00 	movl   $0x12a90,0x38(%ebx)
   12c3e:	c7 43 40 90 2a 01 00 	movl   $0x12a90,0x40(%ebx)
   12c45:	c7 43 44 c0 2a 01 00 	movl   $0x12ac0,0x44(%ebx)
   12c4c:	c7 40 04 a0 2b 01 00 	movl   $0x12ba0,0x4(%eax)
   12c53:	c7 43 48 c0 2a 01 00 	movl   $0x12ac0,0x48(%ebx)
   12c5a:	c7 43 70 f0 2a 01 00 	movl   $0x12af0,0x70(%ebx)
   12c61:	c7 83 a4 00 00 00 20 	movl   $0x12b20,0xa4(%ebx)
   12c68:	2b 01 00 

  return STATUS_SUCCESS;
}
   12c6b:	31 c0                	xor    %eax,%eax
   12c6d:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   12c70:	c9                   	leave  
   12c71:	c2 08 00             	ret    $0x8
   12c74:	90                   	nop    
   12c75:	90                   	nop    
   12c76:	90                   	nop    
   12c77:	90                   	nop    
   12c78:	90                   	nop    
   12c79:	90                   	nop    
   12c7a:	90                   	nop    
   12c7b:	90                   	nop    
   12c7c:	90                   	nop    
   12c7d:	90                   	nop    
   12c7e:	90                   	nop    
   12c7f:	90                   	nop    

00012c80 <_RtlInitAnsiString@8>:
   12c80:	ff 25 c8 50 01 00    	jmp    *0x150c8
   12c86:	90                   	nop    
   12c87:	90                   	nop    
	...

00012c90 <_RtlAnsiStringToUnicodeString@12>:
   12c90:	ff 25 c4 50 01 00    	jmp    *0x150c4
   12c96:	90                   	nop    
   12c97:	90                   	nop    
	...

00012ca0 <_ExAllocatePool@8>:
   12ca0:	ff 25 a8 50 01 00    	jmp    *0x150a8
   12ca6:	90                   	nop    
   12ca7:	90                   	nop    
	...

00012cb0 <_RtlZeroMemory@8>:
   12cb0:	ff 25 cc 50 01 00    	jmp    *0x150cc
   12cb6:	90                   	nop    
   12cb7:	90                   	nop    
	...

00012cc0 <_ExInterlockedInsertTailList@12>:
   12cc0:	ff 25 b0 50 01 00    	jmp    *0x150b0
   12cc6:	90                   	nop    
   12cc7:	90                   	nop    
	...

00012cd0 <_IoCreateDevice@28>:
   12cd0:	ff 25 bc 50 01 00    	jmp    *0x150bc
   12cd6:	90                   	nop    
   12cd7:	90                   	nop    
	...

00012ce0 <@ObfReferenceObject@4>:
   12ce0:	ff 25 a0 50 01 00    	jmp    *0x150a0
   12ce6:	90                   	nop    
   12ce7:	90                   	nop    
	...

00012cf0 <_ExFreePool@4>:
   12cf0:	ff 25 ac 50 01 00    	jmp    *0x150ac
   12cf6:	90                   	nop    
   12cf7:	90                   	nop    
	...

00012d00 <_KeInitializeSpinLock@4>:
   12d00:	ff 25 c0 50 01 00    	jmp    *0x150c0
   12d06:	90                   	nop    
   12d07:	90                   	nop    
	...

00012d10 <_IoCompleteRequest@8>:
   12d10:	ff 25 b8 50 01 00    	jmp    *0x150b8
   12d16:	90                   	nop    
   12d17:	90                   	nop    
	...

00012d20 <_IoAttachDeviceToDeviceStack@8>:
   12d20:	ff 25 b4 50 01 00    	jmp    *0x150b4
   12d26:	90                   	nop    
   12d27:	90                   	nop    
	...

00012d30 <_DbgPrint>:
   12d30:	ff 25 a4 50 01 00    	jmp    *0x150a4
   12d36:	90                   	nop    
   12d37:	90                   	nop    
	...

00012d40 <_WRITE_PORT_UCHAR@8>:
   12d40:	ff 25 94 50 01 00    	jmp    *0x15094
   12d46:	90                   	nop    
   12d47:	90                   	nop    
	...

00012d50 <_KeStallExecutionProcessor@4>:
   12d50:	ff 25 8c 50 01 00    	jmp    *0x1508c
   12d56:	90                   	nop    
   12d57:	90                   	nop    
	...

00012d60 <_READ_PORT_UCHAR@4>:
   12d60:	ff 25 90 50 01 00    	jmp    *0x15090
   12d66:	90                   	nop    
   12d67:	90                   	nop    
	...

00012d70 <__CTOR_LIST__>:
   12d70:	ff                   	(bad)  
   12d71:	ff                   	(bad)  
   12d72:	ff                   	(bad)  
   12d73:	ff 00                	incl   (%eax)
   12d75:	00 00                	add    %al,(%eax)
	...

00012d78 <__DTOR_LIST__>:
   12d78:	ff                   	(bad)  
   12d79:	ff                   	(bad)  
   12d7a:	ff                   	(bad)  
   12d7b:	ff 00                	incl   (%eax)
   12d7d:	00 00                	add    %al,(%eax)
	...
